diff --git a/.gitignore b/.gitignore index afa5d6e..94dd23a 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,4 @@ *.csv .DS_Store *.jar +flink-processor/target/ diff --git a/README.md b/README.md index 3e22444..ec30479 100644 --- a/README.md +++ b/README.md @@ -62,3 +62,35 @@ Kafka producer Flink Processor Flink Processor + +# BerlinMOD-9 × 3 streaming forms — the parity matrix on Flink + +The streaming-side parity matrix runs all nine BerlinMOD reference queries (Q1..Q9) in three streaming forms each on this runtime: **continuous** (always-on, per-event emission), **windowed** (tumbling 10-second aggregation), and **snapshot** (5-second tick — the parity-oracle form whose output at watermark T equals the batch BerlinMOD-Q result on data up to T). + +| Q | Topic | Continuous | Windowed | Snapshot | +|---|---|---|---|---| +| Q1 | "which vehicles have appeared in the stream?" | ✓ | ✓ | ✓ | +| Q2 | "where is vehicle X at time T?" | ✓ | ✓ | ✓ | +| Q3 | "vehicles within d of P at time T?" | ✓ | ✓ | ✓ | +| Q4 | "vehicles entered region R, and when?" | ✓ | ✓ | ✓ | +| Q5 | "pairs of vehicles meeting near P" | ✓ | ✓ | ✓ | +| Q6 | "cumulative distance per vehicle" | ✓ | ✓ | ✓ | +| Q7 | "first passage of vehicles through POIs" | ✓ | ✓ | ✓ | +| Q8 | "vehicles close to a road segment" | ✓ | ✓ | ✓ | +| Q9 | "distance between vehicles X and Y at time T" | ✓ | ✓ | ✓ | + +**27 / 27 cells** = the full MobilityFlink parity-matrix row. Each cell has a dedicated `Q{Continuous,Windowed,Snapshot}Function` class in [`flink-processor/src/main/java/berlinmod/`](flink-processor/src/main/java/berlinmod/) and is locally verified via the companion `BerlinMODQLocalTest` driver running on a Flink mini-cluster. + +The streaming snapshot form converges to the batch BerlinMOD result on the same scale-factor corpus, anchored against the cross-platform outputs in [MobilityDB-BerlinMOD](https://github.com/MobilityDB/MobilityDB-BerlinMOD). + +Spatial predicates route through [`MEOSBridge`](flink-processor/src/main/java/berlinmod/MEOSBridge.java), which holds no spatial mathematics of its own: it builds the MEOS temporal instants and geographies and delegates the computation to libmeos. The within-distance predicate uses MEOS `edwithin_tgeo_geo` — the vehicle position as a `tgeogpoint` instant, tested against the query geography in metres on the WGS84 spheroid; region containment uses `eintersects_tgeo_geo` between the point's `tgeompoint` instant and the region polygon; and the pairwise and cumulative distances use `geog_distance`. + +The Kafka-source entry points for Q2 and Q3 are [`BerlinMODQ2Main`](flink-processor/src/main/java/berlinmod/BerlinMODQ2Main.java) and [`BerlinMODQ3Main`](flink-processor/src/main/java/berlinmod/BerlinMODQ3Main.java); the companion producer is [`python-producer-berlinmod.py`](kafka-producer/python-producer-berlinmod.py). Generate a BerlinMOD CSV with the upstream generator (`meos/examples/data/generate_berlinmod_trips.sql` in MobilityDB) at any scale factor and feed it to the producer. The form-by-form definition with default parameters lives in [`doc/berlinmod-q3-streaming-forms.md`](doc/berlinmod-q3-streaming-forms.md). + +### Sibling parity work in the ecosystem + +- [MobilityKafka#1](https://github.com/MobilityDB/MobilityKafka/pull/1) — the same 27-cell row on Kafka Streams +- [MobilityNebula#15](https://github.com/MobilityDB/MobilityNebula/pull/15) — 27 / 27 cells on NebulaStream scaffold (with [#16](https://github.com/MobilityDB/MobilityNebula/pull/16) adding `TEMPORAL_LENGTH` for Q6 and [#17](https://github.com/MobilityDB/MobilityNebula/pull/17) adding `PAIR_MEETING` + `CROSS_DISTANCE` for Q5/Q9, all calling MEOS C ABI directly) +- [MobilityDB-BerlinMOD#29](https://github.com/MobilityDB/MobilityDB-BerlinMOD/pull/29) — the batch BerlinMOD-9 cross-platform timings (the snapshot form's gold-answer source) +- [MobilityDB/.github#10](https://github.com/MobilityDB/.github/pull/10) — the ecosystem-profile description of the stream-layers tier + diff --git a/doc/berlinmod-q3-streaming-forms.md b/doc/berlinmod-q3-streaming-forms.md new file mode 100644 index 0000000..1a69682 --- /dev/null +++ b/doc/berlinmod-q3-streaming-forms.md @@ -0,0 +1,107 @@ +# BerlinMOD-Q3 streaming forms + +This document defines what **BerlinMOD-Q3** means in each of the three +streaming forms the parity contract specifies for the MobilityFlink / +MobilityKafka / MobilityNebula trio (see the planned-tier section of the +[ecosystem profile](https://github.com/MobilityDB/.github)). + +## The batch query + +> *Which vehicles were within distance `d` of point `P` at time `T`?* + +Parameters: a point `P = (lon, lat)`, a radius `d` in metres, and a time `T`. +Returns: the set of `vehicle_id`s whose trajectory passed within `d` of `P` at `T`. + +The batch reference implementation lives in +[MobilityDB-BerlinMOD](https://github.com/MobilityDB/MobilityDB-BerlinMOD) and +runs against the three SQL surfaces (MobilityDB / MobilityDuck / MobilitySpark) +with byte-identical results — the batch oracle for the snapshot streaming form +below. + +## The three streaming forms + +### 1. Continuous form + +> *"At every moment, which vehicles are currently within `d` of `P`?"* + +For each incoming GPS event `(vehicle_id, t, lon, lat)`: + +- Evaluate the radius predicate `distance((lon, lat), P) ≤ d`. +- Emit `(vehicle_id, t, near)` per event. + +No window; output updates per event. Watermark-independent. + +Use case: real-time geofence alerting where each event matters. + +Implemented by [`Q3ContinuousFunction`](../flink-processor/src/main/java/berlinmod/Q3ContinuousFunction.java). + +### 2. Windowed form + +> *"Per N-second tumbling window, how many distinct vehicles were +> within `d` of `P` at any time during the window?"* + +Tumbling event-time window of size `W` (default `W = 10s`). For each window: + +- Collect all events whose timestamp falls in the window. +- Compute the distinct set `{vehicle_id : ∃ event in window with distance ≤ d}`. +- Emit `(window_start, window_end, distinct_count)`. + +Use case: time-bucketed dashboards, near-real-time aggregates. + +Implemented by [`Q3WindowedFunction`](../flink-processor/src/main/java/berlinmod/Q3WindowedFunction.java). + +### 3. Snapshot form — **the parity oracle** + +> *"At time `T`, which vehicles are within `d` of `P`?"* + +Watermark-driven. Per vehicle, maintain `lastKnownPosition` state. At each +snapshot tick (event-time timer at multiples of `snapshotTickMillis`, +default `5000 ms`): + +- For each vehicle's most recent `(lon, lat)`, evaluate the radius predicate. +- Emit `(T, vehicle_id)` for every vehicle satisfying the predicate at `T`. + +As the watermark advances to `T = max(event_times)`, the streaming snapshot +output **equals the batch BerlinMOD-Q3 result** on the same scale-factor +corpus. This is the parity property the contract enforces: + +``` +streaming-Q3-snapshot(T) ≡ batch-BerlinMOD-Q3 on data up to T + (same SF, same P, same d) +``` + +Use case: lambda-architecture style verification — streaming pipeline's +output must converge to the batch reference. + +Implemented by [`Q3SnapshotFunction`](../flink-processor/src/main/java/berlinmod/Q3SnapshotFunction.java). + +## Default parameters + +The `BerlinMODQ3Main` entry point uses: + +| Parameter | Value | Source | +|---|---|---| +| `P` (lon, lat) | (4.3517, 50.8503) — Brussels city centre | Default centre for the BerlinMOD-Brussels corpus | +| `d` (radius) | 5 000 m | Within-city-centre scale | +| `W` (window size) | 10 s | Same as the AIS example for consistency | +| Snapshot tick | 5 s | Half the window for finer parity-oracle granularity | +| Topic | `berlinmod` | Single shared topic across the three forms | + +## Predicate implementation + +The within-distance predicate evaluates through the MEOS `edwithin_tgeo_geo` +operator — the same call used by `MobilityNebula/Queries/Query1.yaml`. The +vehicle position is built as a `tgeogpoint` instant and tested against the +query geography in metres on the WGS84 spheroid. All spatial predicates route +through [`MEOSBridge`](../flink-processor/src/main/java/berlinmod/MEOSBridge.java), +which holds no spatial mathematics of its own: it constructs the MEOS inputs +(temporal instants and geographies) and delegates the computation to libmeos. + +## Companion producer + +The BerlinMOD CSV → Kafka producer lives at +[`kafka-producer/python-producer-berlinmod.py`](../kafka-producer/python-producer-berlinmod.py). +Generate a BerlinMOD CSV at scale factor SF with the upstream generator +(`meos/examples/data/generate_berlinmod_trips.sql` in MobilityDB), name the +columns `(t, vehicle_id, lon, lat)`, and the producer streams it to the +`berlinmod` topic. diff --git a/flink-processor/docs/benchmark-results.md b/flink-processor/docs/benchmark-results.md new file mode 100644 index 0000000..0254a9a --- /dev/null +++ b/flink-processor/docs/benchmark-results.md @@ -0,0 +1,89 @@ +# BerlinMOD streaming-matrix throughput + +Throughput of the BerlinMOD-9 × 3-form streaming matrix (9 queries × +{continuous, windowed, snapshot} = 27 cells) on the Flink local mini-cluster +over the real BerlinMOD instants corpus. The spatial predicates evaluate through +MEOS: within-distance through `edwithin_tgeo_geo`, region containment through +`eintersects_tgeo_geo`, and distances through `geog_distance` (see +[`MEOSBridge`](../src/main/java/berlinmod/MEOSBridge.java)). + +## Method + +The corpus is the BerlinMOD `berlinmod_instants.csv` produced by the BerlinMOD +generator — 216 075 instants, 5 vehicles, over ~11 days. Instants are stored in +EPSG:3857 and reprojected to EPSG:4326 through MEOS `geo_transform` at load (see +[`BerlinMODCorpus`](../src/main/java/berlinmod/BerlinMODCorpus.java)); the +per-query parameters (point `P` = corpus centroid, region box, road segment, +points of interest, target vehicle ids) and the window/tick granularity are +derived from the corpus so each spatial cell is selective and the matrix +produces a comparable number of windows. Each cell runs as its own Flink job +terminated by a counting sink; throughput is input events ÷ wall-clock and +`output rows` is the sink cardinality. Parallelism 1, Flink 1.16, Java 21, +16-core x86-64 Linux; libmeos built `-DMEOS=ON -DCBUFFER=ON -DNPOINT=ON +-DPOSE=ON -DRGEO=ON`. + +Run from `flink-processor/`: + +``` +LD_LIBRARY_PATH= java \ + --add-opens=java.base/java.lang=ALL-UNNAMED \ + --add-opens=java.base/java.util=ALL-UNNAMED \ + --add-opens=java.base/java.lang.reflect=ALL-UNNAMED \ + --add-opens=java.base/java.io=ALL-UNNAMED \ + --add-opens=java.base/java.time=ALL-UNNAMED \ + -cp target/classes:jar/JMEOS.jar: \ + berlinmod.BerlinMODBenchmark --csv +``` + +## Results — real BerlinMOD instants (216 075 events) + +| Cell | Events in | Output rows | Wall (ms) | Throughput (ev/s) | +|---|---:|---:|---:|---:| +| Q1-continuous | 216075 | 5 | 2508 | 86,154 | +| Q1-windowed | 216075 | 86 | 1294 | 166,982 | +| Q1-snapshot | 216075 | 274 | 1056 | 204,616 | +| Q2-continuous | 216075 | 61170 | 1074 | 201,187 | +| Q2-windowed | 216075 | 50 | 1027 | 210,394 | +| Q2-snapshot | 216075 | 71 | 985 | 219,365 | +| Q3-continuous | 216075 | 216075 | 2928 | 73,796 | +| Q3-windowed | 216075 | 86 | 2507 | 86,189 | +| Q3-snapshot | 216075 | 0 | 926 | 233,342 | +| Q4-continuous | 216075 | 62 | 3254 | 66,403 | +| Q4-windowed | 216075 | 98 | 3234 | 66,814 | +| Q4-snapshot | 216075 | 1944 | 3223 | 67,042 | +| Q5-continuous | 216075 | 73063 | 9161 | 23,586 | +| Q5-windowed | 216075 | 6 | 954 | 226,494 | +| Q5-snapshot | 216075 | 0 | 915 | 236,148 | +| Q6-continuous | 216075 | 216075 | 2382 | 90,712 | +| Q6-windowed | 216075 | 203 | 2637 | 81,940 | +| Q6-snapshot | 216075 | 274 | 2214 | 97,595 | +| Q7-continuous | 216075 | 5 | 3973 | 54,386 | +| Q7-windowed | 216075 | 53 | 5004 | 43,180 | +| Q7-snapshot | 216075 | 288 | 3931 | 54,967 | +| Q8-continuous | 216075 | 216075 | 2883 | 74,948 | +| Q8-windowed | 216075 | 86 | 2864 | 75,445 | +| Q8-snapshot | 216075 | 126 | 928 | 232,839 | +| Q9-continuous | 216075 | 107870 | 1858 | 116,294 | +| Q9-windowed | 216075 | 22 | 924 | 233,847 | +| Q9-snapshot | 216075 | 95 | 992 | 217,818 | + +## Parity — streaming continuous form ≡ batch MEOS predicate + +The continuous form emits `predicate(event)` for every event, so it is checked +event-for-event against a batch pass over the same corpus through the same +`MEOSBridge` call ([`BerlinMODParity`](../src/main/java/berlinmod/BerlinMODParity.java)). +Both spatial-membership queries match exactly. + +| Query | Events | Streaming-true | Batch-true | Mismatches | Parity | +|---|---:|---:|---:|---:|---| +| Q3 (within `d` of `P`) | 216075 | 56086 | 56086 | 0 | exact | +| Q8 (within `d` of segment) | 216075 | 118498 | 118498 | 0 | exact | + +## Characteristics + +Q5-continuous enumerates every meeting pair across all vehicles on each event +(O(V²) per event, keyed to a single subtask); it is the lowest throughput of the +matrix. The snapshot form is a sampled form — it evaluates each vehicle's +last-known position at tick instants — so a within-`P` snapshot can be empty when +no vehicle is within `d` of `P` at a tick boundary even though the continuous +form reports near-`P` events between boundaries. diff --git a/flink-processor/docs/parity-status.md b/flink-processor/docs/parity-status.md new file mode 100644 index 0000000..dd519ee --- /dev/null +++ b/flink-processor/docs/parity-status.md @@ -0,0 +1,46 @@ +# MobilityFlink parity status — MEOS surface audit + +Generated 2026-05-29 by `tools/parity/parity_audit.py`. + +The MobilityFlink MEOS facade (`org.mobilitydb.flink.meos.MeosOps*`) exposes MEOS C functions to Flink through JMEOS. This audit measures, per type family, the share of the **MEOS public C API** that the facade exposes and that JMEOS binds. + +**Headline.** The facade exposes **2296 of 2296 public MEOS functions (100.0%)**. The MEOS public surface (`meos/include/meos*.h`, excluding internal headers) is 2297 functions; JMEOS binds 2296 of them. 0 bindable functions are not exposed (listed in §3). + +Coverage is **static**: a function counts as covered when the facade declares a method of the same name and arity that delegates to a JMEOS export. + +Per-family runtime behaviour is asserted by `src/test/java/org/mobilitydb/flink/meos/MeosFacadeSmokeTest.java`, which constructs and reads back a value in the core, geo, cbuffer, npoint and pose families through the facade against libmeos. The cbuffer, npoint and pose families require a libmeos built with the extended modules (`-DCBUFFER=ON -DNPOINT=ON -DPOSE=ON -DRGEO=ON`); the stock library carries the core and geo surfaces only. + +## 1. Reference surface and method + +- **Denominator**: distinct function names declared `extern` in the MEOS public headers `meos.h`, `meos_geo.h`, `meos_cbuffer.h`, `meos_npoint.h`, `meos_pose.h`, `meos_rgeo.h`. Internal headers (`meos_internal*.h`) are excluded. + +- **Numerator**: `public static` methods on the generated `MeosOps*` facade whose name is also a `functions.GeneratedFunctions` export in the bundled JMEOS jar. + +- **JMEOS jar**: jar/JMEOS.jar exports 2916 static methods. + +## 2. Per-family coverage of the public MEOS surface + +| Family (header) | Public ∩ JMEOS | Exposed | Missing | Coverage | +|---|---:|---:|---:|---:| +| core temporal / set / span / spanset / tbox (`meos.h`) | 1343 | 1343 | 0 | 100.0% | +| geo (tgeo / tpoint / stbox) (`meos_geo.h`) | 421 | 421 | 0 | 100.0% | +| cbuffer (`meos_cbuffer.h`) | 175 | 175 | 0 | 100.0% | +| npoint (`meos_npoint.h`) | 119 | 119 | 0 | 100.0% | +| pose (`meos_pose.h`) | 101 | 101 | 0 | 100.0% | +| rgeo (`meos_rgeo.h`) | 68 | 68 | 0 | 100.0% | +| h3 / th3index (`meos_h3.h`) | 69 | 69 | 0 | 100.0% | +| **total** | **2296** | **2296** | **0** | **100.0%** | + +## 3. Bindable MEOS functions not exposed by the facade + +0 functions are present in the public MEOS headers and bound by JMEOS but not generated into the facade: + + +## 4. MobilityDB SQL-surface cross-check + +The facade is also matched against the underlying MEOS C symbol of each addressable `CREATE FUNCTION` in `mobilitydb/sql/**/*.in.sql` (PG-only sections and helper symbols bucketed out; 876 out-of-scope, 113 SQL/plpgsql-composed functions with no single C symbol). Functions the SQL layer implements through the internal MEOS headers (`meos_internal*.h`) are exposed via `MeosOpsSqlSurface`. + +- Addressable distinct C symbols: **1336**; bound by JMEOS: **1068**; exposed by the facade: **1068** (100.0% of the JMEOS-bindable SQL surface). + +- The remaining **268** addressable C symbols are not exported by JMEOS under the name the SQL layer's extension wrapper uses; the wrapper names differ from the MEOS function names they call. + diff --git a/flink-processor/jar/JMEOS.jar b/flink-processor/jar/JMEOS.jar index 3c22044..b970140 100644 Binary files a/flink-processor/jar/JMEOS.jar and b/flink-processor/jar/JMEOS.jar differ diff --git a/flink-processor/pom.xml b/flink-processor/pom.xml index f4c288f..99ae9d0 100755 --- a/flink-processor/pom.xml +++ b/flink-processor/pom.xml @@ -216,4 +216,318 @@ + + + + + cbuffer-exclude-unset + + !CBUFFER + + + + + maven-compiler-plugin + + + **/meos/MeosOpsTCbuffer.java + **/meos/MeosOpsFreeCbuffer.java + **/meos/MeosOpsCbufferSet.java + + + **/MeosCbufferSmokeTest.java + + + + + + + + cbuffer-exclude-off + + CBUFFEROFF + + + + + maven-compiler-plugin + + + **/meos/MeosOpsTCbuffer.java + **/meos/MeosOpsFreeCbuffer.java + **/meos/MeosOpsCbufferSet.java + + + **/MeosCbufferSmokeTest.java + + + + + + + + cbuffer-exclude-zero + + CBUFFER0 + + + + + maven-compiler-plugin + + + **/meos/MeosOpsTCbuffer.java + **/meos/MeosOpsFreeCbuffer.java + **/meos/MeosOpsCbufferSet.java + + + **/MeosCbufferSmokeTest.java + + + + + + + + pose-exclude-unset + + !POSE + + + + + maven-compiler-plugin + + + **/meos/MeosOpsTPose.java + **/meos/MeosOpsFreePose.java + **/meos/MeosOpsPoseSet.java + + + **/MeosPoseSmokeTest.java + + + + + + + + pose-exclude-off + + POSEOFF + + + + + maven-compiler-plugin + + + **/meos/MeosOpsTPose.java + **/meos/MeosOpsFreePose.java + **/meos/MeosOpsPoseSet.java + + + **/MeosPoseSmokeTest.java + + + + + + + + pose-exclude-zero + + POSE0 + + + + + maven-compiler-plugin + + + **/meos/MeosOpsTPose.java + **/meos/MeosOpsFreePose.java + **/meos/MeosOpsPoseSet.java + + + **/MeosPoseSmokeTest.java + + + + + + + + rgeo-exclude-unset + + !RGEO + + + + + maven-compiler-plugin + + + **/meos/MeosOpsTRGeometry.java + **/meos/MeosOpsTRGeometryInst.java + **/meos/MeosOpsFreeRgeo.java + + + + + + + + rgeo-exclude-off + + RGEOOFF + + + + + maven-compiler-plugin + + + **/meos/MeosOpsTRGeometry.java + **/meos/MeosOpsTRGeometryInst.java + **/meos/MeosOpsFreeRgeo.java + + + + + + + + rgeo-exclude-zero + + RGEO0 + + + + + maven-compiler-plugin + + + **/meos/MeosOpsTRGeometry.java + **/meos/MeosOpsTRGeometryInst.java + **/meos/MeosOpsFreeRgeo.java + + + + + + + + h3-exclude-unset + + !H3 + + + + + maven-compiler-plugin + + + **/meos/MeosOpsTh3index.java + **/meos/MeosOpsFreeH3.java + + + + + + + + h3-exclude-off + + H3OFF + + + + + maven-compiler-plugin + + + **/meos/MeosOpsTh3index.java + **/meos/MeosOpsFreeH3.java + + + + + + + + h3-exclude-zero + + H30 + + + + + maven-compiler-plugin + + + **/meos/MeosOpsTh3index.java + **/meos/MeosOpsFreeH3.java + + + + + + + + npoint-exclude-off + + NPOINTOFF + + + + + maven-compiler-plugin + + + **/meos/MeosOpsTNpoint.java + **/meos/MeosOpsTNpointInst.java + **/meos/MeosOpsFreeNpoint.java + **/meos/MeosOpsNpointSet.java + + + **/MeosNpointSmokeTest.java + + + + + + + + npoint-exclude-zero + + NPOINT0 + + + + + maven-compiler-plugin + + + **/meos/MeosOpsTNpoint.java + **/meos/MeosOpsTNpointInst.java + **/meos/MeosOpsFreeNpoint.java + **/meos/MeosOpsNpointSet.java + + + **/MeosNpointSmokeTest.java + + + + + + + \ No newline at end of file diff --git a/flink-processor/src/main/java/aisdata/Main.java b/flink-processor/src/main/java/aisdata/Main.java index 148caa0..5a62273 100644 --- a/flink-processor/src/main/java/aisdata/Main.java +++ b/flink-processor/src/main/java/aisdata/Main.java @@ -56,7 +56,9 @@ public static void main(String[] args) throws Exception { // Initialize MEOS with proper error handling try { logger.info("Initializing MEOS library"); - functions.meos_initialize("UTC", errorHandler); + // JMEOS 1.4 split: no-arg meos_initialize() + separate tz + error-handler entry points + functions.meos_initialize(); + functions.meos_initialize_timezone("UTC"); final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(); diff --git a/flink-processor/src/main/java/aisdata/TrajectoryWindowFunction.java b/flink-processor/src/main/java/aisdata/TrajectoryWindowFunction.java index e047143..d5e1adb 100644 --- a/flink-processor/src/main/java/aisdata/TrajectoryWindowFunction.java +++ b/flink-processor/src/main/java/aisdata/TrajectoryWindowFunction.java @@ -31,7 +31,9 @@ public class TrajectoryWindowFunction extends public void open(Configuration parameters) throws Exception { super.open(parameters); errorHandler = new error_handler(); // Initialize error handler here - functions.meos_initialize("UTC", errorHandler); + // JMEOS 1.4 split: no-arg meos_initialize() + separate tz + error-handler entry points + functions.meos_initialize(); + functions.meos_initialize_timezone("UTC"); logger.info("MEOS initialized in TrajectoryWindowFunction.open()"); } diff --git a/flink-processor/src/main/java/berlinmod/BerlinMODBenchmark.java b/flink-processor/src/main/java/berlinmod/BerlinMODBenchmark.java new file mode 100644 index 0000000..3bd3a3a --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/BerlinMODBenchmark.java @@ -0,0 +1,153 @@ +package berlinmod; + +import org.apache.flink.api.common.eventtime.WatermarkStrategy; +import org.apache.flink.configuration.Configuration; +import org.apache.flink.streaming.api.datastream.DataStream; +import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment; +import org.apache.flink.streaming.api.functions.sink.RichSinkFunction; +import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows; +import org.apache.flink.streaming.api.windowing.time.Time; + +import java.time.Duration; +import java.util.ArrayList; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.atomic.LongAdder; +import java.util.function.Function; + +/** + * Throughput benchmark for the BerlinMOD-9 × 3-form streaming matrix. + * + *

Runs all 27 cells (9 queries × {continuous, windowed, snapshot} = 27 cells) + * on the Flink local mini-cluster, with the spatial predicates evaluating + * through MEOS (see {@link MEOSBridge}). Each cell runs its own job terminated by + * a counting sink; the harness records input events, output rows, wall-clock, + * and throughput (events per second), then prints a Markdown results table. + * + *

The corpus is either the real BerlinMOD instants ({@code --csv }) or a + * deterministic synthetic corpus ({@code --vehicles}/{@code --events}); the + * per-query parameters and the window/tick granularity are derived from the + * corpus by {@link BerlinMODCorpus}. + * + *

Usage (from {@code flink-processor/}, with an extended libmeos on the + * loader path and the Flink-on-Java-21 {@code --add-opens} flags): + * 

+ *   java … berlinmod.BerlinMODBenchmark --csv <berlinmod_instants.csv> [--max N] [--only Q3]
+ *   java … berlinmod.BerlinMODBenchmark --vehicles 50 --events 600 [--only continuous]
+ *
+ */ +public final class BerlinMODBenchmark { + + private static final ConcurrentHashMap COUNTS = new ConcurrentHashMap<>(); + + private BerlinMODBenchmark() { /* utility */ } + + public static void main(String[] args) throws Exception { + String csv = null, only = null; + int maxRows = 0, vehicles = 50, events = 600; + for (int i = 0; i < args.length; i++) { + switch (args[i]) { + case "--csv": csv = args[++i]; break; + case "--max": maxRows = Integer.parseInt(args[++i]); break; + case "--vehicles": vehicles = Integer.parseInt(args[++i]); break; + case "--events": events = Integer.parseInt(args[++i]); break; + case "--only": only = args[++i]; break; + default: break; + } + } + + List corpus = csv != null + ? BerlinMODCorpus.fromInstantsCsv(csv, maxRows) + : BerlinMODCorpus.synthetic(vehicles, events); + int n = corpus.size(); + BerlinMODCorpus.Params p = BerlinMODCorpus.derive(corpus); + System.out.printf("Corpus: %s, %d events; window=%ds tick=%dms; P=(%.5f,%.5f) targets=%d/%d/%d%n", + csv != null ? "real BerlinMOD instants" : "synthetic", + n, p.windowSeconds, p.snapshotTickMillis, p.pLon, p.pLat, p.targetId, p.xId, p.yId); + + Map, DataStream>> cells = new LinkedHashMap<>(); + cells.put("Q1-continuous", t -> t.keyBy(BerlinMODTrip::getVehicleId).process(new Q1ContinuousFunction())); + cells.put("Q1-windowed", t -> t.windowAll(tumble(p)).process(new Q1WindowedFunction())); + cells.put("Q1-snapshot", t -> t.keyBy(BerlinMODTrip::getVehicleId).process(new Q1SnapshotFunction(p.snapshotTickMillis))); + cells.put("Q2-continuous", t -> t.process(new Q2ContinuousFunction(p.targetId))); + cells.put("Q2-windowed", t -> t.windowAll(tumble(p)).process(new Q2WindowedFunction(p.targetId))); + cells.put("Q2-snapshot", t -> t.keyBy(BerlinMODTrip::getVehicleId).process(new Q2SnapshotFunction(p.targetId, p.snapshotTickMillis))); + cells.put("Q3-continuous", t -> t.process(new Q3ContinuousFunction(p.pLon, p.pLat, p.radiusMetres))); + cells.put("Q3-windowed", t -> t.windowAll(tumble(p)).process(new Q3WindowedFunction(p.pLon, p.pLat, p.radiusMetres))); + cells.put("Q3-snapshot", t -> t.keyBy(BerlinMODTrip::getVehicleId).process(new Q3SnapshotFunction(p.pLon, p.pLat, p.radiusMetres, p.snapshotTickMillis))); + cells.put("Q4-continuous", t -> t.keyBy(BerlinMODTrip::getVehicleId).process(new Q4ContinuousFunction(p.xmin, p.ymin, p.xmax, p.ymax))); + cells.put("Q4-windowed", t -> t.windowAll(tumble(p)).process(new Q4WindowedFunction(p.xmin, p.ymin, p.xmax, p.ymax))); + cells.put("Q4-snapshot", t -> t.keyBy(BerlinMODTrip::getVehicleId).process(new Q4SnapshotFunction(p.xmin, p.ymin, p.xmax, p.ymax, p.snapshotTickMillis))); + cells.put("Q5-continuous", t -> t.keyBy(x -> 0).process(new Q5ContinuousFunction(p.pLon, p.pLat, p.radiusMetres, p.dMeetMetres))); + cells.put("Q5-windowed", t -> t.windowAll(tumble(p)).process(new Q5WindowedFunction(p.pLon, p.pLat, p.radiusMetres, p.dMeetMetres))); + cells.put("Q5-snapshot", t -> t.keyBy(x -> 0).process(new Q5SnapshotFunction(p.pLon, p.pLat, p.radiusMetres, p.dMeetMetres, p.snapshotTickMillis))); + cells.put("Q6-continuous", t -> t.keyBy(BerlinMODTrip::getVehicleId).process(new Q6ContinuousFunction())); + cells.put("Q6-windowed", t -> t.keyBy(BerlinMODTrip::getVehicleId).window(tumble(p)).process(new Q6WindowedFunction())); + cells.put("Q6-snapshot", t -> t.keyBy(BerlinMODTrip::getVehicleId).process(new Q6SnapshotFunction(p.snapshotTickMillis))); + cells.put("Q7-continuous", t -> t.keyBy(BerlinMODTrip::getVehicleId).process(new Q7ContinuousFunction(p.pois))); + cells.put("Q7-windowed", t -> t.windowAll(tumble(p)).process(new Q7WindowedFunction(p.pois))); + cells.put("Q7-snapshot", t -> t.keyBy(BerlinMODTrip::getVehicleId).process(new Q7SnapshotFunction(p.pois, p.snapshotTickMillis))); + cells.put("Q8-continuous", t -> t.process(new Q8ContinuousFunction(p.s1Lon, p.s1Lat, p.s2Lon, p.s2Lat, p.radiusMetres))); + cells.put("Q8-windowed", t -> t.windowAll(tumble(p)).process(new Q8WindowedFunction(p.s1Lon, p.s1Lat, p.s2Lon, p.s2Lat, p.radiusMetres))); + cells.put("Q8-snapshot", t -> t.keyBy(BerlinMODTrip::getVehicleId).process(new Q8SnapshotFunction(p.s1Lon, p.s1Lat, p.s2Lon, p.s2Lat, p.radiusMetres, p.snapshotTickMillis))); + cells.put("Q9-continuous", t -> t.keyBy(x -> 0).process(new Q9ContinuousFunction(p.xId, p.yId))); + cells.put("Q9-windowed", t -> t.windowAll(tumble(p)).process(new Q9WindowedFunction(p.xId, p.yId))); + cells.put("Q9-snapshot", t -> t.keyBy(x -> 0).process(new Q9SnapshotFunction(p.xId, p.yId, p.snapshotTickMillis))); + + List rows = new ArrayList<>(); + for (Map.Entry, DataStream>> cell : cells.entrySet()) { + if (only != null && !cell.getKey().contains(only)) { + continue; + } + long[] r = runCell(cell.getKey(), cell.getValue(), corpus); + double secs = r[1] / 1000.0; + double tput = secs > 0 ? n / secs : 0; + rows.add(new String[]{cell.getKey(), String.valueOf(n), String.valueOf(r[0]), + String.valueOf(r[1]), String.format("%,.0f", tput)}); + System.out.printf(" %-14s out=%-8d %6d ms %,.0f ev/s%n", cell.getKey(), r[0], r[1], tput); + } + + System.out.println(); + System.out.println("| Cell | Events in | Output rows | Wall (ms) | Throughput (ev/s) |"); + System.out.println("|---|---:|---:|---:|---:|"); + for (String[] r : rows) { + System.out.printf("| %s | %s | %s | %s | %s |%n", r[0], r[1], r[2], r[3], r[4]); + } + } + + /** @return {outputRows, wallMillis} for one cell. */ + private static long[] runCell(String name, + Function, DataStream> wiring, + List corpus) throws Exception { + COUNTS.put(name, new LongAdder()); + StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(); + env.setParallelism(1); + DataStream trips = env.fromCollection(corpus) + .assignTimestampsAndWatermarks(WatermarkStrategy + .forBoundedOutOfOrderness(Duration.ofSeconds(1)) + .withTimestampAssigner((e, ts) -> e.getTimestamp())); + @SuppressWarnings("unchecked") + DataStream out = (DataStream) wiring.apply(trips); + out.addSink(new CountingSink(name)); + long t0 = System.nanoTime(); + env.execute(name); + long wall = (System.nanoTime() - t0) / 1_000_000L; + return new long[]{COUNTS.get(name).sum(), wall}; + } + + private static TumblingEventTimeWindows tumble(BerlinMODCorpus.Params p) { + return TumblingEventTimeWindows.of(Time.seconds(p.windowSeconds)); + } + + /** Counts records into the shared per-cell {@link LongAdder}. */ + private static final class CountingSink extends RichSinkFunction { + private final String cell; + CountingSink(String cell) { this.cell = cell; } + @Override public void open(Configuration cfg) { } + @Override public void invoke(Object value, Context context) { + COUNTS.get(cell).increment(); + } + } +} diff --git a/flink-processor/src/main/java/berlinmod/BerlinMODCorpus.java b/flink-processor/src/main/java/berlinmod/BerlinMODCorpus.java new file mode 100644 index 0000000..f2f9f24 --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/BerlinMODCorpus.java @@ -0,0 +1,156 @@ +package berlinmod; + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; +import org.mobilitydb.flink.meos.wirings.MeosWiringRuntime; + +import java.nio.file.Files; +import java.nio.file.Paths; +import java.time.OffsetDateTime; +import java.time.format.DateTimeFormatter; +import java.time.format.DateTimeFormatterBuilder; +import java.time.temporal.ChronoField; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.TreeSet; +import java.util.stream.Stream; + +/** + * Corpus loader and query-parameter derivation for the BerlinMOD streaming + * benchmark. + * + *

Supplies either a deterministic synthetic corpus or the real BerlinMOD + * instants corpus read from the {@code berlinmod_instants.csv} produced by the + * BerlinMOD generator. Real instants are stored in EPSG:3857; they are + * reprojected to EPSG:4326 through MEOS {@code geo_transform} at load — the + * loader holds no projection mathematics of its own. + * + *

{@link Params} fixes the per-query parameters from the corpus itself (its + * centroid, bounding box, vehicle ids, and time span) so every spatial cell is + * selective and the windowing granularity yields a comparable number of windows + * regardless of the corpus time span. + */ +public final class BerlinMODCorpus { + + private static final DateTimeFormatter TS = new DateTimeFormatterBuilder() + .appendPattern("yyyy-MM-dd HH:mm:ss") + .optionalStart().appendFraction(ChronoField.NANO_OF_SECOND, 0, 9, true).optionalEnd() + .appendOffset("+HH", "Z") + .toFormatter(); + + private BerlinMODCorpus() { /* utility */ } + + /** Query parameters derived from a corpus. */ + public static final class Params { + public final double pLon, pLat, radiusMetres, dMeetMetres; + public final double xmin, ymin, xmax, ymax; + public final double s1Lon, s1Lat, s2Lon, s2Lat; + public final List pois; + public final int targetId, xId, yId; + public final long windowSeconds, snapshotTickMillis; + + Params(double pLon, double pLat, double radiusMetres, double dMeetMetres, + double xmin, double ymin, double xmax, double ymax, + double s1Lon, double s1Lat, double s2Lon, double s2Lat, + List pois, int targetId, int xId, int yId, + long windowSeconds, long snapshotTickMillis) { + this.pLon = pLon; this.pLat = pLat; this.radiusMetres = radiusMetres; this.dMeetMetres = dMeetMetres; + this.xmin = xmin; this.ymin = ymin; this.xmax = xmax; this.ymax = ymax; + this.s1Lon = s1Lon; this.s1Lat = s1Lat; this.s2Lon = s2Lon; this.s2Lat = s2Lat; + this.pois = pois; this.targetId = targetId; this.xId = xId; this.yId = yId; + this.windowSeconds = windowSeconds; this.snapshotTickMillis = snapshotTickMillis; + } + } + + /** Deterministic synthetic corpus: vehicles on a disc around Brussels centre, + * drifting per event, with monotonically increasing timestamps. */ + public static List synthetic(int vehicles, int perVehicle) { + final double centreLon = 4.3517, centreLat = 50.8503, spread = 0.12; + final long t0 = 1_735_711_200_000L, spanMillis = 600_000L; + int total = vehicles * perVehicle; + long step = Math.max(1L, spanMillis / total); + List events = new ArrayList<>(total); + long g = 0; + for (int e = 0; e < perVehicle; e++) { + for (int v = 0; v < vehicles; v++) { + double ang = (v * 2.399963) % (2 * Math.PI); + double rad = spread * ((v % 17) / 17.0); + double drift = 0.0005 * Math.sin((e + v) * 0.13); + events.add(make(100 + v, t0 + g * step, + centreLon + rad * Math.cos(ang) + drift, + centreLat + rad * Math.sin(ang) + drift)); + g++; + } + } + return events; + } + + /** Real BerlinMOD instants from {@code berlinmod_instants.csv} + * (columns {@code tripid,vehid,day,seqno,geom,t}), reprojected 3857→4326 + * through MEOS, sorted by timestamp. {@code maxRows <= 0} loads all rows. */ + public static List fromInstantsCsv(String path, int maxRows) throws Exception { + MeosWiringRuntime.ensureInitializedOnThread(); + List events = new ArrayList<>(); + try (Stream lines = Files.lines(Paths.get(path))) { + java.util.Iterator it = lines.iterator(); + if (it.hasNext()) { + it.next(); // header + } + while (it.hasNext() && (maxRows <= 0 || events.size() < maxRows)) { + String[] f = it.next().split(","); + int vid = Integer.parseInt(f[1].trim()); + long ms = OffsetDateTime.parse(f[5].trim(), TS).toInstant().toEpochMilli(); + Pointer g4326 = GeneratedFunctions.geo_transform( + GeneratedFunctions.geom_in(f[4].trim(), -1), 4326); + String txt = GeneratedFunctions.geo_as_text(g4326, 7); // POINT(lon lat) + String[] xy = txt.substring(txt.indexOf('(') + 1, txt.indexOf(')')).trim().split("\\s+"); + events.add(make(vid, ms, Double.parseDouble(xy[0]), Double.parseDouble(xy[1]))); + } + } + events.sort((a, b) -> Long.compare(a.getTimestamp(), b.getTimestamp())); + return events; + } + + /** Derive selective per-query parameters and a window/tick granularity that + * yields ~200 windows over the corpus time span. */ + public static Params derive(List corpus) { + double sumLon = 0, sumLat = 0, minLon = Double.MAX_VALUE, minLat = Double.MAX_VALUE, + maxLon = -Double.MAX_VALUE, maxLat = -Double.MAX_VALUE, minT = Double.MAX_VALUE, maxT = -Double.MAX_VALUE; + TreeSet ids = new TreeSet<>(); + for (BerlinMODTrip t : corpus) { + sumLon += t.getLon(); sumLat += t.getLat(); + minLon = Math.min(minLon, t.getLon()); maxLon = Math.max(maxLon, t.getLon()); + minLat = Math.min(minLat, t.getLat()); maxLat = Math.max(maxLat, t.getLat()); + minT = Math.min(minT, t.getTimestamp()); maxT = Math.max(maxT, t.getTimestamp()); + ids.add(t.getVehicleId()); + } + int n = corpus.size(); + double cLon = sumLon / n, cLat = sumLat / n; + double exLon = maxLon - minLon, exLat = maxLat - minLat; + List idList = new ArrayList<>(ids); + int targetId = idList.get(idList.size() / 2); + int xId = idList.get(0); + int yId = idList.get(Math.min(idList.size() - 1, idList.size() / 2)); + long span = (long) (maxT - minT); + long windowSeconds = Math.max(1L, span / 1000 / 200); + long tickMillis = Math.max(1000L, windowSeconds * 1000L / 2); + List pois = Arrays.asList( + new PointOfInterest(1, cLon, cLat, 2_000.0), + new PointOfInterest(2, cLon + 0.1 * exLon, cLat + 0.1 * exLat, 1_000.0), + new PointOfInterest(3, cLon - 0.1 * exLon, cLat - 0.1 * exLat, 2_000.0)); + return new Params(cLon, cLat, 5_000.0, 5_000.0, + cLon - 0.25 * exLon, cLat - 0.25 * exLat, cLon + 0.25 * exLon, cLat + 0.25 * exLat, + minLon + 0.25 * exLon, cLat, maxLon - 0.25 * exLon, cLat, + pois, targetId, xId, yId, windowSeconds, tickMillis); + } + + private static BerlinMODTrip make(int vid, long t, double lon, double lat) { + BerlinMODTrip trip = new BerlinMODTrip(); + trip.setVehicleId(vid); + trip.setTimestamp(t); + trip.setLon(lon); + trip.setLat(lat); + return trip; + } +} diff --git a/flink-processor/src/main/java/berlinmod/BerlinMODDeserializationSchema.java b/flink-processor/src/main/java/berlinmod/BerlinMODDeserializationSchema.java new file mode 100644 index 0000000..a45b6d1 --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/BerlinMODDeserializationSchema.java @@ -0,0 +1,64 @@ +package berlinmod; + +import com.fasterxml.jackson.core.JsonParser; +import com.fasterxml.jackson.databind.DeserializationFeature; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import org.apache.flink.api.common.serialization.DeserializationSchema; +import org.apache.flink.api.common.typeinfo.TypeInformation; +import org.apache.flink.api.java.typeutils.TypeExtractor; + +import java.io.IOException; +import java.time.LocalDateTime; +import java.time.ZoneId; +import java.time.format.DateTimeFormatter; + +/** + * JSON → {@link BerlinMODTrip} deserializer for the Kafka {@code berlinmod} topic. + * + *

Expected JSON shape per record: + * 

+ *   { "t": "2007-05-28 06:00:00", "vehicle_id": 42, "lon": 4.36, "lat": 50.84 }
+ *
+ * + *

The timestamp format is the same {@code yyyy-MM-dd HH:mm:ss} the BerlinMOD + * generator emits in {@code generate_berlinmod_trips.sql}; we parse it as UTC + * to match the AIS pipeline's event-time convention. + */ +public class BerlinMODDeserializationSchema implements DeserializationSchema { + + private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper(); + private static final DateTimeFormatter TS_FORMATTER = + DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); + + public BerlinMODDeserializationSchema() { + OBJECT_MAPPER.configure(JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS, true); + OBJECT_MAPPER.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + } + + @Override + public BerlinMODTrip deserialize(byte[] message) throws IOException { + JsonNode node = OBJECT_MAPPER.readTree(message); + BerlinMODTrip trip = new BerlinMODTrip(); + trip.setTimestamp(parseTimestamp(node.get("t").asText())); + trip.setVehicleId(node.get("vehicle_id").asInt()); + trip.setLon(node.get("lon").asDouble()); + trip.setLat(node.get("lat").asDouble()); + return trip; + } + + private long parseTimestamp(String s) { + LocalDateTime dt = LocalDateTime.parse(s, TS_FORMATTER); + return dt.atZone(ZoneId.of("UTC")).toInstant().toEpochMilli(); + } + + @Override + public boolean isEndOfStream(BerlinMODTrip nextElement) { + return false; + } + + @Override + public TypeInformation getProducedType() { + return TypeExtractor.getForClass(BerlinMODTrip.class); + } +} diff --git a/flink-processor/src/main/java/berlinmod/BerlinMODParity.java b/flink-processor/src/main/java/berlinmod/BerlinMODParity.java new file mode 100644 index 0000000..60ac61f --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/BerlinMODParity.java @@ -0,0 +1,129 @@ +package berlinmod; + +import org.apache.flink.api.common.eventtime.WatermarkStrategy; +import org.apache.flink.api.java.tuple.Tuple3; +import org.apache.flink.configuration.Configuration; +import org.apache.flink.streaming.api.datastream.DataStream; +import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment; +import org.apache.flink.streaming.api.functions.sink.RichSinkFunction; + +import java.time.Duration; +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.ConcurrentLinkedQueue; +import java.util.function.BiPredicate; + +/** + * Snapshot-form parity check for the BerlinMOD streaming benchmark. + * + *

The streaming parity contract is that a streaming query computes the same + * result as a batch evaluation of the same MEOS predicate. This driver verifies + * it on the continuous form, which is timing-independent: the continuous form + * emits {@code predicate(event)} for every event, and a batch pass over the same + * corpus computes {@code predicate(event)} directly through the same + * {@link MEOSBridge} call. The two must agree event-for-event. + * + *

Checked queries: Q3 (within {@code d} of point {@code P}, MEOS + * {@code edwithin_tgeo_geo}) and Q8 (within {@code d} of a road segment, MEOS + * {@code edwithin_tgeo_geo} against a line). The corpus and parameters are the + * same as {@link BerlinMODBenchmark}. + * + * 

+ *   java … berlinmod.BerlinMODParity --csv <berlinmod_instants.csv> [--max N]
+ *   java … berlinmod.BerlinMODParity --vehicles 50 --events 600
+ *
+ */ +public final class BerlinMODParity { + + // Continuous-form outputs in arrival order (parallelism 1, no keyBy → stream + // order equals corpus order), so element i corresponds to corpus event i. + private static final ConcurrentLinkedQueue STREAMED = new ConcurrentLinkedQueue<>(); + + private BerlinMODParity() { /* utility */ } + + public static void main(String[] args) throws Exception { + String csv = null; + int maxRows = 0, vehicles = 50, events = 600; + for (int i = 0; i < args.length; i++) { + switch (args[i]) { + case "--csv": csv = args[++i]; break; + case "--max": maxRows = Integer.parseInt(args[++i]); break; + case "--vehicles": vehicles = Integer.parseInt(args[++i]); break; + case "--events": events = Integer.parseInt(args[++i]); break; + default: break; + } + } + List corpus = csv != null + ? BerlinMODCorpus.fromInstantsCsv(csv, maxRows) + : BerlinMODCorpus.synthetic(vehicles, events); + BerlinMODCorpus.Params p = BerlinMODCorpus.derive(corpus); + System.out.printf("Corpus: %s, %d events; P=(%.5f,%.5f) r=%.0fm%n", + csv != null ? "real BerlinMOD instants" : "synthetic", corpus.size(), + p.pLon, p.pLat, p.radiusMetres); + + MeosWiringInit(); + BiPredicate q3 = (lon, lat) -> + MEOSBridge.dwithinMetres(lon, lat, p.pLon, p.pLat, p.radiusMetres); + BiPredicate q8 = (lon, lat) -> + MEOSBridge.dwithinSegmentMetres(lon, lat, p.s1Lon, p.s1Lat, p.s2Lon, p.s2Lat, p.radiusMetres); + + List rows = new ArrayList<>(); + rows.add(check("Q3", corpus, + t -> t.process(new Q3ContinuousFunction(p.pLon, p.pLat, p.radiusMetres)), q3)); + rows.add(check("Q8", corpus, + t -> t.process(new Q8ContinuousFunction(p.s1Lon, p.s1Lat, p.s2Lon, p.s2Lat, p.radiusMetres)), q8)); + + System.out.println(); + System.out.println("| Query | Events | Streaming-true | Batch-true | Mismatches | Parity |"); + System.out.println("|---|---:|---:|---:|---:|---|"); + for (String[] r : rows) { + System.out.printf("| %s | %s | %s | %s | %s | %s |%n", r[0], r[1], r[2], r[3], r[4], r[5]); + } + } + + private static String[] check(String query, List corpus, + java.util.function.Function, DataStream>> wiring, + BiPredicate batch) throws Exception { + STREAMED.clear(); + StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(); + env.setParallelism(1); + DataStream trips = env.fromCollection(corpus) + .assignTimestampsAndWatermarks(WatermarkStrategy + .forBoundedOutOfOrderness(Duration.ofSeconds(1)) + .withTimestampAssigner((e, ts) -> e.getTimestamp())); + wiring.apply(trips).addSink(new CollectSink()); + env.execute("parity-" + query); + + Boolean[] streamed = STREAMED.toArray(new Boolean[0]); + long streamingTrue = 0, batchTrue = 0, mismatches = 0; + for (int i = 0; i < corpus.size(); i++) { + boolean expected = batch.test(corpus.get(i).getLon(), corpus.get(i).getLat()); + if (expected) { + batchTrue++; + } + if (i < streamed.length && streamed[i]) { + streamingTrue++; + } + if (i >= streamed.length || streamed[i].booleanValue() != expected) { + mismatches++; + } + } + boolean parity = mismatches == 0 && streamed.length == corpus.size(); + System.out.printf(" %s: events=%d streaming-out=%d streaming-true=%d batch-true=%d mismatches=%d parity=%s%n", + query, corpus.size(), streamed.length, streamingTrue, batchTrue, mismatches, parity ? "YES" : "NO"); + return new String[]{query, String.valueOf(corpus.size()), String.valueOf(streamingTrue), + String.valueOf(batchTrue), String.valueOf(mismatches), parity ? "exact" : "MISMATCH"}; + } + + private static void MeosWiringInit() { + org.mobilitydb.flink.meos.wirings.MeosWiringRuntime.ensureInitializedOnThread(); + } + + /** Records each continuous-form output's {@code near} flag in arrival order. */ + private static final class CollectSink extends RichSinkFunction> { + @Override public void open(Configuration cfg) { } + @Override public void invoke(Tuple3 v, Context context) { + STREAMED.add(v.f2); + } + } +} diff --git a/flink-processor/src/main/java/berlinmod/BerlinMODQ1LocalTest.java b/flink-processor/src/main/java/berlinmod/BerlinMODQ1LocalTest.java new file mode 100644 index 0000000..9218e16 --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/BerlinMODQ1LocalTest.java @@ -0,0 +1,95 @@ +package berlinmod; + +import org.apache.flink.api.common.eventtime.WatermarkStrategy; +import org.apache.flink.api.java.tuple.Tuple2; +import org.apache.flink.api.java.tuple.Tuple3; +import org.apache.flink.streaming.api.datastream.DataStream; +import org.apache.flink.streaming.api.datastream.DataStreamSource; +import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment; +import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows; +import org.apache.flink.streaming.api.windowing.time.Time; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.time.Duration; +import java.util.ArrayList; +import java.util.List; + +/** + * Local end-to-end test driver for the BerlinMOD-Q1 three streaming forms. + * + *

Same 21-event synthetic corpus as Q2/Q3 local tests. Q1 has no spatial + * predicate and no per-event filter parameter — it simply enumerates vehicles + * seen. + * + *

Expected output: + *

    + *
  • Q1-continuous: 3 lines, one per distinct vehicle (firstSeenTime)
    • + *
  • Q1-windowed: 2 windows, each with distinctCount=3
    • + *
  • Q1-snapshot: 9 lines (3 ticks × 3 vehicles all seen by source-close)
    • + *
+ */ +public class BerlinMODQ1LocalTest { + + private static final Logger LOG = LoggerFactory.getLogger(BerlinMODQ1LocalTest.class); + + private static final long WINDOW_SIZE_SECONDS = 10L; + private static final long SNAPSHOT_TICK_MILLIS = 5_000L; + private static final long T0 = 1_735_711_200_000L; + + public static void main(String[] args) throws Exception { + LOG.info("BerlinMODQ1LocalTest starting; window={}s tick={}ms", + WINDOW_SIZE_SECONDS, SNAPSHOT_TICK_MILLIS); + + StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(); + env.setParallelism(1); + + List events = buildEvents(); + DataStreamSource raw = env.fromCollection(events); + DataStream trips = raw.assignTimestampsAndWatermarks( + WatermarkStrategy + .forBoundedOutOfOrderness(Duration.ofSeconds(1)) + .withTimestampAssigner((e, t) -> e.getTimestamp())); + + DataStream> cont = trips + .keyBy(BerlinMODTrip::getVehicleId) + .process(new Q1ContinuousFunction()); + cont.print("Q1-continuous"); + + DataStream> win = trips + .windowAll(TumblingEventTimeWindows.of(Time.seconds(WINDOW_SIZE_SECONDS))) + .process(new Q1WindowedFunction()); + win.print("Q1-windowed"); + + DataStream> snap = trips + .keyBy(BerlinMODTrip::getVehicleId) + .process(new Q1SnapshotFunction(SNAPSHOT_TICK_MILLIS)); + snap.print("Q1-snapshot"); + + env.execute("BerlinMODQ1LocalTest"); + LOG.info("BerlinMODQ1LocalTest done"); + } + + private static List buildEvents() { + List events = new ArrayList<>(); + for (int i = 0; i <= 12; i += 2) { + events.add(make(100, T0 + i * 1000L, 4.3517, 50.8503)); + } + for (int i = 1; i <= 13; i += 2) { + events.add(make(200, T0 + i * 1000L, 4.3060, 50.8270)); + } + for (int i = 0; i <= 12; i += 2) { + events.add(make(300, T0 + i * 1000L, 4.2000, 50.7500)); + } + return events; + } + + private static BerlinMODTrip make(int vid, long t, double lon, double lat) { + BerlinMODTrip trip = new BerlinMODTrip(); + trip.setVehicleId(vid); + trip.setTimestamp(t); + trip.setLon(lon); + trip.setLat(lat); + return trip; + } +} diff --git a/flink-processor/src/main/java/berlinmod/BerlinMODQ2LocalTest.java b/flink-processor/src/main/java/berlinmod/BerlinMODQ2LocalTest.java new file mode 100644 index 0000000..84950c9 --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/BerlinMODQ2LocalTest.java @@ -0,0 +1,104 @@ +package berlinmod; + +import org.apache.flink.api.common.eventtime.WatermarkStrategy; +import org.apache.flink.api.java.tuple.Tuple4; +import org.apache.flink.api.java.tuple.Tuple5; +import org.apache.flink.streaming.api.datastream.DataStream; +import org.apache.flink.streaming.api.datastream.DataStreamSource; +import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment; +import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows; +import org.apache.flink.streaming.api.windowing.time.Time; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.time.Duration; +import java.util.ArrayList; +import java.util.List; + +/** + * Local end-to-end test driver for the BerlinMOD-Q2 three streaming forms. + * + *

Same structural shape as {@link BerlinMODQ3LocalTest} but exercises Q2 ("where is vehicle X + * at time T?") with {@code X = 200} (the Anderlecht vehicle). Same 3-vehicle / + * 21-event synthetic corpus. + * + *

Expected output shape (with {@code X = 200}): + *

    + *
  • Q2-continuous: 7 events (the 7 vehicle-200 events; vehicles 100 and 300 filtered out)
    • + *
  • Q2-windowed: 2 windows of size 10 s, each emitting the last vehicle-200 position seen in the window
    • + *
  • Q2-snapshot: 3 ticks × 1 emission each = 3 lines (vehicle 200's last-known position at each 5 s tick)
    • + *
+ * + *

Run after {@code mvn package} with: + * 

+ *   java -cp target/flink-kafka2postgres-1.0-SNAPSHOT.jar berlinmod.BerlinMODQ2LocalTest
+ *
+ */ +public class BerlinMODQ2LocalTest { + + private static final Logger LOG = LoggerFactory.getLogger(BerlinMODQ2LocalTest.class); + + private static final int TARGET_VEHICLE_ID = 200; + private static final long WINDOW_SIZE_SECONDS = 10L; + private static final long SNAPSHOT_TICK_MILLIS = 5_000L; + private static final long T0 = 1_735_711_200_000L; // 2025-01-01 06:00:00 UTC + + public static void main(String[] args) throws Exception { + LOG.info("BerlinMODQ2LocalTest starting; X={} window={}s tick={}ms", + TARGET_VEHICLE_ID, WINDOW_SIZE_SECONDS, SNAPSHOT_TICK_MILLIS); + + StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(); + env.setParallelism(1); // deterministic output ordering + + List events = buildEvents(); + DataStreamSource raw = env.fromCollection(events); + DataStream trips = raw.assignTimestampsAndWatermarks( + WatermarkStrategy + .forBoundedOutOfOrderness(Duration.ofSeconds(1)) + .withTimestampAssigner((e, t) -> e.getTimestamp())); + + DataStream cont = trips + .process(new Q2ContinuousFunction(TARGET_VEHICLE_ID)); + cont.map(t -> String.format("v=%d t=%d (%.4f,%.4f)", + t.getVehicleId(), t.getTimestamp(), t.getLon(), t.getLat())) + .print("Q2-continuous"); + + DataStream> win = trips + .windowAll(TumblingEventTimeWindows.of(Time.seconds(WINDOW_SIZE_SECONDS))) + .process(new Q2WindowedFunction(TARGET_VEHICLE_ID)); + win.print("Q2-windowed"); + + DataStream> snap = trips + .keyBy(BerlinMODTrip::getVehicleId) + .process(new Q2SnapshotFunction(TARGET_VEHICLE_ID, SNAPSHOT_TICK_MILLIS)); + snap.print("Q2-snapshot"); + + env.execute("BerlinMODQ2LocalTest"); + LOG.info("BerlinMODQ2LocalTest done"); + } + + private static List buildEvents() { + List events = new ArrayList<>(); + // Same synthetic corpus as Q3LocalTest, so any user can run both and + // see them work over identical inputs. + for (int i = 0; i <= 12; i += 2) { + events.add(make(100, T0 + i * 1000L, 4.3517, 50.8503)); + } + for (int i = 1; i <= 13; i += 2) { + events.add(make(200, T0 + i * 1000L, 4.3060, 50.8270)); + } + for (int i = 0; i <= 12; i += 2) { + events.add(make(300, T0 + i * 1000L, 4.2000, 50.7500)); + } + return events; + } + + private static BerlinMODTrip make(int vid, long t, double lon, double lat) { + BerlinMODTrip trip = new BerlinMODTrip(); + trip.setVehicleId(vid); + trip.setTimestamp(t); + trip.setLon(lon); + trip.setLat(lat); + return trip; + } +} diff --git a/flink-processor/src/main/java/berlinmod/BerlinMODQ2Main.java b/flink-processor/src/main/java/berlinmod/BerlinMODQ2Main.java new file mode 100644 index 0000000..c5b9220 --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/BerlinMODQ2Main.java @@ -0,0 +1,108 @@ +package berlinmod; + +import org.apache.flink.api.common.eventtime.SerializableTimestampAssigner; +import org.apache.flink.api.common.eventtime.WatermarkStrategy; +import org.apache.flink.api.common.functions.MapFunction; +import org.apache.flink.api.common.serialization.SimpleStringSchema; +import org.apache.flink.api.java.tuple.Tuple4; +import org.apache.flink.api.java.tuple.Tuple5; +import org.apache.flink.connector.kafka.source.KafkaSource; +import org.apache.flink.connector.kafka.source.enumerator.initializer.OffsetsInitializer; +import org.apache.flink.streaming.api.datastream.DataStream; +import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment; +import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows; +import org.apache.flink.streaming.api.windowing.time.Time; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.time.Duration; + +/** + * Entry point for the BerlinMOD-Q2 scaffold on MobilityFlink. + * + *

Runs the three streaming forms of BerlinMOD-Q2 ("where is vehicle X at + * time T?") side by side over the same Kafka input topic {@code berlinmod}: + *

    + *
  • {@link Q2ContinuousFunction} — emit every event of vehicle X as it arrives
    • + *
  • {@link Q2WindowedFunction} — last-known (lon, lat) of vehicle X per N-second tumbling window
    • + *
  • {@link Q2SnapshotFunction} — vehicle X's last-known (lon, lat) at each watermark tick; + * the parity-oracle form (≡ batch BerlinMOD-Q2 at the same scale factor)
    • + *
+ * + *

The queried vehicle id and other defaults match + * {@code doc/berlinmod-q3-streaming-forms.md}. The companion local test driver + * is {@link BerlinMODQ2LocalTest}. + */ +public class BerlinMODQ2Main { + + private static final Logger LOG = LoggerFactory.getLogger(BerlinMODQ2Main.class); + + // Default Q2 parameters — query vehicle 200 (Anderlecht), 10 s windows, + // 5 s snapshot tick. Matches the synthetic-corpus defaults. + private static final int TARGET_VEHICLE_ID = 200; + private static final long WINDOW_SIZE_SECONDS = 10L; + private static final long SNAPSHOT_TICK_MILLIS = 5_000L; + private static final String KAFKA_TOPIC = "berlinmod"; + private static final String KAFKA_BOOTSTRAP = "kafka:29092"; + private static final String CONSUMER_GROUP = "flink_berlinmod_q2"; + + public static void main(String[] args) throws Exception { + LOG.info("BerlinMODQ2Main starting; X={} window={}s tick={}ms", + TARGET_VEHICLE_ID, WINDOW_SIZE_SECONDS, SNAPSHOT_TICK_MILLIS); + + final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(); + + KafkaSource kafkaSource = KafkaSource.builder() + .setBootstrapServers(KAFKA_BOOTSTRAP) + .setGroupId(CONSUMER_GROUP) + .setTopics(KAFKA_TOPIC) + .setStartingOffsets(OffsetsInitializer.earliest()) + .setValueOnlyDeserializer(new SimpleStringSchema()) + .build(); + + DataStream raw = env.fromSource( + kafkaSource, WatermarkStrategy.noWatermarks(), "Kafka Source (berlinmod)"); + + DataStream trips = raw + .map(new DeserializeBerlinMODMapFunction()) + .assignTimestampsAndWatermarks( + WatermarkStrategy.forBoundedOutOfOrderness(Duration.ofSeconds(10)) + .withTimestampAssigner(new BerlinMODTimestampAssigner()) + .withIdleness(Duration.ofMinutes(1)) + ); + + // Continuous form — per-event pass-through for the queried vehicle + DataStream continuous = trips + .process(new Q2ContinuousFunction(TARGET_VEHICLE_ID)); + continuous.print("Q2-continuous"); + + // Windowed form — last-known (lon, lat) per tumbling window + DataStream> windowed = trips + .windowAll(TumblingEventTimeWindows.of(Time.seconds(WINDOW_SIZE_SECONDS))) + .process(new Q2WindowedFunction(TARGET_VEHICLE_ID)); + windowed.print("Q2-windowed"); + + // Snapshot form — keyed by vehicle, emits queried vehicle's last position at each tick + DataStream> snapshot = trips + .keyBy(BerlinMODTrip::getVehicleId) + .process(new Q2SnapshotFunction(TARGET_VEHICLE_ID, SNAPSHOT_TICK_MILLIS)); + snapshot.print("Q2-snapshot"); + + env.execute("BerlinMOD-Q2 (continuous / windowed / snapshot)"); + LOG.info("BerlinMODQ2Main done"); + } + + public static class DeserializeBerlinMODMapFunction implements MapFunction { + @Override + public BerlinMODTrip map(String value) throws Exception { + return new BerlinMODDeserializationSchema().deserialize(value.getBytes()); + } + } + + public static class BerlinMODTimestampAssigner implements SerializableTimestampAssigner { + @Override + public long extractTimestamp(BerlinMODTrip element, long recordTimestamp) { + return element.getTimestamp(); + } + } +} diff --git a/flink-processor/src/main/java/berlinmod/BerlinMODQ3LocalTest.java b/flink-processor/src/main/java/berlinmod/BerlinMODQ3LocalTest.java new file mode 100644 index 0000000..69e2022 --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/BerlinMODQ3LocalTest.java @@ -0,0 +1,114 @@ +package berlinmod; + +import org.apache.flink.api.common.eventtime.WatermarkStrategy; +import org.apache.flink.api.java.tuple.Tuple2; +import org.apache.flink.api.java.tuple.Tuple3; +import org.apache.flink.streaming.api.datastream.DataStream; +import org.apache.flink.streaming.api.datastream.DataStreamSource; +import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment; +import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows; +import org.apache.flink.streaming.api.windowing.time.Time; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.time.Duration; +import java.util.ArrayList; +import java.util.List; + +/** + * Local end-to-end test driver for the BerlinMOD-Q3 three streaming forms. + * + *

Runs the same three form functions {@link BerlinMODQ3Main} runs (continuous, + * windowed, snapshot) but reads from a hardcoded synthetic event list via + * {@code env.fromCollection(...)} instead of from Kafka. This lets the scaffold + * be verified on any machine with Java + Maven, without Docker, a Kafka broker, + * the MEOS native lib, or any JMEOS call. + * + *

Synthetic corpus: 3 vehicles, 21 events over 14 simulated seconds — + *

    + *
  • Vehicle 100 — sits on Brussels city centre {@code P}, distance 0 m, near
    • + *
  • Vehicle 200 — Anderlecht, ~4.1 km from {@code P}, near (within the 5 km radius)
    • + *
  • Vehicle 300 — Forest, ~15.4 km from {@code P}, not near (outside the 5 km radius)
    • + *
+ * + *

Expected output shape: + *

    + *
  • Q3-continuous: 21 lines, {@code near=true} for vehicles 100 and 200, {@code false} for 300
    • + *
  • Q3-windowed: 2 windows of size 10 s, each with {@code distinctCount=2} (vehicles 100 and 200)
    • + *
  • Q3-snapshot: 3 ticks × 2 near vehicles = 6 lines (vehicles 100 and 200 at each of the three 5 s ticks)
    • + *
+ * + *

Run after {@code mvn package} with: + * 

+ *   java -cp target/flink-kafka2postgres-1.0-SNAPSHOT.jar berlinmod.BerlinMODQ3LocalTest
+ *
+ */ +public class BerlinMODQ3LocalTest { + + private static final Logger LOG = LoggerFactory.getLogger(BerlinMODQ3LocalTest.class); + + private static final double P_LON = 4.3517; + private static final double P_LAT = 50.8503; + private static final double RADIUS_METRES = 5_000.0; + private static final long WINDOW_SIZE_SECONDS = 10L; + private static final long SNAPSHOT_TICK_MILLIS = 5_000L; + private static final long T0 = 1_735_711_200_000L; // 2025-01-01 06:00:00 UTC + + public static void main(String[] args) throws Exception { + LOG.info("BerlinMODQ3LocalTest starting; P=({}, {}) radius={}m window={}s tick={}ms", + P_LON, P_LAT, RADIUS_METRES, WINDOW_SIZE_SECONDS, SNAPSHOT_TICK_MILLIS); + + StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(); + env.setParallelism(1); // deterministic output ordering for the test + + List events = buildEvents(); + DataStreamSource raw = env.fromCollection(events); + DataStream trips = raw.assignTimestampsAndWatermarks( + WatermarkStrategy + .forBoundedOutOfOrderness(Duration.ofSeconds(1)) + .withTimestampAssigner((e, t) -> e.getTimestamp())); + + DataStream> cont = trips + .process(new Q3ContinuousFunction(P_LON, P_LAT, RADIUS_METRES)); + cont.print("Q3-continuous"); + + DataStream> win = trips + .windowAll(TumblingEventTimeWindows.of(Time.seconds(WINDOW_SIZE_SECONDS))) + .process(new Q3WindowedFunction(P_LON, P_LAT, RADIUS_METRES)); + win.print("Q3-windowed"); + + DataStream> snap = trips + .keyBy(BerlinMODTrip::getVehicleId) + .process(new Q3SnapshotFunction(P_LON, P_LAT, RADIUS_METRES, SNAPSHOT_TICK_MILLIS)); + snap.print("Q3-snapshot"); + + env.execute("BerlinMODQ3LocalTest"); + LOG.info("BerlinMODQ3LocalTest done"); + } + + private static List buildEvents() { + List events = new ArrayList<>(); + // Vehicle 100 — Brussels city centre (= P), 7 events at t0, t0+2s, …, t0+12s + for (int i = 0; i <= 12; i += 2) { + events.add(make(100, T0 + i * 1000L, 4.3517, 50.8503)); + } + // Vehicle 200 — Anderlecht ~4.1 km from P, 7 events at t0+1s, t0+3s, …, t0+13s + for (int i = 1; i <= 13; i += 2) { + events.add(make(200, T0 + i * 1000L, 4.3060, 50.8270)); + } + // Vehicle 300 — Forest ~15.4 km from P, 7 events at t0, t0+2s, …, t0+12s + for (int i = 0; i <= 12; i += 2) { + events.add(make(300, T0 + i * 1000L, 4.2000, 50.7500)); + } + return events; + } + + private static BerlinMODTrip make(int vid, long t, double lon, double lat) { + BerlinMODTrip trip = new BerlinMODTrip(); + trip.setVehicleId(vid); + trip.setTimestamp(t); + trip.setLon(lon); + trip.setLat(lat); + return trip; + } +} diff --git a/flink-processor/src/main/java/berlinmod/BerlinMODQ3Main.java b/flink-processor/src/main/java/berlinmod/BerlinMODQ3Main.java new file mode 100644 index 0000000..29bc518 --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/BerlinMODQ3Main.java @@ -0,0 +1,111 @@ +package berlinmod; + +import org.apache.flink.api.common.eventtime.SerializableTimestampAssigner; +import org.apache.flink.api.common.eventtime.WatermarkStrategy; +import org.apache.flink.api.common.functions.MapFunction; +import org.apache.flink.api.common.serialization.SimpleStringSchema; +import org.apache.flink.api.java.tuple.Tuple2; +import org.apache.flink.api.java.tuple.Tuple3; +import org.apache.flink.connector.kafka.source.KafkaSource; +import org.apache.flink.connector.kafka.source.enumerator.initializer.OffsetsInitializer; +import org.apache.flink.streaming.api.datastream.DataStream; +import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment; +import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows; +import org.apache.flink.streaming.api.windowing.time.Time; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.time.Duration; + +/** + * Entry point for the BerlinMOD-Q3 scaffold on MobilityFlink. + * + *

Runs the three streaming forms of BerlinMOD-Q3 side by side over the same + * Kafka input topic {@code berlinmod}: + *

    + *
  • {@link Q3ContinuousFunction} — per-event near/not-near
    • + *
  • {@link Q3WindowedFunction} — distinct-count per N-second tumbling window
    • + *
  • {@link Q3SnapshotFunction} — set of vehicles near P at each watermark tick + * (the parity-oracle form; ≡ batch BerlinMOD-Q3 at the same scale factor)
    • + *
+ * + *

Reference point P, radius {@code d}, window size and snapshot tick are + * the hardcoded defaults from the BerlinMOD-Q3 streaming-forms spec (see + * {@code doc/berlinmod-q3-streaming-forms.md}). The Kafka producer is the + * companion {@code kafka-producer/python-producer-berlinmod.py}. + */ +public class BerlinMODQ3Main { + + private static final Logger LOG = LoggerFactory.getLogger(BerlinMODQ3Main.class); + + // Default Q3 parameters — Brussels city centre, 5 km radius, 10 s windows, + // 5 s snapshot tick. Matches the defaults in the spec doc. + private static final double P_LON = 4.3517; + private static final double P_LAT = 50.8503; + private static final double RADIUS_METRES = 5_000.0; + private static final long WINDOW_SIZE_SECONDS = 10L; + private static final long SNAPSHOT_TICK_MILLIS = 5_000L; + private static final String KAFKA_TOPIC = "berlinmod"; + private static final String KAFKA_BOOTSTRAP = "kafka:29092"; + private static final String CONSUMER_GROUP = "flink_berlinmod_q3"; + + public static void main(String[] args) throws Exception { + LOG.info("BerlinMODQ3Main starting; P=({}, {}) radius={}m window={}s tick={}ms", + P_LON, P_LAT, RADIUS_METRES, WINDOW_SIZE_SECONDS, SNAPSHOT_TICK_MILLIS); + + final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(); + + KafkaSource kafkaSource = KafkaSource.builder() + .setBootstrapServers(KAFKA_BOOTSTRAP) + .setGroupId(CONSUMER_GROUP) + .setTopics(KAFKA_TOPIC) + .setStartingOffsets(OffsetsInitializer.earliest()) + .setValueOnlyDeserializer(new SimpleStringSchema()) + .build(); + + DataStream raw = env.fromSource( + kafkaSource, WatermarkStrategy.noWatermarks(), "Kafka Source (berlinmod)"); + + DataStream trips = raw + .map(new DeserializeBerlinMODMapFunction()) + .assignTimestampsAndWatermarks( + WatermarkStrategy.forBoundedOutOfOrderness(Duration.ofSeconds(10)) + .withTimestampAssigner(new BerlinMODTimestampAssigner()) + .withIdleness(Duration.ofMinutes(1)) + ); + + // Continuous form — per-event near/not-near + DataStream> continuous = trips + .process(new Q3ContinuousFunction(P_LON, P_LAT, RADIUS_METRES)); + continuous.print("Q3-continuous"); + + // Windowed form — distinct count per tumbling window + DataStream> windowed = trips + .windowAll(TumblingEventTimeWindows.of(Time.seconds(WINDOW_SIZE_SECONDS))) + .process(new Q3WindowedFunction(P_LON, P_LAT, RADIUS_METRES)); + windowed.print("Q3-windowed"); + + // Snapshot form — keyed by vehicle, emits set of vehicles near P at each tick + DataStream> snapshot = trips + .keyBy(BerlinMODTrip::getVehicleId) + .process(new Q3SnapshotFunction(P_LON, P_LAT, RADIUS_METRES, SNAPSHOT_TICK_MILLIS)); + snapshot.print("Q3-snapshot"); + + env.execute("BerlinMOD-Q3 (continuous / windowed / snapshot)"); + LOG.info("BerlinMODQ3Main done"); + } + + public static class DeserializeBerlinMODMapFunction implements MapFunction { + @Override + public BerlinMODTrip map(String value) throws Exception { + return new BerlinMODDeserializationSchema().deserialize(value.getBytes()); + } + } + + public static class BerlinMODTimestampAssigner implements SerializableTimestampAssigner { + @Override + public long extractTimestamp(BerlinMODTrip element, long recordTimestamp) { + return element.getTimestamp(); + } + } +} diff --git a/flink-processor/src/main/java/berlinmod/BerlinMODQ4LocalTest.java b/flink-processor/src/main/java/berlinmod/BerlinMODQ4LocalTest.java new file mode 100644 index 0000000..428e7fc --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/BerlinMODQ4LocalTest.java @@ -0,0 +1,130 @@ +package berlinmod; + +import org.apache.flink.api.common.eventtime.WatermarkStrategy; +import org.apache.flink.api.java.tuple.Tuple2; +import org.apache.flink.api.java.tuple.Tuple3; +import org.apache.flink.api.java.tuple.Tuple4; +import org.apache.flink.streaming.api.datastream.DataStream; +import org.apache.flink.streaming.api.datastream.DataStreamSource; +import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment; +import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows; +import org.apache.flink.streaming.api.windowing.time.Time; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.time.Duration; +import java.util.ArrayList; +import java.util.List; + +/** + * Local end-to-end test driver for the BerlinMOD-Q4 three streaming forms. + * + *

Region R = bounding box {@code (4.30, 50.84, 4.36, 50.86)} — a rectangle + * around Brussels city centre. The synthetic corpus is designed to produce + * multiple outside → inside transitions so the entry-detection logic + * is exercised non-trivially: + * + *

    + *
  • Vehicle 100 sits inside R for all 7 events (no transitions).
    • + *
  • Vehicle 200 oscillates: outside at t=1, inside at t=3 (entry), + * outside at t=5, inside at t=7 (entry), outside at t=9, inside at + * t=11 (entry), outside at t=13 → three entries.
    • + *
  • Vehicle 300 stays in Forest (outside R) for all 7 events.
    • + *
+ * + *

Expected output: + *

    + *
  • Q4-continuous: 3 entries (v200's three outside → inside transitions)
    • + *
  • Q4-windowed: per the intra-window scoping convention — window + * [0, 10 s) contains v100's first-seen-inside event AND v200's two entries + * (t=3, t=7); window [10, 20 s) contains v100's first-event-in-window + * AND v200's third entry (t=11). 5 emissions total.
    • + *
  • Q4-snapshot: cumulative entries up to each tick. Tick 5: 1 + * (v200 t=3). Tick 10: 2 (v200 t=3, t=7). Tick 15: 3 (v200 t=3, t=7, + * t=11). v100 contributes 0 (always inside, no transition). v300 + * contributes 0. 6 emissions total (1+2+3).
    • + *
+ */ +public class BerlinMODQ4LocalTest { + + private static final Logger LOG = LoggerFactory.getLogger(BerlinMODQ4LocalTest.class); + + // Region R — Brussels centre rectangle + private static final double XMIN = 4.30; + private static final double YMIN = 50.84; + private static final double XMAX = 4.36; + private static final double YMAX = 50.86; + + private static final long WINDOW_SIZE_SECONDS = 10L; + private static final long SNAPSHOT_TICK_MILLIS = 5_000L; + private static final long T0 = 1_735_711_200_000L; + + public static void main(String[] args) throws Exception { + LOG.info("BerlinMODQ4LocalTest starting; R=({},{},{},{}) window={}s tick={}ms", + XMIN, YMIN, XMAX, YMAX, WINDOW_SIZE_SECONDS, SNAPSHOT_TICK_MILLIS); + + StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(); + env.setParallelism(1); + + List events = buildEvents(); + DataStreamSource raw = env.fromCollection(events); + DataStream trips = raw.assignTimestampsAndWatermarks( + WatermarkStrategy + .forBoundedOutOfOrderness(Duration.ofSeconds(1)) + .withTimestampAssigner((e, t) -> e.getTimestamp())); + + DataStream> cont = trips + .keyBy(BerlinMODTrip::getVehicleId) + .process(new Q4ContinuousFunction(XMIN, YMIN, XMAX, YMAX)); + cont.print("Q4-continuous"); + + DataStream> win = trips + .windowAll(TumblingEventTimeWindows.of(Time.seconds(WINDOW_SIZE_SECONDS))) + .process(new Q4WindowedFunction(XMIN, YMIN, XMAX, YMAX)); + win.print("Q4-windowed"); + + DataStream> snap = trips + .keyBy(BerlinMODTrip::getVehicleId) + .process(new Q4SnapshotFunction(XMIN, YMIN, XMAX, YMAX, SNAPSHOT_TICK_MILLIS)); + snap.print("Q4-snapshot"); + + env.execute("BerlinMODQ4LocalTest"); + LOG.info("BerlinMODQ4LocalTest done"); + } + + private static List buildEvents() { + List events = new ArrayList<>(); + // v100 always inside R + for (int i = 0; i <= 12; i += 2) { + events.add(make(100, T0 + i * 1000L, 4.3517, 50.8503)); + } + // v200 oscillates in/out: out, IN, out, IN, out, IN, out + double[][] v200Path = { + {4.3060, 50.8270}, // t=1 out (lat<50.84) + {4.3060, 50.8500}, // t=3 IN + {4.3060, 50.8300}, // t=5 out + {4.3060, 50.8500}, // t=7 IN + {4.3060, 50.8100}, // t=9 out + {4.3060, 50.8500}, // t=11 IN + {4.3060, 50.8300}, // t=13 out + }; + int idx = 0; + for (int i = 1; i <= 13; i += 2, idx++) { + events.add(make(200, T0 + i * 1000L, v200Path[idx][0], v200Path[idx][1])); + } + // v300 always outside R + for (int i = 0; i <= 12; i += 2) { + events.add(make(300, T0 + i * 1000L, 4.2000, 50.7500)); + } + return events; + } + + private static BerlinMODTrip make(int vid, long t, double lon, double lat) { + BerlinMODTrip trip = new BerlinMODTrip(); + trip.setVehicleId(vid); + trip.setTimestamp(t); + trip.setLon(lon); + trip.setLat(lat); + return trip; + } +} diff --git a/flink-processor/src/main/java/berlinmod/BerlinMODQ5LocalTest.java b/flink-processor/src/main/java/berlinmod/BerlinMODQ5LocalTest.java new file mode 100644 index 0000000..394932d --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/BerlinMODQ5LocalTest.java @@ -0,0 +1,109 @@ +package berlinmod; + +import org.apache.flink.api.common.eventtime.WatermarkStrategy; +import org.apache.flink.api.java.tuple.Tuple4; +import org.apache.flink.api.java.tuple.Tuple5; +import org.apache.flink.streaming.api.datastream.DataStream; +import org.apache.flink.streaming.api.datastream.DataStreamSource; +import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment; +import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows; +import org.apache.flink.streaming.api.windowing.time.Time; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.time.Duration; +import java.util.ArrayList; +import java.util.List; + +/** + * Local end-to-end test driver for the BerlinMOD-Q5 three streaming forms. + * + *

Same stationary-vehicle corpus as Q1/Q2/Q3/Q9. Reference point P = + * Brussels city centre (4.3517, 50.8503); {@code dP = 5 km} (vehicle near P); + * {@code dMeet = 5 km} (pair-meeting threshold). + * + *

Pairs: + *

    + *
  • (100, 200) — both near P; distance 4.1 km ≤ dMeet → MEET
    • + *
  • (100, 300) — v300 not near P → don't qualify
    • + *
  • (200, 300) — v300 not near P → don't qualify
    • + *
+ * + *

Expected output (only the (100, 200) pair qualifies): + *

    + *
  • Q5-continuous: pair (100, 200) emits on every event from t=1 + * onward (the first t=0 events of v100 and v300 happen before v200 is + * known, so no pair exists yet). 21 - 2 = 19 emissions.
    • + *
  • Q5-windowed: each of the two 10-second windows contains + * events for v100 and v200 — both qualify, the pair meets. 2 emissions.
    • + *
  • Q5-snapshot: 3 ticks × 1 meeting pair = 3 emissions.
    • + *
+ */ +public class BerlinMODQ5LocalTest { + + private static final Logger LOG = LoggerFactory.getLogger(BerlinMODQ5LocalTest.class); + + private static final double P_LON = 4.3517; + private static final double P_LAT = 50.8503; + private static final double D_P_METRES = 5_000.0; + private static final double D_MEET_METRES = 5_000.0; + private static final long WINDOW_SIZE_SECONDS = 10L; + private static final long SNAPSHOT_TICK_MILLIS = 5_000L; + private static final long T0 = 1_735_711_200_000L; + + public static void main(String[] args) throws Exception { + LOG.info("BerlinMODQ5LocalTest starting; P=({}, {}) dP={}m dMeet={}m", + P_LON, P_LAT, D_P_METRES, D_MEET_METRES); + + StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(); + env.setParallelism(1); + + List events = buildEvents(); + DataStreamSource raw = env.fromCollection(events); + DataStream trips = raw.assignTimestampsAndWatermarks( + WatermarkStrategy + .forBoundedOutOfOrderness(Duration.ofSeconds(1)) + .withTimestampAssigner((e, t) -> e.getTimestamp())); + + DataStream> cont = trips + .keyBy(t -> 0) + .process(new Q5ContinuousFunction(P_LON, P_LAT, D_P_METRES, D_MEET_METRES)); + cont.print("Q5-continuous"); + + DataStream> win = trips + .windowAll(TumblingEventTimeWindows.of(Time.seconds(WINDOW_SIZE_SECONDS))) + .process(new Q5WindowedFunction(P_LON, P_LAT, D_P_METRES, D_MEET_METRES)); + win.print("Q5-windowed"); + + DataStream> snap = trips + .keyBy(t -> 0) + .process(new Q5SnapshotFunction(P_LON, P_LAT, D_P_METRES, D_MEET_METRES, SNAPSHOT_TICK_MILLIS)); + snap.print("Q5-snapshot"); + + env.execute("BerlinMODQ5LocalTest"); + LOG.info("BerlinMODQ5LocalTest done"); + } + + private static List buildEvents() { + List events = new ArrayList<>(); + for (int i = 0; i <= 12; i += 2) { + events.add(make(100, T0 + i * 1000L, 4.3517, 50.8503)); + } + for (int i = 1; i <= 13; i += 2) { + events.add(make(200, T0 + i * 1000L, 4.3060, 50.8270)); + } + for (int i = 0; i <= 12; i += 2) { + events.add(make(300, T0 + i * 1000L, 4.2000, 50.7500)); + } + return events; + } + + private static BerlinMODTrip make(int vid, long t, double lon, double lat) { + BerlinMODTrip trip = new BerlinMODTrip(); + trip.setVehicleId(vid); + trip.setTimestamp(t); + trip.setLon(lon); + trip.setLat(lat); + return trip; + } +} diff --git a/flink-processor/src/main/java/berlinmod/BerlinMODQ6LocalTest.java b/flink-processor/src/main/java/berlinmod/BerlinMODQ6LocalTest.java new file mode 100644 index 0000000..6a6fd2b --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/BerlinMODQ6LocalTest.java @@ -0,0 +1,121 @@ +package berlinmod; + +import org.apache.flink.api.common.eventtime.WatermarkStrategy; +import org.apache.flink.api.java.tuple.Tuple3; +import org.apache.flink.api.java.tuple.Tuple4; +import org.apache.flink.streaming.api.datastream.DataStream; +import org.apache.flink.streaming.api.datastream.DataStreamSource; +import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment; +import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows; +import org.apache.flink.streaming.api.windowing.time.Time; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.time.Duration; +import java.util.ArrayList; +import java.util.List; + +/** + * Local end-to-end test driver for the BerlinMOD-Q6 three streaming forms. + * + *

Unlike Q1/Q2/Q3 which use a stationary-vehicles corpus, Q6 needs vehicles + * that actually move so the cumulative-distance arithmetic produces non-zero + * output. The synthetic corpus here drifts each vehicle by a fixed bearing + * per event: + * + *

    + *
  • Vehicle 100 drifts east ~100 m per 2 s event (0.001423° lon at lat 50.85)
    • + *
  • Vehicle 200 drifts south ~50 m per 2 s event (0.000450° lat)
    • + *
  • Vehicle 300 drifts west ~200 m per 2 s event (0.002846° lon)
    • + *
+ * + *

With 7 events per vehicle (6 inter-event steps), per-vehicle totals are + * approximately: + * + *

    + *
  • v100: 6 × 100 m = 600 m
    • + *
  • v200: 6 × 50 m = 300 m
    • + *
  • v300: 6 × 200 m = 1200 m
    • + *
+ * + *

Expected output: + * + *

    + *
  • Q6-continuous: 21 lines, cumulative metres rising monotonically per vehicle
    • + *
  • Q6-windowed: 6 windowed emissions (2 windows × 3 vehicles)
    • + *
  • Q6-snapshot: 9 emissions (3 ticks × 3 vehicles, all-source-closed)
    • + *
+ */ +public class BerlinMODQ6LocalTest { + + private static final Logger LOG = LoggerFactory.getLogger(BerlinMODQ6LocalTest.class); + + private static final long WINDOW_SIZE_SECONDS = 10L; + private static final long SNAPSHOT_TICK_MILLIS = 5_000L; + private static final long T0 = 1_735_711_200_000L; + + // Drift per event step + private static final double V100_DLON = 100.0 / (111_000.0 * Math.cos(Math.toRadians(50.85))); + private static final double V200_DLAT = -50.0 / 111_000.0; + private static final double V300_DLON = -200.0 / (111_000.0 * Math.cos(Math.toRadians(50.85))); + + public static void main(String[] args) throws Exception { + LOG.info("BerlinMODQ6LocalTest starting; window={}s tick={}ms", + WINDOW_SIZE_SECONDS, SNAPSHOT_TICK_MILLIS); + + StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(); + env.setParallelism(1); + + List events = buildEvents(); + DataStreamSource raw = env.fromCollection(events); + DataStream trips = raw.assignTimestampsAndWatermarks( + WatermarkStrategy + .forBoundedOutOfOrderness(Duration.ofSeconds(1)) + .withTimestampAssigner((e, t) -> e.getTimestamp())); + + DataStream> cont = trips + .keyBy(BerlinMODTrip::getVehicleId) + .process(new Q6ContinuousFunction()); + cont.print("Q6-continuous"); + + DataStream> win = trips + .keyBy(BerlinMODTrip::getVehicleId) + .window(TumblingEventTimeWindows.of(Time.seconds(WINDOW_SIZE_SECONDS))) + .process(new Q6WindowedFunction()); + win.print("Q6-windowed"); + + DataStream> snap = trips + .keyBy(BerlinMODTrip::getVehicleId) + .process(new Q6SnapshotFunction(SNAPSHOT_TICK_MILLIS)); + snap.print("Q6-snapshot"); + + env.execute("BerlinMODQ6LocalTest"); + LOG.info("BerlinMODQ6LocalTest done"); + } + + private static List buildEvents() { + List events = new ArrayList<>(); + int step = 0; + for (int i = 0; i <= 12; i += 2, step++) { + events.add(make(100, T0 + i * 1000L, 4.3517 + step * V100_DLON, 50.8503)); + } + step = 0; + for (int i = 1; i <= 13; i += 2, step++) { + events.add(make(200, T0 + i * 1000L, 4.3060, 50.8270 + step * V200_DLAT)); + } + step = 0; + for (int i = 0; i <= 12; i += 2, step++) { + events.add(make(300, T0 + i * 1000L, 4.2000 + step * V300_DLON, 50.7500)); + } + return events; + } + + private static BerlinMODTrip make(int vid, long t, double lon, double lat) { + BerlinMODTrip trip = new BerlinMODTrip(); + trip.setVehicleId(vid); + trip.setTimestamp(t); + trip.setLon(lon); + trip.setLat(lat); + return trip; + } +} diff --git a/flink-processor/src/main/java/berlinmod/BerlinMODQ7LocalTest.java b/flink-processor/src/main/java/berlinmod/BerlinMODQ7LocalTest.java new file mode 100644 index 0000000..e7560c8 --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/BerlinMODQ7LocalTest.java @@ -0,0 +1,116 @@ +package berlinmod; + +import org.apache.flink.api.common.eventtime.WatermarkStrategy; +import org.apache.flink.api.java.tuple.Tuple3; +import org.apache.flink.api.java.tuple.Tuple4; +import org.apache.flink.api.java.tuple.Tuple5; +import org.apache.flink.streaming.api.datastream.DataStream; +import org.apache.flink.streaming.api.datastream.DataStreamSource; +import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment; +import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows; +import org.apache.flink.streaming.api.windowing.time.Time; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.time.Duration; +import java.util.Arrays; +import java.util.ArrayList; +import java.util.List; + +/** + * Local end-to-end test driver for the BerlinMOD-Q7 three streaming forms. + * + *

Same stationary-vehicle corpus as Q1/Q2/Q3/Q5/Q9. POI list: + *

    + *
  • POI 1 = Brussels city centre (4.3517, 50.8503), radius 2000 m
    • + *
  • POI 2 = Anderlecht (4.3060, 50.8270), radius 1000 m
    • + *
  • POI 3 = south of Brussels (4.2100, 50.7600), radius 2000 m
    • + *
+ * + *

Per (vehicle, POI) match-up: + *

    + *
  • v100 is inside POI 1 (0 m), outside POI 2 (~4.1 km) and POI 3 (~13 km)
    • + *
  • v200 is inside POI 2 (0 m), outside POI 1 and POI 3
    • + *
  • v300 is inside POI 3 (~1.3 km), outside POI 1 and POI 2
    • + *
+ * + *

Expected output: + *

    + *
  • Q7-continuous: 3 emissions — first-passages on each vehicle's + * very first event (v100 t=0 → POI 1; v200 t=1 → POI 2; v300 t=0 → + * POI 3)
    • + *
  • Q7-windowed: per-window intra-window first-passages — + * window [0, 10 s) sees all 3 first-passages; window [10, 20 s) sees + * all 3 again (intra-window scoping has no cross-window memory). 6 lines.
    • + *
  • Q7-snapshot: 3 ticks × 3 cumulative (vehicle, POI) first-passages = 9 lines
    • + *
+ */ +public class BerlinMODQ7LocalTest { + + private static final Logger LOG = LoggerFactory.getLogger(BerlinMODQ7LocalTest.class); + + private static final long WINDOW_SIZE_SECONDS = 10L; + private static final long SNAPSHOT_TICK_MILLIS = 5_000L; + private static final long T0 = 1_735_711_200_000L; + + private static final List POIS = Arrays.asList( + new PointOfInterest(1, 4.3517, 50.8503, 2_000.0), + new PointOfInterest(2, 4.3060, 50.8270, 1_000.0), + new PointOfInterest(3, 4.2100, 50.7600, 2_000.0)); + + public static void main(String[] args) throws Exception { + LOG.info("BerlinMODQ7LocalTest starting; #POIs={} window={}s tick={}ms", + POIS.size(), WINDOW_SIZE_SECONDS, SNAPSHOT_TICK_MILLIS); + + StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(); + env.setParallelism(1); + + List events = buildEvents(); + DataStreamSource raw = env.fromCollection(events); + DataStream trips = raw.assignTimestampsAndWatermarks( + WatermarkStrategy + .forBoundedOutOfOrderness(Duration.ofSeconds(1)) + .withTimestampAssigner((e, t) -> e.getTimestamp())); + + DataStream> cont = trips + .keyBy(BerlinMODTrip::getVehicleId) + .process(new Q7ContinuousFunction(POIS)); + cont.print("Q7-continuous"); + + DataStream> win = trips + .windowAll(TumblingEventTimeWindows.of(Time.seconds(WINDOW_SIZE_SECONDS))) + .process(new Q7WindowedFunction(POIS)); + win.print("Q7-windowed"); + + DataStream> snap = trips + .keyBy(BerlinMODTrip::getVehicleId) + .process(new Q7SnapshotFunction(POIS, SNAPSHOT_TICK_MILLIS)); + snap.print("Q7-snapshot"); + + env.execute("BerlinMODQ7LocalTest"); + LOG.info("BerlinMODQ7LocalTest done"); + } + + private static List buildEvents() { + List events = new ArrayList<>(); + for (int i = 0; i <= 12; i += 2) { + events.add(make(100, T0 + i * 1000L, 4.3517, 50.8503)); + } + for (int i = 1; i <= 13; i += 2) { + events.add(make(200, T0 + i * 1000L, 4.3060, 50.8270)); + } + for (int i = 0; i <= 12; i += 2) { + events.add(make(300, T0 + i * 1000L, 4.2000, 50.7500)); + } + return events; + } + + private static BerlinMODTrip make(int vid, long t, double lon, double lat) { + BerlinMODTrip trip = new BerlinMODTrip(); + trip.setVehicleId(vid); + trip.setTimestamp(t); + trip.setLon(lon); + trip.setLat(lat); + return trip; + } +} diff --git a/flink-processor/src/main/java/berlinmod/BerlinMODQ8LocalTest.java b/flink-processor/src/main/java/berlinmod/BerlinMODQ8LocalTest.java new file mode 100644 index 0000000..9dc6709 --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/BerlinMODQ8LocalTest.java @@ -0,0 +1,107 @@ +package berlinmod; + +import org.apache.flink.api.common.eventtime.WatermarkStrategy; +import org.apache.flink.api.java.tuple.Tuple2; +import org.apache.flink.api.java.tuple.Tuple3; +import org.apache.flink.streaming.api.datastream.DataStream; +import org.apache.flink.streaming.api.datastream.DataStreamSource; +import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment; +import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows; +import org.apache.flink.streaming.api.windowing.time.Time; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.time.Duration; +import java.util.ArrayList; +import java.util.List; + +/** + * Local end-to-end test driver for the BerlinMOD-Q8 three streaming forms. + * + *

Same stationary-vehicle corpus as the other Qs. Road segment runs + * from (4.30, 50.83) to (4.36, 50.87) — a diagonal across the Brussels- + * centre region. With a {@code d = 5 km} proximity threshold: + * + *

    + *
  • v100 at (4.3517, 50.8503) — ~1.1 km from segment → near
    • + *
  • v200 at (4.3060, 50.8270) — ~0.5 km from segment → near
    • + *
  • v300 at (4.2000, 50.7500) — ~13 km from segment → not near
    • + *
+ * + *

Expected output shape: + *

    + *
  • Q8-continuous: 21 events (14 near=true for v100/v200, 7 near=false for v300)
    • + *
  • Q8-windowed: 2 windows, each with {@code distinctCount=2} (vehicles 100 and 200)
    • + *
  • Q8-snapshot: 3 ticks × 2 near vehicles = 6 emissions
    • + *
+ * + *

Same shape as Q3 with a segment-distance predicate substituted for the + * point-radius one — the algebraic pattern parity intentional. + */ +public class BerlinMODQ8LocalTest { + + private static final Logger LOG = LoggerFactory.getLogger(BerlinMODQ8LocalTest.class); + + // Road segment endpoints + private static final double S1_LON = 4.30, S1_LAT = 50.83; + private static final double S2_LON = 4.36, S2_LAT = 50.87; + private static final double RADIUS_METRES = 5_000.0; + private static final long WINDOW_SIZE_SECONDS = 10L; + private static final long SNAPSHOT_TICK_MILLIS = 5_000L; + private static final long T0 = 1_735_711_200_000L; + + public static void main(String[] args) throws Exception { + LOG.info("BerlinMODQ8LocalTest starting; segment=({},{}) → ({},{}) d={}m", + S1_LON, S1_LAT, S2_LON, S2_LAT, RADIUS_METRES); + + StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(); + env.setParallelism(1); + + List events = buildEvents(); + DataStreamSource raw = env.fromCollection(events); + DataStream trips = raw.assignTimestampsAndWatermarks( + WatermarkStrategy + .forBoundedOutOfOrderness(Duration.ofSeconds(1)) + .withTimestampAssigner((e, t) -> e.getTimestamp())); + + DataStream> cont = trips + .process(new Q8ContinuousFunction(S1_LON, S1_LAT, S2_LON, S2_LAT, RADIUS_METRES)); + cont.print("Q8-continuous"); + + DataStream> win = trips + .windowAll(TumblingEventTimeWindows.of(Time.seconds(WINDOW_SIZE_SECONDS))) + .process(new Q8WindowedFunction(S1_LON, S1_LAT, S2_LON, S2_LAT, RADIUS_METRES)); + win.print("Q8-windowed"); + + DataStream> snap = trips + .keyBy(BerlinMODTrip::getVehicleId) + .process(new Q8SnapshotFunction(S1_LON, S1_LAT, S2_LON, S2_LAT, RADIUS_METRES, SNAPSHOT_TICK_MILLIS)); + snap.print("Q8-snapshot"); + + env.execute("BerlinMODQ8LocalTest"); + LOG.info("BerlinMODQ8LocalTest done"); + } + + private static List buildEvents() { + List events = new ArrayList<>(); + for (int i = 0; i <= 12; i += 2) { + events.add(make(100, T0 + i * 1000L, 4.3517, 50.8503)); + } + for (int i = 1; i <= 13; i += 2) { + events.add(make(200, T0 + i * 1000L, 4.3060, 50.8270)); + } + for (int i = 0; i <= 12; i += 2) { + events.add(make(300, T0 + i * 1000L, 4.2000, 50.7500)); + } + return events; + } + + private static BerlinMODTrip make(int vid, long t, double lon, double lat) { + BerlinMODTrip trip = new BerlinMODTrip(); + trip.setVehicleId(vid); + trip.setTimestamp(t); + trip.setLon(lon); + trip.setLat(lat); + return trip; + } +} diff --git a/flink-processor/src/main/java/berlinmod/BerlinMODQ9LocalTest.java b/flink-processor/src/main/java/berlinmod/BerlinMODQ9LocalTest.java new file mode 100644 index 0000000..f990031 --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/BerlinMODQ9LocalTest.java @@ -0,0 +1,107 @@ +package berlinmod; + +import org.apache.flink.api.common.eventtime.WatermarkStrategy; +import org.apache.flink.api.java.tuple.Tuple2; +import org.apache.flink.api.java.tuple.Tuple3; +import org.apache.flink.streaming.api.datastream.DataStream; +import org.apache.flink.streaming.api.datastream.DataStreamSource; +import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment; +import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows; +import org.apache.flink.streaming.api.windowing.time.Time; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.time.Duration; +import java.util.ArrayList; +import java.util.List; + +/** + * Local end-to-end test driver for the BerlinMOD-Q9 three streaming forms. + * + *

Same stationary-vehicle synthetic corpus as Q1/Q2/Q3 (3 vehicles, 21 + * events). Queried pair X = 100 (Brussels city centre), Y = 200 (Anderlecht); + * their actual distance is ~4.1 km — the expected output for every emission. + * + *

Expected output: + *

    + *
  • Q9-continuous: 13 lines — emitted whenever either X or Y has + * a new event AND the other has been seen at least once. v100 fires + * first at t=0; v200's first event at t=1 produces the first paired + * emission; subsequent 12 events (alternating) each produce one + * emission.
    • + *
  • Q9-windowed: 2 windows — both contain X and Y events, each + * emits the X-Y distance using last seen-in-window positions.
    • + *
  • Q9-snapshot: 3 ticks × 1 emission each = 3 lines.
    • + *
+ */ +public class BerlinMODQ9LocalTest { + + private static final Logger LOG = LoggerFactory.getLogger(BerlinMODQ9LocalTest.class); + + private static final int X_VEHICLE_ID = 100; + private static final int Y_VEHICLE_ID = 200; + private static final long WINDOW_SIZE_SECONDS = 10L; + private static final long SNAPSHOT_TICK_MILLIS = 5_000L; + private static final long T0 = 1_735_711_200_000L; + + public static void main(String[] args) throws Exception { + LOG.info("BerlinMODQ9LocalTest starting; X={} Y={} window={}s tick={}ms", + X_VEHICLE_ID, Y_VEHICLE_ID, WINDOW_SIZE_SECONDS, SNAPSHOT_TICK_MILLIS); + + StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(); + env.setParallelism(1); + + List events = buildEvents(); + DataStreamSource raw = env.fromCollection(events); + DataStream trips = raw.assignTimestampsAndWatermarks( + WatermarkStrategy + .forBoundedOutOfOrderness(Duration.ofSeconds(1)) + .withTimestampAssigner((e, t) -> e.getTimestamp())); + + // Pre-filter to {X, Y} and key by a constant so the shared X+Y state + // lives in a single subtask. + DataStream xy = trips + .filter(t -> t.getVehicleId() == X_VEHICLE_ID || t.getVehicleId() == Y_VEHICLE_ID); + + DataStream> cont = xy + .keyBy(t -> 0) + .process(new Q9ContinuousFunction(X_VEHICLE_ID, Y_VEHICLE_ID)); + cont.print("Q9-continuous"); + + DataStream> win = xy + .windowAll(TumblingEventTimeWindows.of(Time.seconds(WINDOW_SIZE_SECONDS))) + .process(new Q9WindowedFunction(X_VEHICLE_ID, Y_VEHICLE_ID)); + win.print("Q9-windowed"); + + DataStream> snap = xy + .keyBy(t -> 0) + .process(new Q9SnapshotFunction(X_VEHICLE_ID, Y_VEHICLE_ID, SNAPSHOT_TICK_MILLIS)); + snap.print("Q9-snapshot"); + + env.execute("BerlinMODQ9LocalTest"); + LOG.info("BerlinMODQ9LocalTest done"); + } + + private static List buildEvents() { + List events = new ArrayList<>(); + for (int i = 0; i <= 12; i += 2) { + events.add(make(100, T0 + i * 1000L, 4.3517, 50.8503)); + } + for (int i = 1; i <= 13; i += 2) { + events.add(make(200, T0 + i * 1000L, 4.3060, 50.8270)); + } + for (int i = 0; i <= 12; i += 2) { + events.add(make(300, T0 + i * 1000L, 4.2000, 50.7500)); + } + return events; + } + + private static BerlinMODTrip make(int vid, long t, double lon, double lat) { + BerlinMODTrip trip = new BerlinMODTrip(); + trip.setVehicleId(vid); + trip.setTimestamp(t); + trip.setLon(lon); + trip.setLat(lat); + return trip; + } +} diff --git a/flink-processor/src/main/java/berlinmod/BerlinMODTrip.java b/flink-processor/src/main/java/berlinmod/BerlinMODTrip.java new file mode 100644 index 0000000..6eb8e80 --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/BerlinMODTrip.java @@ -0,0 +1,48 @@ +package berlinmod; + +/** + * Plain data class for a single GPS event from a BerlinMOD trip. + * + *

Matches the {@code aisdata.AISData} field set but uses the BerlinMOD vehicle + * identifier {@code vehicleId} instead of an AIS {@code mmsi} and drops the + * AIS-specific {@code speed}/{@code course} channels (BerlinMOD's generator + * does not export those for the streaming form). + */ +public class BerlinMODTrip { + private long timestamp; // epoch milliseconds (event time) + private int vehicleId; + private double lon; + private double lat; + + public long getTimestamp() { + return timestamp; + } + + public void setTimestamp(long timestamp) { + this.timestamp = timestamp; + } + + public int getVehicleId() { + return vehicleId; + } + + public void setVehicleId(int vehicleId) { + this.vehicleId = vehicleId; + } + + public double getLon() { + return lon; + } + + public void setLon(double lon) { + this.lon = lon; + } + + public double getLat() { + return lat; + } + + public void setLat(double lat) { + this.lat = lat; + } +} diff --git a/flink-processor/src/main/java/berlinmod/MEOSBridge.java b/flink-processor/src/main/java/berlinmod/MEOSBridge.java new file mode 100644 index 0000000..6b29952 --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/MEOSBridge.java @@ -0,0 +1,133 @@ +package berlinmod; + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; +import org.mobilitydb.flink.meos.wirings.MeosWiringRuntime; + +/** + * Thin wiring from the BerlinMOD streaming-form predicates to MEOS via JMEOS. + * + *

Every spatial predicate exercised by the BerlinMOD-9 × 3-form scaffold + * flows through this class, and every predicate evaluates through MEOS. The + * within-distance predicate is the canonical temporal operator + * {@code edwithin_tgeo_geo} — ever-within between the vehicle's {@code tgeogpoint} + * instant and the query geography, in metres on the WGS84 spheroid — the same + * MEOS operator the streaming-form parity contract names. Distances are + * {@code geog_distance} over WGS84 geographies. This class holds no spatial + * mathematics of its own: it constructs the MEOS inputs and delegates the + * computation to libmeos. + * + *

{@link MeosWiringRuntime#ensureInitializedOnThread()} initialises MEOS on + * the calling task thread (idempotent per thread) before the first call, since + * MEOS keeps its session state per OS thread. + */ +public final class MEOSBridge { + + private MEOSBridge() { + // utility + } + + // ---------------------------------------------------------------------- + // Public predicate surface — all evaluation delegated to MEOS. + // ---------------------------------------------------------------------- + + /** + * @return {@code true} iff the WGS84 spheroidal distance from + * {@code (lon1, lat1)} to {@code (lon2, lat2)} is at most + * {@code radiusMetres}, via MEOS {@code edwithin_tgeo_geo} between + * the {@code (lon1, lat1)} {@code tgeogpoint} instant and the + * {@code (lon2, lat2)} point geography. + */ + public static boolean dwithinMetres(double lon1, double lat1, + double lon2, double lat2, + double radiusMetres) { + MeosWiringRuntime.ensureInitializedOnThread(); + return GeneratedFunctions.edwithin_tgeo_geo( + tgeogInst(lon1, lat1), pointGeog(lon2, lat2), radiusMetres) == 1; + } + + /** + * @return {@code true} iff the WGS84 spheroidal distance from + * {@code (pLon, pLat)} to the LineString {@code (s1, s2)} is at most + * {@code radiusMetres}, via MEOS {@code edwithin_tgeo_geo} between + * the point {@code tgeogpoint} instant and the line geography. + */ + public static boolean dwithinSegmentMetres(double pLon, double pLat, + double s1Lon, double s1Lat, + double s2Lon, double s2Lat, + double radiusMetres) { + MeosWiringRuntime.ensureInitializedOnThread(); + return GeneratedFunctions.edwithin_tgeo_geo( + tgeogInst(pLon, pLat), + lineGeog(s1Lon, s1Lat, s2Lon, s2Lat), radiusMetres) == 1; + } + + /** + * @return {@code true} iff {@code (lon, lat)} lies in the axis-aligned box + * {@code [xmin, xmax] × [ymin, ymax]}, via MEOS + * {@code eintersects_tgeo_geo} between the point's {@code tgeompoint} + * instant and the box polygon (planar, SRID 4326). + */ + public static boolean intersectsBox(double lon, double lat, + double xmin, double ymin, + double xmax, double ymax) { + MeosWiringRuntime.ensureInitializedOnThread(); + return GeneratedFunctions.eintersects_tgeo_geo( + tgeomInst(lon, lat), boxPolygon(xmin, ymin, xmax, ymax)) == 1; + } + + /** + * @return the WGS84 spheroidal distance in metres between two points, via + * MEOS {@code geog_distance}. + */ + public static double distanceMetres(double lon1, double lat1, + double lon2, double lat2) { + MeosWiringRuntime.ensureInitializedOnThread(); + return GeneratedFunctions.geog_distance(pointGeog(lon1, lat1), pointGeog(lon2, lat2)); + } + + /** + * @return the WGS84 spheroidal distance in metres from {@code (pLon, pLat)} + * to the LineString {@code (s1, s2)}, via MEOS {@code geog_distance}. + */ + public static double distanceSegmentMetres(double pLon, double pLat, + double s1Lon, double s1Lat, + double s2Lon, double s2Lat) { + MeosWiringRuntime.ensureInitializedOnThread(); + return GeneratedFunctions.geog_distance( + pointGeog(pLon, pLat), lineGeog(s1Lon, s1Lat, s2Lon, s2Lat)); + } + + // ---------------------------------------------------------------------- + // Internal helpers — construct the MEOS temporal / geography inputs. + // ---------------------------------------------------------------------- + + private static Pointer tgeogInst(double lon, double lat) { + return GeneratedFunctions.tgeogpoint_in( + String.format("SRID=4326;Point(%.7f %.7f)@2000-01-01", lon, lat)); + } + + private static Pointer tgeomInst(double lon, double lat) { + return GeneratedFunctions.tgeompoint_in( + String.format("SRID=4326;Point(%.7f %.7f)@2000-01-01", lon, lat)); + } + + private static Pointer boxPolygon(double xmin, double ymin, + double xmax, double ymax) { + return GeneratedFunctions.geom_in(String.format( + "SRID=4326;Polygon((%.7f %.7f, %.7f %.7f, %.7f %.7f, %.7f %.7f, %.7f %.7f))", + xmin, ymin, xmax, ymin, xmax, ymax, xmin, ymax, xmin, ymin), -1); + } + + private static Pointer pointGeog(double lon, double lat) { + return GeneratedFunctions.geom_to_geog( + GeneratedFunctions.geom_in(String.format("SRID=4326;Point(%.7f %.7f)", lon, lat), -1)); + } + + private static Pointer lineGeog(double s1Lon, double s1Lat, + double s2Lon, double s2Lat) { + return GeneratedFunctions.geom_to_geog( + GeneratedFunctions.geom_in(String.format( + "SRID=4326;LineString(%.7f %.7f, %.7f %.7f)", s1Lon, s1Lat, s2Lon, s2Lat), -1)); + } +} diff --git a/flink-processor/src/main/java/berlinmod/PointOfInterest.java b/flink-processor/src/main/java/berlinmod/PointOfInterest.java new file mode 100644 index 0000000..0dc3ac5 --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/PointOfInterest.java @@ -0,0 +1,24 @@ +package berlinmod; + +import java.io.Serializable; + +/** + * Simple point-of-interest record for BerlinMOD-Q7 — a (lon, lat) plus a + * proximity radius in metres and an integer id. Serializable for use in + * Flink operator state and configuration. + */ +public final class PointOfInterest implements Serializable { + private static final long serialVersionUID = 1L; + + public final int id; + public final double lon; + public final double lat; + public final double radiusMetres; + + public PointOfInterest(int id, double lon, double lat, double radiusMetres) { + this.id = id; + this.lon = lon; + this.lat = lat; + this.radiusMetres = radiusMetres; + } +} diff --git a/flink-processor/src/main/java/berlinmod/Q1ContinuousFunction.java b/flink-processor/src/main/java/berlinmod/Q1ContinuousFunction.java new file mode 100644 index 0000000..dcaa383 --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/Q1ContinuousFunction.java @@ -0,0 +1,41 @@ +package berlinmod; + +import org.apache.flink.api.common.state.ValueState; +import org.apache.flink.api.common.state.ValueStateDescriptor; +import org.apache.flink.api.java.tuple.Tuple2; +import org.apache.flink.configuration.Configuration; +import org.apache.flink.streaming.api.functions.KeyedProcessFunction; +import org.apache.flink.util.Collector; + +/** + * BerlinMOD-Q1 — continuous form. + * + *

"Which vehicles have appeared in the stream?" + * + *

Emits {@code (vehicleId, firstSeenTimestamp)} the first time each vehicle + * is seen; subsequent events for the same vehicle are deduplicated via keyed + * state. Keyed by vehicleId. + */ +public class Q1ContinuousFunction + extends KeyedProcessFunction> { + + private transient ValueState seen; + + @Override + public void open(Configuration parameters) { + seen = getRuntimeContext().getState( + new ValueStateDescriptor<>("q1SeenVehicle", Boolean.class)); + } + + @Override + public void processElement( + BerlinMODTrip trip, + Context ctx, + Collector> out) throws Exception { + Boolean s = seen.value(); + if (s == null || !s) { + out.collect(new Tuple2<>(trip.getVehicleId(), trip.getTimestamp())); + seen.update(true); + } + } +} diff --git a/flink-processor/src/main/java/berlinmod/Q1SnapshotFunction.java b/flink-processor/src/main/java/berlinmod/Q1SnapshotFunction.java new file mode 100644 index 0000000..03c171a --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/Q1SnapshotFunction.java @@ -0,0 +1,59 @@ +package berlinmod; + +import org.apache.flink.api.common.state.ValueState; +import org.apache.flink.api.common.state.ValueStateDescriptor; +import org.apache.flink.api.java.tuple.Tuple2; +import org.apache.flink.configuration.Configuration; +import org.apache.flink.streaming.api.functions.KeyedProcessFunction; +import org.apache.flink.util.Collector; + +/** + * BerlinMOD-Q1 — snapshot form. + * + *

"At time T, which vehicles have appeared in the stream up to T?" + * + *

Keyed by vehicleId. On each event, mark the vehicle as seen and register + * an event-time timer at the next snapshot tick. When the timer fires at time + * T, emit {@code (T, vehicleId)} for each vehicle that has been seen by T. + * + *

This is the parity-oracle form: at watermark T, the streaming output is + * the set of vehicleIds whose first event occurred at or before T, which + * equals the batch BerlinMOD-Q1 result on data up to T. + */ +public class Q1SnapshotFunction + extends KeyedProcessFunction> { + + private final long snapshotTickMillis; + private transient ValueState seen; + + public Q1SnapshotFunction(long snapshotTickMillis) { + this.snapshotTickMillis = snapshotTickMillis; + } + + @Override + public void open(Configuration parameters) { + seen = getRuntimeContext().getState( + new ValueStateDescriptor<>("q1SnapshotSeen", Boolean.class)); + } + + @Override + public void processElement( + BerlinMODTrip trip, + Context ctx, + Collector> out) throws Exception { + seen.update(true); + long nextTick = ((trip.getTimestamp() / snapshotTickMillis) + 1) * snapshotTickMillis; + ctx.timerService().registerEventTimeTimer(nextTick); + } + + @Override + public void onTimer( + long timestamp, + OnTimerContext ctx, + Collector> out) throws Exception { + Boolean s = seen.value(); + if (Boolean.TRUE.equals(s)) { + out.collect(new Tuple2<>(timestamp, ctx.getCurrentKey())); + } + } +} diff --git a/flink-processor/src/main/java/berlinmod/Q1WindowedFunction.java b/flink-processor/src/main/java/berlinmod/Q1WindowedFunction.java new file mode 100644 index 0000000..4581422 --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/Q1WindowedFunction.java @@ -0,0 +1,33 @@ +package berlinmod; + +import org.apache.flink.api.java.tuple.Tuple3; +import org.apache.flink.streaming.api.functions.windowing.ProcessAllWindowFunction; +import org.apache.flink.streaming.api.windowing.windows.TimeWindow; +import org.apache.flink.util.Collector; + +import java.util.HashSet; +import java.util.Set; + +/** + * BerlinMOD-Q1 — windowed form. + * + *

"Per N-second tumbling window, how many distinct vehicles appeared + * in the window?" + * + *

Emits {@code (windowStart, windowEnd, distinctCount)} per window. + */ +public class Q1WindowedFunction + extends ProcessAllWindowFunction, TimeWindow> { + + @Override + public void process( + Context ctx, + Iterable elements, + Collector> out) { + Set distinct = new HashSet<>(); + for (BerlinMODTrip trip : elements) { + distinct.add(trip.getVehicleId()); + } + out.collect(new Tuple3<>(ctx.window().getStart(), ctx.window().getEnd(), (long) distinct.size())); + } +} diff --git a/flink-processor/src/main/java/berlinmod/Q2ContinuousFunction.java b/flink-processor/src/main/java/berlinmod/Q2ContinuousFunction.java new file mode 100644 index 0000000..9d87dcb --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/Q2ContinuousFunction.java @@ -0,0 +1,40 @@ +package berlinmod; + +import org.apache.flink.streaming.api.functions.ProcessFunction; +import org.apache.flink.util.Collector; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * BerlinMOD-Q2 — continuous form. + * + *

"Where is vehicle X right now?" + * + *

For each incoming GPS event {@link BerlinMODTrip}, emit it unchanged if it + * belongs to the queried vehicle, otherwise drop. No windowing, no state — + * a per-event filter against {@code targetVehicleId}. + */ +public class Q2ContinuousFunction extends ProcessFunction { + + private static final Logger LOG = LoggerFactory.getLogger(Q2ContinuousFunction.class); + + private final int targetVehicleId; + + public Q2ContinuousFunction(int targetVehicleId) { + this.targetVehicleId = targetVehicleId; + } + + @Override + public void processElement( + BerlinMODTrip trip, + Context ctx, + Collector out) { + if (trip.getVehicleId() == targetVehicleId) { + out.collect(trip); + if (LOG.isDebugEnabled()) { + LOG.debug("Q2-continuous: vehicle={} t={} ({}, {})", + trip.getVehicleId(), trip.getTimestamp(), trip.getLon(), trip.getLat()); + } + } + } +} diff --git a/flink-processor/src/main/java/berlinmod/Q2SnapshotFunction.java b/flink-processor/src/main/java/berlinmod/Q2SnapshotFunction.java new file mode 100644 index 0000000..4468d82 --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/Q2SnapshotFunction.java @@ -0,0 +1,83 @@ +package berlinmod; + +import org.apache.flink.api.common.state.ValueState; +import org.apache.flink.api.common.state.ValueStateDescriptor; +import org.apache.flink.api.common.typeinfo.TypeHint; +import org.apache.flink.api.common.typeinfo.TypeInformation; +import org.apache.flink.api.java.tuple.Tuple3; +import org.apache.flink.api.java.tuple.Tuple4; +import org.apache.flink.configuration.Configuration; +import org.apache.flink.streaming.api.functions.KeyedProcessFunction; +import org.apache.flink.util.Collector; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * BerlinMOD-Q2 — snapshot form. + * + *

"At time T, where is vehicle X?" + * + *

This is the parity-oracle form: streaming output at watermark T must + * equal the batch BerlinMOD-Q2 result on the same data up to T (the most + * recent known position of vehicle X on or before T). + * + *

Keyed by vehicleId (so the operator scales naturally if the queried + * vehicle changes, and so reuse across multiple queried vehicles is a + * fan-out keying choice rather than a code change). For events whose key + * matches {@code targetVehicleId}, update last-known state and register an + * event-time timer for the next snapshot tick. When the timer fires, emit + * {@code (T, lon, lat, t_of_last_event)}. + */ +public class Q2SnapshotFunction + extends KeyedProcessFunction> { + + private static final Logger LOG = LoggerFactory.getLogger(Q2SnapshotFunction.class); + + private final int targetVehicleId; + private final long snapshotTickMillis; + + private transient ValueState> lastKnown; // (lon, lat, ts) + + public Q2SnapshotFunction(int targetVehicleId, long snapshotTickMillis) { + this.targetVehicleId = targetVehicleId; + this.snapshotTickMillis = snapshotTickMillis; + } + + @Override + public void open(Configuration parameters) { + TypeInformation> tInfo = + TypeInformation.of(new TypeHint>() {}); + ValueStateDescriptor> desc = + new ValueStateDescriptor<>("q2LastKnownPosition", tInfo); + lastKnown = getRuntimeContext().getState(desc); + } + + @Override + public void processElement( + BerlinMODTrip trip, + Context ctx, + Collector> out) throws Exception { + if (trip.getVehicleId() != targetVehicleId) { + return; + } + lastKnown.update(new Tuple3<>(trip.getLon(), trip.getLat(), trip.getTimestamp())); + long nextTick = ((trip.getTimestamp() / snapshotTickMillis) + 1) * snapshotTickMillis; + ctx.timerService().registerEventTimeTimer(nextTick); + } + + @Override + public void onTimer( + long timestamp, + OnTimerContext ctx, + Collector> out) throws Exception { + Tuple3 p = lastKnown.value(); + if (p == null) { + return; + } + out.collect(new Tuple4<>(timestamp, p.f0, p.f1, p.f2)); + if (LOG.isDebugEnabled()) { + LOG.debug("Q2-snapshot: T={} vehicle={} ({}, {}) at t={}", + timestamp, ctx.getCurrentKey(), p.f0, p.f1, p.f2); + } + } +} diff --git a/flink-processor/src/main/java/berlinmod/Q2WindowedFunction.java b/flink-processor/src/main/java/berlinmod/Q2WindowedFunction.java new file mode 100644 index 0000000..38ee0ff --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/Q2WindowedFunction.java @@ -0,0 +1,58 @@ +package berlinmod; + +import org.apache.flink.api.java.tuple.Tuple5; +import org.apache.flink.streaming.api.functions.windowing.ProcessAllWindowFunction; +import org.apache.flink.streaming.api.windowing.windows.TimeWindow; +import org.apache.flink.util.Collector; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * BerlinMOD-Q2 — windowed form. + * + *

"Per N-second tumbling window, what is vehicle X's most recent + * position seen within the window?" + * + *

For each window, filter to events matching {@code targetVehicleId}, keep + * the event with the largest timestamp, and emit + * {@code (windowStart, windowEnd, vehicleId, lon, lat)}. If the vehicle had + * no events in the window, emit nothing. + */ +public class Q2WindowedFunction + extends ProcessAllWindowFunction, TimeWindow> { + + private static final Logger LOG = LoggerFactory.getLogger(Q2WindowedFunction.class); + + private final int targetVehicleId; + + public Q2WindowedFunction(int targetVehicleId) { + this.targetVehicleId = targetVehicleId; + } + + @Override + public void process( + Context ctx, + Iterable elements, + Collector> out) { + BerlinMODTrip latest = null; + for (BerlinMODTrip trip : elements) { + if (trip.getVehicleId() != targetVehicleId) { + continue; + } + if (latest == null || trip.getTimestamp() > latest.getTimestamp()) { + latest = trip; + } + } + if (latest != null) { + out.collect(new Tuple5<>( + ctx.window().getStart(), + ctx.window().getEnd(), + latest.getVehicleId(), + latest.getLon(), + latest.getLat())); + LOG.info("Q2-windowed: [{}, {}) vehicle={} last=({}, {})", + ctx.window().getStart(), ctx.window().getEnd(), + latest.getVehicleId(), latest.getLon(), latest.getLat()); + } + } +} diff --git a/flink-processor/src/main/java/berlinmod/Q3ContinuousFunction.java b/flink-processor/src/main/java/berlinmod/Q3ContinuousFunction.java new file mode 100644 index 0000000..e28f825 --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/Q3ContinuousFunction.java @@ -0,0 +1,47 @@ +package berlinmod; + +import org.apache.flink.api.java.tuple.Tuple3; +import org.apache.flink.streaming.api.functions.ProcessFunction; +import org.apache.flink.util.Collector; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * BerlinMOD-Q3 — continuous form. + * + *

"At every moment, which vehicles are currently within {@code d} metres + * of point P?" + * + *

For each incoming GPS event {@link BerlinMODTrip}, evaluate the radius + * predicate and emit {@code (vehicleId, eventTimeMillis, isNear)} per event. + * No windowing — output updates per event, watermark-independent. + * + *

Predicate: {@link MEOSBridge#dwithinMetres} — MEOS + * {@code edwithin_tgeo_geo} over WGS84 geographies. + */ +public class Q3ContinuousFunction extends ProcessFunction> { + + private static final Logger LOG = LoggerFactory.getLogger(Q3ContinuousFunction.class); + + private final double pLon; + private final double pLat; + private final double radiusMetres; + + public Q3ContinuousFunction(double pLon, double pLat, double radiusMetres) { + this.pLon = pLon; + this.pLat = pLat; + this.radiusMetres = radiusMetres; + } + + @Override + public void processElement( + BerlinMODTrip trip, + Context ctx, + Collector> out) { + boolean near = MEOSBridge.dwithinMetres(trip.getLon(), trip.getLat(), pLon, pLat, radiusMetres); + out.collect(new Tuple3<>(trip.getVehicleId(), trip.getTimestamp(), near)); + if (LOG.isDebugEnabled()) { + LOG.debug("Q3-continuous: vehicle={} ts={} near={}", trip.getVehicleId(), trip.getTimestamp(), near); + } + } +} diff --git a/flink-processor/src/main/java/berlinmod/Q3SnapshotFunction.java b/flink-processor/src/main/java/berlinmod/Q3SnapshotFunction.java new file mode 100644 index 0000000..467a19b --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/Q3SnapshotFunction.java @@ -0,0 +1,90 @@ +package berlinmod; + +import org.apache.flink.api.common.state.ValueState; +import org.apache.flink.api.common.state.ValueStateDescriptor; +import org.apache.flink.api.common.typeinfo.TypeHint; +import org.apache.flink.api.common.typeinfo.TypeInformation; +import org.apache.flink.api.java.tuple.Tuple2; +import org.apache.flink.api.java.tuple.Tuple3; +import org.apache.flink.configuration.Configuration; +import org.apache.flink.streaming.api.functions.KeyedProcessFunction; +import org.apache.flink.util.Collector; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * BerlinMOD-Q3 — snapshot form. + * + *

"At time T, which vehicles are within {@code d} metres of point P?" + * + *

This is the parity-oracle form: streaming output at watermark T + * must equal the batch BerlinMOD-Q3 result on the same data up to T. + * + *

Keyed by vehicleId. Maintains a per-vehicle {@code lastKnownPosition} + * state. On each event, update the state, then register an event-time timer + * for the snapshot tick. When the timer fires at time T, evaluate the radius + * predicate against the most recent known position and emit + * {@code (T, vehicleId)} if the vehicle is within {@code d} of P at that + * snapshot. + * + *

Predicate: {@link MEOSBridge#dwithinMetres} — MEOS + * {@code edwithin_tgeo_geo} over WGS84 geographies. The snapshot-form output + * at watermark T is equal to the batch BerlinMOD-Q3 result up to T. + */ +public class Q3SnapshotFunction + extends KeyedProcessFunction> { + + private static final Logger LOG = LoggerFactory.getLogger(Q3SnapshotFunction.class); + + private final double pLon; + private final double pLat; + private final double radiusMetres; + private final long snapshotTickMillis; + + private transient ValueState> lastKnown; // (lon, lat, ts) + + public Q3SnapshotFunction( + double pLon, double pLat, double radiusMetres, long snapshotTickMillis) { + this.pLon = pLon; + this.pLat = pLat; + this.radiusMetres = radiusMetres; + this.snapshotTickMillis = snapshotTickMillis; + } + + @Override + public void open(Configuration parameters) { + TypeInformation> tInfo = + TypeInformation.of(new TypeHint>() {}); + ValueStateDescriptor> desc = + new ValueStateDescriptor<>("lastKnownPosition", tInfo); + lastKnown = getRuntimeContext().getState(desc); + } + + @Override + public void processElement( + BerlinMODTrip trip, + Context ctx, + Collector> out) throws Exception { + lastKnown.update(new Tuple3<>(trip.getLon(), trip.getLat(), trip.getTimestamp())); + long nextTick = ((trip.getTimestamp() / snapshotTickMillis) + 1) * snapshotTickMillis; + ctx.timerService().registerEventTimeTimer(nextTick); + } + + @Override + public void onTimer( + long timestamp, + OnTimerContext ctx, + Collector> out) throws Exception { + Tuple3 p = lastKnown.value(); + if (p == null) { + return; + } + if (MEOSBridge.dwithinMetres(p.f0, p.f1, pLon, pLat, radiusMetres)) { + Integer vehicleId = ctx.getCurrentKey(); + out.collect(new Tuple2<>(timestamp, vehicleId)); + if (LOG.isDebugEnabled()) { + LOG.debug("Q3-snapshot: T={} vehicle={}", timestamp, vehicleId); + } + } + } +} diff --git a/flink-processor/src/main/java/berlinmod/Q3WindowedFunction.java b/flink-processor/src/main/java/berlinmod/Q3WindowedFunction.java new file mode 100644 index 0000000..8806791 --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/Q3WindowedFunction.java @@ -0,0 +1,58 @@ +package berlinmod; + +import org.apache.flink.api.java.tuple.Tuple3; +import org.apache.flink.streaming.api.functions.windowing.ProcessAllWindowFunction; +import org.apache.flink.streaming.api.windowing.windows.TimeWindow; +import org.apache.flink.util.Collector; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.HashSet; +import java.util.Set; + +/** + * BerlinMOD-Q3 — windowed form. + * + *

"Per N-second window, how many distinct vehicles were within + * {@code d} metres of point P at any time during the window?" + * + *

Tumbling event-time window of configurable size. For each window, scan + * all events whose timestamp falls in the window, count distinct vehicleIds + * for which at least one event satisfies the radius predicate, and emit + * {@code (windowStart, windowEnd, distinctCount)}. + * + *

Predicate: {@link MEOSBridge#dwithinMetres} — MEOS + * {@code edwithin_tgeo_geo} over WGS84 geographies. + */ +public class Q3WindowedFunction + extends ProcessAllWindowFunction, TimeWindow> { + + private static final Logger LOG = LoggerFactory.getLogger(Q3WindowedFunction.class); + + private final double pLon; + private final double pLat; + private final double radiusMetres; + + public Q3WindowedFunction(double pLon, double pLat, double radiusMetres) { + this.pLon = pLon; + this.pLat = pLat; + this.radiusMetres = radiusMetres; + } + + @Override + public void process( + Context ctx, + Iterable elements, + Collector> out) { + Set distinctNear = new HashSet<>(); + for (BerlinMODTrip trip : elements) { + if (MEOSBridge.dwithinMetres(trip.getLon(), trip.getLat(), pLon, pLat, radiusMetres)) { + distinctNear.add(trip.getVehicleId()); + } + } + long count = distinctNear.size(); + out.collect(new Tuple3<>(ctx.window().getStart(), ctx.window().getEnd(), count)); + LOG.info("Q3-windowed: [{}, {}) distinct-near={}", + ctx.window().getStart(), ctx.window().getEnd(), count); + } +} diff --git a/flink-processor/src/main/java/berlinmod/Q4ContinuousFunction.java b/flink-processor/src/main/java/berlinmod/Q4ContinuousFunction.java new file mode 100644 index 0000000..472d1f1 --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/Q4ContinuousFunction.java @@ -0,0 +1,61 @@ +package berlinmod; + +import org.apache.flink.api.common.state.ValueState; +import org.apache.flink.api.common.state.ValueStateDescriptor; +import org.apache.flink.api.java.tuple.Tuple2; +import org.apache.flink.configuration.Configuration; +import org.apache.flink.streaming.api.functions.KeyedProcessFunction; +import org.apache.flink.util.Collector; + +/** + * BerlinMOD-Q4 — continuous form. + * + *

"Which vehicles entered region R (transition outside → inside), + * and when?" + * + *

Keyed by vehicleId. Per-vehicle state tracks the last seen + * inside-or-outside flag for R. On each event, computes the current + * inside-or-outside, and if the transition is outside→inside, emits + * {@code (vehicleId, entryTime)}. + * + *

Predicate: {@link MEOSBridge#intersectsBox} — MEOS + * {@code eintersects_tgeo_geo} between the point's {@code tgeompoint} instant + * and the region polygon. + */ +public class Q4ContinuousFunction + extends KeyedProcessFunction> { + + private final double xmin, ymin, xmax, ymax; + private transient ValueState wasInside; + + public Q4ContinuousFunction(double xmin, double ymin, double xmax, double ymax) { + this.xmin = xmin; + this.ymin = ymin; + this.xmax = xmax; + this.ymax = ymax; + } + + @Override + public void open(Configuration parameters) { + wasInside = getRuntimeContext().getState( + new ValueStateDescriptor<>("q4WasInside", Boolean.class)); + } + + @Override + public void processElement( + BerlinMODTrip trip, + Context ctx, + Collector> out) throws Exception { + boolean isInside = inBox(trip.getLon(), trip.getLat()); + Boolean prev = wasInside.value(); + boolean prevInside = prev != null && prev; + if (isInside && !prevInside) { + out.collect(new Tuple2<>(trip.getVehicleId(), trip.getTimestamp())); + } + wasInside.update(isInside); + } + + private boolean inBox(double lon, double lat) { + return MEOSBridge.intersectsBox(lon, lat, xmin, ymin, xmax, ymax); + } +} diff --git a/flink-processor/src/main/java/berlinmod/Q4SnapshotFunction.java b/flink-processor/src/main/java/berlinmod/Q4SnapshotFunction.java new file mode 100644 index 0000000..45b05fa --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/Q4SnapshotFunction.java @@ -0,0 +1,82 @@ +package berlinmod; + +import org.apache.flink.api.common.state.ListState; +import org.apache.flink.api.common.state.ListStateDescriptor; +import org.apache.flink.api.common.state.ValueState; +import org.apache.flink.api.common.state.ValueStateDescriptor; +import org.apache.flink.api.java.tuple.Tuple3; +import org.apache.flink.configuration.Configuration; +import org.apache.flink.streaming.api.functions.KeyedProcessFunction; +import org.apache.flink.util.Collector; + +/** + * BerlinMOD-Q4 — snapshot form. + * + *

"At time T, what is the list of (vehicleId, entryTime) pairs for all + * vehicles that entered region R at or before T?" + * + *

This is the parity-oracle form: streaming output at watermark T must + * equal the batch BerlinMOD-Q4 result on the same data up to T. + * + *

Keyed by vehicleId. Per-vehicle state: a {@code wasInside} flag plus a + * {@code ListState} of recorded entry times. On each event, detect + * outside → inside transitions and append entry time. Register an event-time + * timer at the next snapshot tick. On timer fire at T, emit one + * {@code (T, vehicleId, entryTime)} per recorded entry. + */ +public class Q4SnapshotFunction + extends KeyedProcessFunction> { + + private final double xmin, ymin, xmax, ymax; + private final long snapshotTickMillis; + private transient ValueState wasInside; + private transient ListState entries; + + public Q4SnapshotFunction(double xmin, double ymin, double xmax, double ymax, long snapshotTickMillis) { + this.xmin = xmin; + this.ymin = ymin; + this.xmax = xmax; + this.ymax = ymax; + this.snapshotTickMillis = snapshotTickMillis; + } + + @Override + public void open(Configuration parameters) { + wasInside = getRuntimeContext().getState( + new ValueStateDescriptor<>("q4SnapWasInside", Boolean.class)); + entries = getRuntimeContext().getListState( + new ListStateDescriptor<>("q4SnapEntries", Long.class)); + } + + @Override + public void processElement( + BerlinMODTrip trip, + Context ctx, + Collector> out) throws Exception { + boolean curr = inBox(trip.getLon(), trip.getLat()); + Boolean prev = wasInside.value(); + boolean prevInside = prev != null && prev; + if (curr && !prevInside) { + entries.add(trip.getTimestamp()); + } + wasInside.update(curr); + long nextTick = ((trip.getTimestamp() / snapshotTickMillis) + 1) * snapshotTickMillis; + ctx.timerService().registerEventTimeTimer(nextTick); + } + + @Override + public void onTimer( + long timestamp, + OnTimerContext ctx, + Collector> out) throws Exception { + for (Long entry : entries.get()) { + if (entry <= timestamp) { + out.collect(new Tuple3<>(timestamp, ctx.getCurrentKey(), entry)); + } + } + } + + private boolean inBox(double lon, double lat) { + return MEOSBridge.intersectsBox(lon, lat, xmin, ymin, xmax, ymax); + } +} diff --git a/flink-processor/src/main/java/berlinmod/Q4WindowedFunction.java b/flink-processor/src/main/java/berlinmod/Q4WindowedFunction.java new file mode 100644 index 0000000..e38c364 --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/Q4WindowedFunction.java @@ -0,0 +1,74 @@ +package berlinmod; + +import org.apache.flink.api.java.tuple.Tuple4; +import org.apache.flink.streaming.api.functions.windowing.ProcessAllWindowFunction; +import org.apache.flink.streaming.api.windowing.windows.TimeWindow; +import org.apache.flink.util.Collector; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +/** + * BerlinMOD-Q4 — windowed form. + * + *

"Per N-second tumbling window, which vehicles entered region R during + * the window, and at what time?" + * + *

Scans all events in the window, sorted per-vehicle by time, and detects + * outside → inside transitions within the window. Emits one + * {@code (windowStart, windowEnd, vehicleId, entryTime)} per detected entry. + * + *

Note: a vehicle's "outside" state at window start is inferred only from + * the window's first event (no cross-window state). This intra-window + * scoping matches BerlinMOD-Q4's "first N entries during a period" form. + */ +public class Q4WindowedFunction + extends ProcessAllWindowFunction, TimeWindow> { + + private final double xmin, ymin, xmax, ymax; + + public Q4WindowedFunction(double xmin, double ymin, double xmax, double ymax) { + this.xmin = xmin; + this.ymin = ymin; + this.xmax = xmax; + this.ymax = ymax; + } + + @Override + public void process( + Context ctx, + Iterable elements, + Collector> out) { + Map> perVehicle = new HashMap<>(); + for (BerlinMODTrip trip : elements) { + perVehicle.computeIfAbsent(trip.getVehicleId(), k -> new ArrayList<>()).add(trip); + } + for (Map.Entry> e : perVehicle.entrySet()) { + List sorted = e.getValue(); + sorted.sort((a, b) -> Long.compare(a.getTimestamp(), b.getTimestamp())); + boolean prevInside = false; // intra-window only — treats first event as the prior + for (int i = 0; i < sorted.size(); i++) { + BerlinMODTrip t = sorted.get(i); + boolean curr = inBox(t.getLon(), t.getLat()); + if (i == 0) { + if (curr) { + // first event already inside — count as entry per the + // intra-window scoping convention (no prior visibility) + out.collect(new Tuple4<>(ctx.window().getStart(), ctx.window().getEnd(), + e.getKey(), t.getTimestamp())); + } + } else if (curr && !prevInside) { + out.collect(new Tuple4<>(ctx.window().getStart(), ctx.window().getEnd(), + e.getKey(), t.getTimestamp())); + } + prevInside = curr; + } + } + } + + private boolean inBox(double lon, double lat) { + return MEOSBridge.intersectsBox(lon, lat, xmin, ymin, xmax, ymax); + } +} diff --git a/flink-processor/src/main/java/berlinmod/Q5ContinuousFunction.java b/flink-processor/src/main/java/berlinmod/Q5ContinuousFunction.java new file mode 100644 index 0000000..51037b8 --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/Q5ContinuousFunction.java @@ -0,0 +1,94 @@ +package berlinmod; + +import org.apache.flink.api.common.state.MapState; +import org.apache.flink.api.common.state.MapStateDescriptor; +import org.apache.flink.api.common.typeinfo.TypeHint; +import org.apache.flink.api.common.typeinfo.TypeInformation; +import org.apache.flink.api.java.tuple.Tuple2; +import org.apache.flink.api.java.tuple.Tuple4; +import org.apache.flink.configuration.Configuration; +import org.apache.flink.streaming.api.functions.KeyedProcessFunction; +import org.apache.flink.util.Collector; + +import java.util.ArrayList; +import java.util.Comparator; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +/** + * BerlinMOD-Q5 — continuous form. + * + *

"Which pairs of vehicles are currently meeting near point P?" + * + *

A pair {@code (a, b)} meets near P when both vehicles are within + * {@code dP} metres of {@code P} and the distance between them is at most + * {@code dMeet} metres. + * + *

Caller is expected to key the input stream by a constant so the shared + * cross-vehicle last-known state lives in a single subtask. Per-event: + * update the last-known position of the event's vehicle, then enumerate all + * known pairs and emit {@code (a, b, eventTime, distanceMetres)} for every + * currently-meeting pair (with {@code a < b} for stable identity). + * + *

Predicate: {@link MEOSBridge#dwithinMetres} (MEOS + * {@code edwithin_tgeo_geo}) for the near-P filter and + * {@link MEOSBridge#distanceMetres} (MEOS {@code geog_distance}) for the + * pairwise meeting distance. + */ +public class Q5ContinuousFunction + extends KeyedProcessFunction> { + + private final double pLon, pLat, dPMetres, dMeetMetres; + private transient MapState> lastPos; + + public Q5ContinuousFunction(double pLon, double pLat, double dPMetres, double dMeetMetres) { + this.pLon = pLon; + this.pLat = pLat; + this.dPMetres = dPMetres; + this.dMeetMetres = dMeetMetres; + } + + @Override + public void open(Configuration parameters) { + TypeInformation> vInfo = + TypeInformation.of(new TypeHint>() {}); + lastPos = getRuntimeContext().getMapState( + new MapStateDescriptor<>("q5LastPos", TypeInformation.of(Integer.class), vInfo)); + } + + @Override + public void processElement( + BerlinMODTrip trip, + Context ctx, + Collector> out) throws Exception { + lastPos.put(trip.getVehicleId(), new Tuple2<>(trip.getLon(), trip.getLat())); + + // Snapshot the map and pick pairs near P + Map> snap = new HashMap<>(); + for (Map.Entry> e : lastPos.entries()) { + snap.put(e.getKey(), e.getValue()); + } + List>> nearP = new ArrayList<>(); + for (Map.Entry> e : snap.entrySet()) { + Tuple2 p = e.getValue(); + if (MEOSBridge.dwithinMetres(p.f0, p.f1, pLon, pLat, dPMetres)) { + nearP.add(e); + } + } + nearP.sort(Comparator.comparingInt(Map.Entry::getKey)); + + for (int i = 0; i < nearP.size(); i++) { + for (int j = i + 1; j < nearP.size(); j++) { + Tuple2 a = nearP.get(i).getValue(); + Tuple2 b = nearP.get(j).getValue(); + double d = MEOSBridge.distanceMetres(a.f0, a.f1, b.f0, b.f1); + if (d <= dMeetMetres) { + out.collect(new Tuple4<>( + nearP.get(i).getKey(), nearP.get(j).getKey(), + trip.getTimestamp(), d)); + } + } + } + } +} diff --git a/flink-processor/src/main/java/berlinmod/Q5SnapshotFunction.java b/flink-processor/src/main/java/berlinmod/Q5SnapshotFunction.java new file mode 100644 index 0000000..b2f2758 --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/Q5SnapshotFunction.java @@ -0,0 +1,97 @@ +package berlinmod; + +import org.apache.flink.api.common.state.MapState; +import org.apache.flink.api.common.state.MapStateDescriptor; +import org.apache.flink.api.common.typeinfo.TypeHint; +import org.apache.flink.api.common.typeinfo.TypeInformation; +import org.apache.flink.api.java.tuple.Tuple2; +import org.apache.flink.api.java.tuple.Tuple4; +import org.apache.flink.configuration.Configuration; +import org.apache.flink.streaming.api.functions.KeyedProcessFunction; +import org.apache.flink.util.Collector; + +import java.util.ArrayList; +import java.util.Comparator; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +/** + * BerlinMOD-Q5 — snapshot form. + * + *

"At time T, which pairs of vehicles are meeting near P (using each + * vehicle's most-recent-known position on or before T)?" + * + *

This is the parity-oracle form: streaming output at watermark T must + * equal the batch BerlinMOD-Q5 result on the same data up to T. + * + *

Caller is expected to key the stream by a constant; the + * cross-vehicle last-known state is a {@link MapState}. On each event, + * update last-known and register an event-time timer at the next snapshot + * tick. On timer fire at T, snapshot the map and emit all meeting pairs. + */ +public class Q5SnapshotFunction + extends KeyedProcessFunction> { + + private final double pLon, pLat, dPMetres, dMeetMetres; + private final long snapshotTickMillis; + private transient MapState> lastPos; + + public Q5SnapshotFunction(double pLon, double pLat, double dPMetres, + double dMeetMetres, long snapshotTickMillis) { + this.pLon = pLon; + this.pLat = pLat; + this.dPMetres = dPMetres; + this.dMeetMetres = dMeetMetres; + this.snapshotTickMillis = snapshotTickMillis; + } + + @Override + public void open(Configuration parameters) { + TypeInformation> vInfo = + TypeInformation.of(new TypeHint>() {}); + lastPos = getRuntimeContext().getMapState( + new MapStateDescriptor<>("q5SnapLastPos", TypeInformation.of(Integer.class), vInfo)); + } + + @Override + public void processElement( + BerlinMODTrip trip, + Context ctx, + Collector> out) throws Exception { + lastPos.put(trip.getVehicleId(), new Tuple2<>(trip.getLon(), trip.getLat())); + long nextTick = ((trip.getTimestamp() / snapshotTickMillis) + 1) * snapshotTickMillis; + ctx.timerService().registerEventTimeTimer(nextTick); + } + + @Override + public void onTimer( + long timestamp, + OnTimerContext ctx, + Collector> out) throws Exception { + Map> snap = new HashMap<>(); + for (Map.Entry> e : lastPos.entries()) { + snap.put(e.getKey(), e.getValue()); + } + List>> nearP = new ArrayList<>(); + for (Map.Entry> e : snap.entrySet()) { + Tuple2 p = e.getValue(); + if (MEOSBridge.dwithinMetres(p.f0, p.f1, pLon, pLat, dPMetres)) { + nearP.add(e); + } + } + nearP.sort(Comparator.comparingInt(Map.Entry::getKey)); + + for (int i = 0; i < nearP.size(); i++) { + for (int j = i + 1; j < nearP.size(); j++) { + Tuple2 a = nearP.get(i).getValue(); + Tuple2 b = nearP.get(j).getValue(); + double d = MEOSBridge.distanceMetres(a.f0, a.f1, b.f0, b.f1); + if (d <= dMeetMetres) { + out.collect(new Tuple4<>(timestamp, + nearP.get(i).getKey(), nearP.get(j).getKey(), d)); + } + } + } + } +} diff --git a/flink-processor/src/main/java/berlinmod/Q5WindowedFunction.java b/flink-processor/src/main/java/berlinmod/Q5WindowedFunction.java new file mode 100644 index 0000000..8140d0f --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/Q5WindowedFunction.java @@ -0,0 +1,75 @@ +package berlinmod; + +import org.apache.flink.api.java.tuple.Tuple2; +import org.apache.flink.api.java.tuple.Tuple5; +import org.apache.flink.streaming.api.functions.windowing.ProcessAllWindowFunction; +import org.apache.flink.streaming.api.windowing.windows.TimeWindow; +import org.apache.flink.util.Collector; + +import java.util.ArrayList; +import java.util.Comparator; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +/** + * BerlinMOD-Q5 — windowed form. + * + *

"Per N-second tumbling window, which pairs of vehicles met near P + * (using each vehicle's last-seen-in-window position)?" + * + *

Within each window, take each vehicle's latest position from the + * window's events. Run the same near-P-and-within-meet-distance pair check + * as the continuous form. Emit {@code (windowStart, windowEnd, a, b, + * distanceMetres)} per meeting pair. + */ +public class Q5WindowedFunction + extends ProcessAllWindowFunction, TimeWindow> { + + private final double pLon, pLat, dPMetres, dMeetMetres; + + public Q5WindowedFunction(double pLon, double pLat, double dPMetres, double dMeetMetres) { + this.pLon = pLon; + this.pLat = pLat; + this.dPMetres = dPMetres; + this.dMeetMetres = dMeetMetres; + } + + @Override + public void process( + Context ctx, + Iterable elements, + Collector> out) { + // Last position per vehicle within the window + Map latest = new HashMap<>(); + for (BerlinMODTrip trip : elements) { + BerlinMODTrip prev = latest.get(trip.getVehicleId()); + if (prev == null || trip.getTimestamp() > prev.getTimestamp()) { + latest.put(trip.getVehicleId(), trip); + } + } + + // Filter to vehicles near P + List>> nearP = new ArrayList<>(); + for (Map.Entry e : latest.entrySet()) { + BerlinMODTrip t = e.getValue(); + if (MEOSBridge.dwithinMetres(t.getLon(), t.getLat(), pLon, pLat, dPMetres)) { + nearP.add(new HashMap.SimpleEntry<>(e.getKey(), new Tuple2<>(t.getLon(), t.getLat()))); + } + } + nearP.sort(Comparator.comparingInt(Map.Entry::getKey)); + + for (int i = 0; i < nearP.size(); i++) { + for (int j = i + 1; j < nearP.size(); j++) { + Tuple2 a = nearP.get(i).getValue(); + Tuple2 b = nearP.get(j).getValue(); + double d = MEOSBridge.distanceMetres(a.f0, a.f1, b.f0, b.f1); + if (d <= dMeetMetres) { + out.collect(new Tuple5<>( + ctx.window().getStart(), ctx.window().getEnd(), + nearP.get(i).getKey(), nearP.get(j).getKey(), d)); + } + } + } + } +} diff --git a/flink-processor/src/main/java/berlinmod/Q6ContinuousFunction.java b/flink-processor/src/main/java/berlinmod/Q6ContinuousFunction.java new file mode 100644 index 0000000..7b7626a --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/Q6ContinuousFunction.java @@ -0,0 +1,58 @@ +package berlinmod; + +import org.apache.flink.api.common.state.ValueState; +import org.apache.flink.api.common.state.ValueStateDescriptor; +import org.apache.flink.api.common.typeinfo.TypeHint; +import org.apache.flink.api.common.typeinfo.TypeInformation; +import org.apache.flink.api.java.tuple.Tuple2; +import org.apache.flink.api.java.tuple.Tuple3; +import org.apache.flink.configuration.Configuration; +import org.apache.flink.streaming.api.functions.KeyedProcessFunction; +import org.apache.flink.util.Collector; + +/** + * BerlinMOD-Q6 — continuous form. + * + *

"What is each vehicle's cumulative distance travelled so far?" + * + *

Keyed by vehicleId. For each event, computes the distance from the + * previous-known position (or 0 if first event), adds it to the cumulative + * total, and emits {@code (vehicleId, t, cumulativeMetres)}. + * + *

Distance: {@link MEOSBridge#distanceMetres} — MEOS {@code geog_distance} + * between consecutive WGS84 positions. + */ +public class Q6ContinuousFunction + extends KeyedProcessFunction> { + + private transient ValueState> lastPos; // lon, lat + private transient ValueState totalDist; + + @Override + public void open(Configuration parameters) { + TypeInformation> posType = + TypeInformation.of(new TypeHint>() {}); + lastPos = getRuntimeContext().getState( + new ValueStateDescriptor<>("q6LastPos", posType)); + totalDist = getRuntimeContext().getState( + new ValueStateDescriptor<>("q6TotalDist", Double.class)); + } + + @Override + public void processElement( + BerlinMODTrip trip, + Context ctx, + Collector> out) throws Exception { + Tuple2 prev = lastPos.value(); + Double total = totalDist.value(); + if (total == null) { + total = 0.0; + } + if (prev != null) { + total += MEOSBridge.distanceMetres(prev.f0, prev.f1, trip.getLon(), trip.getLat()); + } + lastPos.update(new Tuple2<>(trip.getLon(), trip.getLat())); + totalDist.update(total); + out.collect(new Tuple3<>(trip.getVehicleId(), trip.getTimestamp(), total)); + } +} diff --git a/flink-processor/src/main/java/berlinmod/Q6SnapshotFunction.java b/flink-processor/src/main/java/berlinmod/Q6SnapshotFunction.java new file mode 100644 index 0000000..4270f67 --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/Q6SnapshotFunction.java @@ -0,0 +1,76 @@ +package berlinmod; + +import org.apache.flink.api.common.state.ValueState; +import org.apache.flink.api.common.state.ValueStateDescriptor; +import org.apache.flink.api.common.typeinfo.TypeHint; +import org.apache.flink.api.common.typeinfo.TypeInformation; +import org.apache.flink.api.java.tuple.Tuple2; +import org.apache.flink.api.java.tuple.Tuple3; +import org.apache.flink.configuration.Configuration; +import org.apache.flink.streaming.api.functions.KeyedProcessFunction; +import org.apache.flink.util.Collector; + +/** + * BerlinMOD-Q6 — snapshot form. + * + *

"At time T, what is each vehicle's total distance travelled up to T?" + * + *

This is the parity-oracle form: streaming output at watermark T must + * equal the batch BerlinMOD-Q6 result on the same data up to T. + * + *

Keyed by vehicleId. Per event, update {@code lastPos}/{@code totalDist} + * state (matching {@link Q6ContinuousFunction}) and register an event-time + * timer at the next snapshot tick. On timer fire at T, emit + * {@code (T, vehicleId, totalMetres)}. + */ +public class Q6SnapshotFunction + extends KeyedProcessFunction> { + + private final long snapshotTickMillis; + private transient ValueState> lastPos; + private transient ValueState totalDist; + + public Q6SnapshotFunction(long snapshotTickMillis) { + this.snapshotTickMillis = snapshotTickMillis; + } + + @Override + public void open(Configuration parameters) { + TypeInformation> posType = + TypeInformation.of(new TypeHint>() {}); + lastPos = getRuntimeContext().getState( + new ValueStateDescriptor<>("q6SnapLastPos", posType)); + totalDist = getRuntimeContext().getState( + new ValueStateDescriptor<>("q6SnapTotalDist", Double.class)); + } + + @Override + public void processElement( + BerlinMODTrip trip, + Context ctx, + Collector> out) throws Exception { + Tuple2 prev = lastPos.value(); + Double total = totalDist.value(); + if (total == null) { + total = 0.0; + } + if (prev != null) { + total += MEOSBridge.distanceMetres(prev.f0, prev.f1, trip.getLon(), trip.getLat()); + } + lastPos.update(new Tuple2<>(trip.getLon(), trip.getLat())); + totalDist.update(total); + long nextTick = ((trip.getTimestamp() / snapshotTickMillis) + 1) * snapshotTickMillis; + ctx.timerService().registerEventTimeTimer(nextTick); + } + + @Override + public void onTimer( + long timestamp, + OnTimerContext ctx, + Collector> out) throws Exception { + Double total = totalDist.value(); + if (total != null) { + out.collect(new Tuple3<>(timestamp, ctx.getCurrentKey(), total)); + } + } +} diff --git a/flink-processor/src/main/java/berlinmod/Q6WindowedFunction.java b/flink-processor/src/main/java/berlinmod/Q6WindowedFunction.java new file mode 100644 index 0000000..0fc9501 --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/Q6WindowedFunction.java @@ -0,0 +1,45 @@ +package berlinmod; + +import org.apache.flink.api.java.tuple.Tuple4; +import org.apache.flink.streaming.api.functions.windowing.ProcessWindowFunction; +import org.apache.flink.streaming.api.windowing.windows.TimeWindow; +import org.apache.flink.util.Collector; + +import java.util.ArrayList; +import java.util.List; + +/** + * BerlinMOD-Q6 — windowed form. + * + *

"Per N-second tumbling window, per vehicle, how far did the vehicle + * travel during the window?" + * + *

Keyed by vehicleId, tumbling event-time window. Within each window, + * sort events by timestamp and accumulate great-circle distances between + * consecutive points. Emit {@code (windowStart, windowEnd, vehicleId, + * distanceMetres)}. + */ +public class Q6WindowedFunction + extends ProcessWindowFunction, Integer, TimeWindow> { + + @Override + public void process( + Integer vehicleId, + Context ctx, + Iterable elements, + Collector> out) { + List sorted = new ArrayList<>(); + for (BerlinMODTrip trip : elements) { + sorted.add(trip); + } + sorted.sort((a, b) -> Long.compare(a.getTimestamp(), b.getTimestamp())); + double total = 0.0; + for (int i = 1; i < sorted.size(); i++) { + BerlinMODTrip prev = sorted.get(i - 1); + BerlinMODTrip curr = sorted.get(i); + total += MEOSBridge.distanceMetres(prev.getLon(), prev.getLat(), + curr.getLon(), curr.getLat()); + } + out.collect(new Tuple4<>(ctx.window().getStart(), ctx.window().getEnd(), vehicleId, total)); + } +} diff --git a/flink-processor/src/main/java/berlinmod/Q7ContinuousFunction.java b/flink-processor/src/main/java/berlinmod/Q7ContinuousFunction.java new file mode 100644 index 0000000..bc4dc83 --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/Q7ContinuousFunction.java @@ -0,0 +1,57 @@ +package berlinmod; + +import org.apache.flink.api.common.state.MapState; +import org.apache.flink.api.common.state.MapStateDescriptor; +import org.apache.flink.api.common.typeinfo.TypeInformation; +import org.apache.flink.api.java.tuple.Tuple3; +import org.apache.flink.configuration.Configuration; +import org.apache.flink.streaming.api.functions.KeyedProcessFunction; +import org.apache.flink.util.Collector; + +import java.util.List; + +/** + * BerlinMOD-Q7 — continuous form. + * + *

"For each (vehicle, POI) pair, when did the vehicle first come within + * the POI's radius?" + * + *

Keyed by vehicleId. State is a per-vehicle {@code MapState}. On each event, walk the POI list; if the vehicle is + * within a POI's radius AND no first-passage has been recorded for that + * (vehicle, POI), record it and emit {@code (vehicleId, poiId, firstPassageTime)}. + */ +public class Q7ContinuousFunction + extends KeyedProcessFunction> { + + private final List pois; + private transient MapState firstPassed; + + public Q7ContinuousFunction(List pois) { + this.pois = pois; + } + + @Override + public void open(Configuration parameters) { + firstPassed = getRuntimeContext().getMapState( + new MapStateDescriptor<>("q7FirstPassed", + TypeInformation.of(Integer.class), + TypeInformation.of(Long.class))); + } + + @Override + public void processElement( + BerlinMODTrip trip, + Context ctx, + Collector> out) throws Exception { + for (PointOfInterest poi : pois) { + if (firstPassed.contains(poi.id)) { + continue; + } + if (MEOSBridge.dwithinMetres(trip.getLon(), trip.getLat(), poi.lon, poi.lat, poi.radiusMetres)) { + firstPassed.put(poi.id, trip.getTimestamp()); + out.collect(new Tuple3<>(trip.getVehicleId(), poi.id, trip.getTimestamp())); + } + } + } +} diff --git a/flink-processor/src/main/java/berlinmod/Q7SnapshotFunction.java b/flink-processor/src/main/java/berlinmod/Q7SnapshotFunction.java new file mode 100644 index 0000000..49637f6 --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/Q7SnapshotFunction.java @@ -0,0 +1,85 @@ +package berlinmod; + +import org.apache.flink.api.common.state.MapState; +import org.apache.flink.api.common.state.MapStateDescriptor; +import org.apache.flink.api.common.typeinfo.TypeInformation; +import org.apache.flink.api.java.tuple.Tuple4; +import org.apache.flink.configuration.Configuration; +import org.apache.flink.streaming.api.functions.KeyedProcessFunction; +import org.apache.flink.util.Collector; + +import java.util.Comparator; +import java.util.List; +import java.util.Map; +import java.util.TreeMap; + +/** + * BerlinMOD-Q7 — snapshot form. + * + *

"At time T, for each (vehicle, POI), the first time the vehicle came + * within the POI's radius on or before T." + * + *

This is the parity-oracle form: streaming output at watermark T must + * equal the batch BerlinMOD-Q7 result on the same data up to T. + * + *

Keyed by vehicleId. Per-vehicle {@code MapState}. + * On each event, detect new first-passages (matching {@link Q7ContinuousFunction}) + * and register an event-time timer at the next snapshot tick. On timer fire + * at T, emit one {@code (T, vehicleId, poiId, firstPassageTime)} per recorded + * first-passage with {@code firstPassageTime ≤ T}. + */ +public class Q7SnapshotFunction + extends KeyedProcessFunction> { + + private final List pois; + private final long snapshotTickMillis; + private transient MapState firstPassed; + + public Q7SnapshotFunction(List pois, long snapshotTickMillis) { + this.pois = pois; + this.snapshotTickMillis = snapshotTickMillis; + } + + @Override + public void open(Configuration parameters) { + firstPassed = getRuntimeContext().getMapState( + new MapStateDescriptor<>("q7SnapFirstPassed", + TypeInformation.of(Integer.class), + TypeInformation.of(Long.class))); + } + + @Override + public void processElement( + BerlinMODTrip trip, + Context ctx, + Collector> out) throws Exception { + for (PointOfInterest poi : pois) { + if (firstPassed.contains(poi.id)) { + continue; + } + if (MEOSBridge.dwithinMetres(trip.getLon(), trip.getLat(), + poi.lon, poi.lat, poi.radiusMetres)) { + firstPassed.put(poi.id, trip.getTimestamp()); + } + } + long nextTick = ((trip.getTimestamp() / snapshotTickMillis) + 1) * snapshotTickMillis; + ctx.timerService().registerEventTimeTimer(nextTick); + } + + @Override + public void onTimer( + long timestamp, + OnTimerContext ctx, + Collector> out) throws Exception { + // Iterate in poiId order for deterministic output + Map sorted = new TreeMap<>(Comparator.naturalOrder()); + for (Map.Entry e : firstPassed.entries()) { + sorted.put(e.getKey(), e.getValue()); + } + for (Map.Entry e : sorted.entrySet()) { + if (e.getValue() <= timestamp) { + out.collect(new Tuple4<>(timestamp, ctx.getCurrentKey(), e.getKey(), e.getValue())); + } + } + } +} diff --git a/flink-processor/src/main/java/berlinmod/Q7WindowedFunction.java b/flink-processor/src/main/java/berlinmod/Q7WindowedFunction.java new file mode 100644 index 0000000..e256c81 --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/Q7WindowedFunction.java @@ -0,0 +1,69 @@ +package berlinmod; + +import org.apache.flink.api.java.tuple.Tuple5; +import org.apache.flink.streaming.api.functions.windowing.ProcessAllWindowFunction; +import org.apache.flink.streaming.api.windowing.windows.TimeWindow; +import org.apache.flink.util.Collector; + +import java.util.ArrayList; +import java.util.Comparator; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; + +/** + * BerlinMOD-Q7 — windowed form. + * + *

"Per N-second tumbling window, for each (vehicle, POI), what was the + * vehicle's first event in the window that placed it inside the POI's + * radius?" + * + *

Intra-window scoping (no cross-window first-passage state). Per window: + * group events by vehicleId, sort by time, walk and for each POI emit the + * timestamp of the first event in the window where the vehicle is inside + * that POI. + */ +public class Q7WindowedFunction + extends ProcessAllWindowFunction, TimeWindow> { + + private final List pois; + + public Q7WindowedFunction(List pois) { + this.pois = pois; + } + + @Override + public void process( + Context ctx, + Iterable elements, + Collector> out) { + Map> perVehicle = new HashMap<>(); + for (BerlinMODTrip trip : elements) { + perVehicle.computeIfAbsent(trip.getVehicleId(), k -> new ArrayList<>()).add(trip); + } + // For deterministic output, iterate vehicles in id order + List vehicleIds = new ArrayList<>(perVehicle.keySet()); + vehicleIds.sort(Comparator.naturalOrder()); + for (Integer vid : vehicleIds) { + List sorted = perVehicle.get(vid); + sorted.sort((a, b) -> Long.compare(a.getTimestamp(), b.getTimestamp())); + Set emittedPois = new HashSet<>(); + for (BerlinMODTrip trip : sorted) { + for (PointOfInterest poi : pois) { + if (emittedPois.contains(poi.id)) { + continue; + } + if (MEOSBridge.dwithinMetres(trip.getLon(), trip.getLat(), + poi.lon, poi.lat, poi.radiusMetres)) { + emittedPois.add(poi.id); + out.collect(new Tuple5<>( + ctx.window().getStart(), ctx.window().getEnd(), + vid, poi.id, trip.getTimestamp())); + } + } + } + } + } +} diff --git a/flink-processor/src/main/java/berlinmod/Q8ContinuousFunction.java b/flink-processor/src/main/java/berlinmod/Q8ContinuousFunction.java new file mode 100644 index 0000000..18c398a --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/Q8ContinuousFunction.java @@ -0,0 +1,46 @@ +package berlinmod; + +import org.apache.flink.api.java.tuple.Tuple3; +import org.apache.flink.streaming.api.functions.ProcessFunction; +import org.apache.flink.util.Collector; + +/** + * BerlinMOD-Q8 — continuous form. + * + *

"Which vehicles are currently within {@code d} metres of a given + * road segment?" + * + *

For each incoming GPS event {@link BerlinMODTrip}, evaluate the + * point-to-segment distance and emit {@code (vehicleId, eventTime, near)} + * per event. No windowing — same shape as {@link Q3ContinuousFunction} but + * with a segment-distance predicate instead of a point-radius one. + * + *

Predicate: {@link MEOSBridge#dwithinSegmentMetres} — MEOS + * {@code edwithin_tgeo_geo} against a LineString geography. + */ +public class Q8ContinuousFunction extends ProcessFunction> { + + private final double s1Lon, s1Lat, s2Lon, s2Lat, radiusMetres; + + public Q8ContinuousFunction(double s1Lon, double s1Lat, + double s2Lon, double s2Lat, + double radiusMetres) { + this.s1Lon = s1Lon; + this.s1Lat = s1Lat; + this.s2Lon = s2Lon; + this.s2Lat = s2Lat; + this.radiusMetres = radiusMetres; + } + + @Override + public void processElement( + BerlinMODTrip trip, + Context ctx, + Collector> out) { + boolean near = MEOSBridge.dwithinSegmentMetres( + trip.getLon(), trip.getLat(), + s1Lon, s1Lat, s2Lon, s2Lat, + radiusMetres); + out.collect(new Tuple3<>(trip.getVehicleId(), trip.getTimestamp(), near)); + } +} diff --git a/flink-processor/src/main/java/berlinmod/Q8SnapshotFunction.java b/flink-processor/src/main/java/berlinmod/Q8SnapshotFunction.java new file mode 100644 index 0000000..8f61c91 --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/Q8SnapshotFunction.java @@ -0,0 +1,78 @@ +package berlinmod; + +import org.apache.flink.api.common.state.ValueState; +import org.apache.flink.api.common.state.ValueStateDescriptor; +import org.apache.flink.api.common.typeinfo.TypeHint; +import org.apache.flink.api.common.typeinfo.TypeInformation; +import org.apache.flink.api.java.tuple.Tuple2; +import org.apache.flink.api.java.tuple.Tuple3; +import org.apache.flink.configuration.Configuration; +import org.apache.flink.streaming.api.functions.KeyedProcessFunction; +import org.apache.flink.util.Collector; + +/** + * BerlinMOD-Q8 — snapshot form. + * + *

"At time T, which vehicles are within {@code d} metres of the road + * segment (using their last-known position on or before T)?" + * + *

This is the parity-oracle form: streaming output at watermark T must + * equal the batch BerlinMOD-Q8 result on the same data up to T. + * + *

Keyed by vehicleId. State: per-vehicle last-known {@code (lon, lat, t)}. + * On each event, update state and register an event-time timer at the next + * snapshot tick. On timer fire at T, evaluate the segment-distance predicate + * against the latest stored position and emit {@code (T, vehicleId)} for + * each near vehicle. + */ +public class Q8SnapshotFunction + extends KeyedProcessFunction> { + + private final double s1Lon, s1Lat, s2Lon, s2Lat, radiusMetres; + private final long snapshotTickMillis; + private transient ValueState> lastKnown; + + public Q8SnapshotFunction(double s1Lon, double s1Lat, + double s2Lon, double s2Lat, + double radiusMetres, + long snapshotTickMillis) { + this.s1Lon = s1Lon; + this.s1Lat = s1Lat; + this.s2Lon = s2Lon; + this.s2Lat = s2Lat; + this.radiusMetres = radiusMetres; + this.snapshotTickMillis = snapshotTickMillis; + } + + @Override + public void open(Configuration parameters) { + TypeInformation> tInfo = + TypeInformation.of(new TypeHint>() {}); + lastKnown = getRuntimeContext().getState( + new ValueStateDescriptor<>("q8LastKnown", tInfo)); + } + + @Override + public void processElement( + BerlinMODTrip trip, + Context ctx, + Collector> out) throws Exception { + lastKnown.update(new Tuple3<>(trip.getLon(), trip.getLat(), trip.getTimestamp())); + long nextTick = ((trip.getTimestamp() / snapshotTickMillis) + 1) * snapshotTickMillis; + ctx.timerService().registerEventTimeTimer(nextTick); + } + + @Override + public void onTimer( + long timestamp, + OnTimerContext ctx, + Collector> out) throws Exception { + Tuple3 p = lastKnown.value(); + if (p == null) { + return; + } + if (MEOSBridge.dwithinSegmentMetres(p.f0, p.f1, s1Lon, s1Lat, s2Lon, s2Lat, radiusMetres)) { + out.collect(new Tuple2<>(timestamp, ctx.getCurrentKey())); + } + } +} diff --git a/flink-processor/src/main/java/berlinmod/Q8WindowedFunction.java b/flink-processor/src/main/java/berlinmod/Q8WindowedFunction.java new file mode 100644 index 0000000..410a8bf --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/Q8WindowedFunction.java @@ -0,0 +1,53 @@ +package berlinmod; + +import org.apache.flink.api.java.tuple.Tuple3; +import org.apache.flink.streaming.api.functions.windowing.ProcessAllWindowFunction; +import org.apache.flink.streaming.api.windowing.windows.TimeWindow; +import org.apache.flink.util.Collector; + +import java.util.HashSet; +import java.util.Set; + +/** + * BerlinMOD-Q8 — windowed form. + * + *

"Per N-second tumbling window, how many distinct vehicles were within + * {@code d} metres of the road segment at any time during the window?" + * + *

Tumbling event-time window. Walk all events in the window, count + * distinct vehicleIds for which at least one event satisfies the + * segment-distance predicate. Emit {@code (windowStart, windowEnd, + * distinctCount)}. + */ +public class Q8WindowedFunction + extends ProcessAllWindowFunction, TimeWindow> { + + private final double s1Lon, s1Lat, s2Lon, s2Lat, radiusMetres; + + public Q8WindowedFunction(double s1Lon, double s1Lat, + double s2Lon, double s2Lat, + double radiusMetres) { + this.s1Lon = s1Lon; + this.s1Lat = s1Lat; + this.s2Lon = s2Lon; + this.s2Lat = s2Lat; + this.radiusMetres = radiusMetres; + } + + @Override + public void process( + Context ctx, + Iterable elements, + Collector> out) { + Set distinctNear = new HashSet<>(); + for (BerlinMODTrip trip : elements) { + if (MEOSBridge.dwithinSegmentMetres( + trip.getLon(), trip.getLat(), + s1Lon, s1Lat, s2Lon, s2Lat, + radiusMetres)) { + distinctNear.add(trip.getVehicleId()); + } + } + out.collect(new Tuple3<>(ctx.window().getStart(), ctx.window().getEnd(), (long) distinctNear.size())); + } +} diff --git a/flink-processor/src/main/java/berlinmod/Q9ContinuousFunction.java b/flink-processor/src/main/java/berlinmod/Q9ContinuousFunction.java new file mode 100644 index 0000000..09e122c --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/Q9ContinuousFunction.java @@ -0,0 +1,69 @@ +package berlinmod; + +import org.apache.flink.api.common.state.ValueState; +import org.apache.flink.api.common.state.ValueStateDescriptor; +import org.apache.flink.api.common.typeinfo.TypeHint; +import org.apache.flink.api.common.typeinfo.TypeInformation; +import org.apache.flink.api.java.tuple.Tuple2; +import org.apache.flink.api.java.tuple.Tuple4; +import org.apache.flink.configuration.Configuration; +import org.apache.flink.streaming.api.functions.KeyedProcessFunction; +import org.apache.flink.util.Collector; + +/** + * BerlinMOD-Q9 — continuous form. + * + *

"What is the current distance between vehicles X and Y?" + * + *

Driven by events from either X or Y. State holds the last-known position + * of each as {@code Tuple4(xLon, xLat, yLon, yLat)} (with sentinel + * {@code Double.NaN} for unseen). On each event, update the corresponding + * pair of slots; if both are known, emit {@code (eventTime, distanceMetres)}. + * + *

Caller is expected to filter the stream to {@code vehicleId ∈ {X, Y}} + * and key by a constant so the single shared state lives in one subtask. + * (Two-vehicle Q9 is single-task by construction; a generalised "all-pairs" + * variant would be a different operator.) + */ +public class Q9ContinuousFunction + extends KeyedProcessFunction> { + + private final int xVehicleId; + private final int yVehicleId; + private transient ValueState> xy; + + public Q9ContinuousFunction(int xVehicleId, int yVehicleId) { + this.xVehicleId = xVehicleId; + this.yVehicleId = yVehicleId; + } + + @Override + public void open(Configuration parameters) { + TypeInformation> tInfo = + TypeInformation.of(new TypeHint>() {}); + xy = getRuntimeContext().getState(new ValueStateDescriptor<>("q9xy", tInfo)); + } + + @Override + public void processElement( + BerlinMODTrip trip, + Context ctx, + Collector> out) throws Exception { + Tuple4 s = xy.value(); + if (s == null) { + s = new Tuple4<>(Double.NaN, Double.NaN, Double.NaN, Double.NaN); + } + if (trip.getVehicleId() == xVehicleId) { + s = new Tuple4<>(trip.getLon(), trip.getLat(), s.f2, s.f3); + } else if (trip.getVehicleId() == yVehicleId) { + s = new Tuple4<>(s.f0, s.f1, trip.getLon(), trip.getLat()); + } else { + return; + } + xy.update(s); + if (!Double.isNaN(s.f0) && !Double.isNaN(s.f2)) { + double d = MEOSBridge.distanceMetres(s.f0, s.f1, s.f2, s.f3); + out.collect(new Tuple2<>(trip.getTimestamp(), d)); + } + } +} diff --git a/flink-processor/src/main/java/berlinmod/Q9SnapshotFunction.java b/flink-processor/src/main/java/berlinmod/Q9SnapshotFunction.java new file mode 100644 index 0000000..93498c0 --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/Q9SnapshotFunction.java @@ -0,0 +1,80 @@ +package berlinmod; + +import org.apache.flink.api.common.state.ValueState; +import org.apache.flink.api.common.state.ValueStateDescriptor; +import org.apache.flink.api.common.typeinfo.TypeHint; +import org.apache.flink.api.common.typeinfo.TypeInformation; +import org.apache.flink.api.java.tuple.Tuple2; +import org.apache.flink.api.java.tuple.Tuple4; +import org.apache.flink.configuration.Configuration; +import org.apache.flink.streaming.api.functions.KeyedProcessFunction; +import org.apache.flink.util.Collector; + +/** + * BerlinMOD-Q9 — snapshot form. + * + *

"At time T, what is the distance between vehicles X and Y (using + * their most-recent-known positions on or before T)?" + * + *

This is the parity-oracle form: streaming output at watermark T must + * equal the batch BerlinMOD-Q9 result on the same data up to T. + * + *

Shared single-key state matches {@link Q9ContinuousFunction}. On each + * X or Y event, update the corresponding pair of slots and register an + * event-time timer at the next snapshot tick. On timer fire at T, emit + * {@code (T, distanceMetres)} if both X and Y have been seen by T. + */ +public class Q9SnapshotFunction + extends KeyedProcessFunction> { + + private final int xVehicleId; + private final int yVehicleId; + private final long snapshotTickMillis; + private transient ValueState> xy; + + public Q9SnapshotFunction(int xVehicleId, int yVehicleId, long snapshotTickMillis) { + this.xVehicleId = xVehicleId; + this.yVehicleId = yVehicleId; + this.snapshotTickMillis = snapshotTickMillis; + } + + @Override + public void open(Configuration parameters) { + TypeInformation> tInfo = + TypeInformation.of(new TypeHint>() {}); + xy = getRuntimeContext().getState(new ValueStateDescriptor<>("q9SnapXy", tInfo)); + } + + @Override + public void processElement( + BerlinMODTrip trip, + Context ctx, + Collector> out) throws Exception { + Tuple4 s = xy.value(); + if (s == null) { + s = new Tuple4<>(Double.NaN, Double.NaN, Double.NaN, Double.NaN); + } + if (trip.getVehicleId() == xVehicleId) { + s = new Tuple4<>(trip.getLon(), trip.getLat(), s.f2, s.f3); + } else if (trip.getVehicleId() == yVehicleId) { + s = new Tuple4<>(s.f0, s.f1, trip.getLon(), trip.getLat()); + } else { + return; + } + xy.update(s); + long nextTick = ((trip.getTimestamp() / snapshotTickMillis) + 1) * snapshotTickMillis; + ctx.timerService().registerEventTimeTimer(nextTick); + } + + @Override + public void onTimer( + long timestamp, + OnTimerContext ctx, + Collector> out) throws Exception { + Tuple4 s = xy.value(); + if (s != null && !Double.isNaN(s.f0) && !Double.isNaN(s.f2)) { + double d = MEOSBridge.distanceMetres(s.f0, s.f1, s.f2, s.f3); + out.collect(new Tuple2<>(timestamp, d)); + } + } +} diff --git a/flink-processor/src/main/java/berlinmod/Q9WindowedFunction.java b/flink-processor/src/main/java/berlinmod/Q9WindowedFunction.java new file mode 100644 index 0000000..25c9688 --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/Q9WindowedFunction.java @@ -0,0 +1,54 @@ +package berlinmod; + +import org.apache.flink.api.java.tuple.Tuple3; +import org.apache.flink.streaming.api.functions.windowing.ProcessAllWindowFunction; +import org.apache.flink.streaming.api.windowing.windows.TimeWindow; +import org.apache.flink.util.Collector; + +/** + * BerlinMOD-Q9 — windowed form. + * + *

"Per N-second tumbling window, what is the distance between vehicles + * X and Y at the end of the window (their last-seen positions within + * the window)?" + * + *

Scans the window's events, keeps the latest X and the latest Y + * positions, and emits {@code (windowStart, windowEnd, distanceMetres)} if + * both X and Y were seen in the window. If either was missing, emits nothing + * (no triangulation against earlier windows — the windowed form is strictly + * intra-window). + */ +public class Q9WindowedFunction + extends ProcessAllWindowFunction, TimeWindow> { + + private final int xVehicleId; + private final int yVehicleId; + + public Q9WindowedFunction(int xVehicleId, int yVehicleId) { + this.xVehicleId = xVehicleId; + this.yVehicleId = yVehicleId; + } + + @Override + public void process( + Context ctx, + Iterable elements, + Collector> out) { + BerlinMODTrip latestX = null, latestY = null; + for (BerlinMODTrip trip : elements) { + if (trip.getVehicleId() == xVehicleId + && (latestX == null || trip.getTimestamp() > latestX.getTimestamp())) { + latestX = trip; + } else if (trip.getVehicleId() == yVehicleId + && (latestY == null || trip.getTimestamp() > latestY.getTimestamp())) { + latestY = trip; + } + } + if (latestX != null && latestY != null) { + double d = MEOSBridge.distanceMetres( + latestX.getLon(), latestX.getLat(), + latestY.getLon(), latestY.getLat()); + out.collect(new Tuple3<>(ctx.window().getStart(), ctx.window().getEnd(), d)); + } + } +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsBigintSet.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsBigintSet.java new file mode 100644 index 0000000..3cf5098 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsBigintSet.java @@ -0,0 +1,130 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: BigintSet + * Methods emitted: 8 (bounded-state=5 · io-meta=2 · stateless=1) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsBigintSet { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsBigintSet() { /* utility */ } + + /** + * MEOS {@code bigintset_make} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code constructor}.

+ *

Classification: constructor of instant/scalar

+ */ + public static jnr.ffi.Pointer bigintset_make(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bigintset_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bigintset_make(arg0, arg1); + } + + /** + * MEOS {@code bigintset_end_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static long bigintset_end_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bigintset_end_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bigintset_end_value(arg0); + } + + /** + * MEOS {@code bigintset_shift_scale} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer bigintset_shift_scale(jnr.ffi.Pointer arg0, long arg1, long arg2, boolean arg3, boolean arg4) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bigintset_shift_scale requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bigintset_shift_scale(arg0, arg1, arg2, arg3, arg4); + } + + /** + * MEOS {@code bigintset_start_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static long bigintset_start_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bigintset_start_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bigintset_start_value(arg0); + } + + /** + * MEOS {@code bigintset_value_n} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer bigintset_value_n(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bigintset_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bigintset_value_n(arg0, arg1); + } + + /** + * MEOS {@code bigintset_values} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer bigintset_values(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bigintset_values requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bigintset_values(arg0); + } + + /** + * MEOS {@code bigintset_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer bigintset_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bigintset_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bigintset_in(arg0); + } + + /** + * MEOS {@code bigintset_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static java.lang.String bigintset_out(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bigintset_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bigintset_out(arg0); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsBigintSpan.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsBigintSpan.java new file mode 100644 index 0000000..d9d4ca6 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsBigintSpan.java @@ -0,0 +1,144 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: BigintSpan + * Methods emitted: 9 (bounded-state=6 · io-meta=2 · stateless=1) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsBigintSpan { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsBigintSpan() { /* utility */ } + + /** + * MEOS {@code bigintspan_make} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code constructor}.

+ *

Classification: constructor of instant/scalar

+ */ + public static jnr.ffi.Pointer bigintspan_make(long arg0, long arg1, boolean arg2, boolean arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bigintspan_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bigintspan_make(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code bigintspan_bins} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer bigintspan_bins(jnr.ffi.Pointer arg0, long arg1, long arg2, jnr.ffi.Pointer arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bigintspan_bins requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bigintspan_bins(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code bigintspan_expand} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer bigintspan_expand(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bigintspan_expand requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bigintspan_expand(arg0, arg1); + } + + /** + * MEOS {@code bigintspan_lower} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static long bigintspan_lower(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bigintspan_lower requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bigintspan_lower(arg0); + } + + /** + * MEOS {@code bigintspan_shift_scale} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer bigintspan_shift_scale(jnr.ffi.Pointer arg0, long arg1, long arg2, boolean arg3, boolean arg4) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bigintspan_shift_scale requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bigintspan_shift_scale(arg0, arg1, arg2, arg3, arg4); + } + + /** + * MEOS {@code bigintspan_upper} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static long bigintspan_upper(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bigintspan_upper requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bigintspan_upper(arg0); + } + + /** + * MEOS {@code bigintspan_width} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static long bigintspan_width(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bigintspan_width requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bigintspan_width(arg0); + } + + /** + * MEOS {@code bigintspan_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer bigintspan_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bigintspan_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bigintspan_in(arg0); + } + + /** + * MEOS {@code bigintspan_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static java.lang.String bigintspan_out(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bigintspan_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bigintspan_out(arg0); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsBigintSpanSet.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsBigintSpanSet.java new file mode 100644 index 0000000..d66dc3b --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsBigintSpanSet.java @@ -0,0 +1,116 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: BigintSpanSet + * Methods emitted: 7 (bounded-state=5 · io-meta=2) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsBigintSpanSet { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsBigintSpanSet() { /* utility */ } + + /** + * MEOS {@code bigintspanset_bins} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer bigintspanset_bins(jnr.ffi.Pointer arg0, long arg1, long arg2, jnr.ffi.Pointer arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bigintspanset_bins requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bigintspanset_bins(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code bigintspanset_lower} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static long bigintspanset_lower(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bigintspanset_lower requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bigintspanset_lower(arg0); + } + + /** + * MEOS {@code bigintspanset_shift_scale} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer bigintspanset_shift_scale(jnr.ffi.Pointer arg0, long arg1, long arg2, boolean arg3, boolean arg4) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bigintspanset_shift_scale requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bigintspanset_shift_scale(arg0, arg1, arg2, arg3, arg4); + } + + /** + * MEOS {@code bigintspanset_upper} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static long bigintspanset_upper(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bigintspanset_upper requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bigintspanset_upper(arg0); + } + + /** + * MEOS {@code bigintspanset_width} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static long bigintspanset_width(jnr.ffi.Pointer arg0, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bigintspanset_width requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bigintspanset_width(arg0, arg1); + } + + /** + * MEOS {@code bigintspanset_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer bigintspanset_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bigintspanset_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bigintspanset_in(arg0); + } + + /** + * MEOS {@code bigintspanset_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static java.lang.String bigintspanset_out(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bigintspanset_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bigintspanset_out(arg0); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsCbufferSet.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsCbufferSet.java new file mode 100644 index 0000000..6626f2b --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsCbufferSet.java @@ -0,0 +1,116 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: CbufferSet + * Methods emitted: 7 (bounded-state=4 · io-meta=2 · stateless=1) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsCbufferSet { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsCbufferSet() { /* utility */ } + + /** + * MEOS {@code cbufferset_make} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code constructor}.

+ *

Classification: constructor of instant/scalar

+ */ + public static jnr.ffi.Pointer cbufferset_make(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbufferset_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbufferset_make(arg0, arg1); + } + + /** + * MEOS {@code cbufferset_end_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer cbufferset_end_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbufferset_end_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbufferset_end_value(arg0); + } + + /** + * MEOS {@code cbufferset_start_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer cbufferset_start_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbufferset_start_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbufferset_start_value(arg0); + } + + /** + * MEOS {@code cbufferset_value_n} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer cbufferset_value_n(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbufferset_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbufferset_value_n(arg0, arg1); + } + + /** + * MEOS {@code cbufferset_values} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer cbufferset_values(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbufferset_values requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbufferset_values(arg0); + } + + /** + * MEOS {@code cbufferset_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer cbufferset_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbufferset_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbufferset_in(arg0); + } + + /** + * MEOS {@code cbufferset_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static java.lang.String cbufferset_out(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbufferset_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbufferset_out(arg0, arg1); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsDateSet.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsDateSet.java new file mode 100644 index 0000000..c2d6fa3 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsDateSet.java @@ -0,0 +1,144 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: DateSet + * Methods emitted: 9 (bounded-state=5 · io-meta=2 · stateless=2) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsDateSet { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsDateSet() { /* utility */ } + + /** + * MEOS {@code dateset_make} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code constructor}.

+ *

Classification: constructor of instant/scalar

+ */ + public static jnr.ffi.Pointer dateset_make(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "dateset_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.dateset_make(arg0, arg1); + } + + /** + * MEOS {@code dateset_to_tstzset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer dateset_to_tstzset(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "dateset_to_tstzset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.dateset_to_tstzset(arg0); + } + + /** + * MEOS {@code dateset_end_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static int dateset_end_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "dateset_end_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.dateset_end_value(arg0); + } + + /** + * MEOS {@code dateset_shift_scale} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer dateset_shift_scale(jnr.ffi.Pointer arg0, int arg1, int arg2, boolean arg3, boolean arg4) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "dateset_shift_scale requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.dateset_shift_scale(arg0, arg1, arg2, arg3, arg4); + } + + /** + * MEOS {@code dateset_start_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static int dateset_start_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "dateset_start_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.dateset_start_value(arg0); + } + + /** + * MEOS {@code dateset_value_n} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer dateset_value_n(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "dateset_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.dateset_value_n(arg0, arg1); + } + + /** + * MEOS {@code dateset_values} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer dateset_values(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "dateset_values requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.dateset_values(arg0); + } + + /** + * MEOS {@code dateset_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer dateset_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "dateset_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.dateset_in(arg0); + } + + /** + * MEOS {@code dateset_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static java.lang.String dateset_out(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "dateset_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.dateset_out(arg0); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsDateSpan.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsDateSpan.java new file mode 100644 index 0000000..4288d5d --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsDateSpan.java @@ -0,0 +1,144 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: DateSpan + * Methods emitted: 9 (bounded-state=5 · io-meta=2 · stateless=2) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsDateSpan { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsDateSpan() { /* utility */ } + + /** + * MEOS {@code datespan_make} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code constructor}.

+ *

Classification: constructor of instant/scalar

+ */ + public static jnr.ffi.Pointer datespan_make(int arg0, int arg1, boolean arg2, boolean arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "datespan_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.datespan_make(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code datespan_to_tstzspan} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer datespan_to_tstzspan(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "datespan_to_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.datespan_to_tstzspan(arg0); + } + + /** + * MEOS {@code datespan_bins} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer datespan_bins(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, int arg2, jnr.ffi.Pointer arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "datespan_bins requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.datespan_bins(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code datespan_duration} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer datespan_duration(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "datespan_duration requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.datespan_duration(arg0); + } + + /** + * MEOS {@code datespan_lower} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static int datespan_lower(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "datespan_lower requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.datespan_lower(arg0); + } + + /** + * MEOS {@code datespan_shift_scale} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer datespan_shift_scale(jnr.ffi.Pointer arg0, int arg1, int arg2, boolean arg3, boolean arg4) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "datespan_shift_scale requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.datespan_shift_scale(arg0, arg1, arg2, arg3, arg4); + } + + /** + * MEOS {@code datespan_upper} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static int datespan_upper(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "datespan_upper requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.datespan_upper(arg0); + } + + /** + * MEOS {@code datespan_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer datespan_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "datespan_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.datespan_in(arg0); + } + + /** + * MEOS {@code datespan_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static java.lang.String datespan_out(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "datespan_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.datespan_out(arg0); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsDateSpanSet.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsDateSpanSet.java new file mode 100644 index 0000000..9cedda0 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsDateSpanSet.java @@ -0,0 +1,172 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: DateSpanSet + * Methods emitted: 11 (bounded-state=8 · io-meta=2 · stateless=1) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsDateSpanSet { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsDateSpanSet() { /* utility */ } + + /** + * MEOS {@code datespanset_to_tstzspanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer datespanset_to_tstzspanset(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "datespanset_to_tstzspanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.datespanset_to_tstzspanset(arg0); + } + + /** + * MEOS {@code datespanset_bins} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer datespanset_bins(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, int arg2, jnr.ffi.Pointer arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "datespanset_bins requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.datespanset_bins(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code datespanset_date_n} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer datespanset_date_n(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "datespanset_date_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.datespanset_date_n(arg0, arg1); + } + + /** + * MEOS {@code datespanset_dates} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer datespanset_dates(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "datespanset_dates requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.datespanset_dates(arg0); + } + + /** + * MEOS {@code datespanset_duration} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer datespanset_duration(jnr.ffi.Pointer arg0, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "datespanset_duration requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.datespanset_duration(arg0, arg1); + } + + /** + * MEOS {@code datespanset_end_date} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static int datespanset_end_date(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "datespanset_end_date requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.datespanset_end_date(arg0); + } + + /** + * MEOS {@code datespanset_num_dates} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static int datespanset_num_dates(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "datespanset_num_dates requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.datespanset_num_dates(arg0); + } + + /** + * MEOS {@code datespanset_shift_scale} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer datespanset_shift_scale(jnr.ffi.Pointer arg0, int arg1, int arg2, boolean arg3, boolean arg4) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "datespanset_shift_scale requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.datespanset_shift_scale(arg0, arg1, arg2, arg3, arg4); + } + + /** + * MEOS {@code datespanset_start_date} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static int datespanset_start_date(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "datespanset_start_date requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.datespanset_start_date(arg0); + } + + /** + * MEOS {@code datespanset_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer datespanset_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "datespanset_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.datespanset_in(arg0); + } + + /** + * MEOS {@code datespanset_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static java.lang.String datespanset_out(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "datespanset_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.datespanset_out(arg0); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFloatSet.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFloatSet.java new file mode 100644 index 0000000..1786693 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFloatSet.java @@ -0,0 +1,200 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: FloatSet + * Methods emitted: 13 (bounded-state=9 · io-meta=2 · stateless=2) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsFloatSet { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsFloatSet() { /* utility */ } + + /** + * MEOS {@code floatset_make} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code constructor}.

+ *

Classification: constructor of instant/scalar

+ */ + public static jnr.ffi.Pointer floatset_make(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatset_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatset_make(arg0, arg1); + } + + /** + * MEOS {@code floatset_to_intset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer floatset_to_intset(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatset_to_intset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatset_to_intset(arg0); + } + + /** + * MEOS {@code floatset_ceil} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer floatset_ceil(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatset_ceil requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatset_ceil(arg0); + } + + /** + * MEOS {@code floatset_degrees} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer floatset_degrees(jnr.ffi.Pointer arg0, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatset_degrees requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatset_degrees(arg0, arg1); + } + + /** + * MEOS {@code floatset_end_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static double floatset_end_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatset_end_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatset_end_value(arg0); + } + + /** + * MEOS {@code floatset_floor} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer floatset_floor(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatset_floor requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatset_floor(arg0); + } + + /** + * MEOS {@code floatset_radians} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer floatset_radians(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatset_radians requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatset_radians(arg0); + } + + /** + * MEOS {@code floatset_shift_scale} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer floatset_shift_scale(jnr.ffi.Pointer arg0, double arg1, double arg2, boolean arg3, boolean arg4) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatset_shift_scale requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatset_shift_scale(arg0, arg1, arg2, arg3, arg4); + } + + /** + * MEOS {@code floatset_start_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static double floatset_start_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatset_start_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatset_start_value(arg0); + } + + /** + * MEOS {@code floatset_value_n} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer floatset_value_n(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatset_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatset_value_n(arg0, arg1); + } + + /** + * MEOS {@code floatset_values} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer floatset_values(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatset_values requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatset_values(arg0); + } + + /** + * MEOS {@code floatset_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer floatset_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatset_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatset_in(arg0); + } + + /** + * MEOS {@code floatset_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static java.lang.String floatset_out(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatset_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatset_out(arg0, arg1); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFloatSpan.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFloatSpan.java new file mode 100644 index 0000000..824766c --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFloatSpan.java @@ -0,0 +1,228 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: FloatSpan + * Methods emitted: 15 (bounded-state=11 · io-meta=2 · stateless=2) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsFloatSpan { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsFloatSpan() { /* utility */ } + + /** + * MEOS {@code floatspan_make} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code constructor}.

+ *

Classification: constructor of instant/scalar

+ */ + public static jnr.ffi.Pointer floatspan_make(double arg0, double arg1, boolean arg2, boolean arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatspan_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatspan_make(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code floatspan_to_intspan} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer floatspan_to_intspan(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatspan_to_intspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatspan_to_intspan(arg0); + } + + /** + * MEOS {@code floatspan_bins} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer floatspan_bins(jnr.ffi.Pointer arg0, double arg1, double arg2, jnr.ffi.Pointer arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatspan_bins requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatspan_bins(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code floatspan_ceil} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer floatspan_ceil(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatspan_ceil requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatspan_ceil(arg0); + } + + /** + * MEOS {@code floatspan_degrees} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer floatspan_degrees(jnr.ffi.Pointer arg0, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatspan_degrees requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatspan_degrees(arg0, arg1); + } + + /** + * MEOS {@code floatspan_expand} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer floatspan_expand(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatspan_expand requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatspan_expand(arg0, arg1); + } + + /** + * MEOS {@code floatspan_floor} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer floatspan_floor(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatspan_floor requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatspan_floor(arg0); + } + + /** + * MEOS {@code floatspan_lower} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static double floatspan_lower(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatspan_lower requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatspan_lower(arg0); + } + + /** + * MEOS {@code floatspan_radians} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer floatspan_radians(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatspan_radians requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatspan_radians(arg0); + } + + /** + * MEOS {@code floatspan_round} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer floatspan_round(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatspan_round requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatspan_round(arg0, arg1); + } + + /** + * MEOS {@code floatspan_shift_scale} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer floatspan_shift_scale(jnr.ffi.Pointer arg0, double arg1, double arg2, boolean arg3, boolean arg4) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatspan_shift_scale requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatspan_shift_scale(arg0, arg1, arg2, arg3, arg4); + } + + /** + * MEOS {@code floatspan_upper} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static double floatspan_upper(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatspan_upper requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatspan_upper(arg0); + } + + /** + * MEOS {@code floatspan_width} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static double floatspan_width(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatspan_width requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatspan_width(arg0); + } + + /** + * MEOS {@code floatspan_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer floatspan_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatspan_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatspan_in(arg0); + } + + /** + * MEOS {@code floatspan_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static java.lang.String floatspan_out(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatspan_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatspan_out(arg0, arg1); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFloatSpanSet.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFloatSpanSet.java new file mode 100644 index 0000000..38bf45b --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFloatSpanSet.java @@ -0,0 +1,200 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: FloatSpanSet + * Methods emitted: 13 (bounded-state=10 · io-meta=2 · stateless=1) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsFloatSpanSet { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsFloatSpanSet() { /* utility */ } + + /** + * MEOS {@code floatspanset_to_intspanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer floatspanset_to_intspanset(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatspanset_to_intspanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatspanset_to_intspanset(arg0); + } + + /** + * MEOS {@code floatspanset_bins} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer floatspanset_bins(jnr.ffi.Pointer arg0, double arg1, double arg2, jnr.ffi.Pointer arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatspanset_bins requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatspanset_bins(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code floatspanset_ceil} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer floatspanset_ceil(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatspanset_ceil requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatspanset_ceil(arg0); + } + + /** + * MEOS {@code floatspanset_degrees} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer floatspanset_degrees(jnr.ffi.Pointer arg0, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatspanset_degrees requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatspanset_degrees(arg0, arg1); + } + + /** + * MEOS {@code floatspanset_floor} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer floatspanset_floor(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatspanset_floor requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatspanset_floor(arg0); + } + + /** + * MEOS {@code floatspanset_lower} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static double floatspanset_lower(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatspanset_lower requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatspanset_lower(arg0); + } + + /** + * MEOS {@code floatspanset_radians} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer floatspanset_radians(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatspanset_radians requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatspanset_radians(arg0); + } + + /** + * MEOS {@code floatspanset_round} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer floatspanset_round(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatspanset_round requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatspanset_round(arg0, arg1); + } + + /** + * MEOS {@code floatspanset_shift_scale} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer floatspanset_shift_scale(jnr.ffi.Pointer arg0, double arg1, double arg2, boolean arg3, boolean arg4) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatspanset_shift_scale requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatspanset_shift_scale(arg0, arg1, arg2, arg3, arg4); + } + + /** + * MEOS {@code floatspanset_upper} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static double floatspanset_upper(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatspanset_upper requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatspanset_upper(arg0); + } + + /** + * MEOS {@code floatspanset_width} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static double floatspanset_width(jnr.ffi.Pointer arg0, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatspanset_width requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatspanset_width(arg0, arg1); + } + + /** + * MEOS {@code floatspanset_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer floatspanset_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatspanset_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatspanset_in(arg0); + } + + /** + * MEOS {@code floatspanset_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static java.lang.String floatspanset_out(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatspanset_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatspanset_out(arg0, arg1); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFreeCbuffer.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFreeCbuffer.java new file mode 100644 index 0000000..f218a4d --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFreeCbuffer.java @@ -0,0 +1,1957 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_free.py — do not edit by hand. + * Source header: meos_cbuffer.h + * Methods emitted: 149 (bounded-state=68 · stateless=43 · cross-stream=22 · io-meta=8 · windowed=8) + * Scope: MEOS public functions NOT classified into any object-model class + * (free functions, not methods on a class). + * Source: JMEOS PR #19 (functions.GeneratedFunctions) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsFreeCbuffer { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsFreeCbuffer() { /* utility */ } + + /** + * MEOS {@code cbuffer_cmp} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar comparison/hash

+ */ + public static int cbuffer_cmp(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbuffer_cmp requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbuffer_cmp(arg0, arg1); + } + + /** + * MEOS {@code cbuffer_copy} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer cbuffer_copy(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbuffer_copy requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbuffer_copy(arg0); + } + + /** + * MEOS {@code cbuffer_eq} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar comparison/hash

+ */ + public static boolean cbuffer_eq(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbuffer_eq requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbuffer_eq(arg0, arg1); + } + + /** + * MEOS {@code cbuffer_ge} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar comparison/hash

+ */ + public static boolean cbuffer_ge(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbuffer_ge requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbuffer_ge(arg0, arg1); + } + + /** + * MEOS {@code cbuffer_gt} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar comparison/hash

+ */ + public static boolean cbuffer_gt(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbuffer_gt requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbuffer_gt(arg0, arg1); + } + + /** + * MEOS {@code cbuffer_hash} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar comparison/hash

+ */ + public static int cbuffer_hash(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbuffer_hash requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbuffer_hash(arg0); + } + + /** + * MEOS {@code cbuffer_hash_extended} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar comparison/hash

+ */ + public static long cbuffer_hash_extended(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbuffer_hash_extended requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbuffer_hash_extended(arg0, arg1); + } + + /** + * MEOS {@code cbuffer_le} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar comparison/hash

+ */ + public static boolean cbuffer_le(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbuffer_le requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbuffer_le(arg0, arg1); + } + + /** + * MEOS {@code cbuffer_lt} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar comparison/hash

+ */ + public static boolean cbuffer_lt(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbuffer_lt requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbuffer_lt(arg0, arg1); + } + + /** + * MEOS {@code cbuffer_make} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: make/from_base of instant/scalar

+ */ + public static jnr.ffi.Pointer cbuffer_make(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbuffer_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbuffer_make(arg0, arg1); + } + + /** + * MEOS {@code cbuffer_ne} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar comparison/hash

+ */ + public static boolean cbuffer_ne(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbuffer_ne requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbuffer_ne(arg0, arg1); + } + + /** + * MEOS {@code cbuffer_nsame} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static boolean cbuffer_nsame(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbuffer_nsame requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbuffer_nsame(arg0, arg1); + } + + /** + * MEOS {@code cbuffer_point} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer cbuffer_point(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbuffer_point requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbuffer_point(arg0); + } + + /** + * MEOS {@code cbuffer_radius} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static double cbuffer_radius(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbuffer_radius requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbuffer_radius(arg0); + } + + /** + * MEOS {@code cbuffer_round} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: transform/normalize (pure)

+ */ + public static jnr.ffi.Pointer cbuffer_round(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbuffer_round requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbuffer_round(arg0, arg1); + } + + /** + * MEOS {@code cbuffer_same} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static boolean cbuffer_same(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbuffer_same requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbuffer_same(arg0, arg1); + } + + /** + * MEOS {@code cbuffer_set_srid} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static void cbuffer_set_srid(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbuffer_set_srid requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + GeneratedFunctions.cbuffer_set_srid(arg0, arg1); + } + + /** + * MEOS {@code cbuffer_srid} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static int cbuffer_srid(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbuffer_srid requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbuffer_srid(arg0); + } + + /** + * MEOS {@code cbuffer_timestamptz_to_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer cbuffer_timestamptz_to_stbox(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbuffer_timestamptz_to_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbuffer_timestamptz_to_stbox(arg0, arg1); + } + + /** + * MEOS {@code cbuffer_to_geom} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer cbuffer_to_geom(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbuffer_to_geom requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbuffer_to_geom(arg0); + } + + /** + * MEOS {@code cbuffer_to_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer cbuffer_to_set(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbuffer_to_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbuffer_to_set(arg0); + } + + /** + * MEOS {@code cbuffer_to_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer cbuffer_to_stbox(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbuffer_to_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbuffer_to_stbox(arg0); + } + + /** + * MEOS {@code cbuffer_transform} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer cbuffer_transform(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbuffer_transform requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbuffer_transform(arg0, arg1); + } + + /** + * MEOS {@code cbuffer_transform_pipeline} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer cbuffer_transform_pipeline(jnr.ffi.Pointer arg0, java.lang.String arg1, int arg2, boolean arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbuffer_transform_pipeline requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbuffer_transform_pipeline(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code cbuffer_tstzspan_to_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer cbuffer_tstzspan_to_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbuffer_tstzspan_to_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbuffer_tstzspan_to_stbox(arg0, arg1); + } + + /** + * MEOS {@code cbuffer_union_transfn} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer cbuffer_union_transfn(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbuffer_union_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbuffer_union_transfn(arg0, arg1); + } + + /** + * MEOS {@code cbufferarr_round} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: transform/normalize (pure)

+ */ + public static jnr.ffi.Pointer cbufferarr_round(jnr.ffi.Pointer arg0, int arg1, int arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbufferarr_round requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbufferarr_round(arg0, arg1, arg2); + } + + /** + * MEOS {@code cbufferarr_to_geom} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer cbufferarr_to_geom(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbufferarr_to_geom requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbufferarr_to_geom(arg0, arg1); + } + + /** + * MEOS {@code contained_cbuffer_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 scalars (box/span algebra)

+ */ + public static boolean contained_cbuffer_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contained_cbuffer_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contained_cbuffer_set(arg0, arg1); + } + + /** + * MEOS {@code contains_cbuffer_cbuffer} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 scalars (box/span algebra)

+ */ + public static int contains_cbuffer_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_cbuffer_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_cbuffer_cbuffer(arg0, arg1); + } + + /** + * MEOS {@code contains_set_cbuffer} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contains_set_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_set_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_set_cbuffer(arg0, arg1); + } + + /** + * MEOS {@code covers_cbuffer_cbuffer} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar in/out (default-stateless catch-all)

+ */ + public static int covers_cbuffer_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "covers_cbuffer_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.covers_cbuffer_cbuffer(arg0, arg1); + } + + /** + * MEOS {@code disjoint_cbuffer_cbuffer} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar in/out (default-stateless catch-all)

+ */ + public static int disjoint_cbuffer_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "disjoint_cbuffer_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.disjoint_cbuffer_cbuffer(arg0, arg1); + } + + /** + * MEOS {@code dwithin_cbuffer_cbuffer} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar in/out (default-stateless catch-all)

+ */ + public static int dwithin_cbuffer_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, double arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "dwithin_cbuffer_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.dwithin_cbuffer_cbuffer(arg0, arg1, arg2); + } + + /** + * MEOS {@code geom_to_cbuffer} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer geom_to_cbuffer(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geom_to_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geom_to_cbuffer(arg0); + } + + /** + * MEOS {@code intersection_set_cbuffer} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer intersection_set_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intersection_set_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intersection_set_cbuffer(arg0, arg1); + } + + /** + * MEOS {@code intersects_cbuffer_cbuffer} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar in/out (default-stateless catch-all)

+ */ + public static int intersects_cbuffer_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intersects_cbuffer_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intersects_cbuffer_cbuffer(arg0, arg1); + } + + /** + * MEOS {@code teq_cbuffer_tcbuffer} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer teq_cbuffer_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "teq_cbuffer_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.teq_cbuffer_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code teq_tcbuffer_cbuffer} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer teq_tcbuffer_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "teq_tcbuffer_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.teq_tcbuffer_cbuffer(arg0, arg1); + } + + /** + * MEOS {@code tne_cbuffer_tcbuffer} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tne_cbuffer_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tne_cbuffer_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tne_cbuffer_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code tne_tcbuffer_cbuffer} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tne_tcbuffer_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tne_tcbuffer_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tne_tcbuffer_cbuffer(arg0, arg1); + } + + /** + * MEOS {@code touches_cbuffer_cbuffer} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar in/out (default-stateless catch-all)

+ */ + public static int touches_cbuffer_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "touches_cbuffer_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.touches_cbuffer_cbuffer(arg0, arg1); + } + + /** + * MEOS {@code union_set_cbuffer} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_set_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_set_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_set_cbuffer(arg0, arg1); + } + + /** + * MEOS {@code acontains_cbuffer_tcbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int acontains_cbuffer_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "acontains_cbuffer_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.acontains_cbuffer_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code acontains_geo_tcbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int acontains_geo_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "acontains_geo_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.acontains_geo_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code acontains_tcbuffer_cbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int acontains_tcbuffer_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "acontains_tcbuffer_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.acontains_tcbuffer_cbuffer(arg0, arg1); + } + + /** + * MEOS {@code acontains_tcbuffer_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int acontains_tcbuffer_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "acontains_tcbuffer_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.acontains_tcbuffer_geo(arg0, arg1); + } + + /** + * MEOS {@code acovers_cbuffer_tcbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int acovers_cbuffer_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "acovers_cbuffer_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.acovers_cbuffer_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code acovers_geo_tcbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int acovers_geo_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "acovers_geo_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.acovers_geo_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code acovers_tcbuffer_cbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int acovers_tcbuffer_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "acovers_tcbuffer_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.acovers_tcbuffer_cbuffer(arg0, arg1); + } + + /** + * MEOS {@code acovers_tcbuffer_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int acovers_tcbuffer_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "acovers_tcbuffer_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.acovers_tcbuffer_geo(arg0, arg1); + } + + /** + * MEOS {@code adisjoint_tcbuffer_cbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int adisjoint_tcbuffer_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "adisjoint_tcbuffer_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.adisjoint_tcbuffer_cbuffer(arg0, arg1); + } + + /** + * MEOS {@code adisjoint_tcbuffer_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int adisjoint_tcbuffer_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "adisjoint_tcbuffer_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.adisjoint_tcbuffer_geo(arg0, arg1); + } + + /** + * MEOS {@code adwithin_tcbuffer_cbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int adwithin_tcbuffer_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, double arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "adwithin_tcbuffer_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.adwithin_tcbuffer_cbuffer(arg0, arg1, arg2); + } + + /** + * MEOS {@code adwithin_tcbuffer_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int adwithin_tcbuffer_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, double arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "adwithin_tcbuffer_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.adwithin_tcbuffer_geo(arg0, arg1, arg2); + } + + /** + * MEOS {@code aintersects_tcbuffer_cbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int aintersects_tcbuffer_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "aintersects_tcbuffer_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.aintersects_tcbuffer_cbuffer(arg0, arg1); + } + + /** + * MEOS {@code aintersects_tcbuffer_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int aintersects_tcbuffer_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "aintersects_tcbuffer_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.aintersects_tcbuffer_geo(arg0, arg1); + } + + /** + * MEOS {@code atouches_tcbuffer_cbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int atouches_tcbuffer_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "atouches_tcbuffer_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.atouches_tcbuffer_cbuffer(arg0, arg1); + } + + /** + * MEOS {@code atouches_tcbuffer_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int atouches_tcbuffer_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "atouches_tcbuffer_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.atouches_tcbuffer_geo(arg0, arg1); + } + + /** + * MEOS {@code distance_cbuffer_cbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static double distance_cbuffer_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_cbuffer_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_cbuffer_cbuffer(arg0, arg1); + } + + /** + * MEOS {@code distance_cbuffer_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static double distance_cbuffer_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_cbuffer_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_cbuffer_geo(arg0, arg1); + } + + /** + * MEOS {@code distance_cbuffer_stbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static double distance_cbuffer_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_cbuffer_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_cbuffer_stbox(arg0, arg1); + } + + /** + * MEOS {@code econtains_cbuffer_tcbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int econtains_cbuffer_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "econtains_cbuffer_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.econtains_cbuffer_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code econtains_tcbuffer_cbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int econtains_tcbuffer_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "econtains_tcbuffer_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.econtains_tcbuffer_cbuffer(arg0, arg1); + } + + /** + * MEOS {@code econtains_tcbuffer_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int econtains_tcbuffer_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "econtains_tcbuffer_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.econtains_tcbuffer_geo(arg0, arg1); + } + + /** + * MEOS {@code ecovers_cbuffer_tcbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int ecovers_cbuffer_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ecovers_cbuffer_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ecovers_cbuffer_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code ecovers_tcbuffer_cbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int ecovers_tcbuffer_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ecovers_tcbuffer_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ecovers_tcbuffer_cbuffer(arg0, arg1); + } + + /** + * MEOS {@code ecovers_tcbuffer_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int ecovers_tcbuffer_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ecovers_tcbuffer_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ecovers_tcbuffer_geo(arg0, arg1); + } + + /** + * MEOS {@code edisjoint_tcbuffer_cbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int edisjoint_tcbuffer_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "edisjoint_tcbuffer_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.edisjoint_tcbuffer_cbuffer(arg0, arg1); + } + + /** + * MEOS {@code edisjoint_tcbuffer_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int edisjoint_tcbuffer_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "edisjoint_tcbuffer_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.edisjoint_tcbuffer_geo(arg0, arg1); + } + + /** + * MEOS {@code edwithin_tcbuffer_cbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int edwithin_tcbuffer_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, double arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "edwithin_tcbuffer_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.edwithin_tcbuffer_cbuffer(arg0, arg1, arg2); + } + + /** + * MEOS {@code edwithin_tcbuffer_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int edwithin_tcbuffer_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, double arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "edwithin_tcbuffer_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.edwithin_tcbuffer_geo(arg0, arg1, arg2); + } + + /** + * MEOS {@code eintersects_tcbuffer_cbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int eintersects_tcbuffer_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "eintersects_tcbuffer_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.eintersects_tcbuffer_cbuffer(arg0, arg1); + } + + /** + * MEOS {@code eintersects_tcbuffer_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int eintersects_tcbuffer_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "eintersects_tcbuffer_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.eintersects_tcbuffer_geo(arg0, arg1); + } + + /** + * MEOS {@code etouches_tcbuffer_cbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int etouches_tcbuffer_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "etouches_tcbuffer_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.etouches_tcbuffer_cbuffer(arg0, arg1); + } + + /** + * MEOS {@code etouches_tcbuffer_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int etouches_tcbuffer_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "etouches_tcbuffer_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.etouches_tcbuffer_geo(arg0, arg1); + } + + /** + * MEOS {@code minus_cbuffer_set} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_cbuffer_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_cbuffer_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_cbuffer_set(arg0, arg1); + } + + /** + * MEOS {@code minus_set_cbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_set_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_set_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_set_cbuffer(arg0, arg1); + } + + /** + * MEOS {@code nad_cbuffer_stbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static double nad_cbuffer_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nad_cbuffer_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nad_cbuffer_stbox(arg0, arg1); + } + + /** + * MEOS {@code nad_tcbuffer_cbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static double nad_tcbuffer_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nad_tcbuffer_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nad_tcbuffer_cbuffer(arg0, arg1); + } + + /** + * MEOS {@code nad_tcbuffer_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static double nad_tcbuffer_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nad_tcbuffer_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nad_tcbuffer_geo(arg0, arg1); + } + + /** + * MEOS {@code nad_tcbuffer_stbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static double nad_tcbuffer_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nad_tcbuffer_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nad_tcbuffer_stbox(arg0, arg1); + } + + /** + * MEOS {@code nai_tcbuffer_cbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static jnr.ffi.Pointer nai_tcbuffer_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nai_tcbuffer_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nai_tcbuffer_cbuffer(arg0, arg1); + } + + /** + * MEOS {@code nai_tcbuffer_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static jnr.ffi.Pointer nai_tcbuffer_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nai_tcbuffer_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nai_tcbuffer_geo(arg0, arg1); + } + + /** + * MEOS {@code shortestline_tcbuffer_cbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static jnr.ffi.Pointer shortestline_tcbuffer_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "shortestline_tcbuffer_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.shortestline_tcbuffer_cbuffer(arg0, arg1); + } + + /** + * MEOS {@code shortestline_tcbuffer_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static jnr.ffi.Pointer shortestline_tcbuffer_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "shortestline_tcbuffer_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.shortestline_tcbuffer_geo(arg0, arg1); + } + + /** + * MEOS {@code tcontains_cbuffer_tcbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 1 temporal

+ */ + public static jnr.ffi.Pointer tcontains_cbuffer_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tcontains_cbuffer_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tcontains_cbuffer_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code tcontains_geo_tcbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 1 temporal

+ */ + public static jnr.ffi.Pointer tcontains_geo_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tcontains_geo_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tcontains_geo_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code tcontains_tcbuffer_cbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 1 temporal

+ */ + public static jnr.ffi.Pointer tcontains_tcbuffer_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tcontains_tcbuffer_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tcontains_tcbuffer_cbuffer(arg0, arg1); + } + + /** + * MEOS {@code tcontains_tcbuffer_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 1 temporal

+ */ + public static jnr.ffi.Pointer tcontains_tcbuffer_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tcontains_tcbuffer_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tcontains_tcbuffer_geo(arg0, arg1); + } + + /** + * MEOS {@code tcovers_cbuffer_tcbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 1 temporal

+ */ + public static jnr.ffi.Pointer tcovers_cbuffer_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tcovers_cbuffer_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tcovers_cbuffer_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code tcovers_geo_tcbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 1 temporal

+ */ + public static jnr.ffi.Pointer tcovers_geo_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tcovers_geo_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tcovers_geo_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code tcovers_tcbuffer_cbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 1 temporal

+ */ + public static jnr.ffi.Pointer tcovers_tcbuffer_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tcovers_tcbuffer_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tcovers_tcbuffer_cbuffer(arg0, arg1); + } + + /** + * MEOS {@code tcovers_tcbuffer_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 1 temporal

+ */ + public static jnr.ffi.Pointer tcovers_tcbuffer_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tcovers_tcbuffer_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tcovers_tcbuffer_geo(arg0, arg1); + } + + /** + * MEOS {@code tdisjoint_cbuffer_tcbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 1 temporal

+ */ + public static jnr.ffi.Pointer tdisjoint_cbuffer_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tdisjoint_cbuffer_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tdisjoint_cbuffer_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code tdisjoint_geo_tcbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 1 temporal

+ */ + public static jnr.ffi.Pointer tdisjoint_geo_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tdisjoint_geo_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tdisjoint_geo_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code tdisjoint_tcbuffer_cbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 1 temporal

+ */ + public static jnr.ffi.Pointer tdisjoint_tcbuffer_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tdisjoint_tcbuffer_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tdisjoint_tcbuffer_cbuffer(arg0, arg1); + } + + /** + * MEOS {@code tdisjoint_tcbuffer_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 1 temporal

+ */ + public static jnr.ffi.Pointer tdisjoint_tcbuffer_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tdisjoint_tcbuffer_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tdisjoint_tcbuffer_geo(arg0, arg1); + } + + /** + * MEOS {@code tdistance_tcbuffer_cbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static jnr.ffi.Pointer tdistance_tcbuffer_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tdistance_tcbuffer_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tdistance_tcbuffer_cbuffer(arg0, arg1); + } + + /** + * MEOS {@code tdistance_tcbuffer_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static jnr.ffi.Pointer tdistance_tcbuffer_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tdistance_tcbuffer_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tdistance_tcbuffer_geo(arg0, arg1); + } + + /** + * MEOS {@code tdwithin_geo_tcbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 1 temporal

+ */ + public static jnr.ffi.Pointer tdwithin_geo_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, double arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tdwithin_geo_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tdwithin_geo_tcbuffer(arg0, arg1, arg2); + } + + /** + * MEOS {@code tdwithin_tcbuffer_cbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 1 temporal

+ */ + public static jnr.ffi.Pointer tdwithin_tcbuffer_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, double arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tdwithin_tcbuffer_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tdwithin_tcbuffer_cbuffer(arg0, arg1, arg2); + } + + /** + * MEOS {@code tdwithin_tcbuffer_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 1 temporal

+ */ + public static jnr.ffi.Pointer tdwithin_tcbuffer_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, double arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tdwithin_tcbuffer_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tdwithin_tcbuffer_geo(arg0, arg1, arg2); + } + + /** + * MEOS {@code tintersects_cbuffer_tcbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 1 temporal

+ */ + public static jnr.ffi.Pointer tintersects_cbuffer_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tintersects_cbuffer_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tintersects_cbuffer_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code tintersects_geo_tcbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 1 temporal

+ */ + public static jnr.ffi.Pointer tintersects_geo_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tintersects_geo_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tintersects_geo_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code tintersects_tcbuffer_cbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 1 temporal

+ */ + public static jnr.ffi.Pointer tintersects_tcbuffer_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tintersects_tcbuffer_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tintersects_tcbuffer_cbuffer(arg0, arg1); + } + + /** + * MEOS {@code tintersects_tcbuffer_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 1 temporal

+ */ + public static jnr.ffi.Pointer tintersects_tcbuffer_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tintersects_tcbuffer_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tintersects_tcbuffer_geo(arg0, arg1); + } + + /** + * MEOS {@code ttouches_cbuffer_tcbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 1 temporal

+ */ + public static jnr.ffi.Pointer ttouches_cbuffer_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ttouches_cbuffer_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ttouches_cbuffer_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code ttouches_geo_tcbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 1 temporal

+ */ + public static jnr.ffi.Pointer ttouches_geo_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ttouches_geo_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ttouches_geo_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code ttouches_tcbuffer_cbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 1 temporal

+ */ + public static jnr.ffi.Pointer ttouches_tcbuffer_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ttouches_tcbuffer_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ttouches_tcbuffer_cbuffer(arg0, arg1); + } + + /** + * MEOS {@code ttouches_tcbuffer_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 1 temporal

+ */ + public static jnr.ffi.Pointer ttouches_tcbuffer_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ttouches_tcbuffer_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ttouches_tcbuffer_geo(arg0, arg1); + } + + /** + * MEOS {@code always_eq_cbuffer_tcbuffer} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_eq_cbuffer_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_eq_cbuffer_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_eq_cbuffer_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code always_eq_tcbuffer_cbuffer} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_eq_tcbuffer_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_eq_tcbuffer_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_eq_tcbuffer_cbuffer(arg0, arg1); + } + + /** + * MEOS {@code always_ne_cbuffer_tcbuffer} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_ne_cbuffer_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ne_cbuffer_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ne_cbuffer_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code always_ne_tcbuffer_cbuffer} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_ne_tcbuffer_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ne_tcbuffer_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ne_tcbuffer_cbuffer(arg0, arg1); + } + + /** + * MEOS {@code ever_eq_cbuffer_tcbuffer} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_eq_cbuffer_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_eq_cbuffer_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_eq_cbuffer_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code ever_eq_tcbuffer_cbuffer} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_eq_tcbuffer_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_eq_tcbuffer_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_eq_tcbuffer_cbuffer(arg0, arg1); + } + + /** + * MEOS {@code ever_ne_cbuffer_tcbuffer} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_ne_cbuffer_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ne_cbuffer_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ne_cbuffer_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code ever_ne_tcbuffer_cbuffer} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_ne_tcbuffer_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ne_tcbuffer_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ne_tcbuffer_cbuffer(arg0, arg1); + } + + /** + * MEOS {@code adisjoint_tcbuffer_tcbuffer} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 2 temporals

+ */ + public static int adisjoint_tcbuffer_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "adisjoint_tcbuffer_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.adisjoint_tcbuffer_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code adwithin_tcbuffer_tcbuffer} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 2 temporals

+ */ + public static int adwithin_tcbuffer_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, double arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "adwithin_tcbuffer_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.adwithin_tcbuffer_tcbuffer(arg0, arg1, arg2); + } + + /** + * MEOS {@code aintersects_tcbuffer_tcbuffer} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 2 temporals

+ */ + public static int aintersects_tcbuffer_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "aintersects_tcbuffer_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.aintersects_tcbuffer_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code always_eq_tcbuffer_tcbuffer} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always over 2 temporals

+ */ + public static int always_eq_tcbuffer_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_eq_tcbuffer_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_eq_tcbuffer_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code always_ne_tcbuffer_tcbuffer} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always over 2 temporals

+ */ + public static int always_ne_tcbuffer_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ne_tcbuffer_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ne_tcbuffer_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code atouches_tcbuffer_tcbuffer} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 2 temporals

+ */ + public static int atouches_tcbuffer_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "atouches_tcbuffer_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.atouches_tcbuffer_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code ecovers_tcbuffer_tcbuffer} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 2 temporals

+ */ + public static int ecovers_tcbuffer_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ecovers_tcbuffer_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ecovers_tcbuffer_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code edwithin_tcbuffer_tcbuffer} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 2 temporals

+ */ + public static int edwithin_tcbuffer_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, double arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "edwithin_tcbuffer_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.edwithin_tcbuffer_tcbuffer(arg0, arg1, arg2); + } + + /** + * MEOS {@code eintersects_tcbuffer_tcbuffer} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 2 temporals

+ */ + public static int eintersects_tcbuffer_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "eintersects_tcbuffer_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.eintersects_tcbuffer_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code etouches_tcbuffer_tcbuffer} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 2 temporals

+ */ + public static int etouches_tcbuffer_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "etouches_tcbuffer_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.etouches_tcbuffer_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code ever_eq_tcbuffer_tcbuffer} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always over 2 temporals

+ */ + public static int ever_eq_tcbuffer_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_eq_tcbuffer_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_eq_tcbuffer_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code ever_ne_tcbuffer_tcbuffer} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always over 2 temporals

+ */ + public static int ever_ne_tcbuffer_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ne_tcbuffer_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ne_tcbuffer_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code nad_tcbuffer_tcbuffer} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: distance on 2 temporals

+ */ + public static double nad_tcbuffer_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nad_tcbuffer_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nad_tcbuffer_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code nai_tcbuffer_tcbuffer} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: distance on 2 temporals

+ */ + public static jnr.ffi.Pointer nai_tcbuffer_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nai_tcbuffer_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nai_tcbuffer_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code shortestline_tcbuffer_tcbuffer} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: distance on 2 temporals

+ */ + public static jnr.ffi.Pointer shortestline_tcbuffer_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "shortestline_tcbuffer_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.shortestline_tcbuffer_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code tcontains_tcbuffer_tcbuffer} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 2 temporals

+ */ + public static jnr.ffi.Pointer tcontains_tcbuffer_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tcontains_tcbuffer_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tcontains_tcbuffer_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code tcovers_tcbuffer_tcbuffer} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 2 temporals

+ */ + public static jnr.ffi.Pointer tcovers_tcbuffer_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tcovers_tcbuffer_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tcovers_tcbuffer_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code tdisjoint_tcbuffer_tcbuffer} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 2 temporals

+ */ + public static jnr.ffi.Pointer tdisjoint_tcbuffer_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tdisjoint_tcbuffer_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tdisjoint_tcbuffer_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code tdistance_tcbuffer_tcbuffer} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: distance on 2 temporals

+ */ + public static jnr.ffi.Pointer tdistance_tcbuffer_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tdistance_tcbuffer_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tdistance_tcbuffer_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code tdwithin_tcbuffer_tcbuffer} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 2 temporals

+ */ + public static jnr.ffi.Pointer tdwithin_tcbuffer_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, double arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tdwithin_tcbuffer_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tdwithin_tcbuffer_tcbuffer(arg0, arg1, arg2); + } + + /** + * MEOS {@code tintersects_tcbuffer_tcbuffer} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 2 temporals

+ */ + public static jnr.ffi.Pointer tintersects_tcbuffer_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tintersects_tcbuffer_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tintersects_tcbuffer_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code ttouches_tcbuffer_tcbuffer} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 2 temporals

+ */ + public static jnr.ffi.Pointer ttouches_tcbuffer_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ttouches_tcbuffer_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ttouches_tcbuffer_tcbuffer(arg0, arg1); + } + + /** + * MEOS {@code cbuffer_as_ewkt} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static java.lang.String cbuffer_as_ewkt(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbuffer_as_ewkt requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbuffer_as_ewkt(arg0, arg1); + } + + /** + * MEOS {@code cbuffer_as_hexwkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static java.lang.String cbuffer_as_hexwkb(jnr.ffi.Pointer arg0, byte arg1, jnr.ffi.Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbuffer_as_hexwkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbuffer_as_hexwkb(arg0, arg1, arg2); + } + + /** + * MEOS {@code cbuffer_as_text} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static java.lang.String cbuffer_as_text(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbuffer_as_text requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbuffer_as_text(arg0, arg1); + } + + /** + * MEOS {@code cbuffer_as_wkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static jnr.ffi.Pointer cbuffer_as_wkb(jnr.ffi.Pointer arg0, byte arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbuffer_as_wkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbuffer_as_wkb(arg0, arg1); + } + + /** + * MEOS {@code cbuffer_from_hexwkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static jnr.ffi.Pointer cbuffer_from_hexwkb(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbuffer_from_hexwkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbuffer_from_hexwkb(arg0); + } + + /** + * MEOS {@code cbuffer_from_wkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static jnr.ffi.Pointer cbuffer_from_wkb(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbuffer_from_wkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbuffer_from_wkb(arg0, arg1); + } + + /** + * MEOS {@code cbuffer_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static jnr.ffi.Pointer cbuffer_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbuffer_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbuffer_in(arg0); + } + + /** + * MEOS {@code cbuffer_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static java.lang.String cbuffer_out(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbuffer_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbuffer_out(arg0, arg1); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFreeCore.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFreeCore.java new file mode 100644 index 0000000..b22942d --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFreeCore.java @@ -0,0 +1,9719 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_free.py — do not edit by hand. + * Source header: meos.h + * Methods emitted: 746 (stateless=448 · bounded-state=128 · windowed=80 · io-meta=53 · cross-stream=37) + * Scope: MEOS public functions NOT classified into any object-model class + * (free functions, not methods on a class). + * Source: JMEOS PR #19 (functions.GeneratedFunctions) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import functions.error_handler_fn; +import jnr.ffi.Pointer; + +public final class MeosOpsFreeCore { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsFreeCore() { /* utility */ } + + /** + * MEOS {@code add_date_int} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar arithmetic

+ */ + public static int add_date_int(int arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "add_date_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.add_date_int(arg0, arg1); + } + + /** + * MEOS {@code add_float_tfloat} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: arithmetic op on temporal number (per-instant)

+ */ + public static jnr.ffi.Pointer add_float_tfloat(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "add_float_tfloat requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.add_float_tfloat(arg0, arg1); + } + + /** + * MEOS {@code add_int_tint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: arithmetic op on temporal number (per-instant)

+ */ + public static jnr.ffi.Pointer add_int_tint(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "add_int_tint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.add_int_tint(arg0, arg1); + } + + /** + * MEOS {@code add_interval_interval} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: arithmetic op on temporal number (per-instant)

+ */ + public static jnr.ffi.Pointer add_interval_interval(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "add_interval_interval requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.add_interval_interval(arg0, arg1); + } + + /** + * MEOS {@code add_tfloat_float} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: arithmetic op on temporal number (per-instant)

+ */ + public static jnr.ffi.Pointer add_tfloat_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "add_tfloat_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.add_tfloat_float(arg0, arg1); + } + + /** + * MEOS {@code add_timestamptz_interval} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar arithmetic

+ */ + public static java.time.OffsetDateTime add_timestamptz_interval(java.time.OffsetDateTime arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "add_timestamptz_interval requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.add_timestamptz_interval(arg0, arg1); + } + + /** + * MEOS {@code add_tint_int} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: arithmetic op on temporal number (per-instant)

+ */ + public static jnr.ffi.Pointer add_tint_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "add_tint_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.add_tint_int(arg0, arg1); + } + + /** + * MEOS {@code add_tnumber_tnumber} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: arithmetic op on temporal number (per-instant)

+ */ + public static jnr.ffi.Pointer add_tnumber_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "add_tnumber_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.add_tnumber_tnumber(arg0, arg1); + } + + /** + * MEOS {@code adjacent_span_bigint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean adjacent_span_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "adjacent_span_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.adjacent_span_bigint(arg0, arg1); + } + + /** + * MEOS {@code adjacent_span_date} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean adjacent_span_date(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "adjacent_span_date requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.adjacent_span_date(arg0, arg1); + } + + /** + * MEOS {@code adjacent_span_float} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean adjacent_span_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "adjacent_span_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.adjacent_span_float(arg0, arg1); + } + + /** + * MEOS {@code adjacent_span_int} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean adjacent_span_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "adjacent_span_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.adjacent_span_int(arg0, arg1); + } + + /** + * MEOS {@code adjacent_span_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean adjacent_span_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "adjacent_span_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.adjacent_span_span(arg0, arg1); + } + + /** + * MEOS {@code adjacent_span_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean adjacent_span_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "adjacent_span_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.adjacent_span_spanset(arg0, arg1); + } + + /** + * MEOS {@code adjacent_span_timestamptz} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean adjacent_span_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "adjacent_span_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.adjacent_span_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code adjacent_spanset_bigint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean adjacent_spanset_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "adjacent_spanset_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.adjacent_spanset_bigint(arg0, arg1); + } + + /** + * MEOS {@code adjacent_spanset_date} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean adjacent_spanset_date(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "adjacent_spanset_date requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.adjacent_spanset_date(arg0, arg1); + } + + /** + * MEOS {@code adjacent_spanset_float} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean adjacent_spanset_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "adjacent_spanset_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.adjacent_spanset_float(arg0, arg1); + } + + /** + * MEOS {@code adjacent_spanset_int} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean adjacent_spanset_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "adjacent_spanset_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.adjacent_spanset_int(arg0, arg1); + } + + /** + * MEOS {@code adjacent_spanset_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean adjacent_spanset_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "adjacent_spanset_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.adjacent_spanset_span(arg0, arg1); + } + + /** + * MEOS {@code adjacent_spanset_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean adjacent_spanset_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "adjacent_spanset_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.adjacent_spanset_spanset(arg0, arg1); + } + + /** + * MEOS {@code adjacent_spanset_timestamptz} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean adjacent_spanset_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "adjacent_spanset_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.adjacent_spanset_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code adjacent_tbox_tbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean adjacent_tbox_tbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "adjacent_tbox_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.adjacent_tbox_tbox(arg0, arg1); + } + + /** + * MEOS {@code adjacent_tbox_tnumber} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean adjacent_tbox_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "adjacent_tbox_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.adjacent_tbox_tnumber(arg0, arg1); + } + + /** + * MEOS {@code after_date_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean after_date_set(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "after_date_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.after_date_set(arg0, arg1); + } + + /** + * MEOS {@code after_date_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean after_date_span(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "after_date_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.after_date_span(arg0, arg1); + } + + /** + * MEOS {@code after_date_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean after_date_spanset(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "after_date_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.after_date_spanset(arg0, arg1); + } + + /** + * MEOS {@code after_set_date} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean after_set_date(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "after_set_date requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.after_set_date(arg0, arg1); + } + + /** + * MEOS {@code after_set_timestamptz} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean after_set_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "after_set_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.after_set_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code after_span_date} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean after_span_date(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "after_span_date requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.after_span_date(arg0, arg1); + } + + /** + * MEOS {@code after_span_timestamptz} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean after_span_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "after_span_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.after_span_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code after_spanset_date} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean after_spanset_date(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "after_spanset_date requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.after_spanset_date(arg0, arg1); + } + + /** + * MEOS {@code after_spanset_timestamptz} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean after_spanset_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "after_spanset_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.after_spanset_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code after_tbox_tbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean after_tbox_tbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "after_tbox_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.after_tbox_tbox(arg0, arg1); + } + + /** + * MEOS {@code after_tbox_tnumber} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean after_tbox_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "after_tbox_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.after_tbox_tnumber(arg0, arg1); + } + + /** + * MEOS {@code after_timestamptz_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean after_timestamptz_set(java.time.OffsetDateTime arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "after_timestamptz_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.after_timestamptz_set(arg0, arg1); + } + + /** + * MEOS {@code after_timestamptz_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean after_timestamptz_span(java.time.OffsetDateTime arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "after_timestamptz_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.after_timestamptz_span(arg0, arg1); + } + + /** + * MEOS {@code after_timestamptz_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean after_timestamptz_spanset(java.time.OffsetDateTime arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "after_timestamptz_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.after_timestamptz_spanset(arg0, arg1); + } + + /** + * MEOS {@code before_date_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean before_date_set(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "before_date_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.before_date_set(arg0, arg1); + } + + /** + * MEOS {@code before_date_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean before_date_span(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "before_date_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.before_date_span(arg0, arg1); + } + + /** + * MEOS {@code before_date_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean before_date_spanset(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "before_date_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.before_date_spanset(arg0, arg1); + } + + /** + * MEOS {@code before_set_date} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean before_set_date(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "before_set_date requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.before_set_date(arg0, arg1); + } + + /** + * MEOS {@code before_set_timestamptz} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean before_set_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "before_set_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.before_set_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code before_span_date} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean before_span_date(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "before_span_date requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.before_span_date(arg0, arg1); + } + + /** + * MEOS {@code before_span_timestamptz} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean before_span_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "before_span_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.before_span_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code before_spanset_date} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean before_spanset_date(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "before_spanset_date requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.before_spanset_date(arg0, arg1); + } + + /** + * MEOS {@code before_spanset_timestamptz} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean before_spanset_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "before_spanset_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.before_spanset_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code before_tbox_tbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean before_tbox_tbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "before_tbox_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.before_tbox_tbox(arg0, arg1); + } + + /** + * MEOS {@code before_tbox_tnumber} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean before_tbox_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "before_tbox_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.before_tbox_tnumber(arg0, arg1); + } + + /** + * MEOS {@code before_timestamptz_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean before_timestamptz_set(java.time.OffsetDateTime arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "before_timestamptz_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.before_timestamptz_set(arg0, arg1); + } + + /** + * MEOS {@code before_timestamptz_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean before_timestamptz_span(java.time.OffsetDateTime arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "before_timestamptz_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.before_timestamptz_span(arg0, arg1); + } + + /** + * MEOS {@code before_timestamptz_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean before_timestamptz_spanset(java.time.OffsetDateTime arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "before_timestamptz_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.before_timestamptz_spanset(arg0, arg1); + } + + /** + * MEOS {@code bigint_extent_transfn} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer bigint_extent_transfn(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bigint_extent_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bigint_extent_transfn(arg0, arg1); + } + + /** + * MEOS {@code bigint_get_bin} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar comparison/hash

+ */ + public static long bigint_get_bin(long arg0, long arg1, long arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bigint_get_bin requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bigint_get_bin(arg0, arg1, arg2); + } + + /** + * MEOS {@code bigint_to_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer bigint_to_set(long arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bigint_to_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bigint_to_set(arg0); + } + + /** + * MEOS {@code bigint_to_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer bigint_to_span(long arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bigint_to_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bigint_to_span(arg0); + } + + /** + * MEOS {@code bigint_to_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer bigint_to_spanset(long arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bigint_to_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bigint_to_spanset(arg0); + } + + /** + * MEOS {@code bigint_union_transfn} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer bigint_union_transfn(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bigint_union_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bigint_union_transfn(arg0, arg1); + } + + /** + * MEOS {@code contained_bigint_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contained_bigint_set(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contained_bigint_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contained_bigint_set(arg0, arg1); + } + + /** + * MEOS {@code contained_bigint_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contained_bigint_span(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contained_bigint_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contained_bigint_span(arg0, arg1); + } + + /** + * MEOS {@code contained_bigint_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contained_bigint_spanset(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contained_bigint_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contained_bigint_spanset(arg0, arg1); + } + + /** + * MEOS {@code contained_date_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contained_date_set(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contained_date_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contained_date_set(arg0, arg1); + } + + /** + * MEOS {@code contained_date_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contained_date_span(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contained_date_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contained_date_span(arg0, arg1); + } + + /** + * MEOS {@code contained_date_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contained_date_spanset(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contained_date_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contained_date_spanset(arg0, arg1); + } + + /** + * MEOS {@code contained_float_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contained_float_set(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contained_float_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contained_float_set(arg0, arg1); + } + + /** + * MEOS {@code contained_float_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contained_float_span(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contained_float_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contained_float_span(arg0, arg1); + } + + /** + * MEOS {@code contained_float_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contained_float_spanset(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contained_float_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contained_float_spanset(arg0, arg1); + } + + /** + * MEOS {@code contained_int_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contained_int_set(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contained_int_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contained_int_set(arg0, arg1); + } + + /** + * MEOS {@code contained_int_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contained_int_span(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contained_int_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contained_int_span(arg0, arg1); + } + + /** + * MEOS {@code contained_int_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contained_int_spanset(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contained_int_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contained_int_spanset(arg0, arg1); + } + + /** + * MEOS {@code contained_set_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contained_set_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contained_set_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contained_set_set(arg0, arg1); + } + + /** + * MEOS {@code contained_span_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contained_span_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contained_span_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contained_span_span(arg0, arg1); + } + + /** + * MEOS {@code contained_span_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contained_span_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contained_span_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contained_span_spanset(arg0, arg1); + } + + /** + * MEOS {@code contained_spanset_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contained_spanset_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contained_spanset_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contained_spanset_span(arg0, arg1); + } + + /** + * MEOS {@code contained_spanset_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contained_spanset_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contained_spanset_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contained_spanset_spanset(arg0, arg1); + } + + /** + * MEOS {@code contained_tbox_tbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contained_tbox_tbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contained_tbox_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contained_tbox_tbox(arg0, arg1); + } + + /** + * MEOS {@code contained_tbox_tnumber} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contained_tbox_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contained_tbox_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contained_tbox_tnumber(arg0, arg1); + } + + /** + * MEOS {@code contained_text_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contained_text_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contained_text_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contained_text_set(arg0, arg1); + } + + /** + * MEOS {@code contained_timestamptz_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contained_timestamptz_set(java.time.OffsetDateTime arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contained_timestamptz_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contained_timestamptz_set(arg0, arg1); + } + + /** + * MEOS {@code contained_timestamptz_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contained_timestamptz_span(java.time.OffsetDateTime arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contained_timestamptz_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contained_timestamptz_span(arg0, arg1); + } + + /** + * MEOS {@code contained_timestamptz_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contained_timestamptz_spanset(java.time.OffsetDateTime arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contained_timestamptz_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contained_timestamptz_spanset(arg0, arg1); + } + + /** + * MEOS {@code contains_set_bigint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contains_set_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_set_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_set_bigint(arg0, arg1); + } + + /** + * MEOS {@code contains_set_date} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contains_set_date(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_set_date requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_set_date(arg0, arg1); + } + + /** + * MEOS {@code contains_set_float} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contains_set_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_set_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_set_float(arg0, arg1); + } + + /** + * MEOS {@code contains_set_int} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contains_set_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_set_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_set_int(arg0, arg1); + } + + /** + * MEOS {@code contains_set_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contains_set_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_set_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_set_set(arg0, arg1); + } + + /** + * MEOS {@code contains_set_text} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contains_set_text(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_set_text requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_set_text(arg0, arg1); + } + + /** + * MEOS {@code contains_set_timestamptz} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contains_set_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_set_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_set_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code contains_span_bigint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contains_span_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_span_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_span_bigint(arg0, arg1); + } + + /** + * MEOS {@code contains_span_date} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contains_span_date(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_span_date requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_span_date(arg0, arg1); + } + + /** + * MEOS {@code contains_span_float} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contains_span_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_span_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_span_float(arg0, arg1); + } + + /** + * MEOS {@code contains_span_int} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contains_span_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_span_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_span_int(arg0, arg1); + } + + /** + * MEOS {@code contains_span_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contains_span_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_span_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_span_span(arg0, arg1); + } + + /** + * MEOS {@code contains_span_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contains_span_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_span_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_span_spanset(arg0, arg1); + } + + /** + * MEOS {@code contains_span_timestamptz} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contains_span_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_span_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_span_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code contains_spanset_bigint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contains_spanset_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_spanset_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_spanset_bigint(arg0, arg1); + } + + /** + * MEOS {@code contains_spanset_date} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contains_spanset_date(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_spanset_date requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_spanset_date(arg0, arg1); + } + + /** + * MEOS {@code contains_spanset_float} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contains_spanset_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_spanset_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_spanset_float(arg0, arg1); + } + + /** + * MEOS {@code contains_spanset_int} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contains_spanset_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_spanset_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_spanset_int(arg0, arg1); + } + + /** + * MEOS {@code contains_spanset_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contains_spanset_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_spanset_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_spanset_span(arg0, arg1); + } + + /** + * MEOS {@code contains_spanset_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contains_spanset_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_spanset_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_spanset_spanset(arg0, arg1); + } + + /** + * MEOS {@code contains_spanset_timestamptz} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contains_spanset_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_spanset_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_spanset_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code contains_tbox_tbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contains_tbox_tbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_tbox_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_tbox_tbox(arg0, arg1); + } + + /** + * MEOS {@code contains_tbox_tnumber} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contains_tbox_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_tbox_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_tbox_tnumber(arg0, arg1); + } + + /** + * MEOS {@code date_extent_transfn} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer date_extent_transfn(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "date_extent_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.date_extent_transfn(arg0, arg1); + } + + /** + * MEOS {@code date_get_bin} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar comparison/hash

+ */ + public static int date_get_bin(int arg0, jnr.ffi.Pointer arg1, int arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "date_get_bin requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.date_get_bin(arg0, arg1, arg2); + } + + /** + * MEOS {@code date_to_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer date_to_set(int arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "date_to_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.date_to_set(arg0); + } + + /** + * MEOS {@code date_to_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer date_to_span(int arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "date_to_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.date_to_span(arg0); + } + + /** + * MEOS {@code date_to_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer date_to_spanset(int arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "date_to_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.date_to_spanset(arg0); + } + + /** + * MEOS {@code date_to_timestamp} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static java.time.LocalDateTime date_to_timestamp(int arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "date_to_timestamp requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.date_to_timestamp(arg0); + } + + /** + * MEOS {@code date_to_timestamptz} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static java.time.OffsetDateTime date_to_timestamptz(int arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "date_to_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.date_to_timestamptz(arg0); + } + + /** + * MEOS {@code date_union_transfn} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer date_union_transfn(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "date_union_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.date_union_transfn(arg0, arg1); + } + + /** + * MEOS {@code div_float_tfloat} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: arithmetic op on temporal number (per-instant)

+ */ + public static jnr.ffi.Pointer div_float_tfloat(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "div_float_tfloat requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.div_float_tfloat(arg0, arg1); + } + + /** + * MEOS {@code div_int_tint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: arithmetic op on temporal number (per-instant)

+ */ + public static jnr.ffi.Pointer div_int_tint(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "div_int_tint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.div_int_tint(arg0, arg1); + } + + /** + * MEOS {@code div_tfloat_float} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: arithmetic op on temporal number (per-instant)

+ */ + public static jnr.ffi.Pointer div_tfloat_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "div_tfloat_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.div_tfloat_float(arg0, arg1); + } + + /** + * MEOS {@code div_tint_int} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: arithmetic op on temporal number (per-instant)

+ */ + public static jnr.ffi.Pointer div_tint_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "div_tint_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.div_tint_int(arg0, arg1); + } + + /** + * MEOS {@code div_tnumber_tnumber} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: arithmetic op on temporal number (per-instant)

+ */ + public static jnr.ffi.Pointer div_tnumber_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "div_tnumber_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.div_tnumber_tnumber(arg0, arg1); + } + + /** + * MEOS {@code float_angular_difference} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static double float_angular_difference(double arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "float_angular_difference requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.float_angular_difference(arg0, arg1); + } + + /** + * MEOS {@code float_degrees} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static double float_degrees(double arg0, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "float_degrees requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.float_degrees(arg0, arg1); + } + + /** + * MEOS {@code float_exp} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static double float_exp(double arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "float_exp requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.float_exp(arg0); + } + + /** + * MEOS {@code float_extent_transfn} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer float_extent_transfn(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "float_extent_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.float_extent_transfn(arg0, arg1); + } + + /** + * MEOS {@code float_get_bin} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar comparison/hash

+ */ + public static double float_get_bin(double arg0, double arg1, double arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "float_get_bin requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.float_get_bin(arg0, arg1, arg2); + } + + /** + * MEOS {@code float_ln} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static double float_ln(double arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "float_ln requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.float_ln(arg0); + } + + /** + * MEOS {@code float_log10} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static double float_log10(double arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "float_log10 requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.float_log10(arg0); + } + + /** + * MEOS {@code float_round} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: transform/normalize (pure)

+ */ + public static double float_round(double arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "float_round requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.float_round(arg0, arg1); + } + + /** + * MEOS {@code float_timestamptz_to_tbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer float_timestamptz_to_tbox(double arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "float_timestamptz_to_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.float_timestamptz_to_tbox(arg0, arg1); + } + + /** + * MEOS {@code float_to_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer float_to_set(double arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "float_to_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.float_to_set(arg0); + } + + /** + * MEOS {@code float_to_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer float_to_span(double arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "float_to_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.float_to_span(arg0); + } + + /** + * MEOS {@code float_to_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer float_to_spanset(double arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "float_to_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.float_to_spanset(arg0); + } + + /** + * MEOS {@code float_to_tbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer float_to_tbox(double arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "float_to_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.float_to_tbox(arg0); + } + + /** + * MEOS {@code float_tstzspan_to_tbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer float_tstzspan_to_tbox(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "float_tstzspan_to_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.float_tstzspan_to_tbox(arg0, arg1); + } + + /** + * MEOS {@code float_union_transfn} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer float_union_transfn(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "float_union_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.float_union_transfn(arg0, arg1); + } + + /** + * MEOS {@code int32_cmp} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar comparison with width suffix

+ */ + public static int int32_cmp(int arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "int32_cmp requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.int32_cmp(arg0, arg1); + } + + /** + * MEOS {@code int64_cmp} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar comparison with width suffix

+ */ + public static int int64_cmp(long arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "int64_cmp requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.int64_cmp(arg0, arg1); + } + + /** + * MEOS {@code int_extent_transfn} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer int_extent_transfn(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "int_extent_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.int_extent_transfn(arg0, arg1); + } + + /** + * MEOS {@code int_get_bin} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar comparison/hash

+ */ + public static int int_get_bin(int arg0, int arg1, int arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "int_get_bin requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.int_get_bin(arg0, arg1, arg2); + } + + /** + * MEOS {@code int_timestamptz_to_tbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer int_timestamptz_to_tbox(int arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "int_timestamptz_to_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.int_timestamptz_to_tbox(arg0, arg1); + } + + /** + * MEOS {@code int_to_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer int_to_set(int arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "int_to_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.int_to_set(arg0); + } + + /** + * MEOS {@code int_to_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer int_to_span(int arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "int_to_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.int_to_span(arg0); + } + + /** + * MEOS {@code int_to_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer int_to_spanset(int arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "int_to_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.int_to_spanset(arg0); + } + + /** + * MEOS {@code int_to_tbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer int_to_tbox(int arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "int_to_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.int_to_tbox(arg0); + } + + /** + * MEOS {@code int_tstzspan_to_tbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer int_tstzspan_to_tbox(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "int_tstzspan_to_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.int_tstzspan_to_tbox(arg0, arg1); + } + + /** + * MEOS {@code int_union_transfn} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer int_union_transfn(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "int_union_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.int_union_transfn(arg0, arg1); + } + + /** + * MEOS {@code intersection_bigint_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer intersection_bigint_set(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intersection_bigint_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intersection_bigint_set(arg0, arg1); + } + + /** + * MEOS {@code intersection_date_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer intersection_date_set(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intersection_date_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intersection_date_set(arg0, arg1); + } + + /** + * MEOS {@code intersection_float_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer intersection_float_set(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intersection_float_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intersection_float_set(arg0, arg1); + } + + /** + * MEOS {@code intersection_int_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer intersection_int_set(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intersection_int_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intersection_int_set(arg0, arg1); + } + + /** + * MEOS {@code intersection_set_bigint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer intersection_set_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intersection_set_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intersection_set_bigint(arg0, arg1); + } + + /** + * MEOS {@code intersection_set_date} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer intersection_set_date(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intersection_set_date requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intersection_set_date(arg0, arg1); + } + + /** + * MEOS {@code intersection_set_float} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer intersection_set_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intersection_set_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intersection_set_float(arg0, arg1); + } + + /** + * MEOS {@code intersection_set_int} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer intersection_set_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intersection_set_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intersection_set_int(arg0, arg1); + } + + /** + * MEOS {@code intersection_set_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer intersection_set_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intersection_set_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intersection_set_set(arg0, arg1); + } + + /** + * MEOS {@code intersection_set_text} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer intersection_set_text(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intersection_set_text requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intersection_set_text(arg0, arg1); + } + + /** + * MEOS {@code intersection_set_timestamptz} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer intersection_set_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intersection_set_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intersection_set_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code intersection_span_bigint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer intersection_span_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intersection_span_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intersection_span_bigint(arg0, arg1); + } + + /** + * MEOS {@code intersection_span_date} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer intersection_span_date(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intersection_span_date requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intersection_span_date(arg0, arg1); + } + + /** + * MEOS {@code intersection_span_float} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer intersection_span_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intersection_span_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intersection_span_float(arg0, arg1); + } + + /** + * MEOS {@code intersection_span_int} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer intersection_span_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intersection_span_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intersection_span_int(arg0, arg1); + } + + /** + * MEOS {@code intersection_span_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer intersection_span_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intersection_span_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intersection_span_span(arg0, arg1); + } + + /** + * MEOS {@code intersection_span_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer intersection_span_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intersection_span_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intersection_span_spanset(arg0, arg1); + } + + /** + * MEOS {@code intersection_span_timestamptz} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer intersection_span_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intersection_span_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intersection_span_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code intersection_spanset_bigint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer intersection_spanset_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intersection_spanset_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intersection_spanset_bigint(arg0, arg1); + } + + /** + * MEOS {@code intersection_spanset_date} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer intersection_spanset_date(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intersection_spanset_date requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intersection_spanset_date(arg0, arg1); + } + + /** + * MEOS {@code intersection_spanset_float} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer intersection_spanset_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intersection_spanset_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intersection_spanset_float(arg0, arg1); + } + + /** + * MEOS {@code intersection_spanset_int} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer intersection_spanset_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intersection_spanset_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intersection_spanset_int(arg0, arg1); + } + + /** + * MEOS {@code intersection_spanset_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer intersection_spanset_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intersection_spanset_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intersection_spanset_span(arg0, arg1); + } + + /** + * MEOS {@code intersection_spanset_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer intersection_spanset_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intersection_spanset_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intersection_spanset_spanset(arg0, arg1); + } + + /** + * MEOS {@code intersection_spanset_timestamptz} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer intersection_spanset_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intersection_spanset_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intersection_spanset_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code intersection_tbox_tbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer intersection_tbox_tbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intersection_tbox_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intersection_tbox_tbox(arg0, arg1); + } + + /** + * MEOS {@code intersection_text_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer intersection_text_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intersection_text_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intersection_text_set(arg0, arg1); + } + + /** + * MEOS {@code intersection_timestamptz_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer intersection_timestamptz_set(java.time.OffsetDateTime arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intersection_timestamptz_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intersection_timestamptz_set(arg0, arg1); + } + + /** + * MEOS {@code interval_make} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: make/from_base of instant/scalar

+ */ + public static jnr.ffi.Pointer interval_make(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, double arg6) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "interval_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.interval_make(arg0, arg1, arg2, arg3, arg4, arg5, arg6); + } + + /** + * MEOS {@code left_bigint_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean left_bigint_set(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "left_bigint_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.left_bigint_set(arg0, arg1); + } + + /** + * MEOS {@code left_bigint_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean left_bigint_span(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "left_bigint_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.left_bigint_span(arg0, arg1); + } + + /** + * MEOS {@code left_bigint_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean left_bigint_spanset(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "left_bigint_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.left_bigint_spanset(arg0, arg1); + } + + /** + * MEOS {@code left_float_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean left_float_set(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "left_float_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.left_float_set(arg0, arg1); + } + + /** + * MEOS {@code left_float_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean left_float_span(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "left_float_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.left_float_span(arg0, arg1); + } + + /** + * MEOS {@code left_float_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean left_float_spanset(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "left_float_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.left_float_spanset(arg0, arg1); + } + + /** + * MEOS {@code left_int_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean left_int_set(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "left_int_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.left_int_set(arg0, arg1); + } + + /** + * MEOS {@code left_int_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean left_int_span(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "left_int_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.left_int_span(arg0, arg1); + } + + /** + * MEOS {@code left_int_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean left_int_spanset(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "left_int_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.left_int_spanset(arg0, arg1); + } + + /** + * MEOS {@code left_set_bigint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean left_set_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "left_set_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.left_set_bigint(arg0, arg1); + } + + /** + * MEOS {@code left_set_float} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean left_set_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "left_set_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.left_set_float(arg0, arg1); + } + + /** + * MEOS {@code left_set_int} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean left_set_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "left_set_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.left_set_int(arg0, arg1); + } + + /** + * MEOS {@code left_set_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean left_set_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "left_set_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.left_set_set(arg0, arg1); + } + + /** + * MEOS {@code left_set_text} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean left_set_text(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "left_set_text requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.left_set_text(arg0, arg1); + } + + /** + * MEOS {@code left_span_bigint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean left_span_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "left_span_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.left_span_bigint(arg0, arg1); + } + + /** + * MEOS {@code left_span_float} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean left_span_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "left_span_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.left_span_float(arg0, arg1); + } + + /** + * MEOS {@code left_span_int} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean left_span_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "left_span_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.left_span_int(arg0, arg1); + } + + /** + * MEOS {@code left_span_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean left_span_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "left_span_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.left_span_span(arg0, arg1); + } + + /** + * MEOS {@code left_span_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean left_span_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "left_span_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.left_span_spanset(arg0, arg1); + } + + /** + * MEOS {@code left_spanset_bigint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean left_spanset_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "left_spanset_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.left_spanset_bigint(arg0, arg1); + } + + /** + * MEOS {@code left_spanset_float} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean left_spanset_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "left_spanset_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.left_spanset_float(arg0, arg1); + } + + /** + * MEOS {@code left_spanset_int} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean left_spanset_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "left_spanset_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.left_spanset_int(arg0, arg1); + } + + /** + * MEOS {@code left_spanset_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean left_spanset_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "left_spanset_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.left_spanset_span(arg0, arg1); + } + + /** + * MEOS {@code left_spanset_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean left_spanset_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "left_spanset_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.left_spanset_spanset(arg0, arg1); + } + + /** + * MEOS {@code left_tbox_tbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean left_tbox_tbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "left_tbox_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.left_tbox_tbox(arg0, arg1); + } + + /** + * MEOS {@code left_tbox_tnumber} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean left_tbox_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "left_tbox_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.left_tbox_tnumber(arg0, arg1); + } + + /** + * MEOS {@code left_text_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean left_text_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "left_text_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.left_text_set(arg0, arg1); + } + + /** + * MEOS {@code mul_interval_double} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: arithmetic op on temporal number (per-instant)

+ */ + public static jnr.ffi.Pointer mul_interval_double(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "mul_interval_double requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.mul_interval_double(arg0, arg1); + } + + /** + * MEOS {@code numspan_timestamptz_to_tbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer numspan_timestamptz_to_tbox(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "numspan_timestamptz_to_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.numspan_timestamptz_to_tbox(arg0, arg1); + } + + /** + * MEOS {@code numspan_tstzspan_to_tbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer numspan_tstzspan_to_tbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "numspan_tstzspan_to_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.numspan_tstzspan_to_tbox(arg0, arg1); + } + + /** + * MEOS {@code overafter_date_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overafter_date_set(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overafter_date_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overafter_date_set(arg0, arg1); + } + + /** + * MEOS {@code overafter_date_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overafter_date_span(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overafter_date_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overafter_date_span(arg0, arg1); + } + + /** + * MEOS {@code overafter_date_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overafter_date_spanset(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overafter_date_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overafter_date_spanset(arg0, arg1); + } + + /** + * MEOS {@code overafter_set_date} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overafter_set_date(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overafter_set_date requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overafter_set_date(arg0, arg1); + } + + /** + * MEOS {@code overafter_set_timestamptz} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overafter_set_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overafter_set_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overafter_set_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code overafter_span_date} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overafter_span_date(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overafter_span_date requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overafter_span_date(arg0, arg1); + } + + /** + * MEOS {@code overafter_span_timestamptz} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overafter_span_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overafter_span_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overafter_span_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code overafter_spanset_date} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overafter_spanset_date(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overafter_spanset_date requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overafter_spanset_date(arg0, arg1); + } + + /** + * MEOS {@code overafter_spanset_timestamptz} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overafter_spanset_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overafter_spanset_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overafter_spanset_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code overafter_tbox_tbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overafter_tbox_tbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overafter_tbox_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overafter_tbox_tbox(arg0, arg1); + } + + /** + * MEOS {@code overafter_tbox_tnumber} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overafter_tbox_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overafter_tbox_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overafter_tbox_tnumber(arg0, arg1); + } + + /** + * MEOS {@code overafter_timestamptz_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overafter_timestamptz_set(java.time.OffsetDateTime arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overafter_timestamptz_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overafter_timestamptz_set(arg0, arg1); + } + + /** + * MEOS {@code overafter_timestamptz_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overafter_timestamptz_span(java.time.OffsetDateTime arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overafter_timestamptz_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overafter_timestamptz_span(arg0, arg1); + } + + /** + * MEOS {@code overafter_timestamptz_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overafter_timestamptz_spanset(java.time.OffsetDateTime arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overafter_timestamptz_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overafter_timestamptz_spanset(arg0, arg1); + } + + /** + * MEOS {@code overbefore_date_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overbefore_date_set(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overbefore_date_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overbefore_date_set(arg0, arg1); + } + + /** + * MEOS {@code overbefore_date_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overbefore_date_span(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overbefore_date_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overbefore_date_span(arg0, arg1); + } + + /** + * MEOS {@code overbefore_date_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overbefore_date_spanset(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overbefore_date_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overbefore_date_spanset(arg0, arg1); + } + + /** + * MEOS {@code overbefore_set_date} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overbefore_set_date(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overbefore_set_date requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overbefore_set_date(arg0, arg1); + } + + /** + * MEOS {@code overbefore_set_timestamptz} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overbefore_set_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overbefore_set_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overbefore_set_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code overbefore_span_date} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overbefore_span_date(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overbefore_span_date requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overbefore_span_date(arg0, arg1); + } + + /** + * MEOS {@code overbefore_span_timestamptz} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overbefore_span_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overbefore_span_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overbefore_span_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code overbefore_spanset_date} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overbefore_spanset_date(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overbefore_spanset_date requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overbefore_spanset_date(arg0, arg1); + } + + /** + * MEOS {@code overbefore_spanset_timestamptz} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overbefore_spanset_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overbefore_spanset_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overbefore_spanset_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code overbefore_tbox_tbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overbefore_tbox_tbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overbefore_tbox_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overbefore_tbox_tbox(arg0, arg1); + } + + /** + * MEOS {@code overbefore_tbox_tnumber} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overbefore_tbox_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overbefore_tbox_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overbefore_tbox_tnumber(arg0, arg1); + } + + /** + * MEOS {@code overbefore_timestamptz_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overbefore_timestamptz_set(java.time.OffsetDateTime arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overbefore_timestamptz_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overbefore_timestamptz_set(arg0, arg1); + } + + /** + * MEOS {@code overbefore_timestamptz_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overbefore_timestamptz_span(java.time.OffsetDateTime arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overbefore_timestamptz_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overbefore_timestamptz_span(arg0, arg1); + } + + /** + * MEOS {@code overbefore_timestamptz_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overbefore_timestamptz_spanset(java.time.OffsetDateTime arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overbefore_timestamptz_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overbefore_timestamptz_spanset(arg0, arg1); + } + + /** + * MEOS {@code overlaps_set_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overlaps_set_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overlaps_set_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overlaps_set_set(arg0, arg1); + } + + /** + * MEOS {@code overlaps_span_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overlaps_span_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overlaps_span_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overlaps_span_span(arg0, arg1); + } + + /** + * MEOS {@code overlaps_span_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overlaps_span_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overlaps_span_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overlaps_span_spanset(arg0, arg1); + } + + /** + * MEOS {@code overlaps_spanset_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overlaps_spanset_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overlaps_spanset_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overlaps_spanset_span(arg0, arg1); + } + + /** + * MEOS {@code overlaps_spanset_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overlaps_spanset_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overlaps_spanset_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overlaps_spanset_spanset(arg0, arg1); + } + + /** + * MEOS {@code overlaps_tbox_tbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overlaps_tbox_tbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overlaps_tbox_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overlaps_tbox_tbox(arg0, arg1); + } + + /** + * MEOS {@code overlaps_tbox_tnumber} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overlaps_tbox_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overlaps_tbox_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overlaps_tbox_tnumber(arg0, arg1); + } + + /** + * MEOS {@code overleft_bigint_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overleft_bigint_set(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overleft_bigint_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overleft_bigint_set(arg0, arg1); + } + + /** + * MEOS {@code overleft_bigint_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overleft_bigint_span(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overleft_bigint_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overleft_bigint_span(arg0, arg1); + } + + /** + * MEOS {@code overleft_bigint_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overleft_bigint_spanset(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overleft_bigint_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overleft_bigint_spanset(arg0, arg1); + } + + /** + * MEOS {@code overleft_float_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overleft_float_set(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overleft_float_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overleft_float_set(arg0, arg1); + } + + /** + * MEOS {@code overleft_float_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overleft_float_span(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overleft_float_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overleft_float_span(arg0, arg1); + } + + /** + * MEOS {@code overleft_float_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overleft_float_spanset(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overleft_float_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overleft_float_spanset(arg0, arg1); + } + + /** + * MEOS {@code overleft_int_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overleft_int_set(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overleft_int_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overleft_int_set(arg0, arg1); + } + + /** + * MEOS {@code overleft_int_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overleft_int_span(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overleft_int_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overleft_int_span(arg0, arg1); + } + + /** + * MEOS {@code overleft_int_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overleft_int_spanset(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overleft_int_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overleft_int_spanset(arg0, arg1); + } + + /** + * MEOS {@code overleft_set_bigint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overleft_set_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overleft_set_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overleft_set_bigint(arg0, arg1); + } + + /** + * MEOS {@code overleft_set_float} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overleft_set_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overleft_set_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overleft_set_float(arg0, arg1); + } + + /** + * MEOS {@code overleft_set_int} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overleft_set_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overleft_set_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overleft_set_int(arg0, arg1); + } + + /** + * MEOS {@code overleft_set_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overleft_set_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overleft_set_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overleft_set_set(arg0, arg1); + } + + /** + * MEOS {@code overleft_set_text} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overleft_set_text(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overleft_set_text requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overleft_set_text(arg0, arg1); + } + + /** + * MEOS {@code overleft_span_bigint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overleft_span_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overleft_span_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overleft_span_bigint(arg0, arg1); + } + + /** + * MEOS {@code overleft_span_float} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overleft_span_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overleft_span_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overleft_span_float(arg0, arg1); + } + + /** + * MEOS {@code overleft_span_int} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overleft_span_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overleft_span_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overleft_span_int(arg0, arg1); + } + + /** + * MEOS {@code overleft_span_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overleft_span_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overleft_span_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overleft_span_span(arg0, arg1); + } + + /** + * MEOS {@code overleft_span_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overleft_span_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overleft_span_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overleft_span_spanset(arg0, arg1); + } + + /** + * MEOS {@code overleft_spanset_bigint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overleft_spanset_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overleft_spanset_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overleft_spanset_bigint(arg0, arg1); + } + + /** + * MEOS {@code overleft_spanset_float} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overleft_spanset_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overleft_spanset_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overleft_spanset_float(arg0, arg1); + } + + /** + * MEOS {@code overleft_spanset_int} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overleft_spanset_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overleft_spanset_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overleft_spanset_int(arg0, arg1); + } + + /** + * MEOS {@code overleft_spanset_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overleft_spanset_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overleft_spanset_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overleft_spanset_span(arg0, arg1); + } + + /** + * MEOS {@code overleft_spanset_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overleft_spanset_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overleft_spanset_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overleft_spanset_spanset(arg0, arg1); + } + + /** + * MEOS {@code overleft_tbox_tbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overleft_tbox_tbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overleft_tbox_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overleft_tbox_tbox(arg0, arg1); + } + + /** + * MEOS {@code overleft_tbox_tnumber} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overleft_tbox_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overleft_tbox_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overleft_tbox_tnumber(arg0, arg1); + } + + /** + * MEOS {@code overleft_text_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overleft_text_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overleft_text_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overleft_text_set(arg0, arg1); + } + + /** + * MEOS {@code overright_bigint_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overright_bigint_set(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overright_bigint_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overright_bigint_set(arg0, arg1); + } + + /** + * MEOS {@code overright_bigint_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overright_bigint_span(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overright_bigint_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overright_bigint_span(arg0, arg1); + } + + /** + * MEOS {@code overright_bigint_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overright_bigint_spanset(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overright_bigint_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overright_bigint_spanset(arg0, arg1); + } + + /** + * MEOS {@code overright_float_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overright_float_set(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overright_float_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overright_float_set(arg0, arg1); + } + + /** + * MEOS {@code overright_float_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overright_float_span(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overright_float_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overright_float_span(arg0, arg1); + } + + /** + * MEOS {@code overright_float_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overright_float_spanset(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overright_float_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overright_float_spanset(arg0, arg1); + } + + /** + * MEOS {@code overright_int_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overright_int_set(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overright_int_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overright_int_set(arg0, arg1); + } + + /** + * MEOS {@code overright_int_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overright_int_span(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overright_int_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overright_int_span(arg0, arg1); + } + + /** + * MEOS {@code overright_int_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overright_int_spanset(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overright_int_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overright_int_spanset(arg0, arg1); + } + + /** + * MEOS {@code overright_set_bigint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overright_set_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overright_set_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overright_set_bigint(arg0, arg1); + } + + /** + * MEOS {@code overright_set_float} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overright_set_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overright_set_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overright_set_float(arg0, arg1); + } + + /** + * MEOS {@code overright_set_int} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overright_set_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overright_set_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overright_set_int(arg0, arg1); + } + + /** + * MEOS {@code overright_set_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overright_set_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overright_set_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overright_set_set(arg0, arg1); + } + + /** + * MEOS {@code overright_set_text} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overright_set_text(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overright_set_text requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overright_set_text(arg0, arg1); + } + + /** + * MEOS {@code overright_span_bigint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overright_span_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overright_span_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overright_span_bigint(arg0, arg1); + } + + /** + * MEOS {@code overright_span_float} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overright_span_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overright_span_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overright_span_float(arg0, arg1); + } + + /** + * MEOS {@code overright_span_int} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overright_span_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overright_span_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overright_span_int(arg0, arg1); + } + + /** + * MEOS {@code overright_span_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overright_span_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overright_span_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overright_span_span(arg0, arg1); + } + + /** + * MEOS {@code overright_span_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overright_span_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overright_span_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overright_span_spanset(arg0, arg1); + } + + /** + * MEOS {@code overright_spanset_bigint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overright_spanset_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overright_spanset_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overright_spanset_bigint(arg0, arg1); + } + + /** + * MEOS {@code overright_spanset_float} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overright_spanset_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overright_spanset_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overright_spanset_float(arg0, arg1); + } + + /** + * MEOS {@code overright_spanset_int} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overright_spanset_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overright_spanset_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overright_spanset_int(arg0, arg1); + } + + /** + * MEOS {@code overright_spanset_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overright_spanset_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overright_spanset_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overright_spanset_span(arg0, arg1); + } + + /** + * MEOS {@code overright_spanset_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overright_spanset_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overright_spanset_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overright_spanset_spanset(arg0, arg1); + } + + /** + * MEOS {@code overright_tbox_tbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overright_tbox_tbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overright_tbox_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overright_tbox_tbox(arg0, arg1); + } + + /** + * MEOS {@code overright_tbox_tnumber} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overright_tbox_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overright_tbox_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overright_tbox_tnumber(arg0, arg1); + } + + /** + * MEOS {@code overright_text_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overright_text_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overright_text_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overright_text_set(arg0, arg1); + } + + /** + * MEOS {@code right_bigint_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean right_bigint_set(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "right_bigint_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.right_bigint_set(arg0, arg1); + } + + /** + * MEOS {@code right_bigint_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean right_bigint_span(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "right_bigint_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.right_bigint_span(arg0, arg1); + } + + /** + * MEOS {@code right_bigint_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean right_bigint_spanset(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "right_bigint_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.right_bigint_spanset(arg0, arg1); + } + + /** + * MEOS {@code right_float_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean right_float_set(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "right_float_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.right_float_set(arg0, arg1); + } + + /** + * MEOS {@code right_float_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean right_float_span(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "right_float_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.right_float_span(arg0, arg1); + } + + /** + * MEOS {@code right_float_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean right_float_spanset(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "right_float_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.right_float_spanset(arg0, arg1); + } + + /** + * MEOS {@code right_int_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean right_int_set(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "right_int_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.right_int_set(arg0, arg1); + } + + /** + * MEOS {@code right_int_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean right_int_span(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "right_int_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.right_int_span(arg0, arg1); + } + + /** + * MEOS {@code right_int_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean right_int_spanset(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "right_int_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.right_int_spanset(arg0, arg1); + } + + /** + * MEOS {@code right_set_bigint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean right_set_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "right_set_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.right_set_bigint(arg0, arg1); + } + + /** + * MEOS {@code right_set_float} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean right_set_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "right_set_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.right_set_float(arg0, arg1); + } + + /** + * MEOS {@code right_set_int} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean right_set_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "right_set_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.right_set_int(arg0, arg1); + } + + /** + * MEOS {@code right_set_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean right_set_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "right_set_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.right_set_set(arg0, arg1); + } + + /** + * MEOS {@code right_set_text} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean right_set_text(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "right_set_text requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.right_set_text(arg0, arg1); + } + + /** + * MEOS {@code right_span_bigint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean right_span_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "right_span_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.right_span_bigint(arg0, arg1); + } + + /** + * MEOS {@code right_span_float} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean right_span_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "right_span_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.right_span_float(arg0, arg1); + } + + /** + * MEOS {@code right_span_int} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean right_span_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "right_span_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.right_span_int(arg0, arg1); + } + + /** + * MEOS {@code right_span_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean right_span_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "right_span_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.right_span_span(arg0, arg1); + } + + /** + * MEOS {@code right_span_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean right_span_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "right_span_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.right_span_spanset(arg0, arg1); + } + + /** + * MEOS {@code right_spanset_bigint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean right_spanset_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "right_spanset_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.right_spanset_bigint(arg0, arg1); + } + + /** + * MEOS {@code right_spanset_float} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean right_spanset_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "right_spanset_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.right_spanset_float(arg0, arg1); + } + + /** + * MEOS {@code right_spanset_int} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean right_spanset_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "right_spanset_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.right_spanset_int(arg0, arg1); + } + + /** + * MEOS {@code right_spanset_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean right_spanset_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "right_spanset_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.right_spanset_span(arg0, arg1); + } + + /** + * MEOS {@code right_spanset_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean right_spanset_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "right_spanset_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.right_spanset_spanset(arg0, arg1); + } + + /** + * MEOS {@code right_tbox_tbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean right_tbox_tbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "right_tbox_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.right_tbox_tbox(arg0, arg1); + } + + /** + * MEOS {@code right_tbox_tnumber} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean right_tbox_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "right_tbox_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.right_tbox_tnumber(arg0, arg1); + } + + /** + * MEOS {@code right_text_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean right_text_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "right_text_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.right_text_set(arg0, arg1); + } + + /** + * MEOS {@code same_numspan_tnumber} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: same predicate (pure box equality)

+ */ + public static boolean same_numspan_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "same_numspan_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.same_numspan_tnumber(arg0, arg1); + } + + /** + * MEOS {@code same_tbox_tbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: same predicate (pure box equality)

+ */ + public static boolean same_tbox_tbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "same_tbox_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.same_tbox_tbox(arg0, arg1); + } + + /** + * MEOS {@code same_tbox_tnumber} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: same predicate (pure box equality)

+ */ + public static boolean same_tbox_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "same_tbox_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.same_tbox_tnumber(arg0, arg1); + } + + /** + * MEOS {@code same_temporal_tstzspan} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: same predicate (pure box equality)

+ */ + public static boolean same_temporal_tstzspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "same_temporal_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.same_temporal_tstzspan(arg0, arg1); + } + + /** + * MEOS {@code same_tnumber_numspan} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: same predicate (pure box equality)

+ */ + public static boolean same_tnumber_numspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "same_tnumber_numspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.same_tnumber_numspan(arg0, arg1); + } + + /** + * MEOS {@code same_tnumber_tbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: same predicate (pure box equality)

+ */ + public static boolean same_tnumber_tbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "same_tnumber_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.same_tnumber_tbox(arg0, arg1); + } + + /** + * MEOS {@code same_tstzspan_temporal} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: same predicate (pure box equality)

+ */ + public static boolean same_tstzspan_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "same_tstzspan_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.same_tstzspan_temporal(arg0, arg1); + } + + /** + * MEOS {@code sub_float_tfloat} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: arithmetic op on temporal number (per-instant)

+ */ + public static jnr.ffi.Pointer sub_float_tfloat(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "sub_float_tfloat requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.sub_float_tfloat(arg0, arg1); + } + + /** + * MEOS {@code sub_int_tint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: arithmetic op on temporal number (per-instant)

+ */ + public static jnr.ffi.Pointer sub_int_tint(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "sub_int_tint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.sub_int_tint(arg0, arg1); + } + + /** + * MEOS {@code sub_tfloat_float} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: arithmetic op on temporal number (per-instant)

+ */ + public static jnr.ffi.Pointer sub_tfloat_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "sub_tfloat_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.sub_tfloat_float(arg0, arg1); + } + + /** + * MEOS {@code sub_tint_int} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: arithmetic op on temporal number (per-instant)

+ */ + public static jnr.ffi.Pointer sub_tint_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "sub_tint_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.sub_tint_int(arg0, arg1); + } + + /** + * MEOS {@code sub_tnumber_tnumber} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: arithmetic op on temporal number (per-instant)

+ */ + public static jnr.ffi.Pointer sub_tnumber_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "sub_tnumber_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.sub_tnumber_tnumber(arg0, arg1); + } + + /** + * MEOS {@code tboxfloat_xmax} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar in/out (default-stateless catch-all)

+ */ + public static jnr.ffi.Pointer tboxfloat_xmax(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tboxfloat_xmax requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tboxfloat_xmax(arg0); + } + + /** + * MEOS {@code tboxfloat_xmin} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar in/out (default-stateless catch-all)

+ */ + public static jnr.ffi.Pointer tboxfloat_xmin(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tboxfloat_xmin requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tboxfloat_xmin(arg0); + } + + /** + * MEOS {@code tboxint_xmax} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar in/out (default-stateless catch-all)

+ */ + public static jnr.ffi.Pointer tboxint_xmax(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tboxint_xmax requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tboxint_xmax(arg0); + } + + /** + * MEOS {@code tboxint_xmin} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar in/out (default-stateless catch-all)

+ */ + public static jnr.ffi.Pointer tboxint_xmin(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tboxint_xmin requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tboxint_xmin(arg0); + } + + /** + * MEOS {@code temparr_round} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: transform/normalize (pure)

+ */ + public static jnr.ffi.Pointer temparr_round(jnr.ffi.Pointer arg0, int arg1, int arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temparr_round requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temparr_round(arg0, arg1, arg2); + } + + /** + * MEOS {@code teq_bool_tbool} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer teq_bool_tbool(boolean arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "teq_bool_tbool requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.teq_bool_tbool(arg0, arg1); + } + + /** + * MEOS {@code teq_float_tfloat} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer teq_float_tfloat(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "teq_float_tfloat requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.teq_float_tfloat(arg0, arg1); + } + + /** + * MEOS {@code teq_int_tint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer teq_int_tint(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "teq_int_tint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.teq_int_tint(arg0, arg1); + } + + /** + * MEOS {@code teq_tbool_bool} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer teq_tbool_bool(jnr.ffi.Pointer arg0, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "teq_tbool_bool requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.teq_tbool_bool(arg0, arg1); + } + + /** + * MEOS {@code teq_temporal_temporal} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer teq_temporal_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "teq_temporal_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.teq_temporal_temporal(arg0, arg1); + } + + /** + * MEOS {@code teq_text_ttext} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer teq_text_ttext(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "teq_text_ttext requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.teq_text_ttext(arg0, arg1); + } + + /** + * MEOS {@code teq_tfloat_float} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer teq_tfloat_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "teq_tfloat_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.teq_tfloat_float(arg0, arg1); + } + + /** + * MEOS {@code teq_tint_int} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer teq_tint_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "teq_tint_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.teq_tint_int(arg0, arg1); + } + + /** + * MEOS {@code teq_ttext_text} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer teq_ttext_text(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "teq_ttext_text requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.teq_ttext_text(arg0, arg1); + } + + /** + * MEOS {@code text_cmp} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar comparison/hash

+ */ + public static int text_cmp(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "text_cmp requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.text_cmp(arg0, arg1); + } + + /** + * MEOS {@code text_copy} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer text_copy(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "text_copy requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.text_copy(arg0); + } + + /** + * MEOS {@code text_initcap} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer text_initcap(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "text_initcap requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.text_initcap(arg0); + } + + /** + * MEOS {@code text_lower} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer text_lower(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "text_lower requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.text_lower(arg0); + } + + /** + * MEOS {@code text_to_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer text_to_set(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "text_to_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.text_to_set(arg0); + } + + /** + * MEOS {@code text_union_transfn} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer text_union_transfn(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "text_union_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.text_union_transfn(arg0, arg1); + } + + /** + * MEOS {@code text_upper} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer text_upper(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "text_upper requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.text_upper(arg0); + } + + /** + * MEOS {@code textcat_text_text} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: text concatenation (per-instant)

+ */ + public static jnr.ffi.Pointer textcat_text_text(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "textcat_text_text requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.textcat_text_text(arg0, arg1); + } + + /** + * MEOS {@code textcat_text_textset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: text concatenation (per-instant)

+ */ + public static jnr.ffi.Pointer textcat_text_textset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "textcat_text_textset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.textcat_text_textset(arg0, arg1); + } + + /** + * MEOS {@code textcat_text_ttext} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: text concatenation (per-instant)

+ */ + public static jnr.ffi.Pointer textcat_text_ttext(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "textcat_text_ttext requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.textcat_text_ttext(arg0, arg1); + } + + /** + * MEOS {@code textcat_textset_text} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: text concatenation (per-instant)

+ */ + public static jnr.ffi.Pointer textcat_textset_text(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "textcat_textset_text requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.textcat_textset_text(arg0, arg1); + } + + /** + * MEOS {@code textcat_ttext_text} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: text concatenation (per-instant)

+ */ + public static jnr.ffi.Pointer textcat_ttext_text(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "textcat_ttext_text requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.textcat_ttext_text(arg0, arg1); + } + + /** + * MEOS {@code textcat_ttext_ttext} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: text concatenation (per-instant)

+ */ + public static jnr.ffi.Pointer textcat_ttext_ttext(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "textcat_ttext_ttext requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.textcat_ttext_ttext(arg0, arg1); + } + + /** + * MEOS {@code tfloatbox_expand} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: transform/normalize (pure)

+ */ + public static jnr.ffi.Pointer tfloatbox_expand(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloatbox_expand requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloatbox_expand(arg0, arg1); + } + + /** + * MEOS {@code tfloatbox_shift_scale} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: transform/normalize (pure)

+ */ + public static jnr.ffi.Pointer tfloatbox_shift_scale(jnr.ffi.Pointer arg0, double arg1, double arg2, boolean arg3, boolean arg4) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloatbox_shift_scale requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloatbox_shift_scale(arg0, arg1, arg2, arg3, arg4); + } + + /** + * MEOS {@code tge_float_tfloat} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tge_float_tfloat(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tge_float_tfloat requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tge_float_tfloat(arg0, arg1); + } + + /** + * MEOS {@code tge_int_tint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tge_int_tint(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tge_int_tint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tge_int_tint(arg0, arg1); + } + + /** + * MEOS {@code tge_temporal_temporal} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tge_temporal_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tge_temporal_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tge_temporal_temporal(arg0, arg1); + } + + /** + * MEOS {@code tge_text_ttext} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tge_text_ttext(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tge_text_ttext requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tge_text_ttext(arg0, arg1); + } + + /** + * MEOS {@code tge_tfloat_float} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tge_tfloat_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tge_tfloat_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tge_tfloat_float(arg0, arg1); + } + + /** + * MEOS {@code tge_tint_int} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tge_tint_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tge_tint_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tge_tint_int(arg0, arg1); + } + + /** + * MEOS {@code tge_ttext_text} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tge_ttext_text(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tge_ttext_text requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tge_ttext_text(arg0, arg1); + } + + /** + * MEOS {@code tgt_float_tfloat} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tgt_float_tfloat(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgt_float_tfloat requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgt_float_tfloat(arg0, arg1); + } + + /** + * MEOS {@code tgt_int_tint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tgt_int_tint(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgt_int_tint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgt_int_tint(arg0, arg1); + } + + /** + * MEOS {@code tgt_temporal_temporal} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tgt_temporal_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgt_temporal_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgt_temporal_temporal(arg0, arg1); + } + + /** + * MEOS {@code tgt_text_ttext} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tgt_text_ttext(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgt_text_ttext requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgt_text_ttext(arg0, arg1); + } + + /** + * MEOS {@code tgt_tfloat_float} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tgt_tfloat_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgt_tfloat_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgt_tfloat_float(arg0, arg1); + } + + /** + * MEOS {@code tgt_tint_int} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tgt_tint_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgt_tint_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgt_tint_int(arg0, arg1); + } + + /** + * MEOS {@code tgt_ttext_text} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tgt_ttext_text(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgt_ttext_text requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgt_ttext_text(arg0, arg1); + } + + /** + * MEOS {@code timestamp_to_date} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static int timestamp_to_date(java.time.LocalDateTime arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "timestamp_to_date requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.timestamp_to_date(arg0); + } + + /** + * MEOS {@code timestamptz_extent_transfn} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer timestamptz_extent_transfn(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "timestamptz_extent_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.timestamptz_extent_transfn(arg0, arg1); + } + + /** + * MEOS {@code timestamptz_get_bin} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar comparison/hash

+ */ + public static java.time.OffsetDateTime timestamptz_get_bin(java.time.OffsetDateTime arg0, jnr.ffi.Pointer arg1, java.time.OffsetDateTime arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "timestamptz_get_bin requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.timestamptz_get_bin(arg0, arg1, arg2); + } + + /** + * MEOS {@code timestamptz_shift} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: transform/normalize (pure)

+ */ + public static java.time.OffsetDateTime timestamptz_shift(java.time.OffsetDateTime arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "timestamptz_shift requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.timestamptz_shift(arg0, arg1); + } + + /** + * MEOS {@code timestamptz_tcount_transfn} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer timestamptz_tcount_transfn(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "timestamptz_tcount_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.timestamptz_tcount_transfn(arg0, arg1); + } + + /** + * MEOS {@code timestamptz_to_date} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static int timestamptz_to_date(java.time.OffsetDateTime arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "timestamptz_to_date requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.timestamptz_to_date(arg0); + } + + /** + * MEOS {@code timestamptz_to_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer timestamptz_to_set(java.time.OffsetDateTime arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "timestamptz_to_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.timestamptz_to_set(arg0); + } + + /** + * MEOS {@code timestamptz_to_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer timestamptz_to_span(java.time.OffsetDateTime arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "timestamptz_to_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.timestamptz_to_span(arg0); + } + + /** + * MEOS {@code timestamptz_to_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer timestamptz_to_spanset(java.time.OffsetDateTime arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "timestamptz_to_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.timestamptz_to_spanset(arg0); + } + + /** + * MEOS {@code timestamptz_to_tbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer timestamptz_to_tbox(java.time.OffsetDateTime arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "timestamptz_to_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.timestamptz_to_tbox(arg0); + } + + /** + * MEOS {@code timestamptz_tprecision} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static java.time.OffsetDateTime timestamptz_tprecision(java.time.OffsetDateTime arg0, jnr.ffi.Pointer arg1, java.time.OffsetDateTime arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "timestamptz_tprecision requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.timestamptz_tprecision(arg0, arg1, arg2); + } + + /** + * MEOS {@code timestamptz_union_transfn} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer timestamptz_union_transfn(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "timestamptz_union_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.timestamptz_union_transfn(arg0, arg1); + } + + /** + * MEOS {@code tintbox_expand} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: transform/normalize (pure)

+ */ + public static jnr.ffi.Pointer tintbox_expand(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tintbox_expand requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tintbox_expand(arg0, arg1); + } + + /** + * MEOS {@code tintbox_shift_scale} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: transform/normalize (pure)

+ */ + public static jnr.ffi.Pointer tintbox_shift_scale(jnr.ffi.Pointer arg0, int arg1, int arg2, boolean arg3, boolean arg4) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tintbox_shift_scale requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tintbox_shift_scale(arg0, arg1, arg2, arg3, arg4); + } + + /** + * MEOS {@code tle_float_tfloat} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tle_float_tfloat(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tle_float_tfloat requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tle_float_tfloat(arg0, arg1); + } + + /** + * MEOS {@code tle_int_tint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tle_int_tint(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tle_int_tint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tle_int_tint(arg0, arg1); + } + + /** + * MEOS {@code tle_temporal_temporal} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tle_temporal_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tle_temporal_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tle_temporal_temporal(arg0, arg1); + } + + /** + * MEOS {@code tle_text_ttext} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tle_text_ttext(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tle_text_ttext requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tle_text_ttext(arg0, arg1); + } + + /** + * MEOS {@code tle_tfloat_float} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tle_tfloat_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tle_tfloat_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tle_tfloat_float(arg0, arg1); + } + + /** + * MEOS {@code tle_tint_int} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tle_tint_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tle_tint_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tle_tint_int(arg0, arg1); + } + + /** + * MEOS {@code tle_ttext_text} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tle_ttext_text(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tle_ttext_text requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tle_ttext_text(arg0, arg1); + } + + /** + * MEOS {@code tlt_float_tfloat} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tlt_float_tfloat(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tlt_float_tfloat requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tlt_float_tfloat(arg0, arg1); + } + + /** + * MEOS {@code tlt_int_tint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tlt_int_tint(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tlt_int_tint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tlt_int_tint(arg0, arg1); + } + + /** + * MEOS {@code tlt_temporal_temporal} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tlt_temporal_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tlt_temporal_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tlt_temporal_temporal(arg0, arg1); + } + + /** + * MEOS {@code tlt_text_ttext} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tlt_text_ttext(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tlt_text_ttext requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tlt_text_ttext(arg0, arg1); + } + + /** + * MEOS {@code tlt_tfloat_float} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tlt_tfloat_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tlt_tfloat_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tlt_tfloat_float(arg0, arg1); + } + + /** + * MEOS {@code tlt_tint_int} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tlt_tint_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tlt_tint_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tlt_tint_int(arg0, arg1); + } + + /** + * MEOS {@code tlt_ttext_text} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tlt_ttext_text(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tlt_ttext_text requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tlt_ttext_text(arg0, arg1); + } + + /** + * MEOS {@code tne_bool_tbool} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tne_bool_tbool(boolean arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tne_bool_tbool requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tne_bool_tbool(arg0, arg1); + } + + /** + * MEOS {@code tne_float_tfloat} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tne_float_tfloat(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tne_float_tfloat requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tne_float_tfloat(arg0, arg1); + } + + /** + * MEOS {@code tne_int_tint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tne_int_tint(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tne_int_tint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tne_int_tint(arg0, arg1); + } + + /** + * MEOS {@code tne_tbool_bool} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tne_tbool_bool(jnr.ffi.Pointer arg0, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tne_tbool_bool requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tne_tbool_bool(arg0, arg1); + } + + /** + * MEOS {@code tne_temporal_temporal} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tne_temporal_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tne_temporal_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tne_temporal_temporal(arg0, arg1); + } + + /** + * MEOS {@code tne_text_ttext} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tne_text_ttext(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tne_text_ttext requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tne_text_ttext(arg0, arg1); + } + + /** + * MEOS {@code tne_tfloat_float} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tne_tfloat_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tne_tfloat_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tne_tfloat_float(arg0, arg1); + } + + /** + * MEOS {@code tne_tint_int} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tne_tint_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tne_tint_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tne_tint_int(arg0, arg1); + } + + /** + * MEOS {@code tne_ttext_text} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tne_ttext_text(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tne_ttext_text requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tne_ttext_text(arg0, arg1); + } + + /** + * MEOS {@code union_bigint_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_bigint_set(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_bigint_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_bigint_set(arg0, arg1); + } + + /** + * MEOS {@code union_bigint_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_bigint_span(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_bigint_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_bigint_span(arg0, arg1); + } + + /** + * MEOS {@code union_bigint_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_bigint_spanset(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_bigint_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_bigint_spanset(arg0, arg1); + } + + /** + * MEOS {@code union_date_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_date_set(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_date_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_date_set(arg0, arg1); + } + + /** + * MEOS {@code union_date_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_date_span(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_date_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_date_span(arg0, arg1); + } + + /** + * MEOS {@code union_date_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_date_spanset(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_date_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_date_spanset(arg0, arg1); + } + + /** + * MEOS {@code union_float_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_float_set(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_float_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_float_set(arg0, arg1); + } + + /** + * MEOS {@code union_float_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_float_span(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_float_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_float_span(arg0, arg1); + } + + /** + * MEOS {@code union_float_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_float_spanset(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_float_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_float_spanset(arg0, arg1); + } + + /** + * MEOS {@code union_int_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_int_set(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_int_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_int_set(arg0, arg1); + } + + /** + * MEOS {@code union_int_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_int_span(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_int_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_int_span(arg0, arg1); + } + + /** + * MEOS {@code union_int_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_int_spanset(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_int_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_int_spanset(arg0, arg1); + } + + /** + * MEOS {@code union_set_bigint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_set_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_set_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_set_bigint(arg0, arg1); + } + + /** + * MEOS {@code union_set_date} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_set_date(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_set_date requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_set_date(arg0, arg1); + } + + /** + * MEOS {@code union_set_float} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_set_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_set_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_set_float(arg0, arg1); + } + + /** + * MEOS {@code union_set_int} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_set_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_set_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_set_int(arg0, arg1); + } + + /** + * MEOS {@code union_set_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_set_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_set_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_set_set(arg0, arg1); + } + + /** + * MEOS {@code union_set_text} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_set_text(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_set_text requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_set_text(arg0, arg1); + } + + /** + * MEOS {@code union_set_timestamptz} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_set_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_set_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_set_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code union_span_bigint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_span_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_span_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_span_bigint(arg0, arg1); + } + + /** + * MEOS {@code union_span_date} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_span_date(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_span_date requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_span_date(arg0, arg1); + } + + /** + * MEOS {@code union_span_float} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_span_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_span_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_span_float(arg0, arg1); + } + + /** + * MEOS {@code union_span_int} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_span_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_span_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_span_int(arg0, arg1); + } + + /** + * MEOS {@code union_span_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_span_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_span_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_span_span(arg0, arg1); + } + + /** + * MEOS {@code union_span_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_span_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_span_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_span_spanset(arg0, arg1); + } + + /** + * MEOS {@code union_span_timestamptz} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_span_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_span_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_span_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code union_spanset_bigint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_spanset_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_spanset_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_spanset_bigint(arg0, arg1); + } + + /** + * MEOS {@code union_spanset_date} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_spanset_date(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_spanset_date requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_spanset_date(arg0, arg1); + } + + /** + * MEOS {@code union_spanset_float} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_spanset_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_spanset_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_spanset_float(arg0, arg1); + } + + /** + * MEOS {@code union_spanset_int} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_spanset_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_spanset_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_spanset_int(arg0, arg1); + } + + /** + * MEOS {@code union_spanset_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_spanset_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_spanset_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_spanset_span(arg0, arg1); + } + + /** + * MEOS {@code union_spanset_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_spanset_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_spanset_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_spanset_spanset(arg0, arg1); + } + + /** + * MEOS {@code union_spanset_timestamptz} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_spanset_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_spanset_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_spanset_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code union_tbox_tbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_tbox_tbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_tbox_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_tbox_tbox(arg0, arg1, arg2); + } + + /** + * MEOS {@code union_text_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_text_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_text_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_text_set(arg0, arg1); + } + + /** + * MEOS {@code union_timestamptz_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_timestamptz_set(java.time.OffsetDateTime arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_timestamptz_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_timestamptz_set(arg0, arg1); + } + + /** + * MEOS {@code union_timestamptz_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_timestamptz_span(java.time.OffsetDateTime arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_timestamptz_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_timestamptz_span(arg0, arg1); + } + + /** + * MEOS {@code union_timestamptz_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_timestamptz_spanset(java.time.OffsetDateTime arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_timestamptz_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_timestamptz_spanset(arg0, arg1); + } + + /** + * MEOS {@code adjacent_numspan_tnumber} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean adjacent_numspan_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "adjacent_numspan_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.adjacent_numspan_tnumber(arg0, arg1); + } + + /** + * MEOS {@code adjacent_temporal_tstzspan} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean adjacent_temporal_tstzspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "adjacent_temporal_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.adjacent_temporal_tstzspan(arg0, arg1); + } + + /** + * MEOS {@code adjacent_tnumber_numspan} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean adjacent_tnumber_numspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "adjacent_tnumber_numspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.adjacent_tnumber_numspan(arg0, arg1); + } + + /** + * MEOS {@code adjacent_tnumber_tbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean adjacent_tnumber_tbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "adjacent_tnumber_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.adjacent_tnumber_tbox(arg0, arg1); + } + + /** + * MEOS {@code adjacent_tstzspan_temporal} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean adjacent_tstzspan_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "adjacent_tstzspan_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.adjacent_tstzspan_temporal(arg0, arg1); + } + + /** + * MEOS {@code after_temporal_tstzspan} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean after_temporal_tstzspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "after_temporal_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.after_temporal_tstzspan(arg0, arg1); + } + + /** + * MEOS {@code after_tnumber_tbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean after_tnumber_tbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "after_tnumber_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.after_tnumber_tbox(arg0, arg1); + } + + /** + * MEOS {@code after_tstzspan_temporal} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean after_tstzspan_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "after_tstzspan_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.after_tstzspan_temporal(arg0, arg1); + } + + /** + * MEOS {@code before_temporal_tstzspan} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean before_temporal_tstzspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "before_temporal_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.before_temporal_tstzspan(arg0, arg1); + } + + /** + * MEOS {@code before_tnumber_tbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean before_tnumber_tbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "before_tnumber_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.before_tnumber_tbox(arg0, arg1); + } + + /** + * MEOS {@code before_tstzspan_temporal} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean before_tstzspan_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "before_tstzspan_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.before_tstzspan_temporal(arg0, arg1); + } + + /** + * MEOS {@code contained_numspan_tnumber} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean contained_numspan_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contained_numspan_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contained_numspan_tnumber(arg0, arg1); + } + + /** + * MEOS {@code contained_temporal_tstzspan} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean contained_temporal_tstzspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contained_temporal_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contained_temporal_tstzspan(arg0, arg1); + } + + /** + * MEOS {@code contained_tnumber_numspan} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean contained_tnumber_numspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contained_tnumber_numspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contained_tnumber_numspan(arg0, arg1); + } + + /** + * MEOS {@code contained_tnumber_tbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean contained_tnumber_tbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contained_tnumber_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contained_tnumber_tbox(arg0, arg1); + } + + /** + * MEOS {@code contained_tstzspan_temporal} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean contained_tstzspan_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contained_tstzspan_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contained_tstzspan_temporal(arg0, arg1); + } + + /** + * MEOS {@code contains_numspan_tnumber} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean contains_numspan_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_numspan_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_numspan_tnumber(arg0, arg1); + } + + /** + * MEOS {@code contains_temporal_tstzspan} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean contains_temporal_tstzspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_temporal_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_temporal_tstzspan(arg0, arg1); + } + + /** + * MEOS {@code contains_tnumber_numspan} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean contains_tnumber_numspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_tnumber_numspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_tnumber_numspan(arg0, arg1); + } + + /** + * MEOS {@code contains_tnumber_tbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean contains_tnumber_tbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_tnumber_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_tnumber_tbox(arg0, arg1); + } + + /** + * MEOS {@code contains_tstzspan_temporal} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean contains_tstzspan_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_tstzspan_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_tstzspan_temporal(arg0, arg1); + } + + /** + * MEOS {@code distance_bigintset_bigintset} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static long distance_bigintset_bigintset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_bigintset_bigintset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_bigintset_bigintset(arg0, arg1); + } + + /** + * MEOS {@code distance_bigintspan_bigintspan} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static long distance_bigintspan_bigintspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_bigintspan_bigintspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_bigintspan_bigintspan(arg0, arg1); + } + + /** + * MEOS {@code distance_bigintspanset_bigintspan} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static long distance_bigintspanset_bigintspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_bigintspanset_bigintspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_bigintspanset_bigintspan(arg0, arg1); + } + + /** + * MEOS {@code distance_bigintspanset_bigintspanset} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static long distance_bigintspanset_bigintspanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_bigintspanset_bigintspanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_bigintspanset_bigintspanset(arg0, arg1); + } + + /** + * MEOS {@code distance_dateset_dateset} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static int distance_dateset_dateset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_dateset_dateset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_dateset_dateset(arg0, arg1); + } + + /** + * MEOS {@code distance_datespan_datespan} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static int distance_datespan_datespan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_datespan_datespan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_datespan_datespan(arg0, arg1); + } + + /** + * MEOS {@code distance_datespanset_datespan} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static int distance_datespanset_datespan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_datespanset_datespan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_datespanset_datespan(arg0, arg1); + } + + /** + * MEOS {@code distance_datespanset_datespanset} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static int distance_datespanset_datespanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_datespanset_datespanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_datespanset_datespanset(arg0, arg1); + } + + /** + * MEOS {@code distance_floatset_floatset} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static double distance_floatset_floatset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_floatset_floatset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_floatset_floatset(arg0, arg1); + } + + /** + * MEOS {@code distance_floatspan_floatspan} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static double distance_floatspan_floatspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_floatspan_floatspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_floatspan_floatspan(arg0, arg1); + } + + /** + * MEOS {@code distance_floatspanset_floatspan} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static double distance_floatspanset_floatspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_floatspanset_floatspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_floatspanset_floatspan(arg0, arg1); + } + + /** + * MEOS {@code distance_floatspanset_floatspanset} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static double distance_floatspanset_floatspanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_floatspanset_floatspanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_floatspanset_floatspanset(arg0, arg1); + } + + /** + * MEOS {@code distance_intset_intset} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static int distance_intset_intset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_intset_intset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_intset_intset(arg0, arg1); + } + + /** + * MEOS {@code distance_intspan_intspan} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static int distance_intspan_intspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_intspan_intspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_intspan_intspan(arg0, arg1); + } + + /** + * MEOS {@code distance_intspanset_intspan} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static int distance_intspanset_intspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_intspanset_intspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_intspanset_intspan(arg0, arg1); + } + + /** + * MEOS {@code distance_intspanset_intspanset} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static int distance_intspanset_intspanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_intspanset_intspanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_intspanset_intspanset(arg0, arg1); + } + + /** + * MEOS {@code distance_set_bigint} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static long distance_set_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_set_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_set_bigint(arg0, arg1); + } + + /** + * MEOS {@code distance_set_date} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static int distance_set_date(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_set_date requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_set_date(arg0, arg1); + } + + /** + * MEOS {@code distance_set_float} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static double distance_set_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_set_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_set_float(arg0, arg1); + } + + /** + * MEOS {@code distance_set_int} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static int distance_set_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_set_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_set_int(arg0, arg1); + } + + /** + * MEOS {@code distance_set_timestamptz} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static double distance_set_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_set_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_set_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code distance_span_bigint} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static long distance_span_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_span_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_span_bigint(arg0, arg1); + } + + /** + * MEOS {@code distance_span_date} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static int distance_span_date(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_span_date requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_span_date(arg0, arg1); + } + + /** + * MEOS {@code distance_span_float} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static double distance_span_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_span_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_span_float(arg0, arg1); + } + + /** + * MEOS {@code distance_span_int} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static int distance_span_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_span_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_span_int(arg0, arg1); + } + + /** + * MEOS {@code distance_span_timestamptz} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static double distance_span_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_span_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_span_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code distance_spanset_bigint} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static long distance_spanset_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_spanset_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_spanset_bigint(arg0, arg1); + } + + /** + * MEOS {@code distance_spanset_date} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static int distance_spanset_date(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_spanset_date requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_spanset_date(arg0, arg1); + } + + /** + * MEOS {@code distance_spanset_float} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static double distance_spanset_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_spanset_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_spanset_float(arg0, arg1); + } + + /** + * MEOS {@code distance_spanset_int} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static int distance_spanset_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_spanset_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_spanset_int(arg0, arg1); + } + + /** + * MEOS {@code distance_spanset_timestamptz} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static double distance_spanset_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_spanset_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_spanset_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code distance_tstzset_tstzset} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static double distance_tstzset_tstzset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_tstzset_tstzset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_tstzset_tstzset(arg0, arg1); + } + + /** + * MEOS {@code distance_tstzspan_tstzspan} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static double distance_tstzspan_tstzspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_tstzspan_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_tstzspan_tstzspan(arg0, arg1); + } + + /** + * MEOS {@code distance_tstzspanset_tstzspan} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static double distance_tstzspanset_tstzspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_tstzspanset_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_tstzspanset_tstzspan(arg0, arg1); + } + + /** + * MEOS {@code distance_tstzspanset_tstzspanset} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static double distance_tstzspanset_tstzspanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_tstzspanset_tstzspanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_tstzspanset_tstzspanset(arg0, arg1); + } + + /** + * MEOS {@code left_numspan_tnumber} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean left_numspan_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "left_numspan_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.left_numspan_tnumber(arg0, arg1); + } + + /** + * MEOS {@code left_tnumber_numspan} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean left_tnumber_numspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "left_tnumber_numspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.left_tnumber_numspan(arg0, arg1); + } + + /** + * MEOS {@code left_tnumber_tbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean left_tnumber_tbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "left_tnumber_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.left_tnumber_tbox(arg0, arg1); + } + + /** + * MEOS {@code minus_bigint_set} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_bigint_set(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_bigint_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_bigint_set(arg0, arg1); + } + + /** + * MEOS {@code minus_bigint_span} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_bigint_span(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_bigint_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_bigint_span(arg0, arg1); + } + + /** + * MEOS {@code minus_bigint_spanset} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_bigint_spanset(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_bigint_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_bigint_spanset(arg0, arg1); + } + + /** + * MEOS {@code minus_date_date} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static int minus_date_date(int arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_date_date requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_date_date(arg0, arg1); + } + + /** + * MEOS {@code minus_date_int} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static int minus_date_int(int arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_date_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_date_int(arg0, arg1); + } + + /** + * MEOS {@code minus_date_set} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_date_set(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_date_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_date_set(arg0, arg1); + } + + /** + * MEOS {@code minus_date_span} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_date_span(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_date_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_date_span(arg0, arg1); + } + + /** + * MEOS {@code minus_date_spanset} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_date_spanset(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_date_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_date_spanset(arg0, arg1); + } + + /** + * MEOS {@code minus_float_set} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_float_set(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_float_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_float_set(arg0, arg1); + } + + /** + * MEOS {@code minus_float_span} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_float_span(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_float_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_float_span(arg0, arg1); + } + + /** + * MEOS {@code minus_float_spanset} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_float_spanset(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_float_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_float_spanset(arg0, arg1); + } + + /** + * MEOS {@code minus_int_set} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_int_set(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_int_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_int_set(arg0, arg1); + } + + /** + * MEOS {@code minus_int_span} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_int_span(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_int_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_int_span(arg0, arg1); + } + + /** + * MEOS {@code minus_int_spanset} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_int_spanset(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_int_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_int_spanset(arg0, arg1); + } + + /** + * MEOS {@code minus_set_bigint} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_set_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_set_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_set_bigint(arg0, arg1); + } + + /** + * MEOS {@code minus_set_date} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_set_date(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_set_date requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_set_date(arg0, arg1); + } + + /** + * MEOS {@code minus_set_float} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_set_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_set_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_set_float(arg0, arg1); + } + + /** + * MEOS {@code minus_set_int} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_set_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_set_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_set_int(arg0, arg1); + } + + /** + * MEOS {@code minus_set_set} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_set_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_set_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_set_set(arg0, arg1); + } + + /** + * MEOS {@code minus_set_text} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_set_text(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_set_text requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_set_text(arg0, arg1); + } + + /** + * MEOS {@code minus_set_timestamptz} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_set_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_set_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_set_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code minus_span_bigint} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_span_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_span_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_span_bigint(arg0, arg1); + } + + /** + * MEOS {@code minus_span_date} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_span_date(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_span_date requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_span_date(arg0, arg1); + } + + /** + * MEOS {@code minus_span_float} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_span_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_span_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_span_float(arg0, arg1); + } + + /** + * MEOS {@code minus_span_int} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_span_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_span_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_span_int(arg0, arg1); + } + + /** + * MEOS {@code minus_span_span} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_span_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_span_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_span_span(arg0, arg1); + } + + /** + * MEOS {@code minus_span_spanset} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_span_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_span_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_span_spanset(arg0, arg1); + } + + /** + * MEOS {@code minus_span_timestamptz} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_span_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_span_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_span_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code minus_spanset_bigint} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_spanset_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_spanset_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_spanset_bigint(arg0, arg1); + } + + /** + * MEOS {@code minus_spanset_date} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_spanset_date(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_spanset_date requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_spanset_date(arg0, arg1); + } + + /** + * MEOS {@code minus_spanset_float} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_spanset_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_spanset_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_spanset_float(arg0, arg1); + } + + /** + * MEOS {@code minus_spanset_int} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_spanset_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_spanset_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_spanset_int(arg0, arg1); + } + + /** + * MEOS {@code minus_spanset_span} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_spanset_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_spanset_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_spanset_span(arg0, arg1); + } + + /** + * MEOS {@code minus_spanset_spanset} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_spanset_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_spanset_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_spanset_spanset(arg0, arg1); + } + + /** + * MEOS {@code minus_spanset_timestamptz} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_spanset_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_spanset_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_spanset_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code minus_text_set} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_text_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_text_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_text_set(arg0, arg1); + } + + /** + * MEOS {@code minus_timestamptz_interval} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static java.time.OffsetDateTime minus_timestamptz_interval(java.time.OffsetDateTime arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_timestamptz_interval requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_timestamptz_interval(arg0, arg1); + } + + /** + * MEOS {@code minus_timestamptz_set} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_timestamptz_set(java.time.OffsetDateTime arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_timestamptz_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_timestamptz_set(arg0, arg1); + } + + /** + * MEOS {@code minus_timestamptz_span} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_timestamptz_span(java.time.OffsetDateTime arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_timestamptz_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_timestamptz_span(arg0, arg1); + } + + /** + * MEOS {@code minus_timestamptz_spanset} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_timestamptz_spanset(java.time.OffsetDateTime arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_timestamptz_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_timestamptz_spanset(arg0, arg1); + } + + /** + * MEOS {@code minus_timestamptz_timestamptz} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_timestamptz_timestamptz(java.time.OffsetDateTime arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_timestamptz_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_timestamptz_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code nad_tboxfloat_tboxfloat} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static double nad_tboxfloat_tboxfloat(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nad_tboxfloat_tboxfloat requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nad_tboxfloat_tboxfloat(arg0, arg1); + } + + /** + * MEOS {@code nad_tboxint_tboxint} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static int nad_tboxint_tboxint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nad_tboxint_tboxint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nad_tboxint_tboxint(arg0, arg1); + } + + /** + * MEOS {@code nad_tfloat_float} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static double nad_tfloat_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nad_tfloat_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nad_tfloat_float(arg0, arg1); + } + + /** + * MEOS {@code nad_tfloat_tbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static double nad_tfloat_tbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nad_tfloat_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nad_tfloat_tbox(arg0, arg1); + } + + /** + * MEOS {@code nad_tint_int} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static int nad_tint_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nad_tint_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nad_tint_int(arg0, arg1); + } + + /** + * MEOS {@code nad_tint_tbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static int nad_tint_tbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nad_tint_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nad_tint_tbox(arg0, arg1); + } + + /** + * MEOS {@code overafter_temporal_tstzspan} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean overafter_temporal_tstzspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overafter_temporal_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overafter_temporal_tstzspan(arg0, arg1); + } + + /** + * MEOS {@code overafter_tnumber_tbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean overafter_tnumber_tbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overafter_tnumber_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overafter_tnumber_tbox(arg0, arg1); + } + + /** + * MEOS {@code overafter_tstzspan_temporal} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean overafter_tstzspan_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overafter_tstzspan_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overafter_tstzspan_temporal(arg0, arg1); + } + + /** + * MEOS {@code overbefore_temporal_tstzspan} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean overbefore_temporal_tstzspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overbefore_temporal_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overbefore_temporal_tstzspan(arg0, arg1); + } + + /** + * MEOS {@code overbefore_tnumber_tbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean overbefore_tnumber_tbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overbefore_tnumber_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overbefore_tnumber_tbox(arg0, arg1); + } + + /** + * MEOS {@code overbefore_tstzspan_temporal} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean overbefore_tstzspan_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overbefore_tstzspan_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overbefore_tstzspan_temporal(arg0, arg1); + } + + /** + * MEOS {@code overlaps_numspan_tnumber} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean overlaps_numspan_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overlaps_numspan_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overlaps_numspan_tnumber(arg0, arg1); + } + + /** + * MEOS {@code overlaps_temporal_tstzspan} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean overlaps_temporal_tstzspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overlaps_temporal_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overlaps_temporal_tstzspan(arg0, arg1); + } + + /** + * MEOS {@code overlaps_tnumber_numspan} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean overlaps_tnumber_numspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overlaps_tnumber_numspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overlaps_tnumber_numspan(arg0, arg1); + } + + /** + * MEOS {@code overlaps_tnumber_tbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean overlaps_tnumber_tbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overlaps_tnumber_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overlaps_tnumber_tbox(arg0, arg1); + } + + /** + * MEOS {@code overlaps_tstzspan_temporal} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean overlaps_tstzspan_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overlaps_tstzspan_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overlaps_tstzspan_temporal(arg0, arg1); + } + + /** + * MEOS {@code overleft_numspan_tnumber} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean overleft_numspan_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overleft_numspan_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overleft_numspan_tnumber(arg0, arg1); + } + + /** + * MEOS {@code overleft_tnumber_numspan} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean overleft_tnumber_numspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overleft_tnumber_numspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overleft_tnumber_numspan(arg0, arg1); + } + + /** + * MEOS {@code overleft_tnumber_tbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean overleft_tnumber_tbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overleft_tnumber_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overleft_tnumber_tbox(arg0, arg1); + } + + /** + * MEOS {@code overright_numspan_tnumber} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean overright_numspan_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overright_numspan_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overright_numspan_tnumber(arg0, arg1); + } + + /** + * MEOS {@code overright_tnumber_numspan} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean overright_tnumber_numspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overright_tnumber_numspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overright_tnumber_numspan(arg0, arg1); + } + + /** + * MEOS {@code overright_tnumber_tbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean overright_tnumber_tbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overright_tnumber_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overright_tnumber_tbox(arg0, arg1); + } + + /** + * MEOS {@code right_numspan_tnumber} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean right_numspan_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "right_numspan_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.right_numspan_tnumber(arg0, arg1); + } + + /** + * MEOS {@code right_tnumber_numspan} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean right_tnumber_numspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "right_tnumber_numspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.right_tnumber_numspan(arg0, arg1); + } + + /** + * MEOS {@code right_tnumber_tbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean right_tnumber_tbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "right_tnumber_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.right_tnumber_tbox(arg0, arg1); + } + + /** + * MEOS {@code tdistance_tfloat_float} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static jnr.ffi.Pointer tdistance_tfloat_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tdistance_tfloat_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tdistance_tfloat_float(arg0, arg1); + } + + /** + * MEOS {@code tdistance_tint_int} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static jnr.ffi.Pointer tdistance_tint_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tdistance_tint_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tdistance_tint_int(arg0, arg1); + } + + /** + * MEOS {@code always_eq_bool_tbool} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_eq_bool_tbool(boolean arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_eq_bool_tbool requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_eq_bool_tbool(arg0, arg1); + } + + /** + * MEOS {@code always_eq_float_tfloat} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_eq_float_tfloat(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_eq_float_tfloat requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_eq_float_tfloat(arg0, arg1); + } + + /** + * MEOS {@code always_eq_int_tint} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_eq_int_tint(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_eq_int_tint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_eq_int_tint(arg0, arg1); + } + + /** + * MEOS {@code always_eq_tbool_bool} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_eq_tbool_bool(jnr.ffi.Pointer arg0, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_eq_tbool_bool requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_eq_tbool_bool(arg0, arg1); + } + + /** + * MEOS {@code always_eq_text_ttext} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_eq_text_ttext(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_eq_text_ttext requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_eq_text_ttext(arg0, arg1); + } + + /** + * MEOS {@code always_eq_tfloat_float} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_eq_tfloat_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_eq_tfloat_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_eq_tfloat_float(arg0, arg1); + } + + /** + * MEOS {@code always_eq_tint_int} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_eq_tint_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_eq_tint_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_eq_tint_int(arg0, arg1); + } + + /** + * MEOS {@code always_eq_ttext_text} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_eq_ttext_text(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_eq_ttext_text requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_eq_ttext_text(arg0, arg1); + } + + /** + * MEOS {@code always_ge_float_tfloat} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_ge_float_tfloat(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ge_float_tfloat requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ge_float_tfloat(arg0, arg1); + } + + /** + * MEOS {@code always_ge_int_tint} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_ge_int_tint(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ge_int_tint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ge_int_tint(arg0, arg1); + } + + /** + * MEOS {@code always_ge_text_ttext} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_ge_text_ttext(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ge_text_ttext requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ge_text_ttext(arg0, arg1); + } + + /** + * MEOS {@code always_ge_tfloat_float} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_ge_tfloat_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ge_tfloat_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ge_tfloat_float(arg0, arg1); + } + + /** + * MEOS {@code always_ge_tint_int} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_ge_tint_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ge_tint_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ge_tint_int(arg0, arg1); + } + + /** + * MEOS {@code always_ge_ttext_text} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_ge_ttext_text(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ge_ttext_text requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ge_ttext_text(arg0, arg1); + } + + /** + * MEOS {@code always_gt_float_tfloat} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_gt_float_tfloat(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_gt_float_tfloat requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_gt_float_tfloat(arg0, arg1); + } + + /** + * MEOS {@code always_gt_int_tint} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_gt_int_tint(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_gt_int_tint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_gt_int_tint(arg0, arg1); + } + + /** + * MEOS {@code always_gt_text_ttext} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_gt_text_ttext(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_gt_text_ttext requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_gt_text_ttext(arg0, arg1); + } + + /** + * MEOS {@code always_gt_tfloat_float} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_gt_tfloat_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_gt_tfloat_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_gt_tfloat_float(arg0, arg1); + } + + /** + * MEOS {@code always_gt_tint_int} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_gt_tint_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_gt_tint_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_gt_tint_int(arg0, arg1); + } + + /** + * MEOS {@code always_gt_ttext_text} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_gt_ttext_text(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_gt_ttext_text requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_gt_ttext_text(arg0, arg1); + } + + /** + * MEOS {@code always_le_float_tfloat} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_le_float_tfloat(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_le_float_tfloat requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_le_float_tfloat(arg0, arg1); + } + + /** + * MEOS {@code always_le_int_tint} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_le_int_tint(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_le_int_tint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_le_int_tint(arg0, arg1); + } + + /** + * MEOS {@code always_le_text_ttext} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_le_text_ttext(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_le_text_ttext requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_le_text_ttext(arg0, arg1); + } + + /** + * MEOS {@code always_le_tfloat_float} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_le_tfloat_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_le_tfloat_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_le_tfloat_float(arg0, arg1); + } + + /** + * MEOS {@code always_le_tint_int} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_le_tint_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_le_tint_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_le_tint_int(arg0, arg1); + } + + /** + * MEOS {@code always_le_ttext_text} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_le_ttext_text(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_le_ttext_text requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_le_ttext_text(arg0, arg1); + } + + /** + * MEOS {@code always_lt_float_tfloat} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_lt_float_tfloat(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_lt_float_tfloat requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_lt_float_tfloat(arg0, arg1); + } + + /** + * MEOS {@code always_lt_int_tint} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_lt_int_tint(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_lt_int_tint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_lt_int_tint(arg0, arg1); + } + + /** + * MEOS {@code always_lt_text_ttext} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_lt_text_ttext(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_lt_text_ttext requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_lt_text_ttext(arg0, arg1); + } + + /** + * MEOS {@code always_lt_tfloat_float} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_lt_tfloat_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_lt_tfloat_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_lt_tfloat_float(arg0, arg1); + } + + /** + * MEOS {@code always_lt_tint_int} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_lt_tint_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_lt_tint_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_lt_tint_int(arg0, arg1); + } + + /** + * MEOS {@code always_lt_ttext_text} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_lt_ttext_text(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_lt_ttext_text requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_lt_ttext_text(arg0, arg1); + } + + /** + * MEOS {@code always_ne_bool_tbool} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_ne_bool_tbool(boolean arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ne_bool_tbool requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ne_bool_tbool(arg0, arg1); + } + + /** + * MEOS {@code always_ne_float_tfloat} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_ne_float_tfloat(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ne_float_tfloat requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ne_float_tfloat(arg0, arg1); + } + + /** + * MEOS {@code always_ne_int_tint} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_ne_int_tint(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ne_int_tint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ne_int_tint(arg0, arg1); + } + + /** + * MEOS {@code always_ne_tbool_bool} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_ne_tbool_bool(jnr.ffi.Pointer arg0, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ne_tbool_bool requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ne_tbool_bool(arg0, arg1); + } + + /** + * MEOS {@code always_ne_text_ttext} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_ne_text_ttext(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ne_text_ttext requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ne_text_ttext(arg0, arg1); + } + + /** + * MEOS {@code always_ne_tfloat_float} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_ne_tfloat_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ne_tfloat_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ne_tfloat_float(arg0, arg1); + } + + /** + * MEOS {@code always_ne_tint_int} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_ne_tint_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ne_tint_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ne_tint_int(arg0, arg1); + } + + /** + * MEOS {@code always_ne_ttext_text} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_ne_ttext_text(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ne_ttext_text requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ne_ttext_text(arg0, arg1); + } + + /** + * MEOS {@code ever_eq_bool_tbool} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_eq_bool_tbool(boolean arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_eq_bool_tbool requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_eq_bool_tbool(arg0, arg1); + } + + /** + * MEOS {@code ever_eq_float_tfloat} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_eq_float_tfloat(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_eq_float_tfloat requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_eq_float_tfloat(arg0, arg1); + } + + /** + * MEOS {@code ever_eq_int_tint} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_eq_int_tint(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_eq_int_tint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_eq_int_tint(arg0, arg1); + } + + /** + * MEOS {@code ever_eq_tbool_bool} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_eq_tbool_bool(jnr.ffi.Pointer arg0, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_eq_tbool_bool requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_eq_tbool_bool(arg0, arg1); + } + + /** + * MEOS {@code ever_eq_text_ttext} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_eq_text_ttext(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_eq_text_ttext requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_eq_text_ttext(arg0, arg1); + } + + /** + * MEOS {@code ever_eq_tfloat_float} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_eq_tfloat_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_eq_tfloat_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_eq_tfloat_float(arg0, arg1); + } + + /** + * MEOS {@code ever_eq_tint_int} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_eq_tint_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_eq_tint_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_eq_tint_int(arg0, arg1); + } + + /** + * MEOS {@code ever_eq_ttext_text} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_eq_ttext_text(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_eq_ttext_text requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_eq_ttext_text(arg0, arg1); + } + + /** + * MEOS {@code ever_ge_float_tfloat} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_ge_float_tfloat(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ge_float_tfloat requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ge_float_tfloat(arg0, arg1); + } + + /** + * MEOS {@code ever_ge_int_tint} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_ge_int_tint(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ge_int_tint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ge_int_tint(arg0, arg1); + } + + /** + * MEOS {@code ever_ge_text_ttext} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_ge_text_ttext(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ge_text_ttext requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ge_text_ttext(arg0, arg1); + } + + /** + * MEOS {@code ever_ge_tfloat_float} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_ge_tfloat_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ge_tfloat_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ge_tfloat_float(arg0, arg1); + } + + /** + * MEOS {@code ever_ge_tint_int} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_ge_tint_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ge_tint_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ge_tint_int(arg0, arg1); + } + + /** + * MEOS {@code ever_ge_ttext_text} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_ge_ttext_text(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ge_ttext_text requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ge_ttext_text(arg0, arg1); + } + + /** + * MEOS {@code ever_gt_float_tfloat} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_gt_float_tfloat(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_gt_float_tfloat requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_gt_float_tfloat(arg0, arg1); + } + + /** + * MEOS {@code ever_gt_int_tint} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_gt_int_tint(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_gt_int_tint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_gt_int_tint(arg0, arg1); + } + + /** + * MEOS {@code ever_gt_text_ttext} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_gt_text_ttext(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_gt_text_ttext requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_gt_text_ttext(arg0, arg1); + } + + /** + * MEOS {@code ever_gt_tfloat_float} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_gt_tfloat_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_gt_tfloat_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_gt_tfloat_float(arg0, arg1); + } + + /** + * MEOS {@code ever_gt_tint_int} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_gt_tint_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_gt_tint_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_gt_tint_int(arg0, arg1); + } + + /** + * MEOS {@code ever_gt_ttext_text} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_gt_ttext_text(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_gt_ttext_text requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_gt_ttext_text(arg0, arg1); + } + + /** + * MEOS {@code ever_le_float_tfloat} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_le_float_tfloat(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_le_float_tfloat requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_le_float_tfloat(arg0, arg1); + } + + /** + * MEOS {@code ever_le_int_tint} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_le_int_tint(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_le_int_tint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_le_int_tint(arg0, arg1); + } + + /** + * MEOS {@code ever_le_text_ttext} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_le_text_ttext(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_le_text_ttext requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_le_text_ttext(arg0, arg1); + } + + /** + * MEOS {@code ever_le_tfloat_float} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_le_tfloat_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_le_tfloat_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_le_tfloat_float(arg0, arg1); + } + + /** + * MEOS {@code ever_le_tint_int} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_le_tint_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_le_tint_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_le_tint_int(arg0, arg1); + } + + /** + * MEOS {@code ever_le_ttext_text} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_le_ttext_text(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_le_ttext_text requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_le_ttext_text(arg0, arg1); + } + + /** + * MEOS {@code ever_lt_float_tfloat} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_lt_float_tfloat(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_lt_float_tfloat requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_lt_float_tfloat(arg0, arg1); + } + + /** + * MEOS {@code ever_lt_int_tint} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_lt_int_tint(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_lt_int_tint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_lt_int_tint(arg0, arg1); + } + + /** + * MEOS {@code ever_lt_text_ttext} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_lt_text_ttext(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_lt_text_ttext requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_lt_text_ttext(arg0, arg1); + } + + /** + * MEOS {@code ever_lt_tfloat_float} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_lt_tfloat_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_lt_tfloat_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_lt_tfloat_float(arg0, arg1); + } + + /** + * MEOS {@code ever_lt_tint_int} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_lt_tint_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_lt_tint_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_lt_tint_int(arg0, arg1); + } + + /** + * MEOS {@code ever_lt_ttext_text} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_lt_ttext_text(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_lt_ttext_text requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_lt_ttext_text(arg0, arg1); + } + + /** + * MEOS {@code ever_ne_bool_tbool} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_ne_bool_tbool(boolean arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ne_bool_tbool requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ne_bool_tbool(arg0, arg1); + } + + /** + * MEOS {@code ever_ne_float_tfloat} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_ne_float_tfloat(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ne_float_tfloat requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ne_float_tfloat(arg0, arg1); + } + + /** + * MEOS {@code ever_ne_int_tint} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_ne_int_tint(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ne_int_tint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ne_int_tint(arg0, arg1); + } + + /** + * MEOS {@code ever_ne_tbool_bool} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_ne_tbool_bool(jnr.ffi.Pointer arg0, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ne_tbool_bool requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ne_tbool_bool(arg0, arg1); + } + + /** + * MEOS {@code ever_ne_text_ttext} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_ne_text_ttext(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ne_text_ttext requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ne_text_ttext(arg0, arg1); + } + + /** + * MEOS {@code ever_ne_tfloat_float} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_ne_tfloat_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ne_tfloat_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ne_tfloat_float(arg0, arg1); + } + + /** + * MEOS {@code ever_ne_tint_int} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_ne_tint_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ne_tint_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ne_tint_int(arg0, arg1); + } + + /** + * MEOS {@code ever_ne_ttext_text} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_ne_ttext_text(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ne_ttext_text requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ne_ttext_text(arg0, arg1); + } + + /** + * MEOS {@code adjacent_temporal_temporal} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 temporals

+ */ + public static boolean adjacent_temporal_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "adjacent_temporal_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.adjacent_temporal_temporal(arg0, arg1); + } + + /** + * MEOS {@code adjacent_tnumber_tnumber} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 temporals

+ */ + public static boolean adjacent_tnumber_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "adjacent_tnumber_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.adjacent_tnumber_tnumber(arg0, arg1); + } + + /** + * MEOS {@code after_temporal_temporal} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 temporals

+ */ + public static boolean after_temporal_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "after_temporal_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.after_temporal_temporal(arg0, arg1); + } + + /** + * MEOS {@code after_tnumber_tnumber} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 temporals

+ */ + public static boolean after_tnumber_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "after_tnumber_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.after_tnumber_tnumber(arg0, arg1); + } + + /** + * MEOS {@code always_eq_temporal_temporal} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always over 2 temporals

+ */ + public static int always_eq_temporal_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_eq_temporal_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_eq_temporal_temporal(arg0, arg1); + } + + /** + * MEOS {@code always_ge_temporal_temporal} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always over 2 temporals

+ */ + public static int always_ge_temporal_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ge_temporal_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ge_temporal_temporal(arg0, arg1); + } + + /** + * MEOS {@code always_gt_temporal_temporal} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always over 2 temporals

+ */ + public static int always_gt_temporal_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_gt_temporal_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_gt_temporal_temporal(arg0, arg1); + } + + /** + * MEOS {@code always_le_temporal_temporal} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always over 2 temporals

+ */ + public static int always_le_temporal_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_le_temporal_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_le_temporal_temporal(arg0, arg1); + } + + /** + * MEOS {@code always_lt_temporal_temporal} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always over 2 temporals

+ */ + public static int always_lt_temporal_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_lt_temporal_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_lt_temporal_temporal(arg0, arg1); + } + + /** + * MEOS {@code always_ne_temporal_temporal} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always over 2 temporals

+ */ + public static int always_ne_temporal_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ne_temporal_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ne_temporal_temporal(arg0, arg1); + } + + /** + * MEOS {@code before_temporal_temporal} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 temporals

+ */ + public static boolean before_temporal_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "before_temporal_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.before_temporal_temporal(arg0, arg1); + } + + /** + * MEOS {@code before_tnumber_tnumber} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 temporals

+ */ + public static boolean before_tnumber_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "before_tnumber_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.before_tnumber_tnumber(arg0, arg1); + } + + /** + * MEOS {@code contained_temporal_temporal} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 temporals

+ */ + public static boolean contained_temporal_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contained_temporal_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contained_temporal_temporal(arg0, arg1); + } + + /** + * MEOS {@code contained_tnumber_tnumber} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 temporals

+ */ + public static boolean contained_tnumber_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contained_tnumber_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contained_tnumber_tnumber(arg0, arg1); + } + + /** + * MEOS {@code contains_temporal_temporal} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 temporals

+ */ + public static boolean contains_temporal_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_temporal_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_temporal_temporal(arg0, arg1); + } + + /** + * MEOS {@code contains_tnumber_tnumber} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 temporals

+ */ + public static boolean contains_tnumber_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_tnumber_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_tnumber_tnumber(arg0, arg1); + } + + /** + * MEOS {@code ever_eq_temporal_temporal} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always over 2 temporals

+ */ + public static int ever_eq_temporal_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_eq_temporal_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_eq_temporal_temporal(arg0, arg1); + } + + /** + * MEOS {@code ever_ge_temporal_temporal} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always over 2 temporals

+ */ + public static int ever_ge_temporal_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ge_temporal_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ge_temporal_temporal(arg0, arg1); + } + + /** + * MEOS {@code ever_gt_temporal_temporal} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always over 2 temporals

+ */ + public static int ever_gt_temporal_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_gt_temporal_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_gt_temporal_temporal(arg0, arg1); + } + + /** + * MEOS {@code ever_le_temporal_temporal} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always over 2 temporals

+ */ + public static int ever_le_temporal_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_le_temporal_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_le_temporal_temporal(arg0, arg1); + } + + /** + * MEOS {@code ever_lt_temporal_temporal} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always over 2 temporals

+ */ + public static int ever_lt_temporal_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_lt_temporal_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_lt_temporal_temporal(arg0, arg1); + } + + /** + * MEOS {@code ever_ne_temporal_temporal} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always over 2 temporals

+ */ + public static int ever_ne_temporal_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ne_temporal_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ne_temporal_temporal(arg0, arg1); + } + + /** + * MEOS {@code left_tnumber_tnumber} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 temporals

+ */ + public static boolean left_tnumber_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "left_tnumber_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.left_tnumber_tnumber(arg0, arg1); + } + + /** + * MEOS {@code nad_tfloat_tfloat} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: distance on 2 temporals

+ */ + public static double nad_tfloat_tfloat(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nad_tfloat_tfloat requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nad_tfloat_tfloat(arg0, arg1); + } + + /** + * MEOS {@code nad_tint_tint} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: distance on 2 temporals

+ */ + public static int nad_tint_tint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nad_tint_tint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nad_tint_tint(arg0, arg1); + } + + /** + * MEOS {@code overafter_temporal_temporal} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 temporals

+ */ + public static boolean overafter_temporal_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overafter_temporal_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overafter_temporal_temporal(arg0, arg1); + } + + /** + * MEOS {@code overafter_tnumber_tnumber} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 temporals

+ */ + public static boolean overafter_tnumber_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overafter_tnumber_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overafter_tnumber_tnumber(arg0, arg1); + } + + /** + * MEOS {@code overbefore_temporal_temporal} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 temporals

+ */ + public static boolean overbefore_temporal_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overbefore_temporal_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overbefore_temporal_temporal(arg0, arg1); + } + + /** + * MEOS {@code overbefore_tnumber_tnumber} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 temporals

+ */ + public static boolean overbefore_tnumber_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overbefore_tnumber_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overbefore_tnumber_tnumber(arg0, arg1); + } + + /** + * MEOS {@code overlaps_temporal_temporal} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 temporals

+ */ + public static boolean overlaps_temporal_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overlaps_temporal_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overlaps_temporal_temporal(arg0, arg1); + } + + /** + * MEOS {@code overlaps_tnumber_tnumber} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 temporals

+ */ + public static boolean overlaps_tnumber_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overlaps_tnumber_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overlaps_tnumber_tnumber(arg0, arg1); + } + + /** + * MEOS {@code overleft_tnumber_tnumber} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 temporals

+ */ + public static boolean overleft_tnumber_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overleft_tnumber_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overleft_tnumber_tnumber(arg0, arg1); + } + + /** + * MEOS {@code overright_tnumber_tnumber} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 temporals

+ */ + public static boolean overright_tnumber_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overright_tnumber_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overright_tnumber_tnumber(arg0, arg1); + } + + /** + * MEOS {@code right_tnumber_tnumber} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 temporals

+ */ + public static boolean right_tnumber_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "right_tnumber_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.right_tnumber_tnumber(arg0, arg1); + } + + /** + * MEOS {@code same_temporal_temporal} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: same predicate on 2 temporals

+ */ + public static boolean same_temporal_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "same_temporal_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.same_temporal_temporal(arg0, arg1); + } + + /** + * MEOS {@code same_tnumber_tnumber} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: same predicate on 2 temporals

+ */ + public static boolean same_tnumber_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "same_tnumber_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.same_tnumber_tnumber(arg0, arg1); + } + + /** + * MEOS {@code tdistance_tnumber_tnumber} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: distance on 2 temporals

+ */ + public static jnr.ffi.Pointer tdistance_tnumber_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tdistance_tnumber_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tdistance_tnumber_tnumber(arg0, arg1); + } + + /** + * MEOS {@code bool_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static boolean bool_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bool_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bool_in(arg0); + } + + /** + * MEOS {@code bool_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static java.lang.String bool_out(boolean arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bool_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bool_out(arg0); + } + + /** + * MEOS {@code cstring2text} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: string/CString conversion (low-level)

+ */ + public static jnr.ffi.Pointer cstring2text(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cstring2text requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cstring2text(arg0); + } + + /** + * MEOS {@code float8_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static java.lang.String float8_out(double arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "float8_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.float8_out(arg0, arg1); + } + + /** + * MEOS {@code meos_array_add} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

+ */ + public static void meos_array_add(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "meos_array_add requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + GeneratedFunctions.meos_array_add(arg0, arg1); + } + + /** + * MEOS {@code meos_array_count} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

+ */ + public static int meos_array_count(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "meos_array_count requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.meos_array_count(arg0); + } + + /** + * MEOS {@code meos_array_create} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

+ */ + public static jnr.ffi.Pointer meos_array_create(int arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "meos_array_create requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.meos_array_create(arg0); + } + + /** + * MEOS {@code meos_array_destroy} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

+ */ + public static void meos_array_destroy(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "meos_array_destroy requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + GeneratedFunctions.meos_array_destroy(arg0); + } + + /** + * MEOS {@code meos_array_destroy_free} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

+ */ + public static void meos_array_destroy_free(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "meos_array_destroy_free requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + GeneratedFunctions.meos_array_destroy_free(arg0); + } + + /** + * MEOS {@code meos_array_get} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

+ */ + public static jnr.ffi.Pointer meos_array_get(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "meos_array_get requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.meos_array_get(arg0, arg1); + } + + /** + * MEOS {@code meos_array_reset} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

+ */ + public static void meos_array_reset(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "meos_array_reset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + GeneratedFunctions.meos_array_reset(arg0); + } + + /** + * MEOS {@code meos_array_reset_free} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

+ */ + public static void meos_array_reset_free(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "meos_array_reset_free requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + GeneratedFunctions.meos_array_reset_free(arg0); + } + + /** + * MEOS {@code meos_errno} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

+ */ + public static int meos_errno() { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "meos_errno requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.meos_errno(); + } + + /** + * MEOS {@code meos_errno_reset} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

+ */ + public static int meos_errno_reset() { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "meos_errno_reset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.meos_errno_reset(); + } + + /** + * MEOS {@code meos_errno_restore} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

+ */ + public static int meos_errno_restore(int arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "meos_errno_restore requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.meos_errno_restore(arg0); + } + + /** + * MEOS {@code meos_errno_set} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

+ */ + public static int meos_errno_set(int arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "meos_errno_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.meos_errno_set(arg0); + } + + /** + * MEOS {@code meos_error} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

+ */ + public static void meos_error(int arg0, int arg1, java.lang.String arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "meos_error requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + GeneratedFunctions.meos_error(arg0, arg1, arg2); + } + + /** + * MEOS {@code meos_finalize} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

+ */ + public static void meos_finalize() { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "meos_finalize requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + GeneratedFunctions.meos_finalize(); + } + + /** + * MEOS {@code meos_finalize_projsrs} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

+ */ + public static void meos_finalize_projsrs() { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "meos_finalize_projsrs requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + GeneratedFunctions.meos_finalize_projsrs(); + } + + /** + * MEOS {@code meos_finalize_timezone} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

+ */ + public static void meos_finalize_timezone() { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "meos_finalize_timezone requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + GeneratedFunctions.meos_finalize_timezone(); + } + + /** + * MEOS {@code meos_finalize_ways} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

+ */ + public static void meos_finalize_ways() { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "meos_finalize_ways requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + GeneratedFunctions.meos_finalize_ways(); + } + + /** + * MEOS {@code meos_get_datestyle} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

+ */ + public static java.lang.String meos_get_datestyle() { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "meos_get_datestyle requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.meos_get_datestyle(); + } + + /** + * MEOS {@code meos_get_intervalstyle} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

+ */ + public static java.lang.String meos_get_intervalstyle() { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "meos_get_intervalstyle requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.meos_get_intervalstyle(); + } + + /** + * MEOS {@code meos_initialize} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

+ */ + public static void meos_initialize() { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "meos_initialize requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + GeneratedFunctions.meos_initialize(); + } + + /** + * MEOS {@code meos_initialize_error_handler} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

+ */ + public static void meos_initialize_error_handler(functions.error_handler_fn arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "meos_initialize_error_handler requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + GeneratedFunctions.meos_initialize_error_handler(arg0); + } + + /** + * MEOS {@code meos_initialize_timezone} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

+ */ + public static void meos_initialize_timezone(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "meos_initialize_timezone requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + GeneratedFunctions.meos_initialize_timezone(arg0); + } + + /** + * MEOS {@code meos_set_datestyle} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

+ */ + public static boolean meos_set_datestyle(java.lang.String arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "meos_set_datestyle requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.meos_set_datestyle(arg0, arg1); + } + + /** + * MEOS {@code meos_set_intervalstyle} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

+ */ + public static boolean meos_set_intervalstyle(java.lang.String arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "meos_set_intervalstyle requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.meos_set_intervalstyle(arg0, arg1); + } + + /** + * MEOS {@code meos_set_spatial_ref_sys_csv} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

+ */ + public static void meos_set_spatial_ref_sys_csv(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "meos_set_spatial_ref_sys_csv requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + GeneratedFunctions.meos_set_spatial_ref_sys_csv(arg0); + } + + /** + * MEOS {@code pg_date_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static int pg_date_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pg_date_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pg_date_in(arg0); + } + + /** + * MEOS {@code pg_date_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static java.lang.String pg_date_out(int arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pg_date_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pg_date_out(arg0); + } + + /** + * MEOS {@code pg_interval_cmp} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: string/CString conversion (low-level)

+ */ + public static int pg_interval_cmp(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pg_interval_cmp requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pg_interval_cmp(arg0, arg1); + } + + /** + * MEOS {@code pg_interval_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static jnr.ffi.Pointer pg_interval_in(java.lang.String arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pg_interval_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pg_interval_in(arg0, arg1); + } + + /** + * MEOS {@code pg_interval_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static java.lang.String pg_interval_out(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pg_interval_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pg_interval_out(arg0); + } + + /** + * MEOS {@code pg_timestamp_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static java.time.LocalDateTime pg_timestamp_in(java.lang.String arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pg_timestamp_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pg_timestamp_in(arg0, arg1); + } + + /** + * MEOS {@code pg_timestamp_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static java.lang.String pg_timestamp_out(java.time.LocalDateTime arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pg_timestamp_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pg_timestamp_out(arg0); + } + + /** + * MEOS {@code pg_timestamptz_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static java.time.OffsetDateTime pg_timestamptz_in(java.lang.String arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pg_timestamptz_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pg_timestamptz_in(arg0, arg1); + } + + /** + * MEOS {@code pg_timestamptz_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static java.lang.String pg_timestamptz_out(java.time.OffsetDateTime arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pg_timestamptz_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pg_timestamptz_out(arg0); + } + + /** + * MEOS {@code rtree_create_bigintspan} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

+ */ + public static jnr.ffi.Pointer rtree_create_bigintspan() { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "rtree_create_bigintspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.rtree_create_bigintspan(); + } + + /** + * MEOS {@code rtree_create_datespan} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

+ */ + public static jnr.ffi.Pointer rtree_create_datespan() { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "rtree_create_datespan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.rtree_create_datespan(); + } + + /** + * MEOS {@code rtree_create_floatspan} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

+ */ + public static jnr.ffi.Pointer rtree_create_floatspan() { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "rtree_create_floatspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.rtree_create_floatspan(); + } + + /** + * MEOS {@code rtree_create_intspan} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

+ */ + public static jnr.ffi.Pointer rtree_create_intspan() { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "rtree_create_intspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.rtree_create_intspan(); + } + + /** + * MEOS {@code rtree_create_stbox} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

+ */ + public static jnr.ffi.Pointer rtree_create_stbox() { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "rtree_create_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.rtree_create_stbox(); + } + + /** + * MEOS {@code rtree_create_tbox} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

+ */ + public static jnr.ffi.Pointer rtree_create_tbox() { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "rtree_create_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.rtree_create_tbox(); + } + + /** + * MEOS {@code rtree_create_tstzspan} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

+ */ + public static jnr.ffi.Pointer rtree_create_tstzspan() { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "rtree_create_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.rtree_create_tstzspan(); + } + + /** + * MEOS {@code rtree_free} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

+ */ + public static void rtree_free(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "rtree_free requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + GeneratedFunctions.rtree_free(arg0); + } + + /** + * MEOS {@code rtree_insert} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

+ */ + public static void rtree_insert(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, int arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "rtree_insert requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + GeneratedFunctions.rtree_insert(arg0, arg1, arg2); + } + + /** + * MEOS {@code rtree_insert_temporal} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

+ */ + public static void rtree_insert_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, int arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "rtree_insert_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + GeneratedFunctions.rtree_insert_temporal(arg0, arg1, arg2); + } + + /** + * MEOS {@code rtree_search} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

+ */ + public static int rtree_search(jnr.ffi.Pointer arg0, int arg1, jnr.ffi.Pointer arg2, jnr.ffi.Pointer arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "rtree_search requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.rtree_search(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code rtree_search_temporal} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

+ */ + public static int rtree_search_temporal(jnr.ffi.Pointer arg0, int arg1, jnr.ffi.Pointer arg2, jnr.ffi.Pointer arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "rtree_search_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.rtree_search_temporal(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code text2cstring} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: string/CString conversion (low-level)

+ */ + public static java.lang.String text2cstring(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "text2cstring requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.text2cstring(arg0); + } + + /** + * MEOS {@code text_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static jnr.ffi.Pointer text_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "text_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.text_in(arg0); + } + + /** + * MEOS {@code text_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static java.lang.String text_out(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "text_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.text_out(arg0); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFreeGeo.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFreeGeo.java new file mode 100644 index 0000000..45d9ff6 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFreeGeo.java @@ -0,0 +1,3426 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_free.py — do not edit by hand. + * Source header: meos_geo.h + * Methods emitted: 262 (stateless=134 · bounded-state=57 · cross-stream=46 · io-meta=17 · windowed=8) + * Scope: MEOS public functions NOT classified into any object-model class + * (free functions, not methods on a class). + * Source: JMEOS PR #19 (functions.GeneratedFunctions) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsFreeGeo { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsFreeGeo() { /* utility */ } + + /** + * MEOS {@code above_stbox_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean above_stbox_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "above_stbox_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.above_stbox_stbox(arg0, arg1); + } + + /** + * MEOS {@code above_stbox_tspatial} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean above_stbox_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "above_stbox_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.above_stbox_tspatial(arg0, arg1); + } + + /** + * MEOS {@code adjacent_stbox_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean adjacent_stbox_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "adjacent_stbox_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.adjacent_stbox_stbox(arg0, arg1); + } + + /** + * MEOS {@code adjacent_stbox_tspatial} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean adjacent_stbox_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "adjacent_stbox_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.adjacent_stbox_tspatial(arg0, arg1); + } + + /** + * MEOS {@code after_stbox_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean after_stbox_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "after_stbox_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.after_stbox_stbox(arg0, arg1); + } + + /** + * MEOS {@code after_stbox_tspatial} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean after_stbox_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "after_stbox_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.after_stbox_tspatial(arg0, arg1); + } + + /** + * MEOS {@code back_stbox_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean back_stbox_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "back_stbox_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.back_stbox_stbox(arg0, arg1); + } + + /** + * MEOS {@code back_stbox_tspatial} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean back_stbox_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "back_stbox_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.back_stbox_tspatial(arg0, arg1); + } + + /** + * MEOS {@code bearing_point_point} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar in/out (default-stateless catch-all)

+ */ + public static jnr.ffi.Pointer bearing_point_point(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bearing_point_point requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bearing_point_point(arg0, arg1); + } + + /** + * MEOS {@code before_stbox_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean before_stbox_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "before_stbox_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.before_stbox_stbox(arg0, arg1); + } + + /** + * MEOS {@code before_stbox_tspatial} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean before_stbox_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "before_stbox_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.before_stbox_tspatial(arg0, arg1); + } + + /** + * MEOS {@code below_stbox_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean below_stbox_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "below_stbox_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.below_stbox_stbox(arg0, arg1); + } + + /** + * MEOS {@code below_stbox_tspatial} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean below_stbox_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "below_stbox_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.below_stbox_tspatial(arg0, arg1); + } + + /** + * MEOS {@code box3d_make} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: make/from_base of instant/scalar

+ */ + public static jnr.ffi.Pointer box3d_make(double arg0, double arg1, double arg2, double arg3, double arg4, double arg5, int arg6) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "box3d_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.box3d_make(arg0, arg1, arg2, arg3, arg4, arg5, arg6); + } + + /** + * MEOS {@code box3d_to_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer box3d_to_stbox(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "box3d_to_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.box3d_to_stbox(arg0); + } + + /** + * MEOS {@code contained_geo_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contained_geo_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contained_geo_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contained_geo_set(arg0, arg1); + } + + /** + * MEOS {@code contained_stbox_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contained_stbox_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contained_stbox_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contained_stbox_stbox(arg0, arg1); + } + + /** + * MEOS {@code contained_stbox_tspatial} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contained_stbox_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contained_stbox_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contained_stbox_tspatial(arg0, arg1); + } + + /** + * MEOS {@code contains_set_geo} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contains_set_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_set_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_set_geo(arg0, arg1); + } + + /** + * MEOS {@code contains_stbox_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contains_stbox_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_stbox_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_stbox_stbox(arg0, arg1); + } + + /** + * MEOS {@code contains_stbox_tspatial} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contains_stbox_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_stbox_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_stbox_tspatial(arg0, arg1); + } + + /** + * MEOS {@code front_stbox_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean front_stbox_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "front_stbox_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.front_stbox_stbox(arg0, arg1); + } + + /** + * MEOS {@code front_stbox_tspatial} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean front_stbox_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "front_stbox_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.front_stbox_tspatial(arg0, arg1); + } + + /** + * MEOS {@code gbox_make} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: make/from_base of instant/scalar

+ */ + public static jnr.ffi.Pointer gbox_make(boolean arg0, double arg1, double arg2, double arg3, double arg4, double arg5, double arg6) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "gbox_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.gbox_make(arg0, arg1, arg2, arg3, arg4, arg5, arg6); + } + + /** + * MEOS {@code gbox_to_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer gbox_to_stbox(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "gbox_to_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.gbox_to_stbox(arg0); + } + + /** + * MEOS {@code geo_cluster_dbscan} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer geo_cluster_dbscan(jnr.ffi.Pointer arg0, int arg1, double arg2, int arg3, jnr.ffi.Pointer arg4) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_cluster_dbscan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_cluster_dbscan(arg0, arg1, arg2, arg3, arg4); + } + + /** + * MEOS {@code geo_cluster_intersecting} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer geo_cluster_intersecting(jnr.ffi.Pointer arg0, int arg1, jnr.ffi.Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_cluster_intersecting requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_cluster_intersecting(arg0, arg1, arg2); + } + + /** + * MEOS {@code geo_cluster_kmeans} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer geo_cluster_kmeans(jnr.ffi.Pointer arg0, int arg1, int arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_cluster_kmeans requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_cluster_kmeans(arg0, arg1, arg2); + } + + /** + * MEOS {@code geo_cluster_within} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer geo_cluster_within(jnr.ffi.Pointer arg0, int arg1, double arg2, jnr.ffi.Pointer arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_cluster_within requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_cluster_within(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code geo_collect_garray} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer geo_collect_garray(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_collect_garray requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_collect_garray(arg0, arg1); + } + + /** + * MEOS {@code geo_copy} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer geo_copy(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_copy requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_copy(arg0); + } + + /** + * MEOS {@code geo_equals} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar comparison/hash

+ */ + public static int geo_equals(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_equals requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_equals(arg0, arg1); + } + + /** + * MEOS {@code geo_geo_n} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar comparison/hash

+ */ + public static jnr.ffi.Pointer geo_geo_n(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_geo_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_geo_n(arg0, arg1); + } + + /** + * MEOS {@code geo_is_empty} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static boolean geo_is_empty(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_is_empty requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_is_empty(arg0); + } + + /** + * MEOS {@code geo_is_unitary} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static boolean geo_is_unitary(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_is_unitary requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_is_unitary(arg0); + } + + /** + * MEOS {@code geo_makeline_garray} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: make/from_base of instant/scalar

+ */ + public static jnr.ffi.Pointer geo_makeline_garray(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_makeline_garray requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_makeline_garray(arg0, arg1); + } + + /** + * MEOS {@code geo_num_geos} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static int geo_num_geos(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_num_geos requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_num_geos(arg0); + } + + /** + * MEOS {@code geo_num_points} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static int geo_num_points(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_num_points requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_num_points(arg0); + } + + /** + * MEOS {@code geo_pointarr} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer geo_pointarr(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_pointarr requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_pointarr(arg0, arg1); + } + + /** + * MEOS {@code geo_points} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer geo_points(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_points requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_points(arg0); + } + + /** + * MEOS {@code geo_reverse} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer geo_reverse(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_reverse requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_reverse(arg0); + } + + /** + * MEOS {@code geo_round} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: transform/normalize (pure)

+ */ + public static jnr.ffi.Pointer geo_round(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_round requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_round(arg0, arg1); + } + + /** + * MEOS {@code geo_same} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static boolean geo_same(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_same requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_same(arg0, arg1); + } + + /** + * MEOS {@code geo_set_srid} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer geo_set_srid(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_set_srid requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_set_srid(arg0, arg1); + } + + /** + * MEOS {@code geo_split_each_n_stboxes} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer geo_split_each_n_stboxes(jnr.ffi.Pointer arg0, int arg1, jnr.ffi.Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_split_each_n_stboxes requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_split_each_n_stboxes(arg0, arg1, arg2); + } + + /** + * MEOS {@code geo_split_n_stboxes} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer geo_split_n_stboxes(jnr.ffi.Pointer arg0, int arg1, jnr.ffi.Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_split_n_stboxes requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_split_n_stboxes(arg0, arg1, arg2); + } + + /** + * MEOS {@code geo_srid} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static int geo_srid(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_srid requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_srid(arg0); + } + + /** + * MEOS {@code geo_stboxes} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer geo_stboxes(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_stboxes requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_stboxes(arg0, arg1); + } + + /** + * MEOS {@code geo_timestamptz_to_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer geo_timestamptz_to_stbox(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_timestamptz_to_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_timestamptz_to_stbox(arg0, arg1); + } + + /** + * MEOS {@code geo_to_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer geo_to_set(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_to_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_to_set(arg0); + } + + /** + * MEOS {@code geo_to_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer geo_to_stbox(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_to_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_to_stbox(arg0); + } + + /** + * MEOS {@code geo_transform} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer geo_transform(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_transform requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_transform(arg0, arg1); + } + + /** + * MEOS {@code geo_transform_pipeline} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer geo_transform_pipeline(jnr.ffi.Pointer arg0, java.lang.String arg1, int arg2, boolean arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_transform_pipeline requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_transform_pipeline(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code geo_tstzspan_to_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer geo_tstzspan_to_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_tstzspan_to_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_tstzspan_to_stbox(arg0, arg1); + } + + /** + * MEOS {@code geo_typename} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static java.lang.String geo_typename(int arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_typename requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_typename(arg0); + } + + /** + * MEOS {@code geo_union_transfn} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer geo_union_transfn(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_union_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_union_transfn(arg0, arg1); + } + + /** + * MEOS {@code geog_area} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static double geog_area(jnr.ffi.Pointer arg0, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geog_area requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geog_area(arg0, arg1); + } + + /** + * MEOS {@code geog_centroid} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer geog_centroid(jnr.ffi.Pointer arg0, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geog_centroid requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geog_centroid(arg0, arg1); + } + + /** + * MEOS {@code geog_distance} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static double geog_distance(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geog_distance requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geog_distance(arg0, arg1); + } + + /** + * MEOS {@code geog_dwithin} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static boolean geog_dwithin(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, double arg2, boolean arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geog_dwithin requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geog_dwithin(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code geog_from_binary} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer geog_from_binary(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geog_from_binary requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geog_from_binary(arg0); + } + + /** + * MEOS {@code geog_intersects} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static boolean geog_intersects(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geog_intersects requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geog_intersects(arg0, arg1, arg2); + } + + /** + * MEOS {@code geog_length} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar comparison/hash

+ */ + public static double geog_length(jnr.ffi.Pointer arg0, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geog_length requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geog_length(arg0, arg1); + } + + /** + * MEOS {@code geog_perimeter} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static double geog_perimeter(jnr.ffi.Pointer arg0, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geog_perimeter requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geog_perimeter(arg0, arg1); + } + + /** + * MEOS {@code geog_to_geom} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer geog_to_geom(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geog_to_geom requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geog_to_geom(arg0); + } + + /** + * MEOS {@code geom_array_union} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer geom_array_union(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geom_array_union requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geom_array_union(arg0, arg1); + } + + /** + * MEOS {@code geom_azimuth} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer geom_azimuth(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geom_azimuth requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geom_azimuth(arg0, arg1); + } + + /** + * MEOS {@code geom_boundary} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer geom_boundary(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geom_boundary requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geom_boundary(arg0); + } + + /** + * MEOS {@code geom_buffer} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer geom_buffer(jnr.ffi.Pointer arg0, double arg1, java.lang.String arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geom_buffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geom_buffer(arg0, arg1, arg2); + } + + /** + * MEOS {@code geom_centroid} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer geom_centroid(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geom_centroid requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geom_centroid(arg0); + } + + /** + * MEOS {@code geom_contains} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static boolean geom_contains(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geom_contains requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geom_contains(arg0, arg1); + } + + /** + * MEOS {@code geom_convex_hull} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer geom_convex_hull(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geom_convex_hull requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geom_convex_hull(arg0); + } + + /** + * MEOS {@code geom_covers} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static boolean geom_covers(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geom_covers requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geom_covers(arg0, arg1); + } + + /** + * MEOS {@code geom_difference2d} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer geom_difference2d(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geom_difference2d requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geom_difference2d(arg0, arg1); + } + + /** + * MEOS {@code geom_disjoint2d} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static boolean geom_disjoint2d(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geom_disjoint2d requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geom_disjoint2d(arg0, arg1); + } + + /** + * MEOS {@code geom_distance2d} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static double geom_distance2d(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geom_distance2d requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geom_distance2d(arg0, arg1); + } + + /** + * MEOS {@code geom_distance3d} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static double geom_distance3d(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geom_distance3d requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geom_distance3d(arg0, arg1); + } + + /** + * MEOS {@code geom_dwithin2d} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static boolean geom_dwithin2d(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, double arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geom_dwithin2d requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geom_dwithin2d(arg0, arg1, arg2); + } + + /** + * MEOS {@code geom_dwithin3d} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static boolean geom_dwithin3d(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, double arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geom_dwithin3d requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geom_dwithin3d(arg0, arg1, arg2); + } + + /** + * MEOS {@code geom_intersection2d} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer geom_intersection2d(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geom_intersection2d requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geom_intersection2d(arg0, arg1); + } + + /** + * MEOS {@code geom_intersection2d_coll} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer geom_intersection2d_coll(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geom_intersection2d_coll requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geom_intersection2d_coll(arg0, arg1); + } + + /** + * MEOS {@code geom_intersects2d} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static boolean geom_intersects2d(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geom_intersects2d requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geom_intersects2d(arg0, arg1); + } + + /** + * MEOS {@code geom_intersects3d} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static boolean geom_intersects3d(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geom_intersects3d requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geom_intersects3d(arg0, arg1); + } + + /** + * MEOS {@code geom_length} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar comparison/hash

+ */ + public static double geom_length(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geom_length requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geom_length(arg0); + } + + /** + * MEOS {@code geom_min_bounding_radius} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer geom_min_bounding_radius(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geom_min_bounding_radius requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geom_min_bounding_radius(arg0, arg1); + } + + /** + * MEOS {@code geom_perimeter} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static double geom_perimeter(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geom_perimeter requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geom_perimeter(arg0); + } + + /** + * MEOS {@code geom_relate_pattern} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static boolean geom_relate_pattern(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, java.lang.String arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geom_relate_pattern requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geom_relate_pattern(arg0, arg1, arg2); + } + + /** + * MEOS {@code geom_shortestline2d} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer geom_shortestline2d(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geom_shortestline2d requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geom_shortestline2d(arg0, arg1); + } + + /** + * MEOS {@code geom_shortestline3d} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer geom_shortestline3d(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geom_shortestline3d requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geom_shortestline3d(arg0, arg1); + } + + /** + * MEOS {@code geom_to_geog} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer geom_to_geog(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geom_to_geog requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geom_to_geog(arg0); + } + + /** + * MEOS {@code geom_touches} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static boolean geom_touches(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geom_touches requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geom_touches(arg0, arg1); + } + + /** + * MEOS {@code geom_unary_union} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer geom_unary_union(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geom_unary_union requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geom_unary_union(arg0, arg1); + } + + /** + * MEOS {@code intersection_geo_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer intersection_geo_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intersection_geo_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intersection_geo_set(arg0, arg1); + } + + /** + * MEOS {@code intersection_set_geo} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer intersection_set_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intersection_set_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intersection_set_geo(arg0, arg1); + } + + /** + * MEOS {@code intersection_stbox_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer intersection_stbox_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intersection_stbox_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intersection_stbox_stbox(arg0, arg1); + } + + /** + * MEOS {@code left_stbox_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean left_stbox_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "left_stbox_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.left_stbox_stbox(arg0, arg1); + } + + /** + * MEOS {@code left_stbox_tspatial} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean left_stbox_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "left_stbox_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.left_stbox_tspatial(arg0, arg1); + } + + /** + * MEOS {@code line_numpoints} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar in/out (default-stateless catch-all)

+ */ + public static int line_numpoints(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "line_numpoints requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.line_numpoints(arg0); + } + + /** + * MEOS {@code overabove_stbox_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overabove_stbox_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overabove_stbox_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overabove_stbox_stbox(arg0, arg1); + } + + /** + * MEOS {@code overabove_stbox_tspatial} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overabove_stbox_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overabove_stbox_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overabove_stbox_tspatial(arg0, arg1); + } + + /** + * MEOS {@code overafter_stbox_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overafter_stbox_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overafter_stbox_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overafter_stbox_stbox(arg0, arg1); + } + + /** + * MEOS {@code overafter_stbox_tspatial} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overafter_stbox_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overafter_stbox_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overafter_stbox_tspatial(arg0, arg1); + } + + /** + * MEOS {@code overback_stbox_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overback_stbox_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overback_stbox_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overback_stbox_stbox(arg0, arg1); + } + + /** + * MEOS {@code overback_stbox_tspatial} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overback_stbox_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overback_stbox_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overback_stbox_tspatial(arg0, arg1); + } + + /** + * MEOS {@code overbefore_stbox_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overbefore_stbox_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overbefore_stbox_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overbefore_stbox_stbox(arg0, arg1); + } + + /** + * MEOS {@code overbefore_stbox_tspatial} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overbefore_stbox_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overbefore_stbox_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overbefore_stbox_tspatial(arg0, arg1); + } + + /** + * MEOS {@code overbelow_stbox_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overbelow_stbox_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overbelow_stbox_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overbelow_stbox_stbox(arg0, arg1); + } + + /** + * MEOS {@code overbelow_stbox_tspatial} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overbelow_stbox_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overbelow_stbox_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overbelow_stbox_tspatial(arg0, arg1); + } + + /** + * MEOS {@code overfront_stbox_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overfront_stbox_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overfront_stbox_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overfront_stbox_stbox(arg0, arg1); + } + + /** + * MEOS {@code overfront_stbox_tspatial} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overfront_stbox_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overfront_stbox_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overfront_stbox_tspatial(arg0, arg1); + } + + /** + * MEOS {@code overlaps_stbox_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overlaps_stbox_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overlaps_stbox_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overlaps_stbox_stbox(arg0, arg1); + } + + /** + * MEOS {@code overlaps_stbox_tspatial} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overlaps_stbox_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overlaps_stbox_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overlaps_stbox_tspatial(arg0, arg1); + } + + /** + * MEOS {@code overleft_stbox_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overleft_stbox_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overleft_stbox_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overleft_stbox_stbox(arg0, arg1); + } + + /** + * MEOS {@code overleft_stbox_tspatial} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overleft_stbox_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overleft_stbox_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overleft_stbox_tspatial(arg0, arg1); + } + + /** + * MEOS {@code overright_stbox_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overright_stbox_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overright_stbox_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overright_stbox_stbox(arg0, arg1); + } + + /** + * MEOS {@code overright_stbox_tspatial} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean overright_stbox_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overright_stbox_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overright_stbox_tspatial(arg0, arg1); + } + + /** + * MEOS {@code right_stbox_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean right_stbox_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "right_stbox_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.right_stbox_stbox(arg0, arg1); + } + + /** + * MEOS {@code right_stbox_tspatial} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean right_stbox_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "right_stbox_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.right_stbox_tspatial(arg0, arg1); + } + + /** + * MEOS {@code same_stbox_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: same predicate (pure box equality)

+ */ + public static boolean same_stbox_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "same_stbox_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.same_stbox_stbox(arg0, arg1); + } + + /** + * MEOS {@code same_stbox_tspatial} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: same predicate (pure box equality)

+ */ + public static boolean same_stbox_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "same_stbox_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.same_stbox_tspatial(arg0, arg1); + } + + /** + * MEOS {@code same_tspatial_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: same predicate (pure box equality)

+ */ + public static boolean same_tspatial_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "same_tspatial_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.same_tspatial_stbox(arg0, arg1); + } + + /** + * MEOS {@code spatialset_srid} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar in/out (default-stateless catch-all)

+ */ + public static int spatialset_srid(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "spatialset_srid requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.spatialset_srid(arg0); + } + + /** + * MEOS {@code spatialset_to_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer spatialset_to_stbox(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "spatialset_to_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.spatialset_to_stbox(arg0); + } + + /** + * MEOS {@code stboxarr_round} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: transform/normalize (pure)

+ */ + public static jnr.ffi.Pointer stboxarr_round(jnr.ffi.Pointer arg0, int arg1, int arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stboxarr_round requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stboxarr_round(arg0, arg1, arg2); + } + + /** + * MEOS {@code teq_geo_tgeo} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer teq_geo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "teq_geo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.teq_geo_tgeo(arg0, arg1); + } + + /** + * MEOS {@code teq_tgeo_geo} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer teq_tgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "teq_tgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.teq_tgeo_geo(arg0, arg1); + } + + /** + * MEOS {@code tgeoinst_make} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: make/from_base of instant/scalar

+ */ + public static jnr.ffi.Pointer tgeoinst_make(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeoinst_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeoinst_make(arg0, arg1); + } + + /** + * MEOS {@code timestamptz_to_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer timestamptz_to_stbox(java.time.OffsetDateTime arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "timestamptz_to_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.timestamptz_to_stbox(arg0); + } + + /** + * MEOS {@code tne_geo_tgeo} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tne_geo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tne_geo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tne_geo_tgeo(arg0, arg1); + } + + /** + * MEOS {@code tne_tgeo_geo} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tne_tgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tne_tgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tne_tgeo_geo(arg0, arg1); + } + + /** + * MEOS {@code tpointinst_make} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: make/from_base of instant/scalar

+ */ + public static jnr.ffi.Pointer tpointinst_make(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpointinst_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpointinst_make(arg0, arg1); + } + + /** + * MEOS {@code union_geo_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_geo_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_geo_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_geo_set(arg0, arg1); + } + + /** + * MEOS {@code union_set_geo} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_set_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_set_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_set_geo(arg0, arg1); + } + + /** + * MEOS {@code union_stbox_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_stbox_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_stbox_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_stbox_stbox(arg0, arg1, arg2); + } + + /** + * MEOS {@code above_tspatial_stbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean above_tspatial_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "above_tspatial_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.above_tspatial_stbox(arg0, arg1); + } + + /** + * MEOS {@code acontains_geo_tgeo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int acontains_geo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "acontains_geo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.acontains_geo_tgeo(arg0, arg1); + } + + /** + * MEOS {@code acontains_tgeo_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int acontains_tgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "acontains_tgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.acontains_tgeo_geo(arg0, arg1); + } + + /** + * MEOS {@code adisjoint_tgeo_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int adisjoint_tgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "adisjoint_tgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.adisjoint_tgeo_geo(arg0, arg1); + } + + /** + * MEOS {@code adjacent_tspatial_stbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean adjacent_tspatial_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "adjacent_tspatial_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.adjacent_tspatial_stbox(arg0, arg1); + } + + /** + * MEOS {@code adwithin_tgeo_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int adwithin_tgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, double arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "adwithin_tgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.adwithin_tgeo_geo(arg0, arg1, arg2); + } + + /** + * MEOS {@code after_tspatial_stbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean after_tspatial_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "after_tspatial_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.after_tspatial_stbox(arg0, arg1); + } + + /** + * MEOS {@code aintersects_tgeo_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int aintersects_tgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "aintersects_tgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.aintersects_tgeo_geo(arg0, arg1); + } + + /** + * MEOS {@code atouches_tgeo_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int atouches_tgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "atouches_tgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.atouches_tgeo_geo(arg0, arg1); + } + + /** + * MEOS {@code atouches_tpoint_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int atouches_tpoint_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "atouches_tpoint_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.atouches_tpoint_geo(arg0, arg1); + } + + /** + * MEOS {@code back_tspatial_stbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean back_tspatial_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "back_tspatial_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.back_tspatial_stbox(arg0, arg1); + } + + /** + * MEOS {@code before_tspatial_stbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean before_tspatial_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "before_tspatial_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.before_tspatial_stbox(arg0, arg1); + } + + /** + * MEOS {@code below_tspatial_stbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean below_tspatial_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "below_tspatial_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.below_tspatial_stbox(arg0, arg1); + } + + /** + * MEOS {@code contained_tspatial_stbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean contained_tspatial_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contained_tspatial_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contained_tspatial_stbox(arg0, arg1); + } + + /** + * MEOS {@code contains_tspatial_stbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean contains_tspatial_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_tspatial_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_tspatial_stbox(arg0, arg1); + } + + /** + * MEOS {@code econtains_geo_tgeo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int econtains_geo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "econtains_geo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.econtains_geo_tgeo(arg0, arg1); + } + + /** + * MEOS {@code econtains_tgeo_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int econtains_tgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "econtains_tgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.econtains_tgeo_geo(arg0, arg1); + } + + /** + * MEOS {@code ecovers_geo_tgeo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int ecovers_geo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ecovers_geo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ecovers_geo_tgeo(arg0, arg1); + } + + /** + * MEOS {@code ecovers_tgeo_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int ecovers_tgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ecovers_tgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ecovers_tgeo_geo(arg0, arg1); + } + + /** + * MEOS {@code edisjoint_tgeo_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int edisjoint_tgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "edisjoint_tgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.edisjoint_tgeo_geo(arg0, arg1); + } + + /** + * MEOS {@code edwithin_tgeo_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int edwithin_tgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, double arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "edwithin_tgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.edwithin_tgeo_geo(arg0, arg1, arg2); + } + + /** + * MEOS {@code eintersects_tgeo_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int eintersects_tgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "eintersects_tgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.eintersects_tgeo_geo(arg0, arg1); + } + + /** + * MEOS {@code etouches_tgeo_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int etouches_tgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "etouches_tgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.etouches_tgeo_geo(arg0, arg1); + } + + /** + * MEOS {@code etouches_tpoint_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 1 temporal

+ */ + public static int etouches_tpoint_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "etouches_tpoint_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.etouches_tpoint_geo(arg0, arg1); + } + + /** + * MEOS {@code front_tspatial_stbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean front_tspatial_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "front_tspatial_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.front_tspatial_stbox(arg0, arg1); + } + + /** + * MEOS {@code left_tspatial_stbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean left_tspatial_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "left_tspatial_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.left_tspatial_stbox(arg0, arg1); + } + + /** + * MEOS {@code minus_geo_set} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_geo_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_geo_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_geo_set(arg0, arg1); + } + + /** + * MEOS {@code minus_set_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_set_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_set_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_set_geo(arg0, arg1); + } + + /** + * MEOS {@code nad_stbox_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static double nad_stbox_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nad_stbox_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nad_stbox_geo(arg0, arg1); + } + + /** + * MEOS {@code nad_stbox_stbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static double nad_stbox_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nad_stbox_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nad_stbox_stbox(arg0, arg1); + } + + /** + * MEOS {@code nad_tgeo_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static double nad_tgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nad_tgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nad_tgeo_geo(arg0, arg1); + } + + /** + * MEOS {@code nad_tgeo_stbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static double nad_tgeo_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nad_tgeo_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nad_tgeo_stbox(arg0, arg1); + } + + /** + * MEOS {@code nai_tgeo_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static jnr.ffi.Pointer nai_tgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nai_tgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nai_tgeo_geo(arg0, arg1); + } + + /** + * MEOS {@code overabove_tspatial_stbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean overabove_tspatial_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overabove_tspatial_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overabove_tspatial_stbox(arg0, arg1); + } + + /** + * MEOS {@code overafter_tspatial_stbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean overafter_tspatial_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overafter_tspatial_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overafter_tspatial_stbox(arg0, arg1); + } + + /** + * MEOS {@code overback_tspatial_stbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean overback_tspatial_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overback_tspatial_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overback_tspatial_stbox(arg0, arg1); + } + + /** + * MEOS {@code overbefore_tspatial_stbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean overbefore_tspatial_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overbefore_tspatial_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overbefore_tspatial_stbox(arg0, arg1); + } + + /** + * MEOS {@code overbelow_tspatial_stbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean overbelow_tspatial_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overbelow_tspatial_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overbelow_tspatial_stbox(arg0, arg1); + } + + /** + * MEOS {@code overfront_tspatial_stbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean overfront_tspatial_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overfront_tspatial_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overfront_tspatial_stbox(arg0, arg1); + } + + /** + * MEOS {@code overlaps_tspatial_stbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean overlaps_tspatial_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overlaps_tspatial_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overlaps_tspatial_stbox(arg0, arg1); + } + + /** + * MEOS {@code overleft_tspatial_stbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean overleft_tspatial_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overleft_tspatial_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overleft_tspatial_stbox(arg0, arg1); + } + + /** + * MEOS {@code overright_tspatial_stbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean overright_tspatial_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overright_tspatial_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overright_tspatial_stbox(arg0, arg1); + } + + /** + * MEOS {@code right_tspatial_stbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean right_tspatial_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "right_tspatial_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.right_tspatial_stbox(arg0, arg1); + } + + /** + * MEOS {@code shortestline_tgeo_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static jnr.ffi.Pointer shortestline_tgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "shortestline_tgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.shortestline_tgeo_geo(arg0, arg1); + } + + /** + * MEOS {@code tcontains_geo_tgeo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 1 temporal

+ */ + public static jnr.ffi.Pointer tcontains_geo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tcontains_geo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tcontains_geo_tgeo(arg0, arg1); + } + + /** + * MEOS {@code tcontains_tgeo_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 1 temporal

+ */ + public static jnr.ffi.Pointer tcontains_tgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tcontains_tgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tcontains_tgeo_geo(arg0, arg1); + } + + /** + * MEOS {@code tcovers_geo_tgeo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 1 temporal

+ */ + public static jnr.ffi.Pointer tcovers_geo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tcovers_geo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tcovers_geo_tgeo(arg0, arg1); + } + + /** + * MEOS {@code tcovers_tgeo_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 1 temporal

+ */ + public static jnr.ffi.Pointer tcovers_tgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tcovers_tgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tcovers_tgeo_geo(arg0, arg1); + } + + /** + * MEOS {@code tdisjoint_geo_tgeo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 1 temporal

+ */ + public static jnr.ffi.Pointer tdisjoint_geo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tdisjoint_geo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tdisjoint_geo_tgeo(arg0, arg1); + } + + /** + * MEOS {@code tdisjoint_tgeo_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 1 temporal

+ */ + public static jnr.ffi.Pointer tdisjoint_tgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tdisjoint_tgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tdisjoint_tgeo_geo(arg0, arg1); + } + + /** + * MEOS {@code tdistance_tgeo_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static jnr.ffi.Pointer tdistance_tgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tdistance_tgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tdistance_tgeo_geo(arg0, arg1); + } + + /** + * MEOS {@code tdwithin_geo_tgeo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 1 temporal

+ */ + public static jnr.ffi.Pointer tdwithin_geo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, double arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tdwithin_geo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tdwithin_geo_tgeo(arg0, arg1, arg2); + } + + /** + * MEOS {@code tdwithin_tgeo_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 1 temporal

+ */ + public static jnr.ffi.Pointer tdwithin_tgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, double arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tdwithin_tgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tdwithin_tgeo_geo(arg0, arg1, arg2); + } + + /** + * MEOS {@code tintersects_geo_tgeo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 1 temporal

+ */ + public static jnr.ffi.Pointer tintersects_geo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tintersects_geo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tintersects_geo_tgeo(arg0, arg1); + } + + /** + * MEOS {@code tintersects_tgeo_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 1 temporal

+ */ + public static jnr.ffi.Pointer tintersects_tgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tintersects_tgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tintersects_tgeo_geo(arg0, arg1); + } + + /** + * MEOS {@code ttouches_geo_tgeo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 1 temporal

+ */ + public static jnr.ffi.Pointer ttouches_geo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ttouches_geo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ttouches_geo_tgeo(arg0, arg1); + } + + /** + * MEOS {@code ttouches_tgeo_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 1 temporal

+ */ + public static jnr.ffi.Pointer ttouches_tgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ttouches_tgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ttouches_tgeo_geo(arg0, arg1); + } + + /** + * MEOS {@code always_eq_geo_tgeo} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_eq_geo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_eq_geo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_eq_geo_tgeo(arg0, arg1); + } + + /** + * MEOS {@code always_eq_tgeo_geo} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_eq_tgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_eq_tgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_eq_tgeo_geo(arg0, arg1); + } + + /** + * MEOS {@code always_ne_geo_tgeo} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_ne_geo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ne_geo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ne_geo_tgeo(arg0, arg1); + } + + /** + * MEOS {@code always_ne_tgeo_geo} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_ne_tgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ne_tgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ne_tgeo_geo(arg0, arg1); + } + + /** + * MEOS {@code ever_eq_geo_tgeo} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_eq_geo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_eq_geo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_eq_geo_tgeo(arg0, arg1); + } + + /** + * MEOS {@code ever_eq_tgeo_geo} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_eq_tgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_eq_tgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_eq_tgeo_geo(arg0, arg1); + } + + /** + * MEOS {@code ever_ne_geo_tgeo} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_ne_geo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ne_geo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ne_geo_tgeo(arg0, arg1); + } + + /** + * MEOS {@code ever_ne_tgeo_geo} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_ne_tgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ne_tgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ne_tgeo_geo(arg0, arg1); + } + + /** + * MEOS {@code above_tspatial_tspatial} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 temporals

+ */ + public static boolean above_tspatial_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "above_tspatial_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.above_tspatial_tspatial(arg0, arg1); + } + + /** + * MEOS {@code acontains_tgeo_tgeo} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 2 temporals

+ */ + public static int acontains_tgeo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "acontains_tgeo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.acontains_tgeo_tgeo(arg0, arg1); + } + + /** + * MEOS {@code adisjoint_tgeo_tgeo} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 2 temporals

+ */ + public static int adisjoint_tgeo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "adisjoint_tgeo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.adisjoint_tgeo_tgeo(arg0, arg1); + } + + /** + * MEOS {@code adjacent_tspatial_tspatial} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 temporals

+ */ + public static boolean adjacent_tspatial_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "adjacent_tspatial_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.adjacent_tspatial_tspatial(arg0, arg1); + } + + /** + * MEOS {@code adwithin_tgeo_tgeo} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 2 temporals

+ */ + public static int adwithin_tgeo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, double arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "adwithin_tgeo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.adwithin_tgeo_tgeo(arg0, arg1, arg2); + } + + /** + * MEOS {@code after_tspatial_tspatial} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 temporals

+ */ + public static boolean after_tspatial_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "after_tspatial_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.after_tspatial_tspatial(arg0, arg1); + } + + /** + * MEOS {@code aintersects_tgeo_tgeo} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 2 temporals

+ */ + public static int aintersects_tgeo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "aintersects_tgeo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.aintersects_tgeo_tgeo(arg0, arg1); + } + + /** + * MEOS {@code always_eq_tgeo_tgeo} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always over 2 temporals

+ */ + public static int always_eq_tgeo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_eq_tgeo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_eq_tgeo_tgeo(arg0, arg1); + } + + /** + * MEOS {@code always_ne_tgeo_tgeo} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always over 2 temporals

+ */ + public static int always_ne_tgeo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ne_tgeo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ne_tgeo_tgeo(arg0, arg1); + } + + /** + * MEOS {@code atouches_tgeo_tgeo} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 2 temporals

+ */ + public static int atouches_tgeo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "atouches_tgeo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.atouches_tgeo_tgeo(arg0, arg1); + } + + /** + * MEOS {@code back_tspatial_tspatial} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 temporals

+ */ + public static boolean back_tspatial_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "back_tspatial_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.back_tspatial_tspatial(arg0, arg1); + } + + /** + * MEOS {@code before_tspatial_tspatial} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 temporals

+ */ + public static boolean before_tspatial_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "before_tspatial_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.before_tspatial_tspatial(arg0, arg1); + } + + /** + * MEOS {@code below_tspatial_tspatial} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 temporals

+ */ + public static boolean below_tspatial_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "below_tspatial_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.below_tspatial_tspatial(arg0, arg1); + } + + /** + * MEOS {@code contained_tspatial_tspatial} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 temporals

+ */ + public static boolean contained_tspatial_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contained_tspatial_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contained_tspatial_tspatial(arg0, arg1); + } + + /** + * MEOS {@code contains_tspatial_tspatial} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 temporals

+ */ + public static boolean contains_tspatial_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_tspatial_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_tspatial_tspatial(arg0, arg1); + } + + /** + * MEOS {@code econtains_tgeo_tgeo} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 2 temporals

+ */ + public static int econtains_tgeo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "econtains_tgeo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.econtains_tgeo_tgeo(arg0, arg1); + } + + /** + * MEOS {@code ecovers_tgeo_tgeo} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 2 temporals

+ */ + public static int ecovers_tgeo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ecovers_tgeo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ecovers_tgeo_tgeo(arg0, arg1); + } + + /** + * MEOS {@code edisjoint_tgeo_tgeo} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 2 temporals

+ */ + public static int edisjoint_tgeo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "edisjoint_tgeo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.edisjoint_tgeo_tgeo(arg0, arg1); + } + + /** + * MEOS {@code edwithin_tgeo_tgeo} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 2 temporals

+ */ + public static int edwithin_tgeo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, double arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "edwithin_tgeo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.edwithin_tgeo_tgeo(arg0, arg1, arg2); + } + + /** + * MEOS {@code eintersects_tgeo_tgeo} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 2 temporals

+ */ + public static int eintersects_tgeo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "eintersects_tgeo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.eintersects_tgeo_tgeo(arg0, arg1); + } + + /** + * MEOS {@code etouches_tgeo_tgeo} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always spatial-rel on 2 temporals

+ */ + public static int etouches_tgeo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "etouches_tgeo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.etouches_tgeo_tgeo(arg0, arg1); + } + + /** + * MEOS {@code ever_eq_tgeo_tgeo} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always over 2 temporals

+ */ + public static int ever_eq_tgeo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_eq_tgeo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_eq_tgeo_tgeo(arg0, arg1); + } + + /** + * MEOS {@code ever_ne_tgeo_tgeo} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always over 2 temporals

+ */ + public static int ever_ne_tgeo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ne_tgeo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ne_tgeo_tgeo(arg0, arg1); + } + + /** + * MEOS {@code front_tspatial_tspatial} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 temporals

+ */ + public static boolean front_tspatial_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "front_tspatial_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.front_tspatial_tspatial(arg0, arg1); + } + + /** + * MEOS {@code left_tspatial_tspatial} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 temporals

+ */ + public static boolean left_tspatial_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "left_tspatial_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.left_tspatial_tspatial(arg0, arg1); + } + + /** + * MEOS {@code nad_tgeo_tgeo} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: distance on 2 temporals

+ */ + public static double nad_tgeo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nad_tgeo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nad_tgeo_tgeo(arg0, arg1); + } + + /** + * MEOS {@code nai_tgeo_tgeo} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: distance on 2 temporals

+ */ + public static jnr.ffi.Pointer nai_tgeo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nai_tgeo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nai_tgeo_tgeo(arg0, arg1); + } + + /** + * MEOS {@code overabove_tspatial_tspatial} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 temporals

+ */ + public static boolean overabove_tspatial_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overabove_tspatial_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overabove_tspatial_tspatial(arg0, arg1); + } + + /** + * MEOS {@code overafter_tspatial_tspatial} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 temporals

+ */ + public static boolean overafter_tspatial_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overafter_tspatial_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overafter_tspatial_tspatial(arg0, arg1); + } + + /** + * MEOS {@code overback_tspatial_tspatial} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 temporals

+ */ + public static boolean overback_tspatial_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overback_tspatial_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overback_tspatial_tspatial(arg0, arg1); + } + + /** + * MEOS {@code overbefore_tspatial_tspatial} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 temporals

+ */ + public static boolean overbefore_tspatial_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overbefore_tspatial_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overbefore_tspatial_tspatial(arg0, arg1); + } + + /** + * MEOS {@code overbelow_tspatial_tspatial} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 temporals

+ */ + public static boolean overbelow_tspatial_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overbelow_tspatial_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overbelow_tspatial_tspatial(arg0, arg1); + } + + /** + * MEOS {@code overfront_tspatial_tspatial} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 temporals

+ */ + public static boolean overfront_tspatial_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overfront_tspatial_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overfront_tspatial_tspatial(arg0, arg1); + } + + /** + * MEOS {@code overlaps_tspatial_tspatial} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 temporals

+ */ + public static boolean overlaps_tspatial_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overlaps_tspatial_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overlaps_tspatial_tspatial(arg0, arg1); + } + + /** + * MEOS {@code overleft_tspatial_tspatial} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 temporals

+ */ + public static boolean overleft_tspatial_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overleft_tspatial_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overleft_tspatial_tspatial(arg0, arg1); + } + + /** + * MEOS {@code overright_tspatial_tspatial} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 temporals

+ */ + public static boolean overright_tspatial_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overright_tspatial_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overright_tspatial_tspatial(arg0, arg1); + } + + /** + * MEOS {@code right_tspatial_tspatial} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 temporals

+ */ + public static boolean right_tspatial_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "right_tspatial_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.right_tspatial_tspatial(arg0, arg1); + } + + /** + * MEOS {@code same_tspatial_tspatial} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: same predicate on 2 temporals

+ */ + public static boolean same_tspatial_tspatial(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "same_tspatial_tspatial requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.same_tspatial_tspatial(arg0, arg1); + } + + /** + * MEOS {@code shortestline_tgeo_tgeo} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: distance on 2 temporals

+ */ + public static jnr.ffi.Pointer shortestline_tgeo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "shortestline_tgeo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.shortestline_tgeo_tgeo(arg0, arg1); + } + + /** + * MEOS {@code tcontains_tgeo_tgeo} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 2 temporals

+ */ + public static jnr.ffi.Pointer tcontains_tgeo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tcontains_tgeo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tcontains_tgeo_tgeo(arg0, arg1); + } + + /** + * MEOS {@code tcovers_tgeo_tgeo} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 2 temporals

+ */ + public static jnr.ffi.Pointer tcovers_tgeo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tcovers_tgeo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tcovers_tgeo_tgeo(arg0, arg1); + } + + /** + * MEOS {@code tdisjoint_tgeo_tgeo} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 2 temporals

+ */ + public static jnr.ffi.Pointer tdisjoint_tgeo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tdisjoint_tgeo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tdisjoint_tgeo_tgeo(arg0, arg1); + } + + /** + * MEOS {@code tdistance_tgeo_tgeo} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: distance on 2 temporals

+ */ + public static jnr.ffi.Pointer tdistance_tgeo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tdistance_tgeo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tdistance_tgeo_tgeo(arg0, arg1); + } + + /** + * MEOS {@code tdwithin_tgeo_tgeo} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 2 temporals

+ */ + public static jnr.ffi.Pointer tdwithin_tgeo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, double arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tdwithin_tgeo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tdwithin_tgeo_tgeo(arg0, arg1, arg2); + } + + /** + * MEOS {@code tintersects_tgeo_tgeo} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 2 temporals

+ */ + public static jnr.ffi.Pointer tintersects_tgeo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tintersects_tgeo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tintersects_tgeo_tgeo(arg0, arg1); + } + + /** + * MEOS {@code ttouches_tgeo_tgeo} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: temporal spatial-rel lift on 2 temporals

+ */ + public static jnr.ffi.Pointer ttouches_tgeo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ttouches_tgeo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ttouches_tgeo_tgeo(arg0, arg1); + } + + /** + * MEOS {@code box3d_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static java.lang.String box3d_out(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "box3d_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.box3d_out(arg0, arg1); + } + + /** + * MEOS {@code gbox_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static java.lang.String gbox_out(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "gbox_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.gbox_out(arg0, arg1); + } + + /** + * MEOS {@code geo_as_ewkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: name has IO token

+ */ + public static jnr.ffi.Pointer geo_as_ewkb(jnr.ffi.Pointer arg0, java.lang.String arg1, jnr.ffi.Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_as_ewkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_as_ewkb(arg0, arg1, arg2); + } + + /** + * MEOS {@code geo_as_ewkt} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static java.lang.String geo_as_ewkt(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_as_ewkt requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_as_ewkt(arg0, arg1); + } + + /** + * MEOS {@code geo_as_geojson} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static java.lang.String geo_as_geojson(jnr.ffi.Pointer arg0, int arg1, int arg2, java.lang.String arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_as_geojson requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_as_geojson(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code geo_as_hexewkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: name has IO token

+ */ + public static java.lang.String geo_as_hexewkb(jnr.ffi.Pointer arg0, java.lang.String arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_as_hexewkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_as_hexewkb(arg0, arg1); + } + + /** + * MEOS {@code geo_as_text} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static java.lang.String geo_as_text(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_as_text requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_as_text(arg0, arg1); + } + + /** + * MEOS {@code geo_from_ewkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: name has IO token

+ */ + public static jnr.ffi.Pointer geo_from_ewkb(jnr.ffi.Pointer arg0, long arg1, int arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_from_ewkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_from_ewkb(arg0, arg1, arg2); + } + + /** + * MEOS {@code geo_from_geojson} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static jnr.ffi.Pointer geo_from_geojson(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_from_geojson requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_from_geojson(arg0); + } + + /** + * MEOS {@code geo_from_text} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static jnr.ffi.Pointer geo_from_text(java.lang.String arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_from_text requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_from_text(arg0, arg1); + } + + /** + * MEOS {@code geo_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static java.lang.String geo_out(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_out(arg0); + } + + /** + * MEOS {@code geog_from_hexewkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: name has IO token

+ */ + public static jnr.ffi.Pointer geog_from_hexewkb(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geog_from_hexewkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geog_from_hexewkb(arg0); + } + + /** + * MEOS {@code geog_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static jnr.ffi.Pointer geog_in(java.lang.String arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geog_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geog_in(arg0, arg1); + } + + /** + * MEOS {@code geom_from_hexewkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: name has IO token

+ */ + public static jnr.ffi.Pointer geom_from_hexewkb(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geom_from_hexewkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geom_from_hexewkb(arg0); + } + + /** + * MEOS {@code geom_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static jnr.ffi.Pointer geom_in(java.lang.String arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geom_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geom_in(arg0, arg1); + } + + /** + * MEOS {@code spatialset_as_ewkt} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static java.lang.String spatialset_as_ewkt(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "spatialset_as_ewkt requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.spatialset_as_ewkt(arg0, arg1); + } + + /** + * MEOS {@code spatialset_as_text} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static java.lang.String spatialset_as_text(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "spatialset_as_text requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.spatialset_as_text(arg0, arg1); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFreeH3.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFreeH3.java new file mode 100644 index 0000000..df5814d --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFreeH3.java @@ -0,0 +1,258 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by tools/codegen/emit_h3_facade.py — do not edit by hand. + * H3 / th3index family facade over functions.GeneratedFunctions. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsFreeH3 { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsFreeH3() { /* utility */ } + + /** MEOS {@code always_eq_h3index_th3index} — H3 / th3index family. */ + public static int always_eq_h3index_th3index(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_eq_h3index_th3index requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_eq_h3index_th3index(arg0, arg1); + } + + /** MEOS {@code always_eq_th3index_h3index} — H3 / th3index family. */ + public static int always_eq_th3index_h3index(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_eq_th3index_h3index requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_eq_th3index_h3index(arg0, arg1); + } + + /** MEOS {@code always_eq_th3index_th3index} — H3 / th3index family. */ + public static int always_eq_th3index_th3index(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_eq_th3index_th3index requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_eq_th3index_th3index(arg0, arg1); + } + + /** MEOS {@code always_ne_h3index_th3index} — H3 / th3index family. */ + public static int always_ne_h3index_th3index(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ne_h3index_th3index requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ne_h3index_th3index(arg0, arg1); + } + + /** MEOS {@code always_ne_th3index_h3index} — H3 / th3index family. */ + public static int always_ne_th3index_h3index(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ne_th3index_h3index requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ne_th3index_h3index(arg0, arg1); + } + + /** MEOS {@code always_ne_th3index_th3index} — H3 / th3index family. */ + public static int always_ne_th3index_th3index(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ne_th3index_th3index requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ne_th3index_th3index(arg0, arg1); + } + + /** MEOS {@code ever_eq_h3index_th3index} — H3 / th3index family. */ + public static int ever_eq_h3index_th3index(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_eq_h3index_th3index requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_eq_h3index_th3index(arg0, arg1); + } + + /** MEOS {@code ever_eq_h3indexset_th3index} — H3 / th3index family. */ + public static int ever_eq_h3indexset_th3index(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_eq_h3indexset_th3index requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_eq_h3indexset_th3index(arg0, arg1); + } + + /** MEOS {@code ever_eq_th3index_h3index} — H3 / th3index family. */ + public static int ever_eq_th3index_h3index(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_eq_th3index_h3index requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_eq_th3index_h3index(arg0, arg1); + } + + /** MEOS {@code ever_eq_th3index_th3index} — H3 / th3index family. */ + public static int ever_eq_th3index_th3index(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_eq_th3index_th3index requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_eq_th3index_th3index(arg0, arg1); + } + + /** MEOS {@code ever_ne_h3index_th3index} — H3 / th3index family. */ + public static int ever_ne_h3index_th3index(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ne_h3index_th3index requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ne_h3index_th3index(arg0, arg1); + } + + /** MEOS {@code ever_ne_th3index_h3index} — H3 / th3index family. */ + public static int ever_ne_th3index_h3index(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ne_th3index_h3index requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ne_th3index_h3index(arg0, arg1); + } + + /** MEOS {@code ever_ne_th3index_th3index} — H3 / th3index family. */ + public static int ever_ne_th3index_th3index(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ne_th3index_th3index requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ne_th3index_th3index(arg0, arg1); + } + + /** MEOS {@code geo_to_h3index_set} — H3 / th3index family. */ + public static jnr.ffi.Pointer geo_to_h3index_set(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_to_h3index_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_to_h3index_set(arg0, arg1); + } + + /** MEOS {@code h3_gs_point_to_cell} — H3 / th3index family. */ + public static long h3_gs_point_to_cell(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "h3_gs_point_to_cell requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.h3_gs_point_to_cell(arg0, arg1); + } + + /** MEOS {@code h3index_in} — H3 / th3index family. */ + public static long h3index_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "h3index_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.h3index_in(arg0); + } + + /** MEOS {@code h3index_out} — H3 / th3index family. */ + public static java.lang.String h3index_out(long arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "h3index_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.h3index_out(arg0); + } + + /** MEOS {@code tbigint_to_th3index} — H3 / th3index family. */ + public static jnr.ffi.Pointer tbigint_to_th3index(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbigint_to_th3index requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbigint_to_th3index(arg0); + } + + /** MEOS {@code teq_h3index_th3index} — H3 / th3index family. */ + public static jnr.ffi.Pointer teq_h3index_th3index(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "teq_h3index_th3index requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.teq_h3index_th3index(arg0, arg1); + } + + /** MEOS {@code teq_th3index_h3index} — H3 / th3index family. */ + public static jnr.ffi.Pointer teq_th3index_h3index(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "teq_th3index_h3index requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.teq_th3index_h3index(arg0, arg1); + } + + /** MEOS {@code teq_th3index_th3index} — H3 / th3index family. */ + public static jnr.ffi.Pointer teq_th3index_th3index(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "teq_th3index_th3index requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.teq_th3index_th3index(arg0, arg1); + } + + /** MEOS {@code tgeogpoint_great_circle_distance} — H3 / th3index family. */ + public static jnr.ffi.Pointer tgeogpoint_great_circle_distance(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, java.lang.String arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeogpoint_great_circle_distance requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeogpoint_great_circle_distance(arg0, arg1, arg2); + } + + /** MEOS {@code tgeogpoint_to_th3index} — H3 / th3index family. */ + public static jnr.ffi.Pointer tgeogpoint_to_th3index(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeogpoint_to_th3index requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeogpoint_to_th3index(arg0, arg1); + } + + /** MEOS {@code tgeompoint_to_th3index} — H3 / th3index family. */ + public static jnr.ffi.Pointer tgeompoint_to_th3index(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeompoint_to_th3index requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeompoint_to_th3index(arg0, arg1); + } + + /** MEOS {@code tne_h3index_th3index} — H3 / th3index family. */ + public static jnr.ffi.Pointer tne_h3index_th3index(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tne_h3index_th3index requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tne_h3index_th3index(arg0, arg1); + } + + /** MEOS {@code tne_th3index_h3index} — H3 / th3index family. */ + public static jnr.ffi.Pointer tne_th3index_h3index(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tne_th3index_h3index requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tne_th3index_h3index(arg0, arg1); + } + + /** MEOS {@code tne_th3index_th3index} — H3 / th3index family. */ + public static jnr.ffi.Pointer tne_th3index_th3index(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tne_th3index_th3index requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tne_th3index_th3index(arg0, arg1); + } +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFreeNpoint.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFreeNpoint.java new file mode 100644 index 0000000..182b45b --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFreeNpoint.java @@ -0,0 +1,1086 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_free.py — do not edit by hand. + * Source header: meos_npoint.h + * Methods emitted: 82 (stateless=44 · bounded-state=11 · io-meta=10 · windowed=9 · cross-stream=8) + * Scope: MEOS public functions NOT classified into any object-model class + * (free functions, not methods on a class). + * Source: JMEOS PR #19 (functions.GeneratedFunctions) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsFreeNpoint { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsFreeNpoint() { /* utility */ } + + /** + * MEOS {@code contained_npoint_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 scalars (box/span algebra)

+ */ + public static boolean contained_npoint_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contained_npoint_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contained_npoint_set(arg0, arg1); + } + + /** + * MEOS {@code contains_set_npoint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contains_set_npoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_set_npoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_set_npoint(arg0, arg1); + } + + /** + * MEOS {@code geom_to_nsegment} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer geom_to_nsegment(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geom_to_nsegment requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geom_to_nsegment(arg0); + } + + /** + * MEOS {@code get_srid_ways} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar in/out (default-stateless catch-all)

+ */ + public static int get_srid_ways() { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "get_srid_ways requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.get_srid_ways(); + } + + /** + * MEOS {@code intersection_set_npoint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer intersection_set_npoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intersection_set_npoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intersection_set_npoint(arg0, arg1); + } + + /** + * MEOS {@code npoint_cmp} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar comparison/hash

+ */ + public static int npoint_cmp(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npoint_cmp requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npoint_cmp(arg0, arg1); + } + + /** + * MEOS {@code npoint_eq} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar comparison/hash

+ */ + public static boolean npoint_eq(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npoint_eq requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npoint_eq(arg0, arg1); + } + + /** + * MEOS {@code npoint_ge} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar comparison/hash

+ */ + public static boolean npoint_ge(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npoint_ge requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npoint_ge(arg0, arg1); + } + + /** + * MEOS {@code npoint_gt} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar comparison/hash

+ */ + public static boolean npoint_gt(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npoint_gt requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npoint_gt(arg0, arg1); + } + + /** + * MEOS {@code npoint_hash} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar comparison/hash

+ */ + public static int npoint_hash(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npoint_hash requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npoint_hash(arg0); + } + + /** + * MEOS {@code npoint_hash_extended} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar comparison/hash

+ */ + public static long npoint_hash_extended(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npoint_hash_extended requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npoint_hash_extended(arg0, arg1); + } + + /** + * MEOS {@code npoint_le} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar comparison/hash

+ */ + public static boolean npoint_le(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npoint_le requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npoint_le(arg0, arg1); + } + + /** + * MEOS {@code npoint_lt} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar comparison/hash

+ */ + public static boolean npoint_lt(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npoint_lt requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npoint_lt(arg0, arg1); + } + + /** + * MEOS {@code npoint_make} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: make/from_base of instant/scalar

+ */ + public static jnr.ffi.Pointer npoint_make(long arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npoint_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npoint_make(arg0, arg1); + } + + /** + * MEOS {@code npoint_ne} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar comparison/hash

+ */ + public static boolean npoint_ne(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npoint_ne requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npoint_ne(arg0, arg1); + } + + /** + * MEOS {@code npoint_position} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static double npoint_position(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npoint_position requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npoint_position(arg0); + } + + /** + * MEOS {@code npoint_round} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: transform/normalize (pure)

+ */ + public static jnr.ffi.Pointer npoint_round(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npoint_round requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npoint_round(arg0, arg1); + } + + /** + * MEOS {@code npoint_route} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static long npoint_route(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npoint_route requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npoint_route(arg0); + } + + /** + * MEOS {@code npoint_same} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static boolean npoint_same(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npoint_same requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npoint_same(arg0, arg1); + } + + /** + * MEOS {@code npoint_srid} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static int npoint_srid(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npoint_srid requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npoint_srid(arg0); + } + + /** + * MEOS {@code npoint_timestamptz_to_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer npoint_timestamptz_to_stbox(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npoint_timestamptz_to_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npoint_timestamptz_to_stbox(arg0, arg1); + } + + /** + * MEOS {@code npoint_to_geompoint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer npoint_to_geompoint(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npoint_to_geompoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npoint_to_geompoint(arg0); + } + + /** + * MEOS {@code npoint_to_nsegment} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer npoint_to_nsegment(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npoint_to_nsegment requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npoint_to_nsegment(arg0); + } + + /** + * MEOS {@code npoint_to_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer npoint_to_set(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npoint_to_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npoint_to_set(arg0); + } + + /** + * MEOS {@code npoint_to_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer npoint_to_stbox(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npoint_to_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npoint_to_stbox(arg0); + } + + /** + * MEOS {@code npoint_tstzspan_to_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer npoint_tstzspan_to_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npoint_tstzspan_to_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npoint_tstzspan_to_stbox(arg0, arg1); + } + + /** + * MEOS {@code npoint_union_transfn} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer npoint_union_transfn(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npoint_union_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npoint_union_transfn(arg0, arg1); + } + + /** + * MEOS {@code nsegment_cmp} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar in/out (default-stateless catch-all)

+ */ + public static int nsegment_cmp(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nsegment_cmp requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nsegment_cmp(arg0, arg1); + } + + /** + * MEOS {@code nsegment_eq} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar in/out (default-stateless catch-all)

+ */ + public static boolean nsegment_eq(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nsegment_eq requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nsegment_eq(arg0, arg1); + } + + /** + * MEOS {@code nsegment_ge} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar in/out (default-stateless catch-all)

+ */ + public static boolean nsegment_ge(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nsegment_ge requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nsegment_ge(arg0, arg1); + } + + /** + * MEOS {@code nsegment_gt} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar in/out (default-stateless catch-all)

+ */ + public static boolean nsegment_gt(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nsegment_gt requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nsegment_gt(arg0, arg1); + } + + /** + * MEOS {@code nsegment_le} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar in/out (default-stateless catch-all)

+ */ + public static boolean nsegment_le(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nsegment_le requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nsegment_le(arg0, arg1); + } + + /** + * MEOS {@code nsegment_lt} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar in/out (default-stateless catch-all)

+ */ + public static boolean nsegment_lt(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nsegment_lt requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nsegment_lt(arg0, arg1); + } + + /** + * MEOS {@code nsegment_make} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: make/from_base of instant/scalar

+ */ + public static jnr.ffi.Pointer nsegment_make(long arg0, double arg1, double arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nsegment_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nsegment_make(arg0, arg1, arg2); + } + + /** + * MEOS {@code nsegment_ne} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar in/out (default-stateless catch-all)

+ */ + public static boolean nsegment_ne(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nsegment_ne requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nsegment_ne(arg0, arg1); + } + + /** + * MEOS {@code nsegment_round} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: transform/normalize (pure)

+ */ + public static jnr.ffi.Pointer nsegment_round(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nsegment_round requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nsegment_round(arg0, arg1); + } + + /** + * MEOS {@code nsegment_route} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar in/out (default-stateless catch-all)

+ */ + public static long nsegment_route(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nsegment_route requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nsegment_route(arg0); + } + + /** + * MEOS {@code nsegment_srid} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar in/out (default-stateless catch-all)

+ */ + public static int nsegment_srid(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nsegment_srid requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nsegment_srid(arg0); + } + + /** + * MEOS {@code nsegment_to_geom} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer nsegment_to_geom(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nsegment_to_geom requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nsegment_to_geom(arg0); + } + + /** + * MEOS {@code nsegment_to_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer nsegment_to_stbox(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nsegment_to_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nsegment_to_stbox(arg0); + } + + /** + * MEOS {@code route_exists} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar in/out (default-stateless catch-all)

+ */ + public static boolean route_exists(long arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "route_exists requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.route_exists(arg0); + } + + /** + * MEOS {@code teq_tnpoint_npoint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer teq_tnpoint_npoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "teq_tnpoint_npoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.teq_tnpoint_npoint(arg0, arg1); + } + + /** + * MEOS {@code tne_tnpoint_npoint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tne_tnpoint_npoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tne_tnpoint_npoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tne_tnpoint_npoint(arg0, arg1); + } + + /** + * MEOS {@code union_set_npoint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_set_npoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_set_npoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_set_npoint(arg0, arg1); + } + + /** + * MEOS {@code minus_npoint_set} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_npoint_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_npoint_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_npoint_set(arg0, arg1); + } + + /** + * MEOS {@code minus_set_npoint} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_set_npoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_set_npoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_set_npoint(arg0, arg1); + } + + /** + * MEOS {@code nad_tnpoint_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static double nad_tnpoint_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nad_tnpoint_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nad_tnpoint_geo(arg0, arg1); + } + + /** + * MEOS {@code nad_tnpoint_npoint} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static double nad_tnpoint_npoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nad_tnpoint_npoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nad_tnpoint_npoint(arg0, arg1); + } + + /** + * MEOS {@code nad_tnpoint_stbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static double nad_tnpoint_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nad_tnpoint_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nad_tnpoint_stbox(arg0, arg1); + } + + /** + * MEOS {@code nai_tnpoint_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static jnr.ffi.Pointer nai_tnpoint_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nai_tnpoint_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nai_tnpoint_geo(arg0, arg1); + } + + /** + * MEOS {@code nai_tnpoint_npoint} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static jnr.ffi.Pointer nai_tnpoint_npoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nai_tnpoint_npoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nai_tnpoint_npoint(arg0, arg1); + } + + /** + * MEOS {@code shortestline_tnpoint_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static jnr.ffi.Pointer shortestline_tnpoint_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "shortestline_tnpoint_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.shortestline_tnpoint_geo(arg0, arg1); + } + + /** + * MEOS {@code shortestline_tnpoint_npoint} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static jnr.ffi.Pointer shortestline_tnpoint_npoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "shortestline_tnpoint_npoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.shortestline_tnpoint_npoint(arg0, arg1); + } + + /** + * MEOS {@code tdistance_tnpoint_npoint} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static jnr.ffi.Pointer tdistance_tnpoint_npoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tdistance_tnpoint_npoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tdistance_tnpoint_npoint(arg0, arg1); + } + + /** + * MEOS {@code tdistance_tnpoint_point} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static jnr.ffi.Pointer tdistance_tnpoint_point(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tdistance_tnpoint_point requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tdistance_tnpoint_point(arg0, arg1); + } + + /** + * MEOS {@code always_eq_npoint_tnpoint} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_eq_npoint_tnpoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_eq_npoint_tnpoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_eq_npoint_tnpoint(arg0, arg1); + } + + /** + * MEOS {@code always_eq_tnpoint_npoint} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_eq_tnpoint_npoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_eq_tnpoint_npoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_eq_tnpoint_npoint(arg0, arg1); + } + + /** + * MEOS {@code always_ne_npoint_tnpoint} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_ne_npoint_tnpoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ne_npoint_tnpoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ne_npoint_tnpoint(arg0, arg1); + } + + /** + * MEOS {@code always_ne_tnpoint_npoint} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_ne_tnpoint_npoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ne_tnpoint_npoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ne_tnpoint_npoint(arg0, arg1); + } + + /** + * MEOS {@code ever_eq_npoint_tnpoint} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_eq_npoint_tnpoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_eq_npoint_tnpoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_eq_npoint_tnpoint(arg0, arg1); + } + + /** + * MEOS {@code ever_eq_tnpoint_npoint} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_eq_tnpoint_npoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_eq_tnpoint_npoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_eq_tnpoint_npoint(arg0, arg1); + } + + /** + * MEOS {@code ever_ne_npoint_tnpoint} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_ne_npoint_tnpoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ne_npoint_tnpoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ne_npoint_tnpoint(arg0, arg1); + } + + /** + * MEOS {@code ever_ne_tnpoint_npoint} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_ne_tnpoint_npoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ne_tnpoint_npoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ne_tnpoint_npoint(arg0, arg1); + } + + /** + * MEOS {@code route_length} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: sequence-derived metric

+ */ + public static double route_length(long arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "route_length requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.route_length(arg0); + } + + /** + * MEOS {@code always_eq_tnpoint_tnpoint} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always over 2 temporals

+ */ + public static int always_eq_tnpoint_tnpoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_eq_tnpoint_tnpoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_eq_tnpoint_tnpoint(arg0, arg1); + } + + /** + * MEOS {@code always_ne_tnpoint_tnpoint} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always over 2 temporals

+ */ + public static int always_ne_tnpoint_tnpoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ne_tnpoint_tnpoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ne_tnpoint_tnpoint(arg0, arg1); + } + + /** + * MEOS {@code ever_eq_tnpoint_tnpoint} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always over 2 temporals

+ */ + public static int ever_eq_tnpoint_tnpoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_eq_tnpoint_tnpoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_eq_tnpoint_tnpoint(arg0, arg1); + } + + /** + * MEOS {@code ever_ne_tnpoint_tnpoint} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always over 2 temporals

+ */ + public static int ever_ne_tnpoint_tnpoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ne_tnpoint_tnpoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ne_tnpoint_tnpoint(arg0, arg1); + } + + /** + * MEOS {@code nad_tnpoint_tnpoint} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: distance on 2 temporals

+ */ + public static double nad_tnpoint_tnpoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nad_tnpoint_tnpoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nad_tnpoint_tnpoint(arg0, arg1); + } + + /** + * MEOS {@code nai_tnpoint_tnpoint} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: distance on 2 temporals

+ */ + public static jnr.ffi.Pointer nai_tnpoint_tnpoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nai_tnpoint_tnpoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nai_tnpoint_tnpoint(arg0, arg1); + } + + /** + * MEOS {@code shortestline_tnpoint_tnpoint} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: distance on 2 temporals

+ */ + public static jnr.ffi.Pointer shortestline_tnpoint_tnpoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "shortestline_tnpoint_tnpoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.shortestline_tnpoint_tnpoint(arg0, arg1); + } + + /** + * MEOS {@code tdistance_tnpoint_tnpoint} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: distance on 2 temporals

+ */ + public static jnr.ffi.Pointer tdistance_tnpoint_tnpoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tdistance_tnpoint_tnpoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tdistance_tnpoint_tnpoint(arg0, arg1); + } + + /** + * MEOS {@code npoint_as_ewkt} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static java.lang.String npoint_as_ewkt(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npoint_as_ewkt requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npoint_as_ewkt(arg0, arg1); + } + + /** + * MEOS {@code npoint_as_hexwkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static java.lang.String npoint_as_hexwkb(jnr.ffi.Pointer arg0, byte arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npoint_as_hexwkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npoint_as_hexwkb(arg0, arg1); + } + + /** + * MEOS {@code npoint_as_text} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static java.lang.String npoint_as_text(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npoint_as_text requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npoint_as_text(arg0, arg1); + } + + /** + * MEOS {@code npoint_as_wkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static jnr.ffi.Pointer npoint_as_wkb(jnr.ffi.Pointer arg0, byte arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npoint_as_wkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npoint_as_wkb(arg0, arg1); + } + + /** + * MEOS {@code npoint_from_hexwkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static jnr.ffi.Pointer npoint_from_hexwkb(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npoint_from_hexwkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npoint_from_hexwkb(arg0); + } + + /** + * MEOS {@code npoint_from_wkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static jnr.ffi.Pointer npoint_from_wkb(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npoint_from_wkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npoint_from_wkb(arg0, arg1); + } + + /** + * MEOS {@code npoint_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static jnr.ffi.Pointer npoint_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npoint_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npoint_in(arg0); + } + + /** + * MEOS {@code npoint_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static java.lang.String npoint_out(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npoint_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npoint_out(arg0, arg1); + } + + /** + * MEOS {@code nsegment_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static jnr.ffi.Pointer nsegment_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nsegment_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nsegment_in(arg0); + } + + /** + * MEOS {@code nsegment_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static java.lang.String nsegment_out(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nsegment_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nsegment_out(arg0, arg1); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFreePose.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFreePose.java new file mode 100644 index 0000000..1a1c6e2 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFreePose.java @@ -0,0 +1,1008 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_free.py — do not edit by hand. + * Source header: meos_pose.h + * Methods emitted: 76 (stateless=38 · bounded-state=14 · io-meta=8 · cross-stream=8 · windowed=8) + * Scope: MEOS public functions NOT classified into any object-model class + * (free functions, not methods on a class). + * Source: JMEOS PR #19 (functions.GeneratedFunctions) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsFreePose { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsFreePose() { /* utility */ } + + /** + * MEOS {@code contained_pose_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: topology/position rel on 2 scalars (box/span algebra)

+ */ + public static boolean contained_pose_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contained_pose_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contained_pose_set(arg0, arg1); + } + + /** + * MEOS {@code contains_set_pose} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static boolean contains_set_pose(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_set_pose requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_set_pose(arg0, arg1); + } + + /** + * MEOS {@code intersection_set_pose} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer intersection_set_pose(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intersection_set_pose requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intersection_set_pose(arg0, arg1); + } + + /** + * MEOS {@code pose_cmp} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar comparison/hash

+ */ + public static int pose_cmp(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pose_cmp requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pose_cmp(arg0, arg1); + } + + /** + * MEOS {@code pose_copy} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer pose_copy(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pose_copy requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pose_copy(arg0); + } + + /** + * MEOS {@code pose_eq} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar comparison/hash

+ */ + public static boolean pose_eq(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pose_eq requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pose_eq(arg0, arg1); + } + + /** + * MEOS {@code pose_ge} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar comparison/hash

+ */ + public static boolean pose_ge(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pose_ge requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pose_ge(arg0, arg1); + } + + /** + * MEOS {@code pose_gt} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar comparison/hash

+ */ + public static boolean pose_gt(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pose_gt requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pose_gt(arg0, arg1); + } + + /** + * MEOS {@code pose_hash} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar comparison/hash

+ */ + public static int pose_hash(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pose_hash requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pose_hash(arg0); + } + + /** + * MEOS {@code pose_hash_extended} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar comparison/hash

+ */ + public static long pose_hash_extended(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pose_hash_extended requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pose_hash_extended(arg0, arg1); + } + + /** + * MEOS {@code pose_le} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar comparison/hash

+ */ + public static boolean pose_le(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pose_le requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pose_le(arg0, arg1); + } + + /** + * MEOS {@code pose_lt} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar comparison/hash

+ */ + public static boolean pose_lt(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pose_lt requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pose_lt(arg0, arg1); + } + + /** + * MEOS {@code pose_make_2d} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer pose_make_2d(double arg0, double arg1, double arg2, int arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pose_make_2d requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pose_make_2d(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code pose_make_3d} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer pose_make_3d(double arg0, double arg1, double arg2, double arg3, double arg4, double arg5, double arg6, int arg7) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pose_make_3d requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pose_make_3d(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); + } + + /** + * MEOS {@code pose_make_point2d} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer pose_make_point2d(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pose_make_point2d requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pose_make_point2d(arg0, arg1); + } + + /** + * MEOS {@code pose_make_point3d} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer pose_make_point3d(jnr.ffi.Pointer arg0, double arg1, double arg2, double arg3, double arg4) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pose_make_point3d requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pose_make_point3d(arg0, arg1, arg2, arg3, arg4); + } + + /** + * MEOS {@code pose_ne} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: scalar comparison/hash

+ */ + public static boolean pose_ne(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pose_ne requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pose_ne(arg0, arg1); + } + + /** + * MEOS {@code pose_nsame} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static boolean pose_nsame(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pose_nsame requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pose_nsame(arg0, arg1); + } + + /** + * MEOS {@code pose_orientation} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer pose_orientation(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pose_orientation requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pose_orientation(arg0); + } + + /** + * MEOS {@code pose_rotation} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static double pose_rotation(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pose_rotation requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pose_rotation(arg0); + } + + /** + * MEOS {@code pose_round} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: transform/normalize (pure)

+ */ + public static jnr.ffi.Pointer pose_round(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pose_round requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pose_round(arg0, arg1); + } + + /** + * MEOS {@code pose_same} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static boolean pose_same(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pose_same requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pose_same(arg0, arg1); + } + + /** + * MEOS {@code pose_set_srid} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static void pose_set_srid(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pose_set_srid requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + GeneratedFunctions.pose_set_srid(arg0, arg1); + } + + /** + * MEOS {@code pose_srid} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static int pose_srid(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pose_srid requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pose_srid(arg0); + } + + /** + * MEOS {@code pose_timestamptz_to_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer pose_timestamptz_to_stbox(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pose_timestamptz_to_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pose_timestamptz_to_stbox(arg0, arg1); + } + + /** + * MEOS {@code pose_to_point} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer pose_to_point(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pose_to_point requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pose_to_point(arg0); + } + + /** + * MEOS {@code pose_to_set} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer pose_to_set(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pose_to_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pose_to_set(arg0); + } + + /** + * MEOS {@code pose_to_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer pose_to_stbox(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pose_to_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pose_to_stbox(arg0); + } + + /** + * MEOS {@code pose_transform} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer pose_transform(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pose_transform requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pose_transform(arg0, arg1); + } + + /** + * MEOS {@code pose_transform_pipeline} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer pose_transform_pipeline(jnr.ffi.Pointer arg0, java.lang.String arg1, int arg2, boolean arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pose_transform_pipeline requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pose_transform_pipeline(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code pose_tstzspan_to_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: name pattern is _to_

+ */ + public static jnr.ffi.Pointer pose_tstzspan_to_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pose_tstzspan_to_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pose_tstzspan_to_stbox(arg0, arg1); + } + + /** + * MEOS {@code pose_union_transfn} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer pose_union_transfn(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pose_union_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pose_union_transfn(arg0, arg1); + } + + /** + * MEOS {@code posearr_round} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: transform/normalize (pure)

+ */ + public static jnr.ffi.Pointer posearr_round(jnr.ffi.Pointer arg0, int arg1, int arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "posearr_round requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.posearr_round(arg0, arg1, arg2); + } + + /** + * MEOS {@code teq_pose_tpose} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer teq_pose_tpose(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "teq_pose_tpose requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.teq_pose_tpose(arg0, arg1); + } + + /** + * MEOS {@code teq_tpose_pose} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer teq_tpose_pose(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "teq_tpose_pose requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.teq_tpose_pose(arg0, arg1); + } + + /** + * MEOS {@code tne_pose_tpose} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tne_pose_tpose(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tne_pose_tpose requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tne_pose_tpose(arg0, arg1); + } + + /** + * MEOS {@code tne_tpose_pose} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tne_tpose_pose(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tne_tpose_pose requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tne_tpose_pose(arg0, arg1); + } + + /** + * MEOS {@code union_set_pose} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: set/span/box algebra (pure)

+ */ + public static jnr.ffi.Pointer union_set_pose(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_set_pose requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_set_pose(arg0, arg1); + } + + /** + * MEOS {@code distance_pose_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static double distance_pose_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_pose_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_pose_geo(arg0, arg1); + } + + /** + * MEOS {@code distance_pose_pose} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static double distance_pose_pose(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_pose_pose requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_pose_pose(arg0, arg1); + } + + /** + * MEOS {@code distance_pose_stbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static double distance_pose_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_pose_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_pose_stbox(arg0, arg1); + } + + /** + * MEOS {@code minus_pose_set} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_pose_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_pose_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_pose_set(arg0, arg1); + } + + /** + * MEOS {@code minus_set_pose} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: restriction name pattern

+ */ + public static jnr.ffi.Pointer minus_set_pose(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_set_pose requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_set_pose(arg0, arg1); + } + + /** + * MEOS {@code nad_tpose_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static double nad_tpose_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nad_tpose_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nad_tpose_geo(arg0, arg1); + } + + /** + * MEOS {@code nad_tpose_pose} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static double nad_tpose_pose(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nad_tpose_pose requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nad_tpose_pose(arg0, arg1); + } + + /** + * MEOS {@code nad_tpose_stbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static double nad_tpose_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nad_tpose_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nad_tpose_stbox(arg0, arg1); + } + + /** + * MEOS {@code nai_tpose_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static jnr.ffi.Pointer nai_tpose_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nai_tpose_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nai_tpose_geo(arg0, arg1); + } + + /** + * MEOS {@code nai_tpose_pose} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static jnr.ffi.Pointer nai_tpose_pose(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nai_tpose_pose requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nai_tpose_pose(arg0, arg1); + } + + /** + * MEOS {@code shortestline_tpose_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static jnr.ffi.Pointer shortestline_tpose_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "shortestline_tpose_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.shortestline_tpose_geo(arg0, arg1); + } + + /** + * MEOS {@code shortestline_tpose_pose} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static jnr.ffi.Pointer shortestline_tpose_pose(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "shortestline_tpose_pose requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.shortestline_tpose_pose(arg0, arg1); + } + + /** + * MEOS {@code tdistance_tpose_point} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static jnr.ffi.Pointer tdistance_tpose_point(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tdistance_tpose_point requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tdistance_tpose_point(arg0, arg1); + } + + /** + * MEOS {@code tdistance_tpose_pose} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static jnr.ffi.Pointer tdistance_tpose_pose(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tdistance_tpose_pose requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tdistance_tpose_pose(arg0, arg1); + } + + /** + * MEOS {@code always_eq_pose_tpose} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_eq_pose_tpose(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_eq_pose_tpose requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_eq_pose_tpose(arg0, arg1); + } + + /** + * MEOS {@code always_eq_tpose_pose} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_eq_tpose_pose(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_eq_tpose_pose requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_eq_tpose_pose(arg0, arg1); + } + + /** + * MEOS {@code always_ne_pose_tpose} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_ne_pose_tpose(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ne_pose_tpose requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ne_pose_tpose(arg0, arg1); + } + + /** + * MEOS {@code always_ne_tpose_pose} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_ne_tpose_pose(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ne_tpose_pose requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ne_tpose_pose(arg0, arg1); + } + + /** + * MEOS {@code ever_eq_pose_tpose} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_eq_pose_tpose(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_eq_pose_tpose requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_eq_pose_tpose(arg0, arg1); + } + + /** + * MEOS {@code ever_eq_tpose_pose} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_eq_tpose_pose(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_eq_tpose_pose requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_eq_tpose_pose(arg0, arg1); + } + + /** + * MEOS {@code ever_ne_pose_tpose} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_ne_pose_tpose(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ne_pose_tpose requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ne_pose_tpose(arg0, arg1); + } + + /** + * MEOS {@code ever_ne_tpose_pose} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_ne_tpose_pose(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ne_tpose_pose requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ne_tpose_pose(arg0, arg1); + } + + /** + * MEOS {@code always_eq_tpose_tpose} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always over 2 temporals

+ */ + public static int always_eq_tpose_tpose(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_eq_tpose_tpose requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_eq_tpose_tpose(arg0, arg1); + } + + /** + * MEOS {@code always_ne_tpose_tpose} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always over 2 temporals

+ */ + public static int always_ne_tpose_tpose(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ne_tpose_tpose requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ne_tpose_tpose(arg0, arg1); + } + + /** + * MEOS {@code ever_eq_tpose_tpose} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always over 2 temporals

+ */ + public static int ever_eq_tpose_tpose(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_eq_tpose_tpose requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_eq_tpose_tpose(arg0, arg1); + } + + /** + * MEOS {@code ever_ne_tpose_tpose} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always over 2 temporals

+ */ + public static int ever_ne_tpose_tpose(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ne_tpose_tpose requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ne_tpose_tpose(arg0, arg1); + } + + /** + * MEOS {@code nad_tpose_tpose} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: distance on 2 temporals

+ */ + public static double nad_tpose_tpose(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nad_tpose_tpose requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nad_tpose_tpose(arg0, arg1); + } + + /** + * MEOS {@code nai_tpose_tpose} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: distance on 2 temporals

+ */ + public static jnr.ffi.Pointer nai_tpose_tpose(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nai_tpose_tpose requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nai_tpose_tpose(arg0, arg1); + } + + /** + * MEOS {@code shortestline_tpose_tpose} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: distance on 2 temporals

+ */ + public static jnr.ffi.Pointer shortestline_tpose_tpose(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "shortestline_tpose_tpose requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.shortestline_tpose_tpose(arg0, arg1); + } + + /** + * MEOS {@code tdistance_tpose_tpose} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: distance on 2 temporals

+ */ + public static jnr.ffi.Pointer tdistance_tpose_tpose(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tdistance_tpose_tpose requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tdistance_tpose_tpose(arg0, arg1); + } + + /** + * MEOS {@code pose_as_ewkt} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static java.lang.String pose_as_ewkt(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pose_as_ewkt requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pose_as_ewkt(arg0, arg1); + } + + /** + * MEOS {@code pose_as_hexwkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static java.lang.String pose_as_hexwkb(jnr.ffi.Pointer arg0, byte arg1, jnr.ffi.Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pose_as_hexwkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pose_as_hexwkb(arg0, arg1, arg2); + } + + /** + * MEOS {@code pose_as_text} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static java.lang.String pose_as_text(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pose_as_text requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pose_as_text(arg0, arg1); + } + + /** + * MEOS {@code pose_as_wkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static jnr.ffi.Pointer pose_as_wkb(jnr.ffi.Pointer arg0, byte arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pose_as_wkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pose_as_wkb(arg0, arg1); + } + + /** + * MEOS {@code pose_from_hexwkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static jnr.ffi.Pointer pose_from_hexwkb(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pose_from_hexwkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pose_from_hexwkb(arg0); + } + + /** + * MEOS {@code pose_from_wkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static jnr.ffi.Pointer pose_from_wkb(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pose_from_wkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pose_from_wkb(arg0, arg1); + } + + /** + * MEOS {@code pose_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static jnr.ffi.Pointer pose_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pose_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pose_in(arg0); + } + + /** + * MEOS {@code pose_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: IO/serialization

+ */ + public static java.lang.String pose_out(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pose_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pose_out(arg0, arg1); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFreeRgeo.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFreeRgeo.java new file mode 100644 index 0000000..0562738 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFreeRgeo.java @@ -0,0 +1,423 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_free.py — do not edit by hand. + * Source header: meos_rgeo.h + * Methods emitted: 31 (cross-stream=12 · windowed=8 · bounded-state=6 · stateless=5) + * Scope: MEOS public functions NOT classified into any object-model class + * (free functions, not methods on a class). + * Source: JMEOS PR #19 (functions.GeneratedFunctions) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsFreeRgeo { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsFreeRgeo() { /* utility */ } + + /** + * MEOS {@code geo_tpose_to_trgeo} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: base-type fn, default pure

+ */ + public static jnr.ffi.Pointer geo_tpose_to_trgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_tpose_to_trgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_tpose_to_trgeo(arg0, arg1); + } + + /** + * MEOS {@code teq_geo_trgeo} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer teq_geo_trgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "teq_geo_trgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.teq_geo_trgeo(arg0, arg1); + } + + /** + * MEOS {@code teq_trgeo_geo} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer teq_trgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "teq_trgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.teq_trgeo_geo(arg0, arg1); + } + + /** + * MEOS {@code tne_geo_trgeo} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tne_geo_trgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tne_geo_trgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tne_geo_trgeo(arg0, arg1); + } + + /** + * MEOS {@code tne_trgeo_geo} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Free function (not class-classified). Classification rule: temporal comparison (per-instant)

+ */ + public static jnr.ffi.Pointer tne_trgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tne_trgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tne_trgeo_geo(arg0, arg1); + } + + /** + * MEOS {@code nad_stbox_trgeo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static double nad_stbox_trgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nad_stbox_trgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nad_stbox_trgeo(arg0, arg1); + } + + /** + * MEOS {@code nad_trgeo_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static double nad_trgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nad_trgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nad_trgeo_geo(arg0, arg1); + } + + /** + * MEOS {@code nad_trgeo_stbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static double nad_trgeo_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nad_trgeo_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nad_trgeo_stbox(arg0, arg1); + } + + /** + * MEOS {@code nai_trgeo_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static jnr.ffi.Pointer nai_trgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nai_trgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nai_trgeo_geo(arg0, arg1); + } + + /** + * MEOS {@code shortestline_trgeo_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static jnr.ffi.Pointer shortestline_trgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "shortestline_trgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.shortestline_trgeo_geo(arg0, arg1); + } + + /** + * MEOS {@code tdistance_trgeo_geo} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Free function (not class-classified). Classification rule: distance op

+ */ + public static jnr.ffi.Pointer tdistance_trgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tdistance_trgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tdistance_trgeo_geo(arg0, arg1); + } + + /** + * MEOS {@code always_eq_geo_trgeo} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_eq_geo_trgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_eq_geo_trgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_eq_geo_trgeo(arg0, arg1); + } + + /** + * MEOS {@code always_eq_trgeo_geo} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_eq_trgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_eq_trgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_eq_trgeo_geo(arg0, arg1); + } + + /** + * MEOS {@code always_ne_geo_trgeo} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_ne_geo_trgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ne_geo_trgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ne_geo_trgeo(arg0, arg1); + } + + /** + * MEOS {@code always_ne_trgeo_geo} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int always_ne_trgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ne_trgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ne_trgeo_geo(arg0, arg1); + } + + /** + * MEOS {@code ever_eq_geo_trgeo} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_eq_geo_trgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_eq_geo_trgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_eq_geo_trgeo(arg0, arg1); + } + + /** + * MEOS {@code ever_eq_trgeo_geo} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_eq_trgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_eq_trgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_eq_trgeo_geo(arg0, arg1); + } + + /** + * MEOS {@code ever_ne_geo_trgeo} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_ne_geo_trgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ne_geo_trgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ne_geo_trgeo(arg0, arg1); + } + + /** + * MEOS {@code ever_ne_trgeo_geo} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Free function (not class-classified). Classification rule: ever/always over 1 temporal

+ */ + public static int ever_ne_trgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ne_trgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ne_trgeo_geo(arg0, arg1); + } + + /** + * MEOS {@code always_eq_trgeo_trgeo} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always over 2 temporals

+ */ + public static int always_eq_trgeo_trgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_eq_trgeo_trgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_eq_trgeo_trgeo(arg0, arg1); + } + + /** + * MEOS {@code always_ne_trgeo_trgeo} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always over 2 temporals

+ */ + public static int always_ne_trgeo_trgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ne_trgeo_trgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ne_trgeo_trgeo(arg0, arg1); + } + + /** + * MEOS {@code ever_eq_trgeo_trgeo} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always over 2 temporals

+ */ + public static int ever_eq_trgeo_trgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_eq_trgeo_trgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_eq_trgeo_trgeo(arg0, arg1); + } + + /** + * MEOS {@code ever_ne_trgeo_trgeo} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: ever/always over 2 temporals

+ */ + public static int ever_ne_trgeo_trgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ne_trgeo_trgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ne_trgeo_trgeo(arg0, arg1); + } + + /** + * MEOS {@code nad_trgeo_tpoint} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: distance on 2 temporals

+ */ + public static double nad_trgeo_tpoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nad_trgeo_tpoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nad_trgeo_tpoint(arg0, arg1); + } + + /** + * MEOS {@code nad_trgeo_trgeo} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: distance on 2 temporals

+ */ + public static double nad_trgeo_trgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nad_trgeo_trgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nad_trgeo_trgeo(arg0, arg1); + } + + /** + * MEOS {@code nai_trgeo_tpoint} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: distance on 2 temporals

+ */ + public static jnr.ffi.Pointer nai_trgeo_tpoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nai_trgeo_tpoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nai_trgeo_tpoint(arg0, arg1); + } + + /** + * MEOS {@code nai_trgeo_trgeo} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: distance on 2 temporals

+ */ + public static jnr.ffi.Pointer nai_trgeo_trgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nai_trgeo_trgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nai_trgeo_trgeo(arg0, arg1); + } + + /** + * MEOS {@code shortestline_trgeo_tpoint} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: distance on 2 temporals

+ */ + public static jnr.ffi.Pointer shortestline_trgeo_tpoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "shortestline_trgeo_tpoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.shortestline_trgeo_tpoint(arg0, arg1); + } + + /** + * MEOS {@code shortestline_trgeo_trgeo} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: distance on 2 temporals

+ */ + public static jnr.ffi.Pointer shortestline_trgeo_trgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "shortestline_trgeo_trgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.shortestline_trgeo_trgeo(arg0, arg1); + } + + /** + * MEOS {@code tdistance_trgeo_tpoint} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: distance on 2 temporals

+ */ + public static jnr.ffi.Pointer tdistance_trgeo_tpoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tdistance_trgeo_tpoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tdistance_trgeo_tpoint(arg0, arg1); + } + + /** + * MEOS {@code tdistance_trgeo_trgeo} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Free function (not class-classified). Classification rule: distance on 2 temporals

+ */ + public static jnr.ffi.Pointer tdistance_trgeo_trgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tdistance_trgeo_trgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tdistance_trgeo_trgeo(arg0, arg1); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsGeogSet.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsGeogSet.java new file mode 100644 index 0000000..e9558d1 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsGeogSet.java @@ -0,0 +1,32 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: GeogSet + * Methods emitted: 1 (io-meta=1) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsGeogSet { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsGeogSet() { /* utility */ } + + /** + * MEOS {@code geogset_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer geogset_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geogset_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geogset_in(arg0); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsGeomSet.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsGeomSet.java new file mode 100644 index 0000000..c53bee9 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsGeomSet.java @@ -0,0 +1,102 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: GeomSet + * Methods emitted: 6 (bounded-state=4 · io-meta=1 · stateless=1) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsGeomSet { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsGeomSet() { /* utility */ } + + /** + * MEOS {@code geoset_make} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code constructor}.

+ *

Classification: constructor of instant/scalar

+ */ + public static jnr.ffi.Pointer geoset_make(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geoset_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geoset_make(arg0, arg1); + } + + /** + * MEOS {@code geoset_end_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer geoset_end_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geoset_end_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geoset_end_value(arg0); + } + + /** + * MEOS {@code geoset_start_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer geoset_start_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geoset_start_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geoset_start_value(arg0); + } + + /** + * MEOS {@code geoset_value_n} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer geoset_value_n(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geoset_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geoset_value_n(arg0, arg1); + } + + /** + * MEOS {@code geoset_values} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer geoset_values(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geoset_values requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geoset_values(arg0); + } + + /** + * MEOS {@code geomset_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer geomset_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geomset_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geomset_in(arg0); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsIntSet.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsIntSet.java new file mode 100644 index 0000000..67fc71f --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsIntSet.java @@ -0,0 +1,144 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: IntSet + * Methods emitted: 9 (bounded-state=5 · io-meta=2 · stateless=2) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsIntSet { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsIntSet() { /* utility */ } + + /** + * MEOS {@code intset_make} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code constructor}.

+ *

Classification: constructor of instant/scalar

+ */ + public static jnr.ffi.Pointer intset_make(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intset_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intset_make(arg0, arg1); + } + + /** + * MEOS {@code intset_to_floatset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer intset_to_floatset(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intset_to_floatset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intset_to_floatset(arg0); + } + + /** + * MEOS {@code intset_end_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static int intset_end_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intset_end_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intset_end_value(arg0); + } + + /** + * MEOS {@code intset_shift_scale} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer intset_shift_scale(jnr.ffi.Pointer arg0, int arg1, int arg2, boolean arg3, boolean arg4) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intset_shift_scale requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intset_shift_scale(arg0, arg1, arg2, arg3, arg4); + } + + /** + * MEOS {@code intset_start_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static int intset_start_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intset_start_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intset_start_value(arg0); + } + + /** + * MEOS {@code intset_value_n} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer intset_value_n(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intset_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intset_value_n(arg0, arg1); + } + + /** + * MEOS {@code intset_values} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer intset_values(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intset_values requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intset_values(arg0); + } + + /** + * MEOS {@code intset_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer intset_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intset_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intset_in(arg0); + } + + /** + * MEOS {@code intset_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static java.lang.String intset_out(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intset_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intset_out(arg0); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsIntSpan.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsIntSpan.java new file mode 100644 index 0000000..890e311 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsIntSpan.java @@ -0,0 +1,158 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: IntSpan + * Methods emitted: 10 (bounded-state=6 · io-meta=2 · stateless=2) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsIntSpan { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsIntSpan() { /* utility */ } + + /** + * MEOS {@code intspan_make} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code constructor}.

+ *

Classification: constructor of instant/scalar

+ */ + public static jnr.ffi.Pointer intspan_make(int arg0, int arg1, boolean arg2, boolean arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intspan_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intspan_make(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code intspan_to_floatspan} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer intspan_to_floatspan(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intspan_to_floatspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intspan_to_floatspan(arg0); + } + + /** + * MEOS {@code intspan_bins} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer intspan_bins(jnr.ffi.Pointer arg0, int arg1, int arg2, jnr.ffi.Pointer arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intspan_bins requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intspan_bins(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code intspan_expand} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer intspan_expand(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intspan_expand requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intspan_expand(arg0, arg1); + } + + /** + * MEOS {@code intspan_lower} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static int intspan_lower(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intspan_lower requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intspan_lower(arg0); + } + + /** + * MEOS {@code intspan_shift_scale} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer intspan_shift_scale(jnr.ffi.Pointer arg0, int arg1, int arg2, boolean arg3, boolean arg4) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intspan_shift_scale requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intspan_shift_scale(arg0, arg1, arg2, arg3, arg4); + } + + /** + * MEOS {@code intspan_upper} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static int intspan_upper(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intspan_upper requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intspan_upper(arg0); + } + + /** + * MEOS {@code intspan_width} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static int intspan_width(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intspan_width requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intspan_width(arg0); + } + + /** + * MEOS {@code intspan_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer intspan_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intspan_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intspan_in(arg0); + } + + /** + * MEOS {@code intspan_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static java.lang.String intspan_out(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intspan_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intspan_out(arg0); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsIntSpanSet.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsIntSpanSet.java new file mode 100644 index 0000000..6e98092 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsIntSpanSet.java @@ -0,0 +1,130 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: IntSpanSet + * Methods emitted: 8 (bounded-state=5 · io-meta=2 · stateless=1) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsIntSpanSet { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsIntSpanSet() { /* utility */ } + + /** + * MEOS {@code intspanset_to_floatspanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer intspanset_to_floatspanset(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intspanset_to_floatspanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intspanset_to_floatspanset(arg0); + } + + /** + * MEOS {@code intspanset_bins} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer intspanset_bins(jnr.ffi.Pointer arg0, int arg1, int arg2, jnr.ffi.Pointer arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intspanset_bins requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intspanset_bins(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code intspanset_lower} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static int intspanset_lower(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intspanset_lower requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intspanset_lower(arg0); + } + + /** + * MEOS {@code intspanset_shift_scale} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer intspanset_shift_scale(jnr.ffi.Pointer arg0, int arg1, int arg2, boolean arg3, boolean arg4) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intspanset_shift_scale requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intspanset_shift_scale(arg0, arg1, arg2, arg3, arg4); + } + + /** + * MEOS {@code intspanset_upper} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static int intspanset_upper(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intspanset_upper requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intspanset_upper(arg0); + } + + /** + * MEOS {@code intspanset_width} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static int intspanset_width(jnr.ffi.Pointer arg0, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intspanset_width requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intspanset_width(arg0, arg1); + } + + /** + * MEOS {@code intspanset_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer intspanset_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intspanset_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intspanset_in(arg0); + } + + /** + * MEOS {@code intspanset_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static java.lang.String intspanset_out(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intspanset_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intspanset_out(arg0); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsNpointSet.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsNpointSet.java new file mode 100644 index 0000000..8ee8056 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsNpointSet.java @@ -0,0 +1,130 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: NpointSet + * Methods emitted: 8 (bounded-state=5 · io-meta=2 · stateless=1) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsNpointSet { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsNpointSet() { /* utility */ } + + /** + * MEOS {@code npointset_make} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code constructor}.

+ *

Classification: constructor of instant/scalar

+ */ + public static jnr.ffi.Pointer npointset_make(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npointset_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npointset_make(arg0, arg1); + } + + /** + * MEOS {@code npointset_end_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer npointset_end_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npointset_end_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npointset_end_value(arg0); + } + + /** + * MEOS {@code npointset_routes} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer npointset_routes(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npointset_routes requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npointset_routes(arg0); + } + + /** + * MEOS {@code npointset_start_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer npointset_start_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npointset_start_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npointset_start_value(arg0); + } + + /** + * MEOS {@code npointset_value_n} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer npointset_value_n(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npointset_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npointset_value_n(arg0, arg1); + } + + /** + * MEOS {@code npointset_values} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer npointset_values(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npointset_values requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npointset_values(arg0); + } + + /** + * MEOS {@code npointset_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer npointset_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npointset_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npointset_in(arg0); + } + + /** + * MEOS {@code npointset_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static java.lang.String npointset_out(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npointset_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npointset_out(arg0, arg1); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsParityGaps.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsParityGaps.java new file mode 100644 index 0000000..4874336 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsParityGaps.java @@ -0,0 +1,531 @@ +package org.mobilitydb.flink.meos; + +/** + * Forwarding facade methods for MEOS public-surface functions not emitted + * by the tier-aware code generator. Each method delegates to its JMEOS + * {@code functions.GeneratedFunctions} export under the shared + * {@link MeosOpsRuntime#MEOS_AVAILABLE} guard. + */ +public final class MeosOpsParityGaps { + + private MeosOpsParityGaps() { /* utility */ } + + /** MEOS {@code acovers_geo_tgeo} — meos_geo.h · scalar / stateless. */ + public static int acovers_geo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("acovers_geo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.acovers_geo_tgeo(arg0, arg1); + } + + /** MEOS {@code acovers_tcbuffer_tcbuffer} — meos_cbuffer.h · scalar / stateless. */ + public static int acovers_tcbuffer_tcbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("acovers_tcbuffer_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.acovers_tcbuffer_tcbuffer(arg0, arg1); + } + + /** MEOS {@code acovers_tgeo_geo} — meos_geo.h · scalar / stateless. */ + public static int acovers_tgeo_geo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("acovers_tgeo_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.acovers_tgeo_geo(arg0, arg1); + } + + /** MEOS {@code bearing_tpoint_point} — meos_geo.h · scalar / stateless. */ + public static jnr.ffi.Pointer bearing_tpoint_point(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("bearing_tpoint_point requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.bearing_tpoint_point(arg0, arg1, arg2); + } + + /** MEOS {@code bearing_tpoint_tpoint} — meos_geo.h · scalar / stateless. */ + public static jnr.ffi.Pointer bearing_tpoint_tpoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("bearing_tpoint_tpoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.bearing_tpoint_tpoint(arg0, arg1); + } + + /** MEOS {@code bigintspan_to_floatspan} — meos.h · scalar / stateless. */ + public static jnr.ffi.Pointer bigintspan_to_floatspan(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("bigintspan_to_floatspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.bigintspan_to_floatspan(arg0); + } + + /** MEOS {@code bigintspan_to_intspan} — meos.h · scalar / stateless. */ + public static jnr.ffi.Pointer bigintspan_to_intspan(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("bigintspan_to_intspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.bigintspan_to_intspan(arg0); + } + + /** MEOS {@code floatspan_to_bigintspan} — meos.h · scalar / stateless. */ + public static jnr.ffi.Pointer floatspan_to_bigintspan(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("floatspan_to_bigintspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.floatspan_to_bigintspan(arg0); + } + + /** MEOS {@code geogpoint_make2d} — meos_geo.h · scalar / stateless. */ + public static jnr.ffi.Pointer geogpoint_make2d(int arg0, double arg1, double arg2) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("geogpoint_make2d requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.geogpoint_make2d(arg0, arg1, arg2); + } + + /** MEOS {@code geogpoint_make3dz} — meos_geo.h · scalar / stateless. */ + public static jnr.ffi.Pointer geogpoint_make3dz(int arg0, double arg1, double arg2, double arg3) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("geogpoint_make3dz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.geogpoint_make3dz(arg0, arg1, arg2, arg3); + } + + /** MEOS {@code geomeas_to_tpoint} — meos_geo.h · scalar / stateless. */ + public static jnr.ffi.Pointer geomeas_to_tpoint(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("geomeas_to_tpoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.geomeas_to_tpoint(arg0); + } + + /** MEOS {@code geompoint_make2d} — meos_geo.h · scalar / stateless. */ + public static jnr.ffi.Pointer geompoint_make2d(int arg0, double arg1, double arg2) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("geompoint_make2d requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.geompoint_make2d(arg0, arg1, arg2); + } + + /** MEOS {@code geompoint_make3dz} — meos_geo.h · scalar / stateless. */ + public static jnr.ffi.Pointer geompoint_make3dz(int arg0, double arg1, double arg2, double arg3) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("geompoint_make3dz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.geompoint_make3dz(arg0, arg1, arg2, arg3); + } + + /** MEOS {@code geompoint_to_npoint} — meos_npoint.h · scalar / stateless. */ + public static jnr.ffi.Pointer geompoint_to_npoint(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("geompoint_to_npoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.geompoint_to_npoint(arg0); + } + + /** MEOS {@code intersection_cbuffer_set} — meos_cbuffer.h · scalar / stateless. */ + public static jnr.ffi.Pointer intersection_cbuffer_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("intersection_cbuffer_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.intersection_cbuffer_set(arg0, arg1); + } + + /** MEOS {@code intersection_npoint_set} — meos_npoint.h · scalar / stateless. */ + public static jnr.ffi.Pointer intersection_npoint_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("intersection_npoint_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.intersection_npoint_set(arg0, arg1); + } + + /** MEOS {@code intersection_pose_set} — meos_pose.h · scalar / stateless. */ + public static jnr.ffi.Pointer intersection_pose_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("intersection_pose_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.intersection_pose_set(arg0, arg1); + } + + /** MEOS {@code intspan_to_bigintspan} — meos.h · scalar / stateless. */ + public static jnr.ffi.Pointer intspan_to_bigintspan(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("intspan_to_bigintspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.intspan_to_bigintspan(arg0); + } + + /** MEOS {@code line_interpolate_point} — meos_geo.h · scalar / stateless. */ + public static jnr.ffi.Pointer line_interpolate_point(jnr.ffi.Pointer arg0, double arg1, boolean arg2) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("line_interpolate_point requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.line_interpolate_point(arg0, arg1, arg2); + } + + /** MEOS {@code line_locate_point} — meos_geo.h · scalar / stateless. */ + public static double line_locate_point(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("line_locate_point requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.line_locate_point(arg0, arg1); + } + + /** MEOS {@code line_point_n} — meos_geo.h · scalar / stateless. */ + public static jnr.ffi.Pointer line_point_n(jnr.ffi.Pointer arg0, int arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("line_point_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.line_point_n(arg0, arg1); + } + + /** MEOS {@code line_substring} — meos_geo.h · scalar / stateless. */ + public static jnr.ffi.Pointer line_substring(jnr.ffi.Pointer arg0, double arg1, double arg2) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("line_substring requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.line_substring(arg0, arg1, arg2); + } + + /** MEOS {@code meos_initialize_noexit_error_handler} — meos.h · scalar / stateless. */ + public static void meos_initialize_noexit_error_handler() { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("meos_initialize_noexit_error_handler requires libmeos — set -Dmobilityflink.meos.enabled=true"); + functions.GeneratedFunctions.meos_initialize_noexit_error_handler(); + } + + /** MEOS {@code mindistance_tgeo_tgeo} — meos_geo.h · scalar / stateless. */ + public static double mindistance_tgeo_tgeo(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, double arg2) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("mindistance_tgeo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.mindistance_tgeo_tgeo(arg0, arg1, arg2); + } + + /** MEOS {@code mul_float_tfloat} — meos.h · scalar / stateless. */ + public static jnr.ffi.Pointer mul_float_tfloat(double arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("mul_float_tfloat requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.mul_float_tfloat(arg0, arg1); + } + + /** MEOS {@code mul_int_tint} — meos.h · scalar / stateless. */ + public static jnr.ffi.Pointer mul_int_tint(int arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("mul_int_tint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.mul_int_tint(arg0, arg1); + } + + /** MEOS {@code mul_tfloat_float} — meos.h · scalar / stateless. */ + public static jnr.ffi.Pointer mul_tfloat_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("mul_tfloat_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.mul_tfloat_float(arg0, arg1); + } + + /** MEOS {@code mul_tint_int} — meos.h · scalar / stateless. */ + public static jnr.ffi.Pointer mul_tint_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("mul_tint_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.mul_tint_int(arg0, arg1); + } + + /** MEOS {@code mul_tnumber_tnumber} — meos.h · scalar / stateless. */ + public static jnr.ffi.Pointer mul_tnumber_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("mul_tnumber_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.mul_tnumber_tnumber(arg0, arg1); + } + + /** MEOS {@code nsegment_end_position} — meos_npoint.h · scalar / stateless. */ + public static double nsegment_end_position(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("nsegment_end_position requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.nsegment_end_position(arg0); + } + + /** MEOS {@code nsegment_start_position} — meos_npoint.h · scalar / stateless. */ + public static double nsegment_start_position(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("nsegment_start_position requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.nsegment_start_position(arg0); + } + + /** MEOS {@code route_geom} — meos_npoint.h · scalar / stateless. */ + public static jnr.ffi.Pointer route_geom(long arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("route_geom requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.route_geom(arg0); + } + + /** MEOS {@code spatialset_set_srid} — meos_geo.h · scalar / stateless. */ + public static jnr.ffi.Pointer spatialset_set_srid(jnr.ffi.Pointer arg0, int arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("spatialset_set_srid requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.spatialset_set_srid(arg0, arg1); + } + + /** MEOS {@code spatialset_transform} — meos_geo.h · scalar / stateless. */ + public static jnr.ffi.Pointer spatialset_transform(jnr.ffi.Pointer arg0, int arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("spatialset_transform requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.spatialset_transform(arg0, arg1); + } + + /** MEOS {@code spatialset_transform_pipeline} — meos_geo.h · scalar / stateless. */ + public static jnr.ffi.Pointer spatialset_transform_pipeline(jnr.ffi.Pointer arg0, java.lang.String arg1, int arg2, boolean arg3) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("spatialset_transform_pipeline requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.spatialset_transform_pipeline(arg0, arg1, arg2, arg3); + } + + /** MEOS {@code tand_bool_tbool} — meos.h · scalar / stateless. */ + public static jnr.ffi.Pointer tand_bool_tbool(boolean arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tand_bool_tbool requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tand_bool_tbool(arg0, arg1); + } + + /** MEOS {@code tand_tbool_bool} — meos.h · scalar / stateless. */ + public static jnr.ffi.Pointer tand_tbool_bool(jnr.ffi.Pointer arg0, boolean arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tand_tbool_bool requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tand_tbool_bool(arg0, arg1); + } + + /** MEOS {@code tand_tbool_tbool} — meos.h · scalar / stateless. */ + public static jnr.ffi.Pointer tand_tbool_tbool(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tand_tbool_tbool requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tand_tbool_tbool(arg0, arg1); + } + + /** MEOS {@code tboolseq_from_base_tstzset} — meos.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer tboolseq_from_base_tstzset(boolean arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tboolseq_from_base_tstzset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tboolseq_from_base_tstzset(arg0, arg1); + } + + /** MEOS {@code tboolseq_from_base_tstzspan} — meos.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer tboolseq_from_base_tstzspan(boolean arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tboolseq_from_base_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tboolseq_from_base_tstzspan(arg0, arg1); + } + + /** MEOS {@code tboolseqset_from_base_tstzspanset} — meos.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer tboolseqset_from_base_tstzspanset(boolean arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tboolseqset_from_base_tstzspanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tboolseqset_from_base_tstzspanset(arg0, arg1); + } + + /** MEOS {@code tbox_to_bigintspan} — meos.h · scalar / stateless. */ + public static jnr.ffi.Pointer tbox_to_bigintspan(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tbox_to_bigintspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tbox_to_bigintspan(arg0); + } + + /** MEOS {@code tfloatbox_time_tiles} — meos.h · multidimensional tiling (windowed). */ + public static jnr.ffi.Pointer tfloatbox_time_tiles(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, java.time.OffsetDateTime arg2, jnr.ffi.Pointer arg3) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tfloatbox_time_tiles requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tfloatbox_time_tiles(arg0, arg1, arg2, arg3); + } + + /** MEOS {@code tfloatbox_value_tiles} — meos.h · multidimensional tiling (windowed). */ + public static jnr.ffi.Pointer tfloatbox_value_tiles(jnr.ffi.Pointer arg0, double arg1, double arg2, jnr.ffi.Pointer arg3) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tfloatbox_value_tiles requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tfloatbox_value_tiles(arg0, arg1, arg2, arg3); + } + + /** MEOS {@code tfloatbox_value_time_tiles} — meos.h · multidimensional tiling (windowed). */ + public static jnr.ffi.Pointer tfloatbox_value_time_tiles(jnr.ffi.Pointer arg0, double arg1, jnr.ffi.Pointer arg2, double arg3, java.time.OffsetDateTime arg4, jnr.ffi.Pointer arg5) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tfloatbox_value_time_tiles requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tfloatbox_value_time_tiles(arg0, arg1, arg2, arg3, arg4, arg5); + } + + /** MEOS {@code tfloatseq_from_base_tstzset} — meos.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer tfloatseq_from_base_tstzset(double arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tfloatseq_from_base_tstzset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tfloatseq_from_base_tstzset(arg0, arg1); + } + + /** MEOS {@code tfloatseq_from_base_tstzspan} — meos.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer tfloatseq_from_base_tstzspan(double arg0, jnr.ffi.Pointer arg1, int arg2) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tfloatseq_from_base_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tfloatseq_from_base_tstzspan(arg0, arg1, arg2); + } + + /** MEOS {@code tfloatseqset_from_base_tstzspanset} — meos.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer tfloatseqset_from_base_tstzspanset(double arg0, jnr.ffi.Pointer arg1, int arg2) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tfloatseqset_from_base_tstzspanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tfloatseqset_from_base_tstzspanset(arg0, arg1, arg2); + } + + /** MEOS {@code tgeoarr_tgeoarr_mindist} — meos_geo.h · scalar / stateless. */ + public static double tgeoarr_tgeoarr_mindist(jnr.ffi.Pointer arg0, int arg1, jnr.ffi.Pointer arg2, int arg3) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tgeoarr_tgeoarr_mindist requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tgeoarr_tgeoarr_mindist(arg0, arg1, arg2, arg3); + } + + /** MEOS {@code tgeoseq_from_base_tstzset} — meos_geo.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer tgeoseq_from_base_tstzset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tgeoseq_from_base_tstzset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tgeoseq_from_base_tstzset(arg0, arg1); + } + + /** MEOS {@code tgeoseq_from_base_tstzspan} — meos_geo.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer tgeoseq_from_base_tstzspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, int arg2) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tgeoseq_from_base_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tgeoseq_from_base_tstzspan(arg0, arg1, arg2); + } + + /** MEOS {@code tgeoseqset_from_base_tstzspanset} — meos_geo.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer tgeoseqset_from_base_tstzspanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, int arg2) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tgeoseqset_from_base_tstzspanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tgeoseqset_from_base_tstzspanset(arg0, arg1, arg2); + } + + /** MEOS {@code tintbox_time_tiles} — meos.h · multidimensional tiling (windowed). */ + public static jnr.ffi.Pointer tintbox_time_tiles(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, java.time.OffsetDateTime arg2, jnr.ffi.Pointer arg3) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tintbox_time_tiles requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tintbox_time_tiles(arg0, arg1, arg2, arg3); + } + + /** MEOS {@code tintbox_value_tiles} — meos.h · multidimensional tiling (windowed). */ + public static jnr.ffi.Pointer tintbox_value_tiles(jnr.ffi.Pointer arg0, int arg1, int arg2, jnr.ffi.Pointer arg3) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tintbox_value_tiles requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tintbox_value_tiles(arg0, arg1, arg2, arg3); + } + + /** MEOS {@code tintbox_value_time_tiles} — meos.h · multidimensional tiling (windowed). */ + public static jnr.ffi.Pointer tintbox_value_time_tiles(jnr.ffi.Pointer arg0, int arg1, jnr.ffi.Pointer arg2, int arg3, java.time.OffsetDateTime arg4, jnr.ffi.Pointer arg5) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tintbox_value_time_tiles requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tintbox_value_time_tiles(arg0, arg1, arg2, arg3, arg4, arg5); + } + + /** MEOS {@code tintseq_from_base_tstzset} — meos.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer tintseq_from_base_tstzset(int arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tintseq_from_base_tstzset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tintseq_from_base_tstzset(arg0, arg1); + } + + /** MEOS {@code tintseq_from_base_tstzspan} — meos.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer tintseq_from_base_tstzspan(int arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tintseq_from_base_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tintseq_from_base_tstzspan(arg0, arg1); + } + + /** MEOS {@code tintseqset_from_base_tstzspanset} — meos.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer tintseqset_from_base_tstzspanset(int arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tintseqset_from_base_tstzspanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tintseqset_from_base_tstzspanset(arg0, arg1); + } + + /** MEOS {@code tnot_tbool} — meos.h · scalar / stateless. */ + public static jnr.ffi.Pointer tnot_tbool(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tnot_tbool requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tnot_tbool(arg0); + } + + /** MEOS {@code tor_bool_tbool} — meos.h · scalar / stateless. */ + public static jnr.ffi.Pointer tor_bool_tbool(boolean arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tor_bool_tbool requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tor_bool_tbool(arg0, arg1); + } + + /** MEOS {@code tor_tbool_bool} — meos.h · scalar / stateless. */ + public static jnr.ffi.Pointer tor_tbool_bool(jnr.ffi.Pointer arg0, boolean arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tor_tbool_bool requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tor_tbool_bool(arg0, arg1); + } + + /** MEOS {@code tor_tbool_tbool} — meos.h · scalar / stateless. */ + public static jnr.ffi.Pointer tor_tbool_tbool(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tor_tbool_tbool requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tor_tbool_tbool(arg0, arg1); + } + + /** MEOS {@code tpointseq_from_base_tstzset} — meos_geo.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer tpointseq_from_base_tstzset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tpointseq_from_base_tstzset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tpointseq_from_base_tstzset(arg0, arg1); + } + + /** MEOS {@code tpointseq_from_base_tstzspan} — meos_geo.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer tpointseq_from_base_tstzspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, int arg2) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tpointseq_from_base_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tpointseq_from_base_tstzspan(arg0, arg1, arg2); + } + + /** MEOS {@code tpointseq_make_coords} — meos_geo.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer tpointseq_make_coords(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, jnr.ffi.Pointer arg2, jnr.ffi.Pointer arg3, int arg4, int arg5, boolean arg6, boolean arg7, boolean arg8, int arg9, boolean arg10) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tpointseq_make_coords requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tpointseq_make_coords(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10); + } + + /** MEOS {@code tpointseqset_from_base_tstzspanset} — meos_geo.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer tpointseqset_from_base_tstzspanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, int arg2) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tpointseqset_from_base_tstzspanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tpointseqset_from_base_tstzspanset(arg0, arg1, arg2); + } + + /** MEOS {@code tsequence_make} — meos.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer tsequence_make(jnr.ffi.Pointer arg0, int arg1, boolean arg2, boolean arg3, int arg4, boolean arg5) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tsequence_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tsequence_make(arg0, arg1, arg2, arg3, arg4, arg5); + } + + /** MEOS {@code tsequenceset_make} — meos.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer tsequenceset_make(jnr.ffi.Pointer arg0, int arg1, boolean arg2) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tsequenceset_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tsequenceset_make(arg0, arg1, arg2); + } + + /** MEOS {@code ttextseq_from_base_tstzset} — meos.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer ttextseq_from_base_tstzset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("ttextseq_from_base_tstzset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.ttextseq_from_base_tstzset(arg0, arg1); + } + + /** MEOS {@code ttextseq_from_base_tstzspan} — meos.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer ttextseq_from_base_tstzspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("ttextseq_from_base_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.ttextseq_from_base_tstzspan(arg0, arg1); + } + + /** MEOS {@code ttextseqset_from_base_tstzspanset} — meos.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer ttextseqset_from_base_tstzspanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("ttextseqset_from_base_tstzspanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.ttextseqset_from_base_tstzspanset(arg0, arg1); + } + + /** MEOS {@code union_cbuffer_set} — meos_cbuffer.h · scalar / stateless. */ + public static jnr.ffi.Pointer union_cbuffer_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("union_cbuffer_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.union_cbuffer_set(arg0, arg1); + } + + /** MEOS {@code union_npoint_set} — meos_npoint.h · scalar / stateless. */ + public static jnr.ffi.Pointer union_npoint_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("union_npoint_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.union_npoint_set(arg0, arg1); + } + + /** MEOS {@code union_pose_set} — meos_pose.h · scalar / stateless. */ + public static jnr.ffi.Pointer union_pose_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("union_pose_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.union_pose_set(arg0, arg1); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsPoseSet.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsPoseSet.java new file mode 100644 index 0000000..8434bcb --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsPoseSet.java @@ -0,0 +1,116 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: PoseSet + * Methods emitted: 7 (bounded-state=4 · io-meta=2 · stateless=1) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsPoseSet { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsPoseSet() { /* utility */ } + + /** + * MEOS {@code poseset_make} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code constructor}.

+ *

Classification: constructor of instant/scalar

+ */ + public static jnr.ffi.Pointer poseset_make(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "poseset_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.poseset_make(arg0, arg1); + } + + /** + * MEOS {@code poseset_end_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer poseset_end_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "poseset_end_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.poseset_end_value(arg0); + } + + /** + * MEOS {@code poseset_start_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer poseset_start_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "poseset_start_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.poseset_start_value(arg0); + } + + /** + * MEOS {@code poseset_value_n} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer poseset_value_n(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "poseset_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.poseset_value_n(arg0, arg1); + } + + /** + * MEOS {@code poseset_values} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer poseset_values(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "poseset_values requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.poseset_values(arg0); + } + + /** + * MEOS {@code poseset_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer poseset_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "poseset_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.poseset_in(arg0); + } + + /** + * MEOS {@code poseset_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static java.lang.String poseset_out(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "poseset_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.poseset_out(arg0, arg1); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsRuntime.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsRuntime.java new file mode 100644 index 0000000..adf7f55 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsRuntime.java @@ -0,0 +1,29 @@ +package org.mobilitydb.flink.meos; + +import functions.GeneratedFunctions; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * Shared runtime helper: owns the single MEOS_AVAILABLE static-init across + * all generated MeosOps* facades, so libmeos is probed exactly once per + * JVM rather than 82 times. */ +final class MeosOpsRuntime { + + static final boolean MEOS_AVAILABLE; + + static { + boolean enabled = Boolean.parseBoolean( + System.getProperty("mobilityflink.meos.enabled", "true")); + boolean ok = false; + if (enabled) { + try { + GeneratedFunctions.meos_initialize(); + ok = true; + } catch (Throwable t) { + ok = false; + } + } + MEOS_AVAILABLE = ok; + } + + private MeosOpsRuntime() { /* utility */ } +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsSTBox.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsSTBox.java new file mode 100644 index 0000000..02dac11 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsSTBox.java @@ -0,0 +1,774 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: STBox + * Methods emitted: 54 (bounded-state=42 · io-meta=6 · stateless=6) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsSTBox { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsSTBox() { /* utility */ } + + /** + * MEOS {@code stbox_copy} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code constructor}.

+ *

Classification: constructor of instant/scalar

+ */ + public static jnr.ffi.Pointer stbox_copy(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_copy requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_copy(arg0); + } + + /** + * MEOS {@code stbox_make} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code constructor}.

+ *

Classification: constructor of instant/scalar

+ */ + public static jnr.ffi.Pointer stbox_make(boolean arg0, boolean arg1, boolean arg2, int arg3, double arg4, double arg5, double arg6, double arg7, double arg8, double arg9, jnr.ffi.Pointer arg10) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_make(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10); + } + + /** + * MEOS {@code stbox_to_box3d} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer stbox_to_box3d(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_to_box3d requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_to_box3d(arg0); + } + + /** + * MEOS {@code stbox_to_gbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer stbox_to_gbox(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_to_gbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_to_gbox(arg0); + } + + /** + * MEOS {@code stbox_to_geo} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer stbox_to_geo(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_to_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_to_geo(arg0); + } + + /** + * MEOS {@code stbox_to_tstzspan} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer stbox_to_tstzspan(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_to_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_to_tstzspan(arg0); + } + + /** + * MEOS {@code stbox_area} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static double stbox_area(jnr.ffi.Pointer arg0, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_area requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_area(arg0, arg1); + } + + /** + * MEOS {@code stbox_cmp} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 1 temporal

+ */ + public static int stbox_cmp(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_cmp requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_cmp(arg0, arg1); + } + + /** + * MEOS {@code stbox_eq} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 1 temporal

+ */ + public static boolean stbox_eq(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_eq requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_eq(arg0, arg1); + } + + /** + * MEOS {@code stbox_expand_space} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer stbox_expand_space(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_expand_space requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_expand_space(arg0, arg1); + } + + /** + * MEOS {@code stbox_expand_time} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer stbox_expand_time(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_expand_time requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_expand_time(arg0, arg1); + } + + /** + * MEOS {@code stbox_ge} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 1 temporal

+ */ + public static boolean stbox_ge(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_ge requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_ge(arg0, arg1); + } + + /** + * MEOS {@code stbox_get_space} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer stbox_get_space(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_get_space requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_get_space(arg0); + } + + /** + * MEOS {@code stbox_get_space_tile} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer stbox_get_space_tile(jnr.ffi.Pointer arg0, double arg1, double arg2, double arg3, jnr.ffi.Pointer arg4) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_get_space_tile requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_get_space_tile(arg0, arg1, arg2, arg3, arg4); + } + + /** + * MEOS {@code stbox_get_space_time_tile} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer stbox_get_space_time_tile(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1, double arg2, double arg3, double arg4, jnr.ffi.Pointer arg5, jnr.ffi.Pointer arg6, java.time.OffsetDateTime arg7) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_get_space_time_tile requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_get_space_time_tile(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); + } + + /** + * MEOS {@code stbox_get_time_tile} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer stbox_get_time_tile(java.time.OffsetDateTime arg0, jnr.ffi.Pointer arg1, java.time.OffsetDateTime arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_get_time_tile requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_get_time_tile(arg0, arg1, arg2); + } + + /** + * MEOS {@code stbox_gt} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 1 temporal

+ */ + public static boolean stbox_gt(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_gt requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_gt(arg0, arg1); + } + + /** + * MEOS {@code stbox_hash} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static int stbox_hash(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_hash requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_hash(arg0); + } + + /** + * MEOS {@code stbox_hash_extended} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static long stbox_hash_extended(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_hash_extended requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_hash_extended(arg0, arg1); + } + + /** + * MEOS {@code stbox_hast} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static boolean stbox_hast(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_hast requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_hast(arg0); + } + + /** + * MEOS {@code stbox_hasx} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static boolean stbox_hasx(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_hasx requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_hasx(arg0); + } + + /** + * MEOS {@code stbox_hasz} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static boolean stbox_hasz(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_hasz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_hasz(arg0); + } + + /** + * MEOS {@code stbox_isgeodetic} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static boolean stbox_isgeodetic(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_isgeodetic requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_isgeodetic(arg0); + } + + /** + * MEOS {@code stbox_le} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 1 temporal

+ */ + public static boolean stbox_le(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_le requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_le(arg0, arg1); + } + + /** + * MEOS {@code stbox_lt} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 1 temporal

+ */ + public static boolean stbox_lt(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_lt requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_lt(arg0, arg1); + } + + /** + * MEOS {@code stbox_ne} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 1 temporal

+ */ + public static boolean stbox_ne(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_ne requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_ne(arg0, arg1); + } + + /** + * MEOS {@code stbox_perimeter} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static double stbox_perimeter(jnr.ffi.Pointer arg0, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_perimeter requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_perimeter(arg0, arg1); + } + + /** + * MEOS {@code stbox_quad_split} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer stbox_quad_split(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_quad_split requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_quad_split(arg0, arg1); + } + + /** + * MEOS {@code stbox_round} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer stbox_round(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_round requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_round(arg0, arg1); + } + + /** + * MEOS {@code stbox_set_srid} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer stbox_set_srid(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_set_srid requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_set_srid(arg0, arg1); + } + + /** + * MEOS {@code stbox_shift_scale_time} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer stbox_shift_scale_time(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, jnr.ffi.Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_shift_scale_time requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_shift_scale_time(arg0, arg1, arg2); + } + + /** + * MEOS {@code stbox_space_tiles} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer stbox_space_tiles(jnr.ffi.Pointer arg0, double arg1, double arg2, double arg3, jnr.ffi.Pointer arg4, boolean arg5, jnr.ffi.Pointer arg6) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_space_tiles requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_space_tiles(arg0, arg1, arg2, arg3, arg4, arg5, arg6); + } + + /** + * MEOS {@code stbox_space_time_tiles} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer stbox_space_time_tiles(jnr.ffi.Pointer arg0, double arg1, double arg2, double arg3, jnr.ffi.Pointer arg4, jnr.ffi.Pointer arg5, java.time.OffsetDateTime arg6, boolean arg7, jnr.ffi.Pointer arg8) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_space_time_tiles requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_space_time_tiles(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); + } + + /** + * MEOS {@code stbox_srid} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static int stbox_srid(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_srid requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_srid(arg0); + } + + /** + * MEOS {@code stbox_time_tiles} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer stbox_time_tiles(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, java.time.OffsetDateTime arg2, boolean arg3, jnr.ffi.Pointer arg4) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_time_tiles requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_time_tiles(arg0, arg1, arg2, arg3, arg4); + } + + /** + * MEOS {@code stbox_tmax} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer stbox_tmax(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_tmax requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_tmax(arg0); + } + + /** + * MEOS {@code stbox_tmax_inc} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer stbox_tmax_inc(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_tmax_inc requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_tmax_inc(arg0); + } + + /** + * MEOS {@code stbox_tmin} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer stbox_tmin(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_tmin requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_tmin(arg0); + } + + /** + * MEOS {@code stbox_tmin_inc} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer stbox_tmin_inc(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_tmin_inc requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_tmin_inc(arg0); + } + + /** + * MEOS {@code stbox_transform} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer stbox_transform(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_transform requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_transform(arg0, arg1); + } + + /** + * MEOS {@code stbox_transform_pipeline} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer stbox_transform_pipeline(jnr.ffi.Pointer arg0, java.lang.String arg1, int arg2, boolean arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_transform_pipeline requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_transform_pipeline(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code stbox_volume} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static double stbox_volume(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_volume requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_volume(arg0); + } + + /** + * MEOS {@code stbox_xmax} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer stbox_xmax(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_xmax requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_xmax(arg0); + } + + /** + * MEOS {@code stbox_xmin} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer stbox_xmin(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_xmin requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_xmin(arg0); + } + + /** + * MEOS {@code stbox_ymax} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer stbox_ymax(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_ymax requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_ymax(arg0); + } + + /** + * MEOS {@code stbox_ymin} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer stbox_ymin(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_ymin requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_ymin(arg0); + } + + /** + * MEOS {@code stbox_zmax} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer stbox_zmax(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_zmax requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_zmax(arg0); + } + + /** + * MEOS {@code stbox_zmin} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer stbox_zmin(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_zmin requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_zmin(arg0); + } + + /** + * MEOS {@code stbox_as_hexwkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static java.lang.String stbox_as_hexwkb(jnr.ffi.Pointer arg0, byte arg1, jnr.ffi.Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_as_hexwkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_as_hexwkb(arg0, arg1, arg2); + } + + /** + * MEOS {@code stbox_as_wkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer stbox_as_wkb(jnr.ffi.Pointer arg0, byte arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_as_wkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_as_wkb(arg0, arg1); + } + + /** + * MEOS {@code stbox_from_hexwkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer stbox_from_hexwkb(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_from_hexwkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_from_hexwkb(arg0); + } + + /** + * MEOS {@code stbox_from_wkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer stbox_from_wkb(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_from_wkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_from_wkb(arg0, arg1); + } + + /** + * MEOS {@code stbox_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer stbox_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_in(arg0); + } + + /** + * MEOS {@code stbox_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static java.lang.String stbox_out(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_out(arg0, arg1); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsSet.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsSet.java new file mode 100644 index 0000000..d30e220 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsSet.java @@ -0,0 +1,368 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: Set + * Methods emitted: 25 (bounded-state=14 · io-meta=4 · stateless=4 · windowed=3) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsSet { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsSet() { /* utility */ } + + /** + * MEOS {@code set_copy} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code constructor}.

+ *

Classification: constructor of instant/scalar

+ */ + public static jnr.ffi.Pointer set_copy(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "set_copy requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.set_copy(arg0); + } + + /** + * MEOS {@code set_to_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer set_to_span(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "set_to_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.set_to_span(arg0); + } + + /** + * MEOS {@code set_to_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer set_to_spanset(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "set_to_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.set_to_spanset(arg0); + } + + /** + * MEOS {@code set_to_tbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer set_to_tbox(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "set_to_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.set_to_tbox(arg0); + } + + /** + * MEOS {@code set_cmp} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 1 temporal

+ */ + public static int set_cmp(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "set_cmp requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.set_cmp(arg0, arg1); + } + + /** + * MEOS {@code set_eq} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 1 temporal

+ */ + public static boolean set_eq(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "set_eq requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.set_eq(arg0, arg1); + } + + /** + * MEOS {@code set_ge} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 1 temporal

+ */ + public static boolean set_ge(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "set_ge requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.set_ge(arg0, arg1); + } + + /** + * MEOS {@code set_gt} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 1 temporal

+ */ + public static boolean set_gt(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "set_gt requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.set_gt(arg0, arg1); + } + + /** + * MEOS {@code set_hash} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static int set_hash(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "set_hash requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.set_hash(arg0); + } + + /** + * MEOS {@code set_hash_extended} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static long set_hash_extended(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "set_hash_extended requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.set_hash_extended(arg0, arg1); + } + + /** + * MEOS {@code set_le} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 1 temporal

+ */ + public static boolean set_le(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "set_le requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.set_le(arg0, arg1); + } + + /** + * MEOS {@code set_lt} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 1 temporal

+ */ + public static boolean set_lt(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "set_lt requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.set_lt(arg0, arg1); + } + + /** + * MEOS {@code set_ne} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 1 temporal

+ */ + public static boolean set_ne(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "set_ne requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.set_ne(arg0, arg1); + } + + /** + * MEOS {@code set_num_values} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static int set_num_values(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "set_num_values requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.set_num_values(arg0); + } + + /** + * MEOS {@code set_round} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer set_round(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "set_round requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.set_round(arg0, arg1); + } + + /** + * MEOS {@code set_spans} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer set_spans(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "set_spans requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.set_spans(arg0); + } + + /** + * MEOS {@code set_split_each_n_spans} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer set_split_each_n_spans(jnr.ffi.Pointer arg0, int arg1, jnr.ffi.Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "set_split_each_n_spans requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.set_split_each_n_spans(arg0, arg1, arg2); + } + + /** + * MEOS {@code set_split_n_spans} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer set_split_n_spans(jnr.ffi.Pointer arg0, int arg1, jnr.ffi.Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "set_split_n_spans requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.set_split_n_spans(arg0, arg1, arg2); + } + + /** + * MEOS {@code set_extent_transfn} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Object-model role: {@code aggregate}.

+ *

Classification: role=aggregate

+ */ + public static jnr.ffi.Pointer set_extent_transfn(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "set_extent_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.set_extent_transfn(arg0, arg1); + } + + /** + * MEOS {@code set_union_finalfn} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Object-model role: {@code aggregate}.

+ *

Classification: role=aggregate

+ */ + public static jnr.ffi.Pointer set_union_finalfn(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "set_union_finalfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.set_union_finalfn(arg0); + } + + /** + * MEOS {@code set_union_transfn} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Object-model role: {@code aggregate}.

+ *

Classification: role=aggregate

+ */ + public static jnr.ffi.Pointer set_union_transfn(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "set_union_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.set_union_transfn(arg0, arg1); + } + + /** + * MEOS {@code set_as_hexwkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static java.lang.String set_as_hexwkb(jnr.ffi.Pointer arg0, byte arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "set_as_hexwkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.set_as_hexwkb(arg0, arg1); + } + + /** + * MEOS {@code set_as_wkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer set_as_wkb(jnr.ffi.Pointer arg0, byte arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "set_as_wkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.set_as_wkb(arg0, arg1); + } + + /** + * MEOS {@code set_from_hexwkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer set_from_hexwkb(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "set_from_hexwkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.set_from_hexwkb(arg0); + } + + /** + * MEOS {@code set_from_wkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer set_from_wkb(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "set_from_wkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.set_from_wkb(arg0, arg1); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsSpan.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsSpan.java new file mode 100644 index 0000000..dd862f1 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsSpan.java @@ -0,0 +1,298 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: Span + * Methods emitted: 20 (bounded-state=11 · io-meta=4 · stateless=3 · windowed=2) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsSpan { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsSpan() { /* utility */ } + + /** + * MEOS {@code span_copy} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code constructor}.

+ *

Classification: constructor of instant/scalar

+ */ + public static jnr.ffi.Pointer span_copy(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "span_copy requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.span_copy(arg0); + } + + /** + * MEOS {@code span_to_spanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer span_to_spanset(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "span_to_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.span_to_spanset(arg0); + } + + /** + * MEOS {@code span_to_tbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer span_to_tbox(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "span_to_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.span_to_tbox(arg0); + } + + /** + * MEOS {@code span_cmp} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 1 temporal

+ */ + public static int span_cmp(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "span_cmp requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.span_cmp(arg0, arg1); + } + + /** + * MEOS {@code span_eq} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 1 temporal

+ */ + public static boolean span_eq(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "span_eq requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.span_eq(arg0, arg1); + } + + /** + * MEOS {@code span_ge} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 1 temporal

+ */ + public static boolean span_ge(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "span_ge requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.span_ge(arg0, arg1); + } + + /** + * MEOS {@code span_gt} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 1 temporal

+ */ + public static boolean span_gt(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "span_gt requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.span_gt(arg0, arg1); + } + + /** + * MEOS {@code span_hash} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static int span_hash(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "span_hash requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.span_hash(arg0); + } + + /** + * MEOS {@code span_hash_extended} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static long span_hash_extended(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "span_hash_extended requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.span_hash_extended(arg0, arg1); + } + + /** + * MEOS {@code span_le} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 1 temporal

+ */ + public static boolean span_le(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "span_le requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.span_le(arg0, arg1); + } + + /** + * MEOS {@code span_lower_inc} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static boolean span_lower_inc(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "span_lower_inc requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.span_lower_inc(arg0); + } + + /** + * MEOS {@code span_lt} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 1 temporal

+ */ + public static boolean span_lt(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "span_lt requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.span_lt(arg0, arg1); + } + + /** + * MEOS {@code span_ne} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 1 temporal

+ */ + public static boolean span_ne(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "span_ne requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.span_ne(arg0, arg1); + } + + /** + * MEOS {@code span_upper_inc} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static boolean span_upper_inc(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "span_upper_inc requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.span_upper_inc(arg0); + } + + /** + * MEOS {@code span_extent_transfn} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Object-model role: {@code aggregate}.

+ *

Classification: role=aggregate

+ */ + public static jnr.ffi.Pointer span_extent_transfn(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "span_extent_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.span_extent_transfn(arg0, arg1); + } + + /** + * MEOS {@code span_union_transfn} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Object-model role: {@code aggregate}.

+ *

Classification: role=aggregate

+ */ + public static jnr.ffi.Pointer span_union_transfn(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "span_union_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.span_union_transfn(arg0, arg1); + } + + /** + * MEOS {@code span_as_hexwkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static java.lang.String span_as_hexwkb(jnr.ffi.Pointer arg0, byte arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "span_as_hexwkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.span_as_hexwkb(arg0, arg1); + } + + /** + * MEOS {@code span_as_wkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer span_as_wkb(jnr.ffi.Pointer arg0, byte arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "span_as_wkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.span_as_wkb(arg0, arg1); + } + + /** + * MEOS {@code span_from_hexwkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer span_from_hexwkb(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "span_from_hexwkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.span_from_hexwkb(arg0); + } + + /** + * MEOS {@code span_from_wkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer span_from_wkb(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "span_from_wkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.span_from_wkb(arg0, arg1); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsSpanSet.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsSpanSet.java new file mode 100644 index 0000000..72a47ae --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsSpanSet.java @@ -0,0 +1,438 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: SpanSet + * Methods emitted: 30 (bounded-state=20 · io-meta=4 · stateless=3 · windowed=3) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsSpanSet { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsSpanSet() { /* utility */ } + + /** + * MEOS {@code spanset_copy} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code constructor}.

+ *

Classification: constructor of instant/scalar

+ */ + public static jnr.ffi.Pointer spanset_copy(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "spanset_copy requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.spanset_copy(arg0); + } + + /** + * MEOS {@code spanset_make} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code constructor}.

+ *

Classification: constructor of instant/scalar

+ */ + public static jnr.ffi.Pointer spanset_make(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "spanset_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.spanset_make(arg0, arg1); + } + + /** + * MEOS {@code spanset_to_tbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer spanset_to_tbox(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "spanset_to_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.spanset_to_tbox(arg0); + } + + /** + * MEOS {@code spanset_cmp} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 1 temporal

+ */ + public static int spanset_cmp(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "spanset_cmp requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.spanset_cmp(arg0, arg1); + } + + /** + * MEOS {@code spanset_end_span} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer spanset_end_span(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "spanset_end_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.spanset_end_span(arg0); + } + + /** + * MEOS {@code spanset_eq} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 1 temporal

+ */ + public static boolean spanset_eq(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "spanset_eq requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.spanset_eq(arg0, arg1); + } + + /** + * MEOS {@code spanset_ge} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 1 temporal

+ */ + public static boolean spanset_ge(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "spanset_ge requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.spanset_ge(arg0, arg1); + } + + /** + * MEOS {@code spanset_gt} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 1 temporal

+ */ + public static boolean spanset_gt(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "spanset_gt requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.spanset_gt(arg0, arg1); + } + + /** + * MEOS {@code spanset_hash} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static int spanset_hash(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "spanset_hash requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.spanset_hash(arg0); + } + + /** + * MEOS {@code spanset_hash_extended} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static long spanset_hash_extended(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "spanset_hash_extended requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.spanset_hash_extended(arg0, arg1); + } + + /** + * MEOS {@code spanset_le} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 1 temporal

+ */ + public static boolean spanset_le(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "spanset_le requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.spanset_le(arg0, arg1); + } + + /** + * MEOS {@code spanset_lower_inc} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static boolean spanset_lower_inc(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "spanset_lower_inc requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.spanset_lower_inc(arg0); + } + + /** + * MEOS {@code spanset_lt} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 1 temporal

+ */ + public static boolean spanset_lt(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "spanset_lt requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.spanset_lt(arg0, arg1); + } + + /** + * MEOS {@code spanset_ne} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 1 temporal

+ */ + public static boolean spanset_ne(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "spanset_ne requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.spanset_ne(arg0, arg1); + } + + /** + * MEOS {@code spanset_num_spans} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static int spanset_num_spans(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "spanset_num_spans requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.spanset_num_spans(arg0); + } + + /** + * MEOS {@code spanset_span} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer spanset_span(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "spanset_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.spanset_span(arg0); + } + + /** + * MEOS {@code spanset_span_n} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer spanset_span_n(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "spanset_span_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.spanset_span_n(arg0, arg1); + } + + /** + * MEOS {@code spanset_spanarr} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer spanset_spanarr(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "spanset_spanarr requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.spanset_spanarr(arg0); + } + + /** + * MEOS {@code spanset_spans} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer spanset_spans(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "spanset_spans requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.spanset_spans(arg0); + } + + /** + * MEOS {@code spanset_split_each_n_spans} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer spanset_split_each_n_spans(jnr.ffi.Pointer arg0, int arg1, jnr.ffi.Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "spanset_split_each_n_spans requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.spanset_split_each_n_spans(arg0, arg1, arg2); + } + + /** + * MEOS {@code spanset_split_n_spans} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer spanset_split_n_spans(jnr.ffi.Pointer arg0, int arg1, jnr.ffi.Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "spanset_split_n_spans requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.spanset_split_n_spans(arg0, arg1, arg2); + } + + /** + * MEOS {@code spanset_start_span} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer spanset_start_span(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "spanset_start_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.spanset_start_span(arg0); + } + + /** + * MEOS {@code spanset_upper_inc} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static boolean spanset_upper_inc(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "spanset_upper_inc requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.spanset_upper_inc(arg0); + } + + /** + * MEOS {@code spanset_extent_transfn} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Object-model role: {@code aggregate}.

+ *

Classification: role=aggregate

+ */ + public static jnr.ffi.Pointer spanset_extent_transfn(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "spanset_extent_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.spanset_extent_transfn(arg0, arg1); + } + + /** + * MEOS {@code spanset_union_finalfn} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Object-model role: {@code aggregate}.

+ *

Classification: role=aggregate

+ */ + public static jnr.ffi.Pointer spanset_union_finalfn(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "spanset_union_finalfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.spanset_union_finalfn(arg0); + } + + /** + * MEOS {@code spanset_union_transfn} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Object-model role: {@code aggregate}.

+ *

Classification: role=aggregate

+ */ + public static jnr.ffi.Pointer spanset_union_transfn(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "spanset_union_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.spanset_union_transfn(arg0, arg1); + } + + /** + * MEOS {@code spanset_as_hexwkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static java.lang.String spanset_as_hexwkb(jnr.ffi.Pointer arg0, byte arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "spanset_as_hexwkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.spanset_as_hexwkb(arg0, arg1); + } + + /** + * MEOS {@code spanset_as_wkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer spanset_as_wkb(jnr.ffi.Pointer arg0, byte arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "spanset_as_wkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.spanset_as_wkb(arg0, arg1); + } + + /** + * MEOS {@code spanset_from_hexwkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer spanset_from_hexwkb(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "spanset_from_hexwkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.spanset_from_hexwkb(arg0); + } + + /** + * MEOS {@code spanset_from_wkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer spanset_from_wkb(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "spanset_from_wkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.spanset_from_wkb(arg0, arg1); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsSqlSurface.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsSqlSurface.java new file mode 100644 index 0000000..f076677 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsSqlSurface.java @@ -0,0 +1,897 @@ +package org.mobilitydb.flink.meos; + +/** + * Forwarding facade methods for MEOS functions that the MobilityDB SQL layer + * exposes as user functions but whose implementation lives in the internal headers + * ({@code meos_internal*.h}). JMEOS binds them; they are exposed here so the facade + * matches the SQL user surface as well as the public MEOS API. Each method delegates + * to its {@code functions.GeneratedFunctions} export under the + * {@link MeosOpsRuntime#MEOS_AVAILABLE} guard. + */ +public final class MeosOpsSqlSurface { + + private MeosOpsSqlSurface() { /* utility */ } + + /** MEOS {@code adjacent_span_value} — SQL-surface function (meos_internal). */ + public static boolean adjacent_span_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("adjacent_span_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.adjacent_span_value(arg0, arg1); + } + + /** MEOS {@code adjacent_spanset_value} — SQL-surface function (meos_internal). */ + public static boolean adjacent_spanset_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("adjacent_spanset_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.adjacent_spanset_value(arg0, arg1); + } + + /** MEOS {@code adjacent_value_spanset} — SQL-surface function (meos_internal). */ + public static boolean adjacent_value_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("adjacent_value_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.adjacent_value_spanset(arg0, arg1); + } + + /** MEOS {@code always_eq_base_temporal} — SQL-surface function (meos_internal). */ + public static int always_eq_base_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("always_eq_base_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.always_eq_base_temporal(arg0, arg1); + } + + /** MEOS {@code always_eq_temporal_base} — SQL-surface function (meos_internal). */ + public static int always_eq_temporal_base(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("always_eq_temporal_base requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.always_eq_temporal_base(arg0, arg1); + } + + /** MEOS {@code always_ge_base_temporal} — SQL-surface function (meos_internal). */ + public static int always_ge_base_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("always_ge_base_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.always_ge_base_temporal(arg0, arg1); + } + + /** MEOS {@code always_ge_temporal_base} — SQL-surface function (meos_internal). */ + public static int always_ge_temporal_base(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("always_ge_temporal_base requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.always_ge_temporal_base(arg0, arg1); + } + + /** MEOS {@code always_gt_base_temporal} — SQL-surface function (meos_internal). */ + public static int always_gt_base_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("always_gt_base_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.always_gt_base_temporal(arg0, arg1); + } + + /** MEOS {@code always_gt_temporal_base} — SQL-surface function (meos_internal). */ + public static int always_gt_temporal_base(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("always_gt_temporal_base requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.always_gt_temporal_base(arg0, arg1); + } + + /** MEOS {@code always_le_base_temporal} — SQL-surface function (meos_internal). */ + public static int always_le_base_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("always_le_base_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.always_le_base_temporal(arg0, arg1); + } + + /** MEOS {@code always_le_temporal_base} — SQL-surface function (meos_internal). */ + public static int always_le_temporal_base(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("always_le_temporal_base requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.always_le_temporal_base(arg0, arg1); + } + + /** MEOS {@code always_lt_base_temporal} — SQL-surface function (meos_internal). */ + public static int always_lt_base_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("always_lt_base_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.always_lt_base_temporal(arg0, arg1); + } + + /** MEOS {@code always_lt_temporal_base} — SQL-surface function (meos_internal). */ + public static int always_lt_temporal_base(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("always_lt_temporal_base requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.always_lt_temporal_base(arg0, arg1); + } + + /** MEOS {@code always_ne_base_temporal} — SQL-surface function (meos_internal). */ + public static int always_ne_base_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("always_ne_base_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.always_ne_base_temporal(arg0, arg1); + } + + /** MEOS {@code always_ne_temporal_base} — SQL-surface function (meos_internal). */ + public static int always_ne_temporal_base(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("always_ne_temporal_base requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.always_ne_temporal_base(arg0, arg1); + } + + /** MEOS {@code contained_value_set} — SQL-surface function (meos_internal). */ + public static boolean contained_value_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("contained_value_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.contained_value_set(arg0, arg1); + } + + /** MEOS {@code contained_value_span} — SQL-surface function (meos_internal). */ + public static boolean contained_value_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("contained_value_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.contained_value_span(arg0, arg1); + } + + /** MEOS {@code contained_value_spanset} — SQL-surface function (meos_internal). */ + public static boolean contained_value_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("contained_value_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.contained_value_spanset(arg0, arg1); + } + + /** MEOS {@code contains_set_value} — SQL-surface function (meos_internal). */ + public static boolean contains_set_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("contains_set_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.contains_set_value(arg0, arg1); + } + + /** MEOS {@code contains_span_value} — SQL-surface function (meos_internal). */ + public static boolean contains_span_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("contains_span_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.contains_span_value(arg0, arg1); + } + + /** MEOS {@code contains_spanset_value} — SQL-surface function (meos_internal). */ + public static boolean contains_spanset_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("contains_spanset_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.contains_spanset_value(arg0, arg1); + } + + /** MEOS {@code distance_set_set} — SQL-surface function (meos_internal). */ + public static int distance_set_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("distance_set_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.distance_set_set(arg0, arg1); + } + + /** MEOS {@code distance_set_value} — SQL-surface function (meos_internal). */ + public static int distance_set_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("distance_set_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.distance_set_value(arg0, arg1); + } + + /** MEOS {@code distance_span_span} — SQL-surface function (meos_internal). */ + public static int distance_span_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("distance_span_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.distance_span_span(arg0, arg1); + } + + /** MEOS {@code distance_span_value} — SQL-surface function (meos_internal). */ + public static int distance_span_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("distance_span_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.distance_span_value(arg0, arg1); + } + + /** MEOS {@code distance_spanset_span} — SQL-surface function (meos_internal). */ + public static int distance_spanset_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("distance_spanset_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.distance_spanset_span(arg0, arg1); + } + + /** MEOS {@code distance_spanset_spanset} — SQL-surface function (meos_internal). */ + public static int distance_spanset_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("distance_spanset_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.distance_spanset_spanset(arg0, arg1); + } + + /** MEOS {@code distance_spanset_value} — SQL-surface function (meos_internal). */ + public static int distance_spanset_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("distance_spanset_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.distance_spanset_value(arg0, arg1); + } + + /** MEOS {@code distance_value_value} — SQL-surface function (meos_internal). */ + public static int distance_value_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, int arg2) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("distance_value_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.distance_value_value(arg0, arg1, arg2); + } + + /** MEOS {@code ever_eq_base_temporal} — SQL-surface function (meos_internal). */ + public static int ever_eq_base_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("ever_eq_base_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.ever_eq_base_temporal(arg0, arg1); + } + + /** MEOS {@code ever_eq_temporal_base} — SQL-surface function (meos_internal). */ + public static int ever_eq_temporal_base(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("ever_eq_temporal_base requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.ever_eq_temporal_base(arg0, arg1); + } + + /** MEOS {@code ever_ge_base_temporal} — SQL-surface function (meos_internal). */ + public static int ever_ge_base_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("ever_ge_base_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.ever_ge_base_temporal(arg0, arg1); + } + + /** MEOS {@code ever_ge_temporal_base} — SQL-surface function (meos_internal). */ + public static int ever_ge_temporal_base(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("ever_ge_temporal_base requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.ever_ge_temporal_base(arg0, arg1); + } + + /** MEOS {@code ever_gt_base_temporal} — SQL-surface function (meos_internal). */ + public static int ever_gt_base_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("ever_gt_base_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.ever_gt_base_temporal(arg0, arg1); + } + + /** MEOS {@code ever_gt_temporal_base} — SQL-surface function (meos_internal). */ + public static int ever_gt_temporal_base(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("ever_gt_temporal_base requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.ever_gt_temporal_base(arg0, arg1); + } + + /** MEOS {@code ever_le_base_temporal} — SQL-surface function (meos_internal). */ + public static int ever_le_base_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("ever_le_base_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.ever_le_base_temporal(arg0, arg1); + } + + /** MEOS {@code ever_le_temporal_base} — SQL-surface function (meos_internal). */ + public static int ever_le_temporal_base(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("ever_le_temporal_base requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.ever_le_temporal_base(arg0, arg1); + } + + /** MEOS {@code ever_lt_base_temporal} — SQL-surface function (meos_internal). */ + public static int ever_lt_base_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("ever_lt_base_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.ever_lt_base_temporal(arg0, arg1); + } + + /** MEOS {@code ever_lt_temporal_base} — SQL-surface function (meos_internal). */ + public static int ever_lt_temporal_base(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("ever_lt_temporal_base requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.ever_lt_temporal_base(arg0, arg1); + } + + /** MEOS {@code ever_ne_base_temporal} — SQL-surface function (meos_internal). */ + public static int ever_ne_base_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("ever_ne_base_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.ever_ne_base_temporal(arg0, arg1); + } + + /** MEOS {@code ever_ne_temporal_base} — SQL-surface function (meos_internal). */ + public static int ever_ne_temporal_base(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("ever_ne_temporal_base requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.ever_ne_temporal_base(arg0, arg1); + } + + /** MEOS {@code intersection_set_value} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer intersection_set_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("intersection_set_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.intersection_set_value(arg0, arg1); + } + + /** MEOS {@code intersection_span_value} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer intersection_span_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("intersection_span_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.intersection_span_value(arg0, arg1); + } + + /** MEOS {@code intersection_spanset_value} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer intersection_spanset_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("intersection_spanset_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.intersection_spanset_value(arg0, arg1); + } + + /** MEOS {@code intersection_value_set} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer intersection_value_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("intersection_value_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.intersection_value_set(arg0, arg1); + } + + /** MEOS {@code intersection_value_span} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer intersection_value_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("intersection_value_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.intersection_value_span(arg0, arg1); + } + + /** MEOS {@code intersection_value_spanset} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer intersection_value_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("intersection_value_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.intersection_value_spanset(arg0, arg1); + } + + /** MEOS {@code left_set_value} — SQL-surface function (meos_internal). */ + public static boolean left_set_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("left_set_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.left_set_value(arg0, arg1); + } + + /** MEOS {@code left_span_value} — SQL-surface function (meos_internal). */ + public static boolean left_span_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("left_span_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.left_span_value(arg0, arg1); + } + + /** MEOS {@code left_spanset_value} — SQL-surface function (meos_internal). */ + public static boolean left_spanset_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("left_spanset_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.left_spanset_value(arg0, arg1); + } + + /** MEOS {@code left_value_set} — SQL-surface function (meos_internal). */ + public static boolean left_value_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("left_value_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.left_value_set(arg0, arg1); + } + + /** MEOS {@code left_value_span} — SQL-surface function (meos_internal). */ + public static boolean left_value_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("left_value_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.left_value_span(arg0, arg1); + } + + /** MEOS {@code left_value_spanset} — SQL-surface function (meos_internal). */ + public static boolean left_value_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("left_value_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.left_value_spanset(arg0, arg1); + } + + /** MEOS {@code minus_set_value} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer minus_set_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("minus_set_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.minus_set_value(arg0, arg1); + } + + /** MEOS {@code minus_span_value} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer minus_span_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("minus_span_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.minus_span_value(arg0, arg1); + } + + /** MEOS {@code minus_spanset_value} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer minus_spanset_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("minus_spanset_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.minus_spanset_value(arg0, arg1); + } + + /** MEOS {@code minus_value_set} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer minus_value_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("minus_value_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.minus_value_set(arg0, arg1); + } + + /** MEOS {@code minus_value_span} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer minus_value_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("minus_value_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.minus_value_span(arg0, arg1); + } + + /** MEOS {@code minus_value_spanset} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer minus_value_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("minus_value_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.minus_value_spanset(arg0, arg1); + } + + /** MEOS {@code nad_tbox_tbox} — SQL-surface function (meos_internal). */ + public static double nad_tbox_tbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("nad_tbox_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.nad_tbox_tbox(arg0, arg1); + } + + /** MEOS {@code nad_tnumber_number} — SQL-surface function (meos_internal). */ + public static double nad_tnumber_number(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("nad_tnumber_number requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.nad_tnumber_number(arg0, arg1); + } + + /** MEOS {@code nad_tnumber_tbox} — SQL-surface function (meos_internal). */ + public static double nad_tnumber_tbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("nad_tnumber_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.nad_tnumber_tbox(arg0, arg1); + } + + /** MEOS {@code nad_tnumber_tnumber} — SQL-surface function (meos_internal). */ + public static double nad_tnumber_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("nad_tnumber_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.nad_tnumber_tnumber(arg0, arg1); + } + + /** MEOS {@code number_timestamptz_to_tbox} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer number_timestamptz_to_tbox(jnr.ffi.Pointer arg0, int arg1, java.time.OffsetDateTime arg2) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("number_timestamptz_to_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.number_timestamptz_to_tbox(arg0, arg1, arg2); + } + + /** MEOS {@code number_tstzspan_to_tbox} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer number_tstzspan_to_tbox(jnr.ffi.Pointer arg0, int arg1, jnr.ffi.Pointer arg2) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("number_tstzspan_to_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.number_tstzspan_to_tbox(arg0, arg1, arg2); + } + + /** MEOS {@code numset_shift_scale} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer numset_shift_scale(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, jnr.ffi.Pointer arg2, boolean arg3, boolean arg4) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("numset_shift_scale requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.numset_shift_scale(arg0, arg1, arg2, arg3, arg4); + } + + /** MEOS {@code numspan_expand} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer numspan_expand(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("numspan_expand requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.numspan_expand(arg0, arg1); + } + + /** MEOS {@code numspan_shift_scale} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer numspan_shift_scale(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, jnr.ffi.Pointer arg2, boolean arg3, boolean arg4) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("numspan_shift_scale requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.numspan_shift_scale(arg0, arg1, arg2, arg3, arg4); + } + + /** MEOS {@code numspan_width} — SQL-surface function (meos_internal). */ + public static int numspan_width(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("numspan_width requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.numspan_width(arg0); + } + + /** MEOS {@code numspanset_shift_scale} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer numspanset_shift_scale(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, jnr.ffi.Pointer arg2, boolean arg3, boolean arg4) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("numspanset_shift_scale requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.numspanset_shift_scale(arg0, arg1, arg2, arg3, arg4); + } + + /** MEOS {@code numspanset_width} — SQL-surface function (meos_internal). */ + public static int numspanset_width(jnr.ffi.Pointer arg0, boolean arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("numspanset_width requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.numspanset_width(arg0, arg1); + } + + /** MEOS {@code overleft_set_value} — SQL-surface function (meos_internal). */ + public static boolean overleft_set_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("overleft_set_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.overleft_set_value(arg0, arg1); + } + + /** MEOS {@code overleft_span_value} — SQL-surface function (meos_internal). */ + public static boolean overleft_span_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("overleft_span_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.overleft_span_value(arg0, arg1); + } + + /** MEOS {@code overleft_spanset_value} — SQL-surface function (meos_internal). */ + public static boolean overleft_spanset_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("overleft_spanset_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.overleft_spanset_value(arg0, arg1); + } + + /** MEOS {@code overleft_value_set} — SQL-surface function (meos_internal). */ + public static boolean overleft_value_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("overleft_value_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.overleft_value_set(arg0, arg1); + } + + /** MEOS {@code overleft_value_span} — SQL-surface function (meos_internal). */ + public static boolean overleft_value_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("overleft_value_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.overleft_value_span(arg0, arg1); + } + + /** MEOS {@code overleft_value_spanset} — SQL-surface function (meos_internal). */ + public static boolean overleft_value_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("overleft_value_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.overleft_value_spanset(arg0, arg1); + } + + /** MEOS {@code overright_set_value} — SQL-surface function (meos_internal). */ + public static boolean overright_set_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("overright_set_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.overright_set_value(arg0, arg1); + } + + /** MEOS {@code overright_span_value} — SQL-surface function (meos_internal). */ + public static boolean overright_span_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("overright_span_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.overright_span_value(arg0, arg1); + } + + /** MEOS {@code overright_spanset_value} — SQL-surface function (meos_internal). */ + public static boolean overright_spanset_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("overright_spanset_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.overright_spanset_value(arg0, arg1); + } + + /** MEOS {@code overright_value_set} — SQL-surface function (meos_internal). */ + public static boolean overright_value_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("overright_value_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.overright_value_set(arg0, arg1); + } + + /** MEOS {@code overright_value_span} — SQL-surface function (meos_internal). */ + public static boolean overright_value_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("overright_value_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.overright_value_span(arg0, arg1); + } + + /** MEOS {@code overright_value_spanset} — SQL-surface function (meos_internal). */ + public static boolean overright_value_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("overright_value_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.overright_value_spanset(arg0, arg1); + } + + /** MEOS {@code right_set_value} — SQL-surface function (meos_internal). */ + public static boolean right_set_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("right_set_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.right_set_value(arg0, arg1); + } + + /** MEOS {@code right_span_value} — SQL-surface function (meos_internal). */ + public static boolean right_span_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("right_span_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.right_span_value(arg0, arg1); + } + + /** MEOS {@code right_spanset_value} — SQL-surface function (meos_internal). */ + public static boolean right_spanset_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("right_spanset_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.right_spanset_value(arg0, arg1); + } + + /** MEOS {@code right_value_set} — SQL-surface function (meos_internal). */ + public static boolean right_value_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("right_value_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.right_value_set(arg0, arg1); + } + + /** MEOS {@code right_value_span} — SQL-surface function (meos_internal). */ + public static boolean right_value_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("right_value_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.right_value_span(arg0, arg1); + } + + /** MEOS {@code right_value_spanset} — SQL-surface function (meos_internal). */ + public static boolean right_value_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("right_value_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.right_value_spanset(arg0, arg1); + } + + /** MEOS {@code set_end_value} — SQL-surface function (meos_internal). */ + public static int set_end_value(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("set_end_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.set_end_value(arg0); + } + + /** MEOS {@code set_mem_size} — SQL-surface function (meos_internal). */ + public static int set_mem_size(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("set_mem_size requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.set_mem_size(arg0); + } + + /** MEOS {@code set_start_value} — SQL-surface function (meos_internal). */ + public static int set_start_value(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("set_start_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.set_start_value(arg0); + } + + /** MEOS {@code set_value_n} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer set_value_n(jnr.ffi.Pointer arg0, int arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("set_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.set_value_n(arg0, arg1); + } + + /** MEOS {@code set_values} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer set_values(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("set_values requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.set_values(arg0); + } + + /** MEOS {@code span_bins} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer span_bins(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, jnr.ffi.Pointer arg2, jnr.ffi.Pointer arg3) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("span_bins requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.span_bins(arg0, arg1, arg2, arg3); + } + + /** MEOS {@code spanset_bins} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer spanset_bins(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, jnr.ffi.Pointer arg2, jnr.ffi.Pointer arg3) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("spanset_bins requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.spanset_bins(arg0, arg1, arg2, arg3); + } + + /** MEOS {@code spanset_lower} — SQL-surface function (meos_internal). */ + public static int spanset_lower(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("spanset_lower requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.spanset_lower(arg0); + } + + /** MEOS {@code spanset_mem_size} — SQL-surface function (meos_internal). */ + public static int spanset_mem_size(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("spanset_mem_size requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.spanset_mem_size(arg0); + } + + /** MEOS {@code spanset_upper} — SQL-surface function (meos_internal). */ + public static int spanset_upper(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("spanset_upper requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.spanset_upper(arg0); + } + + /** MEOS {@code tbox_expand_value} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer tbox_expand_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, int arg2) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tbox_expand_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tbox_expand_value(arg0, arg1, arg2); + } + + /** MEOS {@code tbox_get_value_time_tile} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer tbox_get_value_time_tile(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1, jnr.ffi.Pointer arg2, jnr.ffi.Pointer arg3, jnr.ffi.Pointer arg4, java.time.OffsetDateTime arg5, int arg6, int arg7) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tbox_get_value_time_tile requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tbox_get_value_time_tile(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); + } + + /** MEOS {@code tbox_shift_scale_value} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer tbox_shift_scale_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, jnr.ffi.Pointer arg2, boolean arg3, boolean arg4) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tbox_shift_scale_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tbox_shift_scale_value(arg0, arg1, arg2, arg3, arg4); + } + + /** MEOS {@code tdistance_tnumber_number} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer tdistance_tnumber_number(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tdistance_tnumber_number requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tdistance_tnumber_number(arg0, arg1); + } + + /** MEOS {@code temporal_end_value} — SQL-surface function (meos_internal). */ + public static int temporal_end_value(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("temporal_end_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.temporal_end_value(arg0); + } + + /** MEOS {@code temporal_from_mfjson} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer temporal_from_mfjson(java.lang.String arg0, int arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("temporal_from_mfjson requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.temporal_from_mfjson(arg0, arg1); + } + + /** MEOS {@code temporal_max_value} — SQL-surface function (meos_internal). */ + public static int temporal_max_value(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("temporal_max_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.temporal_max_value(arg0); + } + + /** MEOS {@code temporal_mem_size} — SQL-surface function (meos_internal). */ + public static long temporal_mem_size(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("temporal_mem_size requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.temporal_mem_size(arg0); + } + + /** MEOS {@code temporal_min_value} — SQL-surface function (meos_internal). */ + public static int temporal_min_value(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("temporal_min_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.temporal_min_value(arg0); + } + + /** MEOS {@code temporal_start_value} — SQL-surface function (meos_internal). */ + public static int temporal_start_value(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("temporal_start_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.temporal_start_value(arg0); + } + + /** MEOS {@code temporal_value_at_timestamptz} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer temporal_value_at_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1, boolean arg2) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("temporal_value_at_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.temporal_value_at_timestamptz(arg0, arg1, arg2); + } + + /** MEOS {@code temporal_value_n} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer temporal_value_n(jnr.ffi.Pointer arg0, int arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("temporal_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.temporal_value_n(arg0, arg1); + } + + /** MEOS {@code tinstant_value} — SQL-surface function (meos_internal). */ + public static int tinstant_value(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tinstant_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tinstant_value(arg0); + } + + /** MEOS {@code tnumber_shift_scale_value} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer tnumber_shift_scale_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, jnr.ffi.Pointer arg2, boolean arg3, boolean arg4) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tnumber_shift_scale_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tnumber_shift_scale_value(arg0, arg1, arg2, arg3, arg4); + } + + /** MEOS {@code tnumber_value_bins} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer tnumber_value_bins(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, jnr.ffi.Pointer arg2, jnr.ffi.Pointer arg3) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tnumber_value_bins requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tnumber_value_bins(arg0, arg1, arg2, arg3); + } + + /** MEOS {@code tnumber_value_split} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer tnumber_value_split(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, jnr.ffi.Pointer arg2, jnr.ffi.Pointer arg3, jnr.ffi.Pointer arg4) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tnumber_value_split requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tnumber_value_split(arg0, arg1, arg2, arg3, arg4); + } + + /** MEOS {@code tnumber_value_time_boxes} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer tnumber_value_time_boxes(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, jnr.ffi.Pointer arg2, jnr.ffi.Pointer arg3, java.time.OffsetDateTime arg4, jnr.ffi.Pointer arg5) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tnumber_value_time_boxes requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tnumber_value_time_boxes(arg0, arg1, arg2, arg3, arg4, arg5); + } + + /** MEOS {@code tnumber_value_time_split} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer tnumber_value_time_split(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, jnr.ffi.Pointer arg2, jnr.ffi.Pointer arg3, java.time.OffsetDateTime arg4, jnr.ffi.Pointer arg5, jnr.ffi.Pointer arg6, jnr.ffi.Pointer arg7) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tnumber_value_time_split requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tnumber_value_time_split(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); + } + + /** MEOS {@code tsequence_from_base_tstzset} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer tsequence_from_base_tstzset(jnr.ffi.Pointer arg0, int arg1, jnr.ffi.Pointer arg2) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tsequence_from_base_tstzset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tsequence_from_base_tstzset(arg0, arg1, arg2); + } + + /** MEOS {@code tsequence_from_base_tstzspan} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer tsequence_from_base_tstzspan(jnr.ffi.Pointer arg0, int arg1, jnr.ffi.Pointer arg2, int arg3) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tsequence_from_base_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tsequence_from_base_tstzspan(arg0, arg1, arg2, arg3); + } + + /** MEOS {@code tsequenceset_from_base_tstzspanset} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer tsequenceset_from_base_tstzspanset(jnr.ffi.Pointer arg0, int arg1, jnr.ffi.Pointer arg2, int arg3) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tsequenceset_from_base_tstzspanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tsequenceset_from_base_tstzspanset(arg0, arg1, arg2, arg3); + } + + /** MEOS {@code union_set_value} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer union_set_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("union_set_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.union_set_value(arg0, arg1); + } + + /** MEOS {@code union_span_value} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer union_span_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("union_span_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.union_span_value(arg0, arg1); + } + + /** MEOS {@code union_spanset_value} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer union_spanset_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("union_spanset_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.union_spanset_value(arg0, arg1); + } + + /** MEOS {@code union_value_set} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer union_value_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("union_value_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.union_value_set(arg0, arg1); + } + + /** MEOS {@code union_value_span} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer union_value_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("union_value_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.union_value_span(arg0, arg1); + } + + /** MEOS {@code union_value_spanset} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer union_value_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("union_value_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.union_value_spanset(arg0, arg1); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTBigint.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTBigint.java new file mode 100644 index 0000000..6576530 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTBigint.java @@ -0,0 +1,537 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by tools/codegen/emit_tbigint_facade.py — do not edit by hand. + * tbigint temporal-type family facade over functions.GeneratedFunctions. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsTBigint { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsTBigint() { /* utility */ } + + /** MEOS {@code add_bigint_tbigint} — tbigint temporal family. */ + public static jnr.ffi.Pointer add_bigint_tbigint(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "add_bigint_tbigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.add_bigint_tbigint(arg0, arg1); + } + + /** MEOS {@code add_tbigint_bigint} — tbigint temporal family. */ + public static jnr.ffi.Pointer add_tbigint_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "add_tbigint_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.add_tbigint_bigint(arg0, arg1); + } + + /** MEOS {@code always_eq_bigint_tbigint} — tbigint temporal family. */ + public static int always_eq_bigint_tbigint(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_eq_bigint_tbigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_eq_bigint_tbigint(arg0, arg1); + } + + /** MEOS {@code always_eq_tbigint_bigint} — tbigint temporal family. */ + public static int always_eq_tbigint_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_eq_tbigint_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_eq_tbigint_bigint(arg0, arg1); + } + + /** MEOS {@code always_ge_bigint_tbigint} — tbigint temporal family. */ + public static int always_ge_bigint_tbigint(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ge_bigint_tbigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ge_bigint_tbigint(arg0, arg1); + } + + /** MEOS {@code always_ge_tbigint_bigint} — tbigint temporal family. */ + public static int always_ge_tbigint_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ge_tbigint_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ge_tbigint_bigint(arg0, arg1); + } + + /** MEOS {@code always_gt_bigint_tbigint} — tbigint temporal family. */ + public static int always_gt_bigint_tbigint(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_gt_bigint_tbigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_gt_bigint_tbigint(arg0, arg1); + } + + /** MEOS {@code always_gt_tbigint_bigint} — tbigint temporal family. */ + public static int always_gt_tbigint_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_gt_tbigint_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_gt_tbigint_bigint(arg0, arg1); + } + + /** MEOS {@code always_le_bigint_tbigint} — tbigint temporal family. */ + public static int always_le_bigint_tbigint(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_le_bigint_tbigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_le_bigint_tbigint(arg0, arg1); + } + + /** MEOS {@code always_le_tbigint_bigint} — tbigint temporal family. */ + public static int always_le_tbigint_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_le_tbigint_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_le_tbigint_bigint(arg0, arg1); + } + + /** MEOS {@code always_lt_bigint_tbigint} — tbigint temporal family. */ + public static int always_lt_bigint_tbigint(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_lt_bigint_tbigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_lt_bigint_tbigint(arg0, arg1); + } + + /** MEOS {@code always_lt_tbigint_bigint} — tbigint temporal family. */ + public static int always_lt_tbigint_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_lt_tbigint_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_lt_tbigint_bigint(arg0, arg1); + } + + /** MEOS {@code always_ne_bigint_tbigint} — tbigint temporal family. */ + public static int always_ne_bigint_tbigint(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ne_bigint_tbigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ne_bigint_tbigint(arg0, arg1); + } + + /** MEOS {@code always_ne_tbigint_bigint} — tbigint temporal family. */ + public static int always_ne_tbigint_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ne_tbigint_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ne_tbigint_bigint(arg0, arg1); + } + + /** MEOS {@code div_bigint_tbigint} — tbigint temporal family. */ + public static jnr.ffi.Pointer div_bigint_tbigint(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "div_bigint_tbigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.div_bigint_tbigint(arg0, arg1); + } + + /** MEOS {@code div_tbigint_bigint} — tbigint temporal family. */ + public static jnr.ffi.Pointer div_tbigint_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "div_tbigint_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.div_tbigint_bigint(arg0, arg1); + } + + /** MEOS {@code ever_eq_bigint_tbigint} — tbigint temporal family. */ + public static int ever_eq_bigint_tbigint(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_eq_bigint_tbigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_eq_bigint_tbigint(arg0, arg1); + } + + /** MEOS {@code ever_eq_tbigint_bigint} — tbigint temporal family. */ + public static int ever_eq_tbigint_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_eq_tbigint_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_eq_tbigint_bigint(arg0, arg1); + } + + /** MEOS {@code ever_ge_bigint_tbigint} — tbigint temporal family. */ + public static int ever_ge_bigint_tbigint(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ge_bigint_tbigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ge_bigint_tbigint(arg0, arg1); + } + + /** MEOS {@code ever_ge_tbigint_bigint} — tbigint temporal family. */ + public static int ever_ge_tbigint_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ge_tbigint_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ge_tbigint_bigint(arg0, arg1); + } + + /** MEOS {@code ever_gt_bigint_tbigint} — tbigint temporal family. */ + public static int ever_gt_bigint_tbigint(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_gt_bigint_tbigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_gt_bigint_tbigint(arg0, arg1); + } + + /** MEOS {@code ever_gt_tbigint_bigint} — tbigint temporal family. */ + public static int ever_gt_tbigint_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_gt_tbigint_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_gt_tbigint_bigint(arg0, arg1); + } + + /** MEOS {@code ever_le_bigint_tbigint} — tbigint temporal family. */ + public static int ever_le_bigint_tbigint(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_le_bigint_tbigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_le_bigint_tbigint(arg0, arg1); + } + + /** MEOS {@code ever_le_tbigint_bigint} — tbigint temporal family. */ + public static int ever_le_tbigint_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_le_tbigint_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_le_tbigint_bigint(arg0, arg1); + } + + /** MEOS {@code ever_lt_bigint_tbigint} — tbigint temporal family. */ + public static int ever_lt_bigint_tbigint(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_lt_bigint_tbigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_lt_bigint_tbigint(arg0, arg1); + } + + /** MEOS {@code ever_lt_tbigint_bigint} — tbigint temporal family. */ + public static int ever_lt_tbigint_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_lt_tbigint_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_lt_tbigint_bigint(arg0, arg1); + } + + /** MEOS {@code ever_ne_bigint_tbigint} — tbigint temporal family. */ + public static int ever_ne_bigint_tbigint(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ne_bigint_tbigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ne_bigint_tbigint(arg0, arg1); + } + + /** MEOS {@code ever_ne_tbigint_bigint} — tbigint temporal family. */ + public static int ever_ne_tbigint_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ne_tbigint_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ne_tbigint_bigint(arg0, arg1); + } + + /** MEOS {@code mul_bigint_tbigint} — tbigint temporal family. */ + public static jnr.ffi.Pointer mul_bigint_tbigint(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "mul_bigint_tbigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.mul_bigint_tbigint(arg0, arg1); + } + + /** MEOS {@code mul_tbigint_bigint} — tbigint temporal family. */ + public static jnr.ffi.Pointer mul_tbigint_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "mul_tbigint_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.mul_tbigint_bigint(arg0, arg1); + } + + /** MEOS {@code sub_bigint_tbigint} — tbigint temporal family. */ + public static jnr.ffi.Pointer sub_bigint_tbigint(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "sub_bigint_tbigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.sub_bigint_tbigint(arg0, arg1); + } + + /** MEOS {@code sub_tbigint_bigint} — tbigint temporal family. */ + public static jnr.ffi.Pointer sub_tbigint_bigint(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "sub_tbigint_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.sub_tbigint_bigint(arg0, arg1); + } + + /** MEOS {@code tbigint_at_value} — tbigint temporal family. */ + public static jnr.ffi.Pointer tbigint_at_value(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbigint_at_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbigint_at_value(arg0, arg1); + } + + /** MEOS {@code tbigint_end_value} — tbigint temporal family. */ + public static long tbigint_end_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbigint_end_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbigint_end_value(arg0); + } + + /** MEOS {@code tbigint_from_base_temp} — tbigint temporal family. */ + public static jnr.ffi.Pointer tbigint_from_base_temp(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbigint_from_base_temp requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbigint_from_base_temp(arg0, arg1); + } + + /** MEOS {@code tbigint_from_mfjson} — tbigint temporal family. */ + public static jnr.ffi.Pointer tbigint_from_mfjson(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbigint_from_mfjson requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbigint_from_mfjson(arg0); + } + + /** MEOS {@code tbigint_in} — tbigint temporal family. */ + public static jnr.ffi.Pointer tbigint_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbigint_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbigint_in(arg0); + } + + /** MEOS {@code tbigint_max_value} — tbigint temporal family. */ + public static long tbigint_max_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbigint_max_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbigint_max_value(arg0); + } + + /** MEOS {@code tbigint_min_value} — tbigint temporal family. */ + public static long tbigint_min_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbigint_min_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbigint_min_value(arg0); + } + + /** MEOS {@code tbigint_minus_value} — tbigint temporal family. */ + public static jnr.ffi.Pointer tbigint_minus_value(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbigint_minus_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbigint_minus_value(arg0, arg1); + } + + /** MEOS {@code tbigint_out} — tbigint temporal family. */ + public static java.lang.String tbigint_out(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbigint_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbigint_out(arg0); + } + + /** MEOS {@code tbigint_scale_value} — tbigint temporal family. */ + public static jnr.ffi.Pointer tbigint_scale_value(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbigint_scale_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbigint_scale_value(arg0, arg1); + } + + /** MEOS {@code tbigint_shift_scale_value} — tbigint temporal family. */ + public static jnr.ffi.Pointer tbigint_shift_scale_value(jnr.ffi.Pointer arg0, long arg1, long arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbigint_shift_scale_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbigint_shift_scale_value(arg0, arg1, arg2); + } + + /** MEOS {@code tbigint_shift_value} — tbigint temporal family. */ + public static jnr.ffi.Pointer tbigint_shift_value(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbigint_shift_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbigint_shift_value(arg0, arg1); + } + + /** MEOS {@code tbigint_start_value} — tbigint temporal family. */ + public static long tbigint_start_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbigint_start_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbigint_start_value(arg0); + } + + /** MEOS {@code tbigint_to_tfloat} — tbigint temporal family. */ + public static jnr.ffi.Pointer tbigint_to_tfloat(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbigint_to_tfloat requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbigint_to_tfloat(arg0); + } + + /** MEOS {@code tbigint_to_tint} — tbigint temporal family. */ + public static jnr.ffi.Pointer tbigint_to_tint(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbigint_to_tint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbigint_to_tint(arg0); + } + + /** MEOS {@code tbigint_value_at_timestamptz} — tbigint temporal family. */ + public static boolean tbigint_value_at_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1, boolean arg2, jnr.ffi.Pointer arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbigint_value_at_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbigint_value_at_timestamptz(arg0, arg1, arg2, arg3); + } + + /** MEOS {@code tbigint_value_n} — tbigint temporal family. */ + public static jnr.ffi.Pointer tbigint_value_n(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbigint_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbigint_value_n(arg0, arg1); + } + + /** MEOS {@code tbigint_values} — tbigint temporal family. */ + public static jnr.ffi.Pointer tbigint_values(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbigint_values requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbigint_values(arg0, arg1); + } + + /** MEOS {@code tbigintbox_expand} — tbigint temporal family. */ + public static jnr.ffi.Pointer tbigintbox_expand(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbigintbox_expand requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbigintbox_expand(arg0, arg1); + } + + /** MEOS {@code tbigintbox_shift_scale} — tbigint temporal family. */ + public static jnr.ffi.Pointer tbigintbox_shift_scale(jnr.ffi.Pointer arg0, long arg1, long arg2, boolean arg3, boolean arg4) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbigintbox_shift_scale requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbigintbox_shift_scale(arg0, arg1, arg2, arg3, arg4); + } + + /** MEOS {@code tbigintinst_make} — tbigint temporal family. */ + public static jnr.ffi.Pointer tbigintinst_make(long arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbigintinst_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbigintinst_make(arg0, arg1); + } + + /** MEOS {@code tbigintseq_from_base_tstzset} — tbigint temporal family. */ + public static jnr.ffi.Pointer tbigintseq_from_base_tstzset(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbigintseq_from_base_tstzset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbigintseq_from_base_tstzset(arg0, arg1); + } + + /** MEOS {@code tbigintseq_from_base_tstzspan} — tbigint temporal family. */ + public static jnr.ffi.Pointer tbigintseq_from_base_tstzspan(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbigintseq_from_base_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbigintseq_from_base_tstzspan(arg0, arg1); + } + + /** MEOS {@code tbigintseqset_from_base_tstzspanset} — tbigint temporal family. */ + public static jnr.ffi.Pointer tbigintseqset_from_base_tstzspanset(long arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbigintseqset_from_base_tstzspanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbigintseqset_from_base_tstzspanset(arg0, arg1); + } + + /** MEOS {@code tfloat_to_tbigint} — tbigint temporal family. */ + public static jnr.ffi.Pointer tfloat_to_tbigint(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_to_tbigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_to_tbigint(arg0); + } + + /** MEOS {@code tint_to_tbigint} — tbigint temporal family. */ + public static jnr.ffi.Pointer tint_to_tbigint(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tint_to_tbigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tint_to_tbigint(arg0); + } +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTBool.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTBool.java new file mode 100644 index 0000000..dba0813 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTBool.java @@ -0,0 +1,228 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: TBool + * Methods emitted: 15 (bounded-state=8 · io-meta=3 · stateless=2 · windowed=2) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsTBool { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsTBool() { /* utility */ } + + /** + * MEOS {@code tbool_from_base_temp} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code constructor}.

+ *

Classification: constructor of instant/scalar

+ */ + public static jnr.ffi.Pointer tbool_from_base_temp(boolean arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbool_from_base_temp requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbool_from_base_temp(arg0, arg1); + } + + /** + * MEOS {@code tbool_to_tint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer tbool_to_tint(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbool_to_tint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbool_to_tint(arg0); + } + + /** + * MEOS {@code tbool_at_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tbool_at_value(jnr.ffi.Pointer arg0, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbool_at_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbool_at_value(arg0, arg1); + } + + /** + * MEOS {@code tbool_end_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static boolean tbool_end_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbool_end_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbool_end_value(arg0); + } + + /** + * MEOS {@code tbool_minus_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tbool_minus_value(jnr.ffi.Pointer arg0, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbool_minus_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbool_minus_value(arg0, arg1); + } + + /** + * MEOS {@code tbool_start_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static boolean tbool_start_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbool_start_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbool_start_value(arg0); + } + + /** + * MEOS {@code tbool_value_at_timestamptz} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static boolean tbool_value_at_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1, boolean arg2, jnr.ffi.Pointer arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbool_value_at_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbool_value_at_timestamptz(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code tbool_value_n} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tbool_value_n(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbool_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbool_value_n(arg0, arg1); + } + + /** + * MEOS {@code tbool_values} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tbool_values(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbool_values requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbool_values(arg0, arg1); + } + + /** + * MEOS {@code tbool_when_true} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tbool_when_true(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbool_when_true requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbool_when_true(arg0); + } + + /** + * MEOS {@code tbool_tand_transfn} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Object-model role: {@code aggregate}.

+ *

Classification: role=aggregate

+ */ + public static jnr.ffi.Pointer tbool_tand_transfn(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbool_tand_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbool_tand_transfn(arg0, arg1); + } + + /** + * MEOS {@code tbool_tor_transfn} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Object-model role: {@code aggregate}.

+ *

Classification: role=aggregate

+ */ + public static jnr.ffi.Pointer tbool_tor_transfn(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbool_tor_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbool_tor_transfn(arg0, arg1); + } + + /** + * MEOS {@code tbool_from_mfjson} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer tbool_from_mfjson(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbool_from_mfjson requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbool_from_mfjson(arg0); + } + + /** + * MEOS {@code tbool_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer tbool_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbool_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbool_in(arg0); + } + + /** + * MEOS {@code tbool_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static java.lang.String tbool_out(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbool_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbool_out(arg0); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTBoolInst.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTBoolInst.java new file mode 100644 index 0000000..a071335 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTBoolInst.java @@ -0,0 +1,32 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: TBoolInst + * Methods emitted: 1 (stateless=1) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsTBoolInst { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsTBoolInst() { /* utility */ } + + /** + * MEOS {@code tboolinst_make} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code constructor}.

+ *

Classification: constructor of instant/scalar

+ */ + public static jnr.ffi.Pointer tboolinst_make(boolean arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tboolinst_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tboolinst_make(arg0, arg1); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTBox.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTBox.java new file mode 100644 index 0000000..ee43b40 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTBox.java @@ -0,0 +1,480 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: TBox + * Methods emitted: 33 (bounded-state=22 · io-meta=6 · stateless=5) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsTBox { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsTBox() { /* utility */ } + + /** + * MEOS {@code tbox_copy} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code constructor}.

+ *

Classification: constructor of instant/scalar

+ */ + public static jnr.ffi.Pointer tbox_copy(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_copy requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_copy(arg0); + } + + /** + * MEOS {@code tbox_make} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code constructor}.

+ *

Classification: constructor of instant/scalar

+ */ + public static jnr.ffi.Pointer tbox_make(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_make(arg0, arg1); + } + + /** + * MEOS {@code tbox_to_floatspan} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer tbox_to_floatspan(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_to_floatspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_to_floatspan(arg0); + } + + /** + * MEOS {@code tbox_to_intspan} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer tbox_to_intspan(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_to_intspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_to_intspan(arg0); + } + + /** + * MEOS {@code tbox_to_tstzspan} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer tbox_to_tstzspan(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_to_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_to_tstzspan(arg0); + } + + /** + * MEOS {@code tbox_cmp} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 1 temporal

+ */ + public static int tbox_cmp(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_cmp requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_cmp(arg0, arg1); + } + + /** + * MEOS {@code tbox_eq} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 1 temporal

+ */ + public static boolean tbox_eq(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_eq requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_eq(arg0, arg1); + } + + /** + * MEOS {@code tbox_expand_time} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tbox_expand_time(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_expand_time requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_expand_time(arg0, arg1); + } + + /** + * MEOS {@code tbox_ge} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 1 temporal

+ */ + public static boolean tbox_ge(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_ge requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_ge(arg0, arg1); + } + + /** + * MEOS {@code tbox_gt} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 1 temporal

+ */ + public static boolean tbox_gt(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_gt requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_gt(arg0, arg1); + } + + /** + * MEOS {@code tbox_hash} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static int tbox_hash(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_hash requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_hash(arg0); + } + + /** + * MEOS {@code tbox_hash_extended} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static long tbox_hash_extended(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_hash_extended requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_hash_extended(arg0, arg1); + } + + /** + * MEOS {@code tbox_hast} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static boolean tbox_hast(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_hast requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_hast(arg0); + } + + /** + * MEOS {@code tbox_hasx} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static boolean tbox_hasx(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_hasx requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_hasx(arg0); + } + + /** + * MEOS {@code tbox_le} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 1 temporal

+ */ + public static boolean tbox_le(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_le requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_le(arg0, arg1); + } + + /** + * MEOS {@code tbox_lt} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 1 temporal

+ */ + public static boolean tbox_lt(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_lt requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_lt(arg0, arg1); + } + + /** + * MEOS {@code tbox_ne} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 1 temporal

+ */ + public static boolean tbox_ne(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_ne requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_ne(arg0, arg1); + } + + /** + * MEOS {@code tbox_round} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tbox_round(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_round requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_round(arg0, arg1); + } + + /** + * MEOS {@code tbox_shift_scale_time} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tbox_shift_scale_time(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, jnr.ffi.Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_shift_scale_time requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_shift_scale_time(arg0, arg1, arg2); + } + + /** + * MEOS {@code tbox_tmax} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tbox_tmax(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_tmax requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_tmax(arg0); + } + + /** + * MEOS {@code tbox_tmax_inc} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tbox_tmax_inc(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_tmax_inc requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_tmax_inc(arg0); + } + + /** + * MEOS {@code tbox_tmin} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tbox_tmin(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_tmin requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_tmin(arg0); + } + + /** + * MEOS {@code tbox_tmin_inc} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tbox_tmin_inc(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_tmin_inc requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_tmin_inc(arg0); + } + + /** + * MEOS {@code tbox_xmax} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tbox_xmax(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_xmax requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_xmax(arg0); + } + + /** + * MEOS {@code tbox_xmax_inc} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tbox_xmax_inc(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_xmax_inc requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_xmax_inc(arg0); + } + + /** + * MEOS {@code tbox_xmin} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tbox_xmin(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_xmin requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_xmin(arg0); + } + + /** + * MEOS {@code tbox_xmin_inc} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tbox_xmin_inc(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_xmin_inc requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_xmin_inc(arg0); + } + + /** + * MEOS {@code tbox_as_hexwkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static java.lang.String tbox_as_hexwkb(jnr.ffi.Pointer arg0, byte arg1, jnr.ffi.Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_as_hexwkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_as_hexwkb(arg0, arg1, arg2); + } + + /** + * MEOS {@code tbox_as_wkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer tbox_as_wkb(jnr.ffi.Pointer arg0, byte arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_as_wkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_as_wkb(arg0, arg1); + } + + /** + * MEOS {@code tbox_from_hexwkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer tbox_from_hexwkb(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_from_hexwkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_from_hexwkb(arg0); + } + + /** + * MEOS {@code tbox_from_wkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer tbox_from_wkb(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_from_wkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_from_wkb(arg0, arg1); + } + + /** + * MEOS {@code tbox_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer tbox_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_in(arg0); + } + + /** + * MEOS {@code tbox_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static java.lang.String tbox_out(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_out(arg0, arg1); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTCbuffer.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTCbuffer.java new file mode 100644 index 0000000..a1ae4b2 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTCbuffer.java @@ -0,0 +1,228 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: TCbuffer + * Methods emitted: 15 (bounded-state=10 · stateless=3 · io-meta=2) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsTCbuffer { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsTCbuffer() { /* utility */ } + + /** + * MEOS {@code tcbuffer_make} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code constructor}.

+ *

Classification: constructor of instant/scalar

+ */ + public static jnr.ffi.Pointer tcbuffer_make(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tcbuffer_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tcbuffer_make(arg0, arg1); + } + + /** + * MEOS {@code tcbuffer_to_tfloat} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer tcbuffer_to_tfloat(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tcbuffer_to_tfloat requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tcbuffer_to_tfloat(arg0); + } + + /** + * MEOS {@code tcbuffer_to_tgeompoint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer tcbuffer_to_tgeompoint(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tcbuffer_to_tgeompoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tcbuffer_to_tgeompoint(arg0); + } + + /** + * MEOS {@code tcbuffer_at_cbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tcbuffer_at_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tcbuffer_at_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tcbuffer_at_cbuffer(arg0, arg1); + } + + /** + * MEOS {@code tcbuffer_at_geom} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tcbuffer_at_geom(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tcbuffer_at_geom requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tcbuffer_at_geom(arg0, arg1); + } + + /** + * MEOS {@code tcbuffer_at_stbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tcbuffer_at_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tcbuffer_at_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tcbuffer_at_stbox(arg0, arg1, arg2); + } + + /** + * MEOS {@code tcbuffer_expand} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tcbuffer_expand(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tcbuffer_expand requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tcbuffer_expand(arg0, arg1); + } + + /** + * MEOS {@code tcbuffer_minus_cbuffer} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tcbuffer_minus_cbuffer(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tcbuffer_minus_cbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tcbuffer_minus_cbuffer(arg0, arg1); + } + + /** + * MEOS {@code tcbuffer_minus_geom} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tcbuffer_minus_geom(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tcbuffer_minus_geom requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tcbuffer_minus_geom(arg0, arg1); + } + + /** + * MEOS {@code tcbuffer_minus_stbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tcbuffer_minus_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tcbuffer_minus_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tcbuffer_minus_stbox(arg0, arg1, arg2); + } + + /** + * MEOS {@code tcbuffer_points} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tcbuffer_points(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tcbuffer_points requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tcbuffer_points(arg0); + } + + /** + * MEOS {@code tcbuffer_radius} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tcbuffer_radius(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tcbuffer_radius requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tcbuffer_radius(arg0); + } + + /** + * MEOS {@code tcbuffer_trav_area} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tcbuffer_trav_area(jnr.ffi.Pointer arg0, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tcbuffer_trav_area requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tcbuffer_trav_area(arg0, arg1); + } + + /** + * MEOS {@code tcbuffer_from_mfjson} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer tcbuffer_from_mfjson(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tcbuffer_from_mfjson requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tcbuffer_from_mfjson(arg0); + } + + /** + * MEOS {@code tcbuffer_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer tcbuffer_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tcbuffer_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tcbuffer_in(arg0); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTFloat.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTFloat.java new file mode 100644 index 0000000..09ca22a --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTFloat.java @@ -0,0 +1,536 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: TFloat + * Methods emitted: 37 (bounded-state=26 · windowed=6 · io-meta=3 · stateless=2) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsTFloat { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsTFloat() { /* utility */ } + + /** + * MEOS {@code tfloat_from_base_temp} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code constructor}.

+ *

Classification: constructor of instant/scalar

+ */ + public static jnr.ffi.Pointer tfloat_from_base_temp(double arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_from_base_temp requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_from_base_temp(arg0, arg1); + } + + /** + * MEOS {@code tfloat_to_tint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer tfloat_to_tint(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_to_tint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_to_tint(arg0); + } + + /** + * MEOS {@code tfloat_at_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tfloat_at_value(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_at_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_at_value(arg0, arg1); + } + + /** + * MEOS {@code tfloat_avg_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static double tfloat_avg_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_avg_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_avg_value(arg0); + } + + /** + * MEOS {@code tfloat_ceil} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tfloat_ceil(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_ceil requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_ceil(arg0); + } + + /** + * MEOS {@code tfloat_degrees} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tfloat_degrees(jnr.ffi.Pointer arg0, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_degrees requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_degrees(arg0, arg1); + } + + /** + * MEOS {@code tfloat_end_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static double tfloat_end_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_end_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_end_value(arg0); + } + + /** + * MEOS {@code tfloat_exp} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tfloat_exp(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_exp requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_exp(arg0); + } + + /** + * MEOS {@code tfloat_floor} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tfloat_floor(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_floor requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_floor(arg0); + } + + /** + * MEOS {@code tfloat_ln} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tfloat_ln(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_ln requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_ln(arg0); + } + + /** + * MEOS {@code tfloat_log10} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tfloat_log10(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_log10 requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_log10(arg0); + } + + /** + * MEOS {@code tfloat_max_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static double tfloat_max_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_max_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_max_value(arg0); + } + + /** + * MEOS {@code tfloat_min_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static double tfloat_min_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_min_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_min_value(arg0); + } + + /** + * MEOS {@code tfloat_minus_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tfloat_minus_value(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_minus_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_minus_value(arg0, arg1); + } + + /** + * MEOS {@code tfloat_radians} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tfloat_radians(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_radians requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_radians(arg0); + } + + /** + * MEOS {@code tfloat_scale_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tfloat_scale_value(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_scale_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_scale_value(arg0, arg1); + } + + /** + * MEOS {@code tfloat_shift_scale_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tfloat_shift_scale_value(jnr.ffi.Pointer arg0, double arg1, double arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_shift_scale_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_shift_scale_value(arg0, arg1, arg2); + } + + /** + * MEOS {@code tfloat_shift_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tfloat_shift_value(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_shift_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_shift_value(arg0, arg1); + } + + /** + * MEOS {@code tfloat_start_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static double tfloat_start_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_start_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_start_value(arg0); + } + + /** + * MEOS {@code tfloat_time_boxes} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tfloat_time_boxes(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, java.time.OffsetDateTime arg2, jnr.ffi.Pointer arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_time_boxes requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_time_boxes(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code tfloat_value_at_timestamptz} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static boolean tfloat_value_at_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1, boolean arg2, jnr.ffi.Pointer arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_value_at_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_value_at_timestamptz(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code tfloat_value_bins} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tfloat_value_bins(jnr.ffi.Pointer arg0, double arg1, double arg2, jnr.ffi.Pointer arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_value_bins requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_value_bins(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code tfloat_value_boxes} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tfloat_value_boxes(jnr.ffi.Pointer arg0, double arg1, double arg2, jnr.ffi.Pointer arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_value_boxes requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_value_boxes(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code tfloat_value_n} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tfloat_value_n(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_value_n(arg0, arg1); + } + + /** + * MEOS {@code tfloat_value_split} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tfloat_value_split(jnr.ffi.Pointer arg0, double arg1, double arg2, jnr.ffi.Pointer arg3, jnr.ffi.Pointer arg4) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_value_split requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_value_split(arg0, arg1, arg2, arg3, arg4); + } + + /** + * MEOS {@code tfloat_value_time_boxes} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tfloat_value_time_boxes(jnr.ffi.Pointer arg0, double arg1, jnr.ffi.Pointer arg2, double arg3, java.time.OffsetDateTime arg4, jnr.ffi.Pointer arg5) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_value_time_boxes requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_value_time_boxes(arg0, arg1, arg2, arg3, arg4, arg5); + } + + /** + * MEOS {@code tfloat_value_time_split} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tfloat_value_time_split(jnr.ffi.Pointer arg0, double arg1, jnr.ffi.Pointer arg2, double arg3, java.time.OffsetDateTime arg4, jnr.ffi.Pointer arg5, jnr.ffi.Pointer arg6, jnr.ffi.Pointer arg7) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_value_time_split requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_value_time_split(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); + } + + /** + * MEOS {@code tfloat_values} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tfloat_values(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_values requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_values(arg0, arg1); + } + + /** + * MEOS {@code tfloat_tmax_transfn} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Object-model role: {@code aggregate}.

+ *

Classification: role=aggregate

+ */ + public static jnr.ffi.Pointer tfloat_tmax_transfn(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_tmax_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_tmax_transfn(arg0, arg1); + } + + /** + * MEOS {@code tfloat_tmin_transfn} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Object-model role: {@code aggregate}.

+ *

Classification: role=aggregate

+ */ + public static jnr.ffi.Pointer tfloat_tmin_transfn(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_tmin_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_tmin_transfn(arg0, arg1); + } + + /** + * MEOS {@code tfloat_tsum_transfn} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Object-model role: {@code aggregate}.

+ *

Classification: role=aggregate

+ */ + public static jnr.ffi.Pointer tfloat_tsum_transfn(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_tsum_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_tsum_transfn(arg0, arg1); + } + + /** + * MEOS {@code tfloat_wmax_transfn} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Object-model role: {@code aggregate}.

+ *

Classification: role=aggregate

+ */ + public static jnr.ffi.Pointer tfloat_wmax_transfn(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, jnr.ffi.Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_wmax_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_wmax_transfn(arg0, arg1, arg2); + } + + /** + * MEOS {@code tfloat_wmin_transfn} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Object-model role: {@code aggregate}.

+ *

Classification: role=aggregate

+ */ + public static jnr.ffi.Pointer tfloat_wmin_transfn(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, jnr.ffi.Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_wmin_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_wmin_transfn(arg0, arg1, arg2); + } + + /** + * MEOS {@code tfloat_wsum_transfn} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Object-model role: {@code aggregate}.

+ *

Classification: role=aggregate

+ */ + public static jnr.ffi.Pointer tfloat_wsum_transfn(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, jnr.ffi.Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_wsum_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_wsum_transfn(arg0, arg1, arg2); + } + + /** + * MEOS {@code tfloat_from_mfjson} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer tfloat_from_mfjson(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_from_mfjson requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_from_mfjson(arg0); + } + + /** + * MEOS {@code tfloat_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer tfloat_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_in(arg0); + } + + /** + * MEOS {@code tfloat_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static java.lang.String tfloat_out(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_out(arg0, arg1); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTFloatInst.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTFloatInst.java new file mode 100644 index 0000000..9de3847 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTFloatInst.java @@ -0,0 +1,32 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: TFloatInst + * Methods emitted: 1 (stateless=1) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsTFloatInst { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsTFloatInst() { /* utility */ } + + /** + * MEOS {@code tfloatinst_make} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code constructor}.

+ *

Classification: constructor of instant/scalar

+ */ + public static jnr.ffi.Pointer tfloatinst_make(double arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloatinst_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloatinst_make(arg0, arg1); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTGeo.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTGeo.java new file mode 100644 index 0000000..27558e7 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTGeo.java @@ -0,0 +1,354 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: TGeo + * Methods emitted: 24 (bounded-state=23 · stateless=1) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsTGeo { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsTGeo() { /* utility */ } + + /** + * MEOS {@code tgeo_from_base_temp} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code constructor}.

+ *

Classification: constructor of instant/scalar

+ */ + public static jnr.ffi.Pointer tgeo_from_base_temp(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeo_from_base_temp requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeo_from_base_temp(arg0, arg1); + } + + /** + * MEOS {@code tgeo_affine} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tgeo_affine(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeo_affine requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeo_affine(arg0, arg1); + } + + /** + * MEOS {@code tgeo_at_geom} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tgeo_at_geom(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeo_at_geom requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeo_at_geom(arg0, arg1); + } + + /** + * MEOS {@code tgeo_at_stbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tgeo_at_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeo_at_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeo_at_stbox(arg0, arg1, arg2); + } + + /** + * MEOS {@code tgeo_at_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tgeo_at_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeo_at_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeo_at_value(arg0, arg1); + } + + /** + * MEOS {@code tgeo_centroid} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tgeo_centroid(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeo_centroid requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeo_centroid(arg0); + } + + /** + * MEOS {@code tgeo_convex_hull} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tgeo_convex_hull(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeo_convex_hull requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeo_convex_hull(arg0); + } + + /** + * MEOS {@code tgeo_end_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tgeo_end_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeo_end_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeo_end_value(arg0); + } + + /** + * MEOS {@code tgeo_minus_geom} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tgeo_minus_geom(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeo_minus_geom requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeo_minus_geom(arg0, arg1); + } + + /** + * MEOS {@code tgeo_minus_stbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tgeo_minus_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeo_minus_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeo_minus_stbox(arg0, arg1, arg2); + } + + /** + * MEOS {@code tgeo_minus_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tgeo_minus_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeo_minus_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeo_minus_value(arg0, arg1); + } + + /** + * MEOS {@code tgeo_scale} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tgeo_scale(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, jnr.ffi.Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeo_scale requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeo_scale(arg0, arg1, arg2); + } + + /** + * MEOS {@code tgeo_space_boxes} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tgeo_space_boxes(jnr.ffi.Pointer arg0, double arg1, double arg2, double arg3, jnr.ffi.Pointer arg4, boolean arg5, boolean arg6, jnr.ffi.Pointer arg7) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeo_space_boxes requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeo_space_boxes(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); + } + + /** + * MEOS {@code tgeo_space_split} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tgeo_space_split(jnr.ffi.Pointer arg0, double arg1, double arg2, double arg3, jnr.ffi.Pointer arg4, boolean arg5, boolean arg6, jnr.ffi.Pointer arg7, jnr.ffi.Pointer arg8) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeo_space_split requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeo_space_split(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); + } + + /** + * MEOS {@code tgeo_space_time_boxes} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tgeo_space_time_boxes(jnr.ffi.Pointer arg0, double arg1, double arg2, double arg3, jnr.ffi.Pointer arg4, jnr.ffi.Pointer arg5, java.time.OffsetDateTime arg6, boolean arg7, boolean arg8, jnr.ffi.Pointer arg9) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeo_space_time_boxes requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeo_space_time_boxes(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); + } + + /** + * MEOS {@code tgeo_space_time_split} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tgeo_space_time_split(jnr.ffi.Pointer arg0, double arg1, double arg2, double arg3, jnr.ffi.Pointer arg4, jnr.ffi.Pointer arg5, java.time.OffsetDateTime arg6, boolean arg7, boolean arg8, jnr.ffi.Pointer arg9, jnr.ffi.Pointer arg10, jnr.ffi.Pointer arg11) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeo_space_time_split requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeo_space_time_split(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11); + } + + /** + * MEOS {@code tgeo_split_each_n_stboxes} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tgeo_split_each_n_stboxes(jnr.ffi.Pointer arg0, int arg1, jnr.ffi.Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeo_split_each_n_stboxes requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeo_split_each_n_stboxes(arg0, arg1, arg2); + } + + /** + * MEOS {@code tgeo_split_n_stboxes} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tgeo_split_n_stboxes(jnr.ffi.Pointer arg0, int arg1, jnr.ffi.Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeo_split_n_stboxes requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeo_split_n_stboxes(arg0, arg1, arg2); + } + + /** + * MEOS {@code tgeo_start_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tgeo_start_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeo_start_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeo_start_value(arg0); + } + + /** + * MEOS {@code tgeo_stboxes} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tgeo_stboxes(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeo_stboxes requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeo_stboxes(arg0, arg1); + } + + /** + * MEOS {@code tgeo_traversed_area} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tgeo_traversed_area(jnr.ffi.Pointer arg0, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeo_traversed_area requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeo_traversed_area(arg0, arg1); + } + + /** + * MEOS {@code tgeo_value_at_timestamptz} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static boolean tgeo_value_at_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1, boolean arg2, jnr.ffi.Pointer arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeo_value_at_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeo_value_at_timestamptz(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code tgeo_value_n} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tgeo_value_n(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeo_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeo_value_n(arg0, arg1); + } + + /** + * MEOS {@code tgeo_values} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tgeo_values(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeo_values requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeo_values(arg0, arg1); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTGeogPoint.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTGeogPoint.java new file mode 100644 index 0000000..43b9b8a --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTGeogPoint.java @@ -0,0 +1,60 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: TGeogPoint + * Methods emitted: 3 (io-meta=2 · stateless=1) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsTGeogPoint { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsTGeogPoint() { /* utility */ } + + /** + * MEOS {@code tgeogpoint_to_tgeography} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer tgeogpoint_to_tgeography(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeogpoint_to_tgeography requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeogpoint_to_tgeography(arg0); + } + + /** + * MEOS {@code tgeogpoint_from_mfjson} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer tgeogpoint_from_mfjson(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeogpoint_from_mfjson requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeogpoint_from_mfjson(arg0); + } + + /** + * MEOS {@code tgeogpoint_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer tgeogpoint_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeogpoint_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeogpoint_in(arg0); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTGeography.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTGeography.java new file mode 100644 index 0000000..e891875 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTGeography.java @@ -0,0 +1,74 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: TGeography + * Methods emitted: 4 (io-meta=2 · stateless=2) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsTGeography { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsTGeography() { /* utility */ } + + /** + * MEOS {@code tgeography_to_tgeogpoint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer tgeography_to_tgeogpoint(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeography_to_tgeogpoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeography_to_tgeogpoint(arg0); + } + + /** + * MEOS {@code tgeography_to_tgeometry} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer tgeography_to_tgeometry(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeography_to_tgeometry requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeography_to_tgeometry(arg0); + } + + /** + * MEOS {@code tgeography_from_mfjson} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer tgeography_from_mfjson(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeography_from_mfjson requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeography_from_mfjson(arg0); + } + + /** + * MEOS {@code tgeography_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer tgeography_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeography_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeography_in(arg0); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTGeomPoint.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTGeomPoint.java new file mode 100644 index 0000000..489dc97 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTGeomPoint.java @@ -0,0 +1,74 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: TGeomPoint + * Methods emitted: 4 (io-meta=2 · stateless=2) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsTGeomPoint { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsTGeomPoint() { /* utility */ } + + /** + * MEOS {@code tgeompoint_to_tgeometry} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer tgeompoint_to_tgeometry(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeompoint_to_tgeometry requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeompoint_to_tgeometry(arg0); + } + + /** + * MEOS {@code tgeompoint_to_tnpoint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer tgeompoint_to_tnpoint(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeompoint_to_tnpoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeompoint_to_tnpoint(arg0); + } + + /** + * MEOS {@code tgeompoint_from_mfjson} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer tgeompoint_from_mfjson(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeompoint_from_mfjson requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeompoint_from_mfjson(arg0); + } + + /** + * MEOS {@code tgeompoint_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer tgeompoint_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeompoint_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeompoint_in(arg0); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTGeometry.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTGeometry.java new file mode 100644 index 0000000..e05842f --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTGeometry.java @@ -0,0 +1,88 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: TGeometry + * Methods emitted: 5 (stateless=3 · io-meta=2) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsTGeometry { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsTGeometry() { /* utility */ } + + /** + * MEOS {@code tgeometry_to_tcbuffer} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer tgeometry_to_tcbuffer(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeometry_to_tcbuffer requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeometry_to_tcbuffer(arg0); + } + + /** + * MEOS {@code tgeometry_to_tgeography} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer tgeometry_to_tgeography(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeometry_to_tgeography requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeometry_to_tgeography(arg0); + } + + /** + * MEOS {@code tgeometry_to_tgeompoint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer tgeometry_to_tgeompoint(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeometry_to_tgeompoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeometry_to_tgeompoint(arg0); + } + + /** + * MEOS {@code tgeometry_from_mfjson} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer tgeometry_from_mfjson(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeometry_from_mfjson requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeometry_from_mfjson(arg0); + } + + /** + * MEOS {@code tgeometry_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer tgeometry_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeometry_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeometry_in(arg0); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTInt.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTInt.java new file mode 100644 index 0000000..ca2b9a6 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTInt.java @@ -0,0 +1,424 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: TInt + * Methods emitted: 29 (bounded-state=18 · windowed=6 · io-meta=3 · stateless=2) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsTInt { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsTInt() { /* utility */ } + + /** + * MEOS {@code tint_from_base_temp} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code constructor}.

+ *

Classification: constructor of instant/scalar

+ */ + public static jnr.ffi.Pointer tint_from_base_temp(int arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tint_from_base_temp requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tint_from_base_temp(arg0, arg1); + } + + /** + * MEOS {@code tint_to_tfloat} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer tint_to_tfloat(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tint_to_tfloat requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tint_to_tfloat(arg0); + } + + /** + * MEOS {@code tint_at_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tint_at_value(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tint_at_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tint_at_value(arg0, arg1); + } + + /** + * MEOS {@code tint_end_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static int tint_end_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tint_end_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tint_end_value(arg0); + } + + /** + * MEOS {@code tint_max_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static int tint_max_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tint_max_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tint_max_value(arg0); + } + + /** + * MEOS {@code tint_min_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static int tint_min_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tint_min_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tint_min_value(arg0); + } + + /** + * MEOS {@code tint_minus_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tint_minus_value(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tint_minus_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tint_minus_value(arg0, arg1); + } + + /** + * MEOS {@code tint_scale_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tint_scale_value(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tint_scale_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tint_scale_value(arg0, arg1); + } + + /** + * MEOS {@code tint_shift_scale_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tint_shift_scale_value(jnr.ffi.Pointer arg0, int arg1, int arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tint_shift_scale_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tint_shift_scale_value(arg0, arg1, arg2); + } + + /** + * MEOS {@code tint_shift_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tint_shift_value(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tint_shift_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tint_shift_value(arg0, arg1); + } + + /** + * MEOS {@code tint_start_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static int tint_start_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tint_start_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tint_start_value(arg0); + } + + /** + * MEOS {@code tint_time_boxes} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tint_time_boxes(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, java.time.OffsetDateTime arg2, jnr.ffi.Pointer arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tint_time_boxes requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tint_time_boxes(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code tint_value_at_timestamptz} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static boolean tint_value_at_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1, boolean arg2, jnr.ffi.Pointer arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tint_value_at_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tint_value_at_timestamptz(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code tint_value_bins} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tint_value_bins(jnr.ffi.Pointer arg0, int arg1, int arg2, jnr.ffi.Pointer arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tint_value_bins requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tint_value_bins(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code tint_value_boxes} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tint_value_boxes(jnr.ffi.Pointer arg0, int arg1, int arg2, jnr.ffi.Pointer arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tint_value_boxes requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tint_value_boxes(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code tint_value_n} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tint_value_n(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tint_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tint_value_n(arg0, arg1); + } + + /** + * MEOS {@code tint_value_split} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tint_value_split(jnr.ffi.Pointer arg0, int arg1, int arg2, jnr.ffi.Pointer arg3, jnr.ffi.Pointer arg4) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tint_value_split requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tint_value_split(arg0, arg1, arg2, arg3, arg4); + } + + /** + * MEOS {@code tint_value_time_boxes} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tint_value_time_boxes(jnr.ffi.Pointer arg0, int arg1, jnr.ffi.Pointer arg2, int arg3, java.time.OffsetDateTime arg4, jnr.ffi.Pointer arg5) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tint_value_time_boxes requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tint_value_time_boxes(arg0, arg1, arg2, arg3, arg4, arg5); + } + + /** + * MEOS {@code tint_value_time_split} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tint_value_time_split(jnr.ffi.Pointer arg0, long arg1, jnr.ffi.Pointer arg2, int arg3, java.time.OffsetDateTime arg4, jnr.ffi.Pointer arg5, jnr.ffi.Pointer arg6, jnr.ffi.Pointer arg7) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tint_value_time_split requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tint_value_time_split(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); + } + + /** + * MEOS {@code tint_values} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tint_values(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tint_values requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tint_values(arg0, arg1); + } + + /** + * MEOS {@code tint_tmax_transfn} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Object-model role: {@code aggregate}.

+ *

Classification: role=aggregate

+ */ + public static jnr.ffi.Pointer tint_tmax_transfn(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tint_tmax_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tint_tmax_transfn(arg0, arg1); + } + + /** + * MEOS {@code tint_tmin_transfn} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Object-model role: {@code aggregate}.

+ *

Classification: role=aggregate

+ */ + public static jnr.ffi.Pointer tint_tmin_transfn(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tint_tmin_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tint_tmin_transfn(arg0, arg1); + } + + /** + * MEOS {@code tint_tsum_transfn} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Object-model role: {@code aggregate}.

+ *

Classification: role=aggregate

+ */ + public static jnr.ffi.Pointer tint_tsum_transfn(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tint_tsum_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tint_tsum_transfn(arg0, arg1); + } + + /** + * MEOS {@code tint_wmax_transfn} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Object-model role: {@code aggregate}.

+ *

Classification: role=aggregate

+ */ + public static jnr.ffi.Pointer tint_wmax_transfn(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, jnr.ffi.Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tint_wmax_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tint_wmax_transfn(arg0, arg1, arg2); + } + + /** + * MEOS {@code tint_wmin_transfn} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Object-model role: {@code aggregate}.

+ *

Classification: role=aggregate

+ */ + public static jnr.ffi.Pointer tint_wmin_transfn(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, jnr.ffi.Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tint_wmin_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tint_wmin_transfn(arg0, arg1, arg2); + } + + /** + * MEOS {@code tint_wsum_transfn} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Object-model role: {@code aggregate}.

+ *

Classification: role=aggregate

+ */ + public static jnr.ffi.Pointer tint_wsum_transfn(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, jnr.ffi.Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tint_wsum_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tint_wsum_transfn(arg0, arg1, arg2); + } + + /** + * MEOS {@code tint_from_mfjson} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer tint_from_mfjson(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tint_from_mfjson requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tint_from_mfjson(arg0); + } + + /** + * MEOS {@code tint_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer tint_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tint_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tint_in(arg0); + } + + /** + * MEOS {@code tint_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static java.lang.String tint_out(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tint_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tint_out(arg0); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTIntInst.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTIntInst.java new file mode 100644 index 0000000..7c3db87 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTIntInst.java @@ -0,0 +1,32 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: TIntInst + * Methods emitted: 1 (stateless=1) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsTIntInst { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsTIntInst() { /* utility */ } + + /** + * MEOS {@code tintinst_make} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code constructor}.

+ *

Classification: constructor of instant/scalar

+ */ + public static jnr.ffi.Pointer tintinst_make(int arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tintinst_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tintinst_make(arg0, arg1); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTNpoint.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTNpoint.java new file mode 100644 index 0000000..dc0d68b --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTNpoint.java @@ -0,0 +1,312 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: TNpoint + * Methods emitted: 21 (bounded-state=16 · io-meta=3 · stateless=1 · windowed=1) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsTNpoint { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsTNpoint() { /* utility */ } + + /** + * MEOS {@code tnpoint_to_tgeompoint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer tnpoint_to_tgeompoint(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnpoint_to_tgeompoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnpoint_to_tgeompoint(arg0); + } + + /** + * MEOS {@code tnpoint_at_geom} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tnpoint_at_geom(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnpoint_at_geom requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnpoint_at_geom(arg0, arg1); + } + + /** + * MEOS {@code tnpoint_at_npoint} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tnpoint_at_npoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnpoint_at_npoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnpoint_at_npoint(arg0, arg1); + } + + /** + * MEOS {@code tnpoint_at_npointset} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tnpoint_at_npointset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnpoint_at_npointset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnpoint_at_npointset(arg0, arg1); + } + + /** + * MEOS {@code tnpoint_at_stbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tnpoint_at_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnpoint_at_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnpoint_at_stbox(arg0, arg1, arg2); + } + + /** + * MEOS {@code tnpoint_cumulative_length} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tnpoint_cumulative_length(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnpoint_cumulative_length requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnpoint_cumulative_length(arg0); + } + + /** + * MEOS {@code tnpoint_length} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static double tnpoint_length(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnpoint_length requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnpoint_length(arg0); + } + + /** + * MEOS {@code tnpoint_minus_geom} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tnpoint_minus_geom(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnpoint_minus_geom requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnpoint_minus_geom(arg0, arg1); + } + + /** + * MEOS {@code tnpoint_minus_npoint} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tnpoint_minus_npoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnpoint_minus_npoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnpoint_minus_npoint(arg0, arg1); + } + + /** + * MEOS {@code tnpoint_minus_npointset} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tnpoint_minus_npointset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnpoint_minus_npointset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnpoint_minus_npointset(arg0, arg1); + } + + /** + * MEOS {@code tnpoint_minus_stbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tnpoint_minus_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnpoint_minus_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnpoint_minus_stbox(arg0, arg1, arg2); + } + + /** + * MEOS {@code tnpoint_positions} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tnpoint_positions(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnpoint_positions requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnpoint_positions(arg0, arg1); + } + + /** + * MEOS {@code tnpoint_route} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static long tnpoint_route(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnpoint_route requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnpoint_route(arg0); + } + + /** + * MEOS {@code tnpoint_routes} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tnpoint_routes(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnpoint_routes requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnpoint_routes(arg0); + } + + /** + * MEOS {@code tnpoint_speed} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tnpoint_speed(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnpoint_speed requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnpoint_speed(arg0); + } + + /** + * MEOS {@code tnpoint_trajectory} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tnpoint_trajectory(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnpoint_trajectory requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnpoint_trajectory(arg0); + } + + /** + * MEOS {@code tnpoint_twcentroid} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tnpoint_twcentroid(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnpoint_twcentroid requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnpoint_twcentroid(arg0); + } + + /** + * MEOS {@code tnpoint_tcentroid_transfn} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Object-model role: {@code aggregate}.

+ *

Classification: role=aggregate

+ */ + public static jnr.ffi.Pointer tnpoint_tcentroid_transfn(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnpoint_tcentroid_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnpoint_tcentroid_transfn(arg0, arg1); + } + + /** + * MEOS {@code tnpoint_from_mfjson} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer tnpoint_from_mfjson(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnpoint_from_mfjson requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnpoint_from_mfjson(arg0); + } + + /** + * MEOS {@code tnpoint_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer tnpoint_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnpoint_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnpoint_in(arg0); + } + + /** + * MEOS {@code tnpoint_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static java.lang.String tnpoint_out(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnpoint_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnpoint_out(arg0, arg1); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTNpointInst.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTNpointInst.java new file mode 100644 index 0000000..f989883 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTNpointInst.java @@ -0,0 +1,32 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: TNpointInst + * Methods emitted: 1 (stateless=1) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsTNpointInst { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsTNpointInst() { /* utility */ } + + /** + * MEOS {@code tnpointinst_make} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code constructor}.

+ *

Classification: constructor of instant/scalar

+ */ + public static jnr.ffi.Pointer tnpointinst_make(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnpointinst_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnpointinst_make(arg0, arg1); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTNumber.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTNumber.java new file mode 100644 index 0000000..af20771 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTNumber.java @@ -0,0 +1,340 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: TNumber + * Methods emitted: 23 (bounded-state=17 · windowed=4 · stateless=2) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsTNumber { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsTNumber() { /* utility */ } + + /** + * MEOS {@code tnumber_to_span} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer tnumber_to_span(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnumber_to_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnumber_to_span(arg0); + } + + /** + * MEOS {@code tnumber_to_tbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer tnumber_to_tbox(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnumber_to_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnumber_to_tbox(arg0); + } + + /** + * MEOS {@code tnumber_abs} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tnumber_abs(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnumber_abs requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnumber_abs(arg0); + } + + /** + * MEOS {@code tnumber_angular_difference} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tnumber_angular_difference(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnumber_angular_difference requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnumber_angular_difference(arg0); + } + + /** + * MEOS {@code tnumber_at_span} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tnumber_at_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnumber_at_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnumber_at_span(arg0, arg1); + } + + /** + * MEOS {@code tnumber_at_spanset} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tnumber_at_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnumber_at_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnumber_at_spanset(arg0, arg1); + } + + /** + * MEOS {@code tnumber_at_tbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tnumber_at_tbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnumber_at_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnumber_at_tbox(arg0, arg1); + } + + /** + * MEOS {@code tnumber_avg_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static double tnumber_avg_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnumber_avg_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnumber_avg_value(arg0); + } + + /** + * MEOS {@code tnumber_delta_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tnumber_delta_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnumber_delta_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnumber_delta_value(arg0); + } + + /** + * MEOS {@code tnumber_integral} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static double tnumber_integral(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnumber_integral requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnumber_integral(arg0); + } + + /** + * MEOS {@code tnumber_minus_span} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tnumber_minus_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnumber_minus_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnumber_minus_span(arg0, arg1); + } + + /** + * MEOS {@code tnumber_minus_spanset} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tnumber_minus_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnumber_minus_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnumber_minus_spanset(arg0, arg1); + } + + /** + * MEOS {@code tnumber_minus_tbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tnumber_minus_tbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnumber_minus_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnumber_minus_tbox(arg0, arg1); + } + + /** + * MEOS {@code tnumber_split_each_n_tboxes} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tnumber_split_each_n_tboxes(jnr.ffi.Pointer arg0, int arg1, jnr.ffi.Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnumber_split_each_n_tboxes requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnumber_split_each_n_tboxes(arg0, arg1, arg2); + } + + /** + * MEOS {@code tnumber_split_n_tboxes} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tnumber_split_n_tboxes(jnr.ffi.Pointer arg0, int arg1, jnr.ffi.Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnumber_split_n_tboxes requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnumber_split_n_tboxes(arg0, arg1, arg2); + } + + /** + * MEOS {@code tnumber_tboxes} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tnumber_tboxes(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnumber_tboxes requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnumber_tboxes(arg0, arg1); + } + + /** + * MEOS {@code tnumber_trend} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tnumber_trend(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnumber_trend requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnumber_trend(arg0); + } + + /** + * MEOS {@code tnumber_twavg} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static double tnumber_twavg(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnumber_twavg requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnumber_twavg(arg0); + } + + /** + * MEOS {@code tnumber_valuespans} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tnumber_valuespans(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnumber_valuespans requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnumber_valuespans(arg0); + } + + /** + * MEOS {@code tnumber_extent_transfn} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Object-model role: {@code aggregate}.

+ *

Classification: role=aggregate

+ */ + public static jnr.ffi.Pointer tnumber_extent_transfn(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnumber_extent_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnumber_extent_transfn(arg0, arg1); + } + + /** + * MEOS {@code tnumber_tavg_finalfn} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Object-model role: {@code aggregate}.

+ *

Classification: role=aggregate

+ */ + public static jnr.ffi.Pointer tnumber_tavg_finalfn(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnumber_tavg_finalfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnumber_tavg_finalfn(arg0); + } + + /** + * MEOS {@code tnumber_tavg_transfn} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Object-model role: {@code aggregate}.

+ *

Classification: role=aggregate

+ */ + public static jnr.ffi.Pointer tnumber_tavg_transfn(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnumber_tavg_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnumber_tavg_transfn(arg0, arg1); + } + + /** + * MEOS {@code tnumber_wavg_transfn} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Object-model role: {@code aggregate}.

+ *

Classification: role=aggregate

+ */ + public static jnr.ffi.Pointer tnumber_wavg_transfn(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, jnr.ffi.Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnumber_wavg_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnumber_wavg_transfn(arg0, arg1, arg2); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTPoint.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTPoint.java new file mode 100644 index 0000000..8a0004d --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTPoint.java @@ -0,0 +1,354 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: TPoint + * Methods emitted: 24 (bounded-state=20 · stateless=2 · windowed=2) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsTPoint { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsTPoint() { /* utility */ } + + /** + * MEOS {@code tpoint_from_base_temp} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code constructor}.

+ *

Classification: constructor of instant/scalar

+ */ + public static jnr.ffi.Pointer tpoint_from_base_temp(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpoint_from_base_temp requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpoint_from_base_temp(arg0, arg1); + } + + /** + * MEOS {@code tpoint_tfloat_to_geomeas} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer tpoint_tfloat_to_geomeas(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpoint_tfloat_to_geomeas requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpoint_tfloat_to_geomeas(arg0, arg1, arg2); + } + + /** + * MEOS {@code tpoint_angular_difference} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tpoint_angular_difference(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpoint_angular_difference requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpoint_angular_difference(arg0); + } + + /** + * MEOS {@code tpoint_as_mvtgeom} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static boolean tpoint_as_mvtgeom(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, int arg2, int arg3, boolean arg4, jnr.ffi.Pointer arg5, jnr.ffi.Pointer arg6, jnr.ffi.Pointer arg7) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpoint_as_mvtgeom requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpoint_as_mvtgeom(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); + } + + /** + * MEOS {@code tpoint_at_elevation} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tpoint_at_elevation(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpoint_at_elevation requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpoint_at_elevation(arg0, arg1); + } + + /** + * MEOS {@code tpoint_at_geom} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tpoint_at_geom(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpoint_at_geom requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpoint_at_geom(arg0, arg1); + } + + /** + * MEOS {@code tpoint_at_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tpoint_at_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpoint_at_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpoint_at_value(arg0, arg1); + } + + /** + * MEOS {@code tpoint_azimuth} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tpoint_azimuth(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpoint_azimuth requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpoint_azimuth(arg0); + } + + /** + * MEOS {@code tpoint_cumulative_length} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tpoint_cumulative_length(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpoint_cumulative_length requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpoint_cumulative_length(arg0); + } + + /** + * MEOS {@code tpoint_direction} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tpoint_direction(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpoint_direction requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpoint_direction(arg0); + } + + /** + * MEOS {@code tpoint_get_x} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tpoint_get_x(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpoint_get_x requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpoint_get_x(arg0); + } + + /** + * MEOS {@code tpoint_get_y} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tpoint_get_y(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpoint_get_y requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpoint_get_y(arg0); + } + + /** + * MEOS {@code tpoint_get_z} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tpoint_get_z(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpoint_get_z requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpoint_get_z(arg0); + } + + /** + * MEOS {@code tpoint_is_simple} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static boolean tpoint_is_simple(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpoint_is_simple requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpoint_is_simple(arg0); + } + + /** + * MEOS {@code tpoint_length} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static double tpoint_length(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpoint_length requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpoint_length(arg0); + } + + /** + * MEOS {@code tpoint_make_simple} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tpoint_make_simple(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpoint_make_simple requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpoint_make_simple(arg0, arg1); + } + + /** + * MEOS {@code tpoint_minus_elevation} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tpoint_minus_elevation(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpoint_minus_elevation requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpoint_minus_elevation(arg0, arg1); + } + + /** + * MEOS {@code tpoint_minus_geom} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tpoint_minus_geom(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpoint_minus_geom requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpoint_minus_geom(arg0, arg1); + } + + /** + * MEOS {@code tpoint_minus_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tpoint_minus_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpoint_minus_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpoint_minus_value(arg0, arg1); + } + + /** + * MEOS {@code tpoint_speed} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tpoint_speed(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpoint_speed requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpoint_speed(arg0); + } + + /** + * MEOS {@code tpoint_trajectory} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tpoint_trajectory(jnr.ffi.Pointer arg0, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpoint_trajectory requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpoint_trajectory(arg0, arg1); + } + + /** + * MEOS {@code tpoint_twcentroid} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tpoint_twcentroid(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpoint_twcentroid requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpoint_twcentroid(arg0); + } + + /** + * MEOS {@code tpoint_tcentroid_finalfn} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Object-model role: {@code aggregate}.

+ *

Classification: role=aggregate

+ */ + public static jnr.ffi.Pointer tpoint_tcentroid_finalfn(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpoint_tcentroid_finalfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpoint_tcentroid_finalfn(arg0); + } + + /** + * MEOS {@code tpoint_tcentroid_transfn} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Object-model role: {@code aggregate}.

+ *

Classification: role=aggregate

+ */ + public static jnr.ffi.Pointer tpoint_tcentroid_transfn(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpoint_tcentroid_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpoint_tcentroid_transfn(arg0, arg1); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTPose.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTPose.java new file mode 100644 index 0000000..a3d1959 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTPose.java @@ -0,0 +1,256 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: TPose + * Methods emitted: 17 (bounded-state=14 · stateless=2 · io-meta=1) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsTPose { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsTPose() { /* utility */ } + + /** + * MEOS {@code tpose_make} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code constructor}.

+ *

Classification: constructor of instant/scalar

+ */ + public static jnr.ffi.Pointer tpose_make(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpose_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpose_make(arg0, arg1); + } + + /** + * MEOS {@code tpose_to_tpoint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer tpose_to_tpoint(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpose_to_tpoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpose_to_tpoint(arg0); + } + + /** + * MEOS {@code tpose_at_geom} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tpose_at_geom(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpose_at_geom requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpose_at_geom(arg0, arg1); + } + + /** + * MEOS {@code tpose_at_pose} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tpose_at_pose(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpose_at_pose requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpose_at_pose(arg0, arg1); + } + + /** + * MEOS {@code tpose_at_stbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tpose_at_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpose_at_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpose_at_stbox(arg0, arg1, arg2); + } + + /** + * MEOS {@code tpose_end_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tpose_end_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpose_end_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpose_end_value(arg0); + } + + /** + * MEOS {@code tpose_minus_geom} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tpose_minus_geom(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpose_minus_geom requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpose_minus_geom(arg0, arg1); + } + + /** + * MEOS {@code tpose_minus_pose} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tpose_minus_pose(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpose_minus_pose requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpose_minus_pose(arg0, arg1); + } + + /** + * MEOS {@code tpose_minus_stbox} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer tpose_minus_stbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpose_minus_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpose_minus_stbox(arg0, arg1, arg2); + } + + /** + * MEOS {@code tpose_points} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tpose_points(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpose_points requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpose_points(arg0); + } + + /** + * MEOS {@code tpose_rotation} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tpose_rotation(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpose_rotation requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpose_rotation(arg0); + } + + /** + * MEOS {@code tpose_start_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tpose_start_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpose_start_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpose_start_value(arg0); + } + + /** + * MEOS {@code tpose_trajectory} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tpose_trajectory(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpose_trajectory requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpose_trajectory(arg0); + } + + /** + * MEOS {@code tpose_value_at_timestamptz} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static boolean tpose_value_at_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1, boolean arg2, jnr.ffi.Pointer arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpose_value_at_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpose_value_at_timestamptz(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code tpose_value_n} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tpose_value_n(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpose_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpose_value_n(arg0, arg1); + } + + /** + * MEOS {@code tpose_values} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tpose_values(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpose_values requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpose_values(arg0, arg1); + } + + /** + * MEOS {@code tpose_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer tpose_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpose_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpose_in(arg0); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTRGeometry.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTRGeometry.java new file mode 100644 index 0000000..ce92704 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTRGeometry.java @@ -0,0 +1,522 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: TRGeometry + * Methods emitted: 36 (bounded-state=32 · stateless=3 · io-meta=1) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsTRGeometry { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsTRGeometry() { /* utility */ } + + /** + * MEOS {@code trgeo_to_tinstant} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer trgeo_to_tinstant(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeo_to_tinstant requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeo_to_tinstant(arg0); + } + + /** + * MEOS {@code trgeo_to_tpoint} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer trgeo_to_tpoint(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeo_to_tpoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeo_to_tpoint(arg0); + } + + /** + * MEOS {@code trgeo_to_tpose} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer trgeo_to_tpose(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeo_to_tpose requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeo_to_tpose(arg0); + } + + /** + * MEOS {@code trgeo_after_timestamptz} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer trgeo_after_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeo_after_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeo_after_timestamptz(arg0, arg1, arg2); + } + + /** + * MEOS {@code trgeo_append_tinstant} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer trgeo_append_tinstant(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, int arg2, double arg3, jnr.ffi.Pointer arg4, boolean arg5) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeo_append_tinstant requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeo_append_tinstant(arg0, arg1, arg2, arg3, arg4, arg5); + } + + /** + * MEOS {@code trgeo_append_tsequence} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer trgeo_append_tsequence(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeo_append_tsequence requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeo_append_tsequence(arg0, arg1, arg2); + } + + /** + * MEOS {@code trgeo_before_timestamptz} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer trgeo_before_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeo_before_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeo_before_timestamptz(arg0, arg1, arg2); + } + + /** + * MEOS {@code trgeo_delete_timestamptz} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer trgeo_delete_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeo_delete_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeo_delete_timestamptz(arg0, arg1, arg2); + } + + /** + * MEOS {@code trgeo_delete_tstzset} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer trgeo_delete_tstzset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeo_delete_tstzset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeo_delete_tstzset(arg0, arg1, arg2); + } + + /** + * MEOS {@code trgeo_delete_tstzspan} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer trgeo_delete_tstzspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeo_delete_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeo_delete_tstzspan(arg0, arg1, arg2); + } + + /** + * MEOS {@code trgeo_delete_tstzspanset} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer trgeo_delete_tstzspanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeo_delete_tstzspanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeo_delete_tstzspanset(arg0, arg1, arg2); + } + + /** + * MEOS {@code trgeo_end_instant} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer trgeo_end_instant(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeo_end_instant requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeo_end_instant(arg0); + } + + /** + * MEOS {@code trgeo_end_sequence} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer trgeo_end_sequence(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeo_end_sequence requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeo_end_sequence(arg0); + } + + /** + * MEOS {@code trgeo_end_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer trgeo_end_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeo_end_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeo_end_value(arg0); + } + + /** + * MEOS {@code trgeo_geom} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer trgeo_geom(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeo_geom requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeo_geom(arg0); + } + + /** + * MEOS {@code trgeo_instant_n} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer trgeo_instant_n(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeo_instant_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeo_instant_n(arg0, arg1); + } + + /** + * MEOS {@code trgeo_instants} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer trgeo_instants(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeo_instants requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeo_instants(arg0, arg1); + } + + /** + * MEOS {@code trgeo_points} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer trgeo_points(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeo_points requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeo_points(arg0); + } + + /** + * MEOS {@code trgeo_restrict_timestamptz} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer trgeo_restrict_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeo_restrict_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeo_restrict_timestamptz(arg0, arg1, arg2); + } + + /** + * MEOS {@code trgeo_restrict_tstzset} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer trgeo_restrict_tstzset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeo_restrict_tstzset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeo_restrict_tstzset(arg0, arg1, arg2); + } + + /** + * MEOS {@code trgeo_restrict_tstzspan} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer trgeo_restrict_tstzspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeo_restrict_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeo_restrict_tstzspan(arg0, arg1, arg2); + } + + /** + * MEOS {@code trgeo_restrict_tstzspanset} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer trgeo_restrict_tstzspanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeo_restrict_tstzspanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeo_restrict_tstzspanset(arg0, arg1, arg2); + } + + /** + * MEOS {@code trgeo_restrict_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer trgeo_restrict_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeo_restrict_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeo_restrict_value(arg0, arg1, arg2); + } + + /** + * MEOS {@code trgeo_restrict_values} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer trgeo_restrict_values(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeo_restrict_values requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeo_restrict_values(arg0, arg1, arg2); + } + + /** + * MEOS {@code trgeo_rotation} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer trgeo_rotation(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeo_rotation requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeo_rotation(arg0); + } + + /** + * MEOS {@code trgeo_round} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer trgeo_round(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeo_round requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeo_round(arg0, arg1); + } + + /** + * MEOS {@code trgeo_segments} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer trgeo_segments(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeo_segments requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeo_segments(arg0, arg1); + } + + /** + * MEOS {@code trgeo_sequence_n} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer trgeo_sequence_n(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeo_sequence_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeo_sequence_n(arg0, arg1); + } + + /** + * MEOS {@code trgeo_sequences} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer trgeo_sequences(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeo_sequences requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeo_sequences(arg0, arg1); + } + + /** + * MEOS {@code trgeo_set_interp} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer trgeo_set_interp(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeo_set_interp requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeo_set_interp(arg0, arg1); + } + + /** + * MEOS {@code trgeo_start_instant} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer trgeo_start_instant(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeo_start_instant requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeo_start_instant(arg0); + } + + /** + * MEOS {@code trgeo_start_sequence} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer trgeo_start_sequence(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeo_start_sequence requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeo_start_sequence(arg0); + } + + /** + * MEOS {@code trgeo_start_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer trgeo_start_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeo_start_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeo_start_value(arg0); + } + + /** + * MEOS {@code trgeo_traversed_area} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer trgeo_traversed_area(jnr.ffi.Pointer arg0, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeo_traversed_area requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeo_traversed_area(arg0, arg1); + } + + /** + * MEOS {@code trgeo_value_n} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer trgeo_value_n(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeo_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeo_value_n(arg0, arg1); + } + + /** + * MEOS {@code trgeo_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static java.lang.String trgeo_out(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeo_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeo_out(arg0); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTRGeometryInst.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTRGeometryInst.java new file mode 100644 index 0000000..d6a4e00 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTRGeometryInst.java @@ -0,0 +1,32 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: TRGeometryInst + * Methods emitted: 1 (stateless=1) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsTRGeometryInst { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsTRGeometryInst() { /* utility */ } + + /** + * MEOS {@code trgeoinst_make} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code constructor}.

+ *

Classification: constructor of instant/scalar

+ */ + public static jnr.ffi.Pointer trgeoinst_make(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, java.time.OffsetDateTime arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeoinst_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeoinst_make(arg0, arg1, arg2); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTSequenceSet.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTSequenceSet.java new file mode 100644 index 0000000..17451f6 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTSequenceSet.java @@ -0,0 +1,32 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: TSequenceSet + * Methods emitted: 1 (bounded-state=1) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsTSequenceSet { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsTSequenceSet() { /* utility */ } + + /** + * MEOS {@code tsequenceset_make_gaps} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tsequenceset_make_gaps(jnr.ffi.Pointer arg0, int arg1, int arg2, jnr.ffi.Pointer arg3, double arg4) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tsequenceset_make_gaps requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tsequenceset_make_gaps(arg0, arg1, arg2, arg3, arg4); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTSpatial.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTSpatial.java new file mode 100644 index 0000000..6312c84 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTSpatial.java @@ -0,0 +1,144 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: TSpatial + * Methods emitted: 9 (bounded-state=4 · io-meta=3 · stateless=1 · windowed=1) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsTSpatial { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsTSpatial() { /* utility */ } + + /** + * MEOS {@code tspatial_to_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer tspatial_to_stbox(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tspatial_to_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tspatial_to_stbox(arg0); + } + + /** + * MEOS {@code tspatial_set_srid} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tspatial_set_srid(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tspatial_set_srid requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tspatial_set_srid(arg0, arg1); + } + + /** + * MEOS {@code tspatial_srid} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static int tspatial_srid(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tspatial_srid requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tspatial_srid(arg0); + } + + /** + * MEOS {@code tspatial_transform} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tspatial_transform(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tspatial_transform requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tspatial_transform(arg0, arg1); + } + + /** + * MEOS {@code tspatial_transform_pipeline} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tspatial_transform_pipeline(jnr.ffi.Pointer arg0, java.lang.String arg1, int arg2, boolean arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tspatial_transform_pipeline requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tspatial_transform_pipeline(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code tspatial_extent_transfn} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Object-model role: {@code aggregate}.

+ *

Classification: role=aggregate

+ */ + public static jnr.ffi.Pointer tspatial_extent_transfn(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tspatial_extent_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tspatial_extent_transfn(arg0, arg1); + } + + /** + * MEOS {@code tspatial_as_ewkt} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static java.lang.String tspatial_as_ewkt(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tspatial_as_ewkt requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tspatial_as_ewkt(arg0, arg1); + } + + /** + * MEOS {@code tspatial_as_text} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static java.lang.String tspatial_as_text(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tspatial_as_text requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tspatial_as_text(arg0, arg1); + } + + /** + * MEOS {@code tspatial_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static java.lang.String tspatial_out(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tspatial_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tspatial_out(arg0, arg1); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTText.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTText.java new file mode 100644 index 0000000..3e54d72 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTText.java @@ -0,0 +1,270 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: TText + * Methods emitted: 18 (bounded-state=12 · io-meta=3 · windowed=2 · stateless=1) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsTText { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsTText() { /* utility */ } + + /** + * MEOS {@code ttext_from_base_temp} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code constructor}.

+ *

Classification: constructor of instant/scalar

+ */ + public static jnr.ffi.Pointer ttext_from_base_temp(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ttext_from_base_temp requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ttext_from_base_temp(arg0, arg1); + } + + /** + * MEOS {@code ttext_at_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer ttext_at_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ttext_at_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ttext_at_value(arg0, arg1); + } + + /** + * MEOS {@code ttext_end_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer ttext_end_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ttext_end_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ttext_end_value(arg0); + } + + /** + * MEOS {@code ttext_initcap} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer ttext_initcap(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ttext_initcap requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ttext_initcap(arg0); + } + + /** + * MEOS {@code ttext_lower} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer ttext_lower(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ttext_lower requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ttext_lower(arg0); + } + + /** + * MEOS {@code ttext_max_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer ttext_max_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ttext_max_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ttext_max_value(arg0); + } + + /** + * MEOS {@code ttext_min_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer ttext_min_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ttext_min_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ttext_min_value(arg0); + } + + /** + * MEOS {@code ttext_minus_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer ttext_minus_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ttext_minus_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ttext_minus_value(arg0, arg1); + } + + /** + * MEOS {@code ttext_start_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer ttext_start_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ttext_start_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ttext_start_value(arg0); + } + + /** + * MEOS {@code ttext_upper} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer ttext_upper(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ttext_upper requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ttext_upper(arg0); + } + + /** + * MEOS {@code ttext_value_at_timestamptz} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static boolean ttext_value_at_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1, boolean arg2, jnr.ffi.Pointer arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ttext_value_at_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ttext_value_at_timestamptz(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code ttext_value_n} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer ttext_value_n(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ttext_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ttext_value_n(arg0, arg1); + } + + /** + * MEOS {@code ttext_values} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer ttext_values(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ttext_values requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ttext_values(arg0, arg1); + } + + /** + * MEOS {@code ttext_tmax_transfn} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Object-model role: {@code aggregate}.

+ *

Classification: role=aggregate

+ */ + public static jnr.ffi.Pointer ttext_tmax_transfn(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ttext_tmax_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ttext_tmax_transfn(arg0, arg1); + } + + /** + * MEOS {@code ttext_tmin_transfn} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Object-model role: {@code aggregate}.

+ *

Classification: role=aggregate

+ */ + public static jnr.ffi.Pointer ttext_tmin_transfn(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ttext_tmin_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ttext_tmin_transfn(arg0, arg1); + } + + /** + * MEOS {@code ttext_from_mfjson} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer ttext_from_mfjson(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ttext_from_mfjson requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ttext_from_mfjson(arg0); + } + + /** + * MEOS {@code ttext_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer ttext_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ttext_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ttext_in(arg0); + } + + /** + * MEOS {@code ttext_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static java.lang.String ttext_out(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ttext_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ttext_out(arg0); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTTextInst.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTTextInst.java new file mode 100644 index 0000000..bc7ea0e --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTTextInst.java @@ -0,0 +1,32 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: TTextInst + * Methods emitted: 1 (stateless=1) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsTTextInst { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsTTextInst() { /* utility */ } + + /** + * MEOS {@code ttextinst_make} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code constructor}.

+ *

Classification: constructor of instant/scalar

+ */ + public static jnr.ffi.Pointer ttextinst_make(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ttextinst_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ttextinst_make(arg0, arg1); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTemporal.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTemporal.java new file mode 100644 index 0000000..13b4a92 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTemporal.java @@ -0,0 +1,1376 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: Temporal + * Methods emitted: 97 (bounded-state=75 · cross-stream=7 · io-meta=5 · stateless=5 · windowed=5) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsTemporal { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsTemporal() { /* utility */ } + + /** + * MEOS {@code temporal_copy} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code constructor}.

+ *

Classification: constructor of instant/scalar

+ */ + public static jnr.ffi.Pointer temporal_copy(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_copy requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_copy(arg0); + } + + /** + * MEOS {@code temporal_to_tinstant} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer temporal_to_tinstant(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_to_tinstant requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_to_tinstant(arg0); + } + + /** + * MEOS {@code temporal_to_tsequence} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer temporal_to_tsequence(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_to_tsequence requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_to_tsequence(arg0, arg1); + } + + /** + * MEOS {@code temporal_to_tsequenceset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer temporal_to_tsequenceset(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_to_tsequenceset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_to_tsequenceset(arg0, arg1); + } + + /** + * MEOS {@code temporal_to_tstzspan} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer temporal_to_tstzspan(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_to_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_to_tstzspan(arg0); + } + + /** + * MEOS {@code temporal_after_timestamptz} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_after_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_after_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_after_timestamptz(arg0, arg1, arg2); + } + + /** + * MEOS {@code temporal_append_tinstant} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_append_tinstant(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, int arg2, double arg3, jnr.ffi.Pointer arg4, boolean arg5) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_append_tinstant requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_append_tinstant(arg0, arg1, arg2, arg3, arg4, arg5); + } + + /** + * MEOS {@code temporal_append_tsequence} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_append_tsequence(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_append_tsequence requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_append_tsequence(arg0, arg1, arg2); + } + + /** + * MEOS {@code temporal_at_max} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer temporal_at_max(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_at_max requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_at_max(arg0); + } + + /** + * MEOS {@code temporal_at_min} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer temporal_at_min(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_at_min requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_at_min(arg0); + } + + /** + * MEOS {@code temporal_at_timestamptz} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer temporal_at_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_at_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_at_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code temporal_at_tstzset} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer temporal_at_tstzset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_at_tstzset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_at_tstzset(arg0, arg1); + } + + /** + * MEOS {@code temporal_at_tstzspan} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer temporal_at_tstzspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_at_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_at_tstzspan(arg0, arg1); + } + + /** + * MEOS {@code temporal_at_tstzspanset} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer temporal_at_tstzspanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_at_tstzspanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_at_tstzspanset(arg0, arg1); + } + + /** + * MEOS {@code temporal_at_values} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer temporal_at_values(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_at_values requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_at_values(arg0, arg1); + } + + /** + * MEOS {@code temporal_before_timestamptz} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_before_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_before_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_before_timestamptz(arg0, arg1, arg2); + } + + /** + * MEOS {@code temporal_delete_timestamptz} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_delete_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_delete_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_delete_timestamptz(arg0, arg1, arg2); + } + + /** + * MEOS {@code temporal_delete_tstzset} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_delete_tstzset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_delete_tstzset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_delete_tstzset(arg0, arg1, arg2); + } + + /** + * MEOS {@code temporal_delete_tstzspan} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_delete_tstzspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_delete_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_delete_tstzspan(arg0, arg1, arg2); + } + + /** + * MEOS {@code temporal_delete_tstzspanset} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_delete_tstzspanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_delete_tstzspanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_delete_tstzspanset(arg0, arg1, arg2); + } + + /** + * MEOS {@code temporal_derivative} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_derivative(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_derivative requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_derivative(arg0); + } + + /** + * MEOS {@code temporal_duration} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_duration(jnr.ffi.Pointer arg0, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_duration requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_duration(arg0, arg1); + } + + /** + * MEOS {@code temporal_dyntimewarp_distance} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static double temporal_dyntimewarp_distance(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_dyntimewarp_distance requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_dyntimewarp_distance(arg0, arg1); + } + + /** + * MEOS {@code temporal_dyntimewarp_path} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_dyntimewarp_path(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, jnr.ffi.Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_dyntimewarp_path requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_dyntimewarp_path(arg0, arg1, arg2); + } + + /** + * MEOS {@code temporal_end_instant} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_end_instant(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_end_instant requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_end_instant(arg0); + } + + /** + * MEOS {@code temporal_end_sequence} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_end_sequence(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_end_sequence requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_end_sequence(arg0); + } + + /** + * MEOS {@code temporal_end_timestamptz} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static java.time.OffsetDateTime temporal_end_timestamptz(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_end_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_end_timestamptz(arg0); + } + + /** + * MEOS {@code temporal_frechet_distance} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static double temporal_frechet_distance(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_frechet_distance requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_frechet_distance(arg0, arg1); + } + + /** + * MEOS {@code temporal_frechet_path} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_frechet_path(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, jnr.ffi.Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_frechet_path requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_frechet_path(arg0, arg1, arg2); + } + + /** + * MEOS {@code temporal_hash} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static int temporal_hash(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_hash requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_hash(arg0); + } + + /** + * MEOS {@code temporal_hausdorff_distance} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static double temporal_hausdorff_distance(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_hausdorff_distance requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_hausdorff_distance(arg0, arg1); + } + + /** + * MEOS {@code temporal_insert} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_insert(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_insert requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_insert(arg0, arg1, arg2); + } + + /** + * MEOS {@code temporal_instant_n} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_instant_n(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_instant_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_instant_n(arg0, arg1); + } + + /** + * MEOS {@code temporal_instants} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_instants(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_instants requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_instants(arg0, arg1); + } + + /** + * MEOS {@code temporal_interp} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static java.lang.String temporal_interp(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_interp requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_interp(arg0); + } + + /** + * MEOS {@code temporal_lower_inc} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static boolean temporal_lower_inc(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_lower_inc requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_lower_inc(arg0); + } + + /** + * MEOS {@code temporal_max_instant} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_max_instant(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_max_instant requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_max_instant(arg0); + } + + /** + * MEOS {@code temporal_merge} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_merge(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_merge requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_merge(arg0, arg1); + } + + /** + * MEOS {@code temporal_merge_array} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_merge_array(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_merge_array requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_merge_array(arg0, arg1); + } + + /** + * MEOS {@code temporal_min_instant} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_min_instant(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_min_instant requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_min_instant(arg0); + } + + /** + * MEOS {@code temporal_minus_max} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer temporal_minus_max(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_minus_max requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_minus_max(arg0); + } + + /** + * MEOS {@code temporal_minus_min} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer temporal_minus_min(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_minus_min requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_minus_min(arg0); + } + + /** + * MEOS {@code temporal_minus_timestamptz} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer temporal_minus_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_minus_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_minus_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code temporal_minus_tstzset} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer temporal_minus_tstzset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_minus_tstzset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_minus_tstzset(arg0, arg1); + } + + /** + * MEOS {@code temporal_minus_tstzspan} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer temporal_minus_tstzspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_minus_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_minus_tstzspan(arg0, arg1); + } + + /** + * MEOS {@code temporal_minus_tstzspanset} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer temporal_minus_tstzspanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_minus_tstzspanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_minus_tstzspanset(arg0, arg1); + } + + /** + * MEOS {@code temporal_minus_values} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static jnr.ffi.Pointer temporal_minus_values(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_minus_values requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_minus_values(arg0, arg1); + } + + /** + * MEOS {@code temporal_num_instants} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static int temporal_num_instants(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_num_instants requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_num_instants(arg0); + } + + /** + * MEOS {@code temporal_num_sequences} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static int temporal_num_sequences(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_num_sequences requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_num_sequences(arg0); + } + + /** + * MEOS {@code temporal_num_timestamps} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static int temporal_num_timestamps(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_num_timestamps requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_num_timestamps(arg0); + } + + /** + * MEOS {@code temporal_round} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_round(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_round requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_round(arg0, arg1); + } + + /** + * MEOS {@code temporal_scale_time} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_scale_time(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_scale_time requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_scale_time(arg0, arg1); + } + + /** + * MEOS {@code temporal_segm_duration} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_segm_duration(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2, boolean arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_segm_duration requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_segm_duration(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code temporal_segments} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_segments(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_segments requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_segments(arg0, arg1); + } + + /** + * MEOS {@code temporal_sequence_n} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_sequence_n(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_sequence_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_sequence_n(arg0, arg1); + } + + /** + * MEOS {@code temporal_sequences} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_sequences(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_sequences requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_sequences(arg0, arg1); + } + + /** + * MEOS {@code temporal_set_interp} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_set_interp(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_set_interp requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_set_interp(arg0, arg1); + } + + /** + * MEOS {@code temporal_shift_scale_time} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_shift_scale_time(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, jnr.ffi.Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_shift_scale_time requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_shift_scale_time(arg0, arg1, arg2); + } + + /** + * MEOS {@code temporal_shift_time} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_shift_time(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_shift_time requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_shift_time(arg0, arg1); + } + + /** + * MEOS {@code temporal_simplify_dp} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_simplify_dp(jnr.ffi.Pointer arg0, double arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_simplify_dp requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_simplify_dp(arg0, arg1, arg2); + } + + /** + * MEOS {@code temporal_simplify_max_dist} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_simplify_max_dist(jnr.ffi.Pointer arg0, double arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_simplify_max_dist requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_simplify_max_dist(arg0, arg1, arg2); + } + + /** + * MEOS {@code temporal_simplify_min_dist} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_simplify_min_dist(jnr.ffi.Pointer arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_simplify_min_dist requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_simplify_min_dist(arg0, arg1); + } + + /** + * MEOS {@code temporal_simplify_min_tdelta} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_simplify_min_tdelta(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_simplify_min_tdelta requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_simplify_min_tdelta(arg0, arg1); + } + + /** + * MEOS {@code temporal_spans} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_spans(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_spans requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_spans(arg0, arg1); + } + + /** + * MEOS {@code temporal_split_each_n_spans} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_split_each_n_spans(jnr.ffi.Pointer arg0, int arg1, jnr.ffi.Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_split_each_n_spans requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_split_each_n_spans(arg0, arg1, arg2); + } + + /** + * MEOS {@code temporal_split_n_spans} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_split_n_spans(jnr.ffi.Pointer arg0, int arg1, jnr.ffi.Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_split_n_spans requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_split_n_spans(arg0, arg1, arg2); + } + + /** + * MEOS {@code temporal_start_instant} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_start_instant(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_start_instant requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_start_instant(arg0); + } + + /** + * MEOS {@code temporal_start_sequence} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_start_sequence(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_start_sequence requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_start_sequence(arg0); + } + + /** + * MEOS {@code temporal_start_timestamptz} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static java.time.OffsetDateTime temporal_start_timestamptz(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_start_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_start_timestamptz(arg0); + } + + /** + * MEOS {@code temporal_stops} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_stops(jnr.ffi.Pointer arg0, double arg1, jnr.ffi.Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_stops requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_stops(arg0, arg1, arg2); + } + + /** + * MEOS {@code temporal_subtype} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static java.lang.String temporal_subtype(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_subtype requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_subtype(arg0); + } + + /** + * MEOS {@code temporal_time} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_time(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_time requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_time(arg0); + } + + /** + * MEOS {@code temporal_time_bins} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_time_bins(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, java.time.OffsetDateTime arg2, jnr.ffi.Pointer arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_time_bins requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_time_bins(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code temporal_time_split} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_time_split(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, java.time.OffsetDateTime arg2, jnr.ffi.Pointer arg3, jnr.ffi.Pointer arg4) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_time_split requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_time_split(arg0, arg1, arg2, arg3, arg4); + } + + /** + * MEOS {@code temporal_timestamps} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_timestamps(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_timestamps requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_timestamps(arg0, arg1); + } + + /** + * MEOS {@code temporal_timestamptz_n} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_timestamptz_n(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_timestamptz_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_timestamptz_n(arg0, arg1); + } + + /** + * MEOS {@code temporal_tprecision} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_tprecision(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, java.time.OffsetDateTime arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_tprecision requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_tprecision(arg0, arg1, arg2); + } + + /** + * MEOS {@code temporal_tsample} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_tsample(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, java.time.OffsetDateTime arg2, int arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_tsample requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_tsample(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code temporal_update} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer temporal_update(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_update requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_update(arg0, arg1, arg2); + } + + /** + * MEOS {@code temporal_upper_inc} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static boolean temporal_upper_inc(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_upper_inc requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_upper_inc(arg0); + } + + /** + * MEOS {@code temporal_extent_transfn} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Object-model role: {@code aggregate}.

+ *

Classification: role=aggregate

+ */ + public static jnr.ffi.Pointer temporal_extent_transfn(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_extent_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_extent_transfn(arg0, arg1); + } + + /** + * MEOS {@code temporal_merge_combinefn} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Object-model role: {@code aggregate}.

+ *

Classification: role=aggregate

+ */ + public static jnr.ffi.Pointer temporal_merge_combinefn(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_merge_combinefn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_merge_combinefn(arg0, arg1); + } + + /** + * MEOS {@code temporal_merge_transfn} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Object-model role: {@code aggregate}.

+ *

Classification: role=aggregate

+ */ + public static jnr.ffi.Pointer temporal_merge_transfn(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_merge_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_merge_transfn(arg0, arg1); + } + + /** + * MEOS {@code temporal_tagg_finalfn} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Object-model role: {@code aggregate}.

+ *

Classification: role=aggregate

+ */ + public static jnr.ffi.Pointer temporal_tagg_finalfn(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_tagg_finalfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_tagg_finalfn(arg0); + } + + /** + * MEOS {@code temporal_tcount_transfn} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Object-model role: {@code aggregate}.

+ *

Classification: role=aggregate

+ */ + public static jnr.ffi.Pointer temporal_tcount_transfn(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_tcount_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_tcount_transfn(arg0, arg1); + } + + /** + * MEOS {@code temporal_cmp} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 2 temporals

+ */ + public static int temporal_cmp(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_cmp requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_cmp(arg0, arg1); + } + + /** + * MEOS {@code temporal_eq} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 2 temporals

+ */ + public static boolean temporal_eq(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_eq requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_eq(arg0, arg1); + } + + /** + * MEOS {@code temporal_ge} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 2 temporals

+ */ + public static boolean temporal_ge(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_ge requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_ge(arg0, arg1); + } + + /** + * MEOS {@code temporal_gt} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 2 temporals

+ */ + public static boolean temporal_gt(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_gt requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_gt(arg0, arg1); + } + + /** + * MEOS {@code temporal_le} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 2 temporals

+ */ + public static boolean temporal_le(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_le requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_le(arg0, arg1); + } + + /** + * MEOS {@code temporal_lt} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 2 temporals

+ */ + public static boolean temporal_lt(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_lt requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_lt(arg0, arg1); + } + + /** + * MEOS {@code temporal_ne} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 2 temporals

+ */ + public static boolean temporal_ne(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_ne requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_ne(arg0, arg1); + } + + /** + * MEOS {@code temporal_as_hexwkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static java.lang.String temporal_as_hexwkb(jnr.ffi.Pointer arg0, byte arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_as_hexwkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_as_hexwkb(arg0, arg1); + } + + /** + * MEOS {@code temporal_as_mfjson} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static java.lang.String temporal_as_mfjson(jnr.ffi.Pointer arg0, boolean arg1, int arg2, int arg3, java.lang.String arg4) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_as_mfjson requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_as_mfjson(arg0, arg1, arg2, arg3, arg4); + } + + /** + * MEOS {@code temporal_as_wkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer temporal_as_wkb(jnr.ffi.Pointer arg0, byte arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_as_wkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_as_wkb(arg0, arg1); + } + + /** + * MEOS {@code temporal_from_hexwkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer temporal_from_hexwkb(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_from_hexwkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_from_hexwkb(arg0); + } + + /** + * MEOS {@code temporal_from_wkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer temporal_from_wkb(jnr.ffi.Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_from_wkb requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_from_wkb(arg0, arg1); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTextSet.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTextSet.java new file mode 100644 index 0000000..11b294f --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTextSet.java @@ -0,0 +1,158 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: TextSet + * Methods emitted: 10 (bounded-state=7 · io-meta=2 · stateless=1) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsTextSet { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsTextSet() { /* utility */ } + + /** + * MEOS {@code textset_make} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code constructor}.

+ *

Classification: constructor of instant/scalar

+ */ + public static jnr.ffi.Pointer textset_make(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "textset_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.textset_make(arg0, arg1); + } + + /** + * MEOS {@code textset_end_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer textset_end_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "textset_end_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.textset_end_value(arg0); + } + + /** + * MEOS {@code textset_initcap} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer textset_initcap(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "textset_initcap requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.textset_initcap(arg0); + } + + /** + * MEOS {@code textset_lower} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer textset_lower(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "textset_lower requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.textset_lower(arg0); + } + + /** + * MEOS {@code textset_start_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer textset_start_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "textset_start_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.textset_start_value(arg0); + } + + /** + * MEOS {@code textset_upper} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer textset_upper(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "textset_upper requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.textset_upper(arg0); + } + + /** + * MEOS {@code textset_value_n} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer textset_value_n(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "textset_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.textset_value_n(arg0, arg1); + } + + /** + * MEOS {@code textset_values} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer textset_values(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "textset_values requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.textset_values(arg0); + } + + /** + * MEOS {@code textset_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer textset_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "textset_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.textset_in(arg0); + } + + /** + * MEOS {@code textset_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static java.lang.String textset_out(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "textset_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.textset_out(arg0); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTh3index.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTh3index.java new file mode 100644 index 0000000..e458c66 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTh3index.java @@ -0,0 +1,393 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by tools/codegen/emit_h3_facade.py — do not edit by hand. + * H3 / th3index family facade over functions.GeneratedFunctions. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsTh3index { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsTh3index() { /* utility */ } + + /** MEOS {@code th3index_are_neighbor_cells} — H3 / th3index family. */ + public static jnr.ffi.Pointer th3index_are_neighbor_cells(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3index_are_neighbor_cells requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3index_are_neighbor_cells(arg0, arg1); + } + + /** MEOS {@code th3index_cell_area} — H3 / th3index family. */ + public static jnr.ffi.Pointer th3index_cell_area(jnr.ffi.Pointer arg0, java.lang.String arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3index_cell_area requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3index_cell_area(arg0, arg1); + } + + /** MEOS {@code th3index_cell_to_boundary} — H3 / th3index family. */ + public static jnr.ffi.Pointer th3index_cell_to_boundary(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3index_cell_to_boundary requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3index_cell_to_boundary(arg0); + } + + /** MEOS {@code th3index_cell_to_center_child} — H3 / th3index family. */ + public static jnr.ffi.Pointer th3index_cell_to_center_child(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3index_cell_to_center_child requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3index_cell_to_center_child(arg0, arg1); + } + + /** MEOS {@code th3index_cell_to_center_child_next} — H3 / th3index family. */ + public static jnr.ffi.Pointer th3index_cell_to_center_child_next(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3index_cell_to_center_child_next requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3index_cell_to_center_child_next(arg0); + } + + /** MEOS {@code th3index_cell_to_child_pos} — H3 / th3index family. */ + public static jnr.ffi.Pointer th3index_cell_to_child_pos(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3index_cell_to_child_pos requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3index_cell_to_child_pos(arg0, arg1); + } + + /** MEOS {@code th3index_cell_to_local_ij} — H3 / th3index family. */ + public static jnr.ffi.Pointer th3index_cell_to_local_ij(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3index_cell_to_local_ij requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3index_cell_to_local_ij(arg0, arg1); + } + + /** MEOS {@code th3index_cell_to_parent} — H3 / th3index family. */ + public static jnr.ffi.Pointer th3index_cell_to_parent(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3index_cell_to_parent requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3index_cell_to_parent(arg0, arg1); + } + + /** MEOS {@code th3index_cell_to_parent_next} — H3 / th3index family. */ + public static jnr.ffi.Pointer th3index_cell_to_parent_next(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3index_cell_to_parent_next requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3index_cell_to_parent_next(arg0); + } + + /** MEOS {@code th3index_cell_to_vertex} — H3 / th3index family. */ + public static jnr.ffi.Pointer th3index_cell_to_vertex(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3index_cell_to_vertex requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3index_cell_to_vertex(arg0, arg1); + } + + /** MEOS {@code th3index_cells_to_directed_edge} — H3 / th3index family. */ + public static jnr.ffi.Pointer th3index_cells_to_directed_edge(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3index_cells_to_directed_edge requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3index_cells_to_directed_edge(arg0, arg1); + } + + /** MEOS {@code th3index_child_pos_to_cell} — H3 / th3index family. */ + public static jnr.ffi.Pointer th3index_child_pos_to_cell(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, int arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3index_child_pos_to_cell requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3index_child_pos_to_cell(arg0, arg1, arg2); + } + + /** MEOS {@code th3index_directed_edge_to_boundary} — H3 / th3index family. */ + public static jnr.ffi.Pointer th3index_directed_edge_to_boundary(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3index_directed_edge_to_boundary requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3index_directed_edge_to_boundary(arg0); + } + + /** MEOS {@code th3index_edge_length} — H3 / th3index family. */ + public static jnr.ffi.Pointer th3index_edge_length(jnr.ffi.Pointer arg0, java.lang.String arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3index_edge_length requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3index_edge_length(arg0, arg1); + } + + /** MEOS {@code th3index_end_value} — H3 / th3index family. */ + public static long th3index_end_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3index_end_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3index_end_value(arg0); + } + + /** MEOS {@code th3index_get_base_cell_number} — H3 / th3index family. */ + public static jnr.ffi.Pointer th3index_get_base_cell_number(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3index_get_base_cell_number requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3index_get_base_cell_number(arg0); + } + + /** MEOS {@code th3index_get_directed_edge_destination} — H3 / th3index family. */ + public static jnr.ffi.Pointer th3index_get_directed_edge_destination(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3index_get_directed_edge_destination requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3index_get_directed_edge_destination(arg0); + } + + /** MEOS {@code th3index_get_directed_edge_origin} — H3 / th3index family. */ + public static jnr.ffi.Pointer th3index_get_directed_edge_origin(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3index_get_directed_edge_origin requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3index_get_directed_edge_origin(arg0); + } + + /** MEOS {@code th3index_get_resolution} — H3 / th3index family. */ + public static jnr.ffi.Pointer th3index_get_resolution(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3index_get_resolution requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3index_get_resolution(arg0); + } + + /** MEOS {@code th3index_grid_distance} — H3 / th3index family. */ + public static jnr.ffi.Pointer th3index_grid_distance(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3index_grid_distance requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3index_grid_distance(arg0, arg1); + } + + /** MEOS {@code th3index_in} — H3 / th3index family. */ + public static jnr.ffi.Pointer th3index_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3index_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3index_in(arg0); + } + + /** MEOS {@code th3index_is_pentagon} — H3 / th3index family. */ + public static jnr.ffi.Pointer th3index_is_pentagon(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3index_is_pentagon requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3index_is_pentagon(arg0); + } + + /** MEOS {@code th3index_is_res_class_iii} — H3 / th3index family. */ + public static jnr.ffi.Pointer th3index_is_res_class_iii(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3index_is_res_class_iii requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3index_is_res_class_iii(arg0); + } + + /** MEOS {@code th3index_is_valid_cell} — H3 / th3index family. */ + public static jnr.ffi.Pointer th3index_is_valid_cell(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3index_is_valid_cell requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3index_is_valid_cell(arg0); + } + + /** MEOS {@code th3index_is_valid_directed_edge} — H3 / th3index family. */ + public static jnr.ffi.Pointer th3index_is_valid_directed_edge(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3index_is_valid_directed_edge requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3index_is_valid_directed_edge(arg0); + } + + /** MEOS {@code th3index_is_valid_vertex} — H3 / th3index family. */ + public static jnr.ffi.Pointer th3index_is_valid_vertex(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3index_is_valid_vertex requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3index_is_valid_vertex(arg0); + } + + /** MEOS {@code th3index_local_ij_to_cell} — H3 / th3index family. */ + public static jnr.ffi.Pointer th3index_local_ij_to_cell(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3index_local_ij_to_cell requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3index_local_ij_to_cell(arg0, arg1); + } + + /** MEOS {@code th3index_make} — H3 / th3index family. */ + public static jnr.ffi.Pointer th3index_make(long arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3index_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3index_make(arg0, arg1); + } + + /** MEOS {@code th3index_start_value} — H3 / th3index family. */ + public static long th3index_start_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3index_start_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3index_start_value(arg0); + } + + /** MEOS {@code th3index_to_tbigint} — H3 / th3index family. */ + public static jnr.ffi.Pointer th3index_to_tbigint(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3index_to_tbigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3index_to_tbigint(arg0); + } + + /** MEOS {@code th3index_to_tgeogpoint} — H3 / th3index family. */ + public static jnr.ffi.Pointer th3index_to_tgeogpoint(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3index_to_tgeogpoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3index_to_tgeogpoint(arg0); + } + + /** MEOS {@code th3index_to_tgeompoint} — H3 / th3index family. */ + public static jnr.ffi.Pointer th3index_to_tgeompoint(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3index_to_tgeompoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3index_to_tgeompoint(arg0); + } + + /** MEOS {@code th3index_value_at_timestamptz} — H3 / th3index family. */ + public static jnr.ffi.Pointer th3index_value_at_timestamptz(jnr.ffi.Pointer arg0, java.time.OffsetDateTime arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3index_value_at_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3index_value_at_timestamptz(arg0, arg1, arg2); + } + + /** MEOS {@code th3index_value_n} — H3 / th3index family. */ + public static jnr.ffi.Pointer th3index_value_n(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3index_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3index_value_n(arg0, arg1); + } + + /** MEOS {@code th3index_values} — H3 / th3index family. */ + public static jnr.ffi.Pointer th3index_values(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3index_values requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3index_values(arg0, arg1); + } + + /** MEOS {@code th3index_vertex_to_latlng} — H3 / th3index family. */ + public static jnr.ffi.Pointer th3index_vertex_to_latlng(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3index_vertex_to_latlng requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3index_vertex_to_latlng(arg0); + } + + /** MEOS {@code th3indexinst_in} — H3 / th3index family. */ + public static jnr.ffi.Pointer th3indexinst_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3indexinst_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3indexinst_in(arg0); + } + + /** MEOS {@code th3indexinst_make} — H3 / th3index family. */ + public static jnr.ffi.Pointer th3indexinst_make(long arg0, java.time.OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3indexinst_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3indexinst_make(arg0, arg1); + } + + /** MEOS {@code th3indexseq_in} — H3 / th3index family. */ + public static jnr.ffi.Pointer th3indexseq_in(java.lang.String arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3indexseq_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3indexseq_in(arg0, arg1); + } + + /** MEOS {@code th3indexseq_make} — H3 / th3index family. */ + public static jnr.ffi.Pointer th3indexseq_make(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, int arg2, boolean arg3, boolean arg4) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3indexseq_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3indexseq_make(arg0, arg1, arg2, arg3, arg4); + } + + /** MEOS {@code th3indexseqset_in} — H3 / th3index family. */ + public static jnr.ffi.Pointer th3indexseqset_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3indexseqset_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3indexseqset_in(arg0); + } + + /** MEOS {@code th3indexseqset_make} — H3 / th3index family. */ + public static jnr.ffi.Pointer th3indexseqset_make(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "th3indexseqset_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.th3indexseqset_make(arg0, arg1); + } +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTstzSet.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTstzSet.java new file mode 100644 index 0000000..21f1bb3 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTstzSet.java @@ -0,0 +1,186 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: TstzSet + * Methods emitted: 12 (bounded-state=6 · stateless=3 · io-meta=2 · windowed=1) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsTstzSet { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsTstzSet() { /* utility */ } + + /** + * MEOS {@code tstzset_make} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code constructor}.

+ *

Classification: constructor of instant/scalar

+ */ + public static jnr.ffi.Pointer tstzset_make(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzset_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzset_make(arg0, arg1); + } + + /** + * MEOS {@code tstzset_to_dateset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer tstzset_to_dateset(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzset_to_dateset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzset_to_dateset(arg0); + } + + /** + * MEOS {@code tstzset_to_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer tstzset_to_stbox(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzset_to_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzset_to_stbox(arg0); + } + + /** + * MEOS {@code tstzset_end_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static java.time.OffsetDateTime tstzset_end_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzset_end_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzset_end_value(arg0); + } + + /** + * MEOS {@code tstzset_shift_scale} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tstzset_shift_scale(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, jnr.ffi.Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzset_shift_scale requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzset_shift_scale(arg0, arg1, arg2); + } + + /** + * MEOS {@code tstzset_start_value} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static java.time.OffsetDateTime tstzset_start_value(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzset_start_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzset_start_value(arg0); + } + + /** + * MEOS {@code tstzset_tprecision} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tstzset_tprecision(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, java.time.OffsetDateTime arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzset_tprecision requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzset_tprecision(arg0, arg1, arg2); + } + + /** + * MEOS {@code tstzset_value_n} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tstzset_value_n(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzset_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzset_value_n(arg0, arg1); + } + + /** + * MEOS {@code tstzset_values} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tstzset_values(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzset_values requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzset_values(arg0); + } + + /** + * MEOS {@code tstzset_tcount_transfn} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Object-model role: {@code aggregate}.

+ *

Classification: role=aggregate

+ */ + public static jnr.ffi.Pointer tstzset_tcount_transfn(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzset_tcount_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzset_tcount_transfn(arg0, arg1); + } + + /** + * MEOS {@code tstzset_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer tstzset_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzset_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzset_in(arg0); + } + + /** + * MEOS {@code tstzset_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static java.lang.String tstzset_out(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzset_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzset_out(arg0); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTstzSpan.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTstzSpan.java new file mode 100644 index 0000000..addbfd3 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTstzSpan.java @@ -0,0 +1,200 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: TstzSpan + * Methods emitted: 13 (bounded-state=7 · stateless=3 · io-meta=2 · windowed=1) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsTstzSpan { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsTstzSpan() { /* utility */ } + + /** + * MEOS {@code tstzspan_make} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code constructor}.

+ *

Classification: constructor of instant/scalar

+ */ + public static jnr.ffi.Pointer tstzspan_make(java.time.OffsetDateTime arg0, java.time.OffsetDateTime arg1, boolean arg2, boolean arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzspan_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzspan_make(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code tstzspan_to_datespan} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer tstzspan_to_datespan(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzspan_to_datespan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzspan_to_datespan(arg0); + } + + /** + * MEOS {@code tstzspan_to_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer tstzspan_to_stbox(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzspan_to_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzspan_to_stbox(arg0); + } + + /** + * MEOS {@code tstzspan_bins} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tstzspan_bins(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, java.time.OffsetDateTime arg2, jnr.ffi.Pointer arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzspan_bins requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzspan_bins(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code tstzspan_duration} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tstzspan_duration(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzspan_duration requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzspan_duration(arg0); + } + + /** + * MEOS {@code tstzspan_expand} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tstzspan_expand(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzspan_expand requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzspan_expand(arg0, arg1); + } + + /** + * MEOS {@code tstzspan_lower} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static java.time.OffsetDateTime tstzspan_lower(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzspan_lower requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzspan_lower(arg0); + } + + /** + * MEOS {@code tstzspan_shift_scale} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tstzspan_shift_scale(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, jnr.ffi.Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzspan_shift_scale requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzspan_shift_scale(arg0, arg1, arg2); + } + + /** + * MEOS {@code tstzspan_tprecision} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tstzspan_tprecision(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, java.time.OffsetDateTime arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzspan_tprecision requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzspan_tprecision(arg0, arg1, arg2); + } + + /** + * MEOS {@code tstzspan_upper} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static java.time.OffsetDateTime tstzspan_upper(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzspan_upper requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzspan_upper(arg0); + } + + /** + * MEOS {@code tstzspan_tcount_transfn} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Object-model role: {@code aggregate}.

+ *

Classification: role=aggregate

+ */ + public static jnr.ffi.Pointer tstzspan_tcount_transfn(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzspan_tcount_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzspan_tcount_transfn(arg0, arg1); + } + + /** + * MEOS {@code tstzspan_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer tstzspan_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzspan_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzspan_in(arg0); + } + + /** + * MEOS {@code tstzspan_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static java.lang.String tstzspan_out(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzspan_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzspan_out(arg0); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTstzSpanSet.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTstzSpanSet.java new file mode 100644 index 0000000..2869051 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTstzSpanSet.java @@ -0,0 +1,242 @@ +package org.mobilitydb.flink.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: TstzSpanSet + * Methods emitted: 16 (bounded-state=11 · io-meta=2 · stateless=2 · windowed=1) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; + +public final class MeosOpsTstzSpanSet { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsTstzSpanSet() { /* utility */ } + + /** + * MEOS {@code tstzspanset_to_datespanset} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer tstzspanset_to_datespanset(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzspanset_to_datespanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzspanset_to_datespanset(arg0); + } + + /** + * MEOS {@code tstzspanset_to_stbox} — tier stateless. + *

Pure per-event; safe in any Flink scalar position.

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static jnr.ffi.Pointer tstzspanset_to_stbox(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzspanset_to_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzspanset_to_stbox(arg0); + } + + /** + * MEOS {@code tstzspanset_bins} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tstzspanset_bins(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, java.time.OffsetDateTime arg2, jnr.ffi.Pointer arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzspanset_bins requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzspanset_bins(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code tstzspanset_duration} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tstzspanset_duration(jnr.ffi.Pointer arg0, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzspanset_duration requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzspanset_duration(arg0, arg1); + } + + /** + * MEOS {@code tstzspanset_end_timestamptz} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static java.time.OffsetDateTime tstzspanset_end_timestamptz(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzspanset_end_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzspanset_end_timestamptz(arg0); + } + + /** + * MEOS {@code tstzspanset_lower} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static java.time.OffsetDateTime tstzspanset_lower(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzspanset_lower requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzspanset_lower(arg0); + } + + /** + * MEOS {@code tstzspanset_num_timestamps} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static int tstzspanset_num_timestamps(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzspanset_num_timestamps requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzspanset_num_timestamps(arg0); + } + + /** + * MEOS {@code tstzspanset_shift_scale} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tstzspanset_shift_scale(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, jnr.ffi.Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzspanset_shift_scale requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzspanset_shift_scale(arg0, arg1, arg2); + } + + /** + * MEOS {@code tstzspanset_start_timestamptz} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static java.time.OffsetDateTime tstzspanset_start_timestamptz(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzspanset_start_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzspanset_start_timestamptz(arg0); + } + + /** + * MEOS {@code tstzspanset_timestamps} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tstzspanset_timestamps(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzspanset_timestamps requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzspanset_timestamps(arg0); + } + + /** + * MEOS {@code tstzspanset_timestamptz_n} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tstzspanset_timestamptz_n(jnr.ffi.Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzspanset_timestamptz_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzspanset_timestamptz_n(arg0, arg1); + } + + /** + * MEOS {@code tstzspanset_tprecision} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static jnr.ffi.Pointer tstzspanset_tprecision(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, java.time.OffsetDateTime arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzspanset_tprecision requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzspanset_tprecision(arg0, arg1, arg2); + } + + /** + * MEOS {@code tstzspanset_upper} — tier bounded-state. + *

Per-event with bounded per-key state (MEOS handle).

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static java.time.OffsetDateTime tstzspanset_upper(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzspanset_upper requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzspanset_upper(arg0); + } + + /** + * MEOS {@code tstzspanset_tcount_transfn} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

Object-model role: {@code aggregate}.

+ *

Classification: role=aggregate

+ */ + public static jnr.ffi.Pointer tstzspanset_tcount_transfn(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzspanset_tcount_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzspanset_tcount_transfn(arg0, arg1); + } + + /** + * MEOS {@code tstzspanset_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static jnr.ffi.Pointer tstzspanset_in(java.lang.String arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzspanset_in requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzspanset_in(arg0); + } + + /** + * MEOS {@code tstzspanset_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static java.lang.String tstzspanset_out(jnr.ffi.Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzspanset_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzspanset_out(arg0); + } + +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/MeosBoundedStateMap.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/MeosBoundedStateMap.java new file mode 100644 index 0000000..2b21f21 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/MeosBoundedStateMap.java @@ -0,0 +1,158 @@ +package org.mobilitydb.flink.meos.wirings; + +import jnr.ffi.Pointer; +import org.apache.flink.api.common.state.ValueState; +import org.apache.flink.api.common.state.ValueStateDescriptor; +import org.apache.flink.api.common.typeinfo.PrimitiveArrayTypeInfo; +import org.apache.flink.configuration.Configuration; +import org.apache.flink.streaming.api.functions.KeyedProcessFunction; +import org.apache.flink.util.Collector; + +import java.io.Serializable; + +/** + * DataStream wiring for the {@code bounded-state} streaming tier of + * the generated {@code org.mobilitydb.flink.meos.MeosOps*} facades. + * + *

The {@code bounded-state} tier is "per-event with bounded per-key + * state, the state IS a MEOS handle". The canonical example is a + * per-key accumulator that keeps the running MEOS value alive across + * events (e.g. per-vehicle running trajectory, per-key tbox union). + * + *

Why state lives as bytes, not as a {@code Pointer}. A + * {@code jnr.ffi.Pointer} is a raw native-memory address. It is not + * portable across JVM restarts; Flink would not be able to checkpoint + * or replay state. The wiring stores the state as a {@code byte[]} + * (typically the MEOS-WKB serialization of the temporal value), with + * adopter-supplied serialize / deserialize / step lambdas mediating + * the round-trip through MEOS: + * + * 

{@code
+ *  byte[] state               -- the per-key serialized MEOS value
+ *      ↓ deserialize (MEOS-WKB → Pointer)
+ *  Pointer prev               -- the in-flight MEOS handle
+ *      ↓ step(prev, event) → (newPointer, output)
+ *  Pointer next, OUT out      -- the new in-flight handle + per-event output
+ *      ↓ serialize (Pointer → MEOS-WKB)
+ *  byte[] newState            -- the per-key serialized new MEOS value
+ * }
+ * + *

This serde discipline is the same one MobilityDuck's persistent + * state machines use; it survives Flink savepoint / checkpoint / + * rescaling correctly because state crossing the operator boundary is + * always the MEOS-WKB bytes — never a raw pointer. + * + *

Typical usage — per-vehicle running tbox union via + * {@code MeosOpsFreeCore.union_tbox_tbox} (stateless on its own; + * stateful when applied as a running fold): + * + * 

{@code
+ * DataStream in = ...;          // (vehicleId, tbox)
+ * DataStream out = in
+ *     .keyBy(VehicleTbox::vehicleId)
+ *     .process(new MeosBoundedStateMap(
+ *         /* serialize *(/   ptr -> MeosOpsTBox.tbox_as_wkb(ptr, (byte) 4).array(),
+ *         /* deserialize *(/ bytes -> MeosOpsTBox.tbox_from_wkb(Pointer.wrap(...), bytes.length),
+ *         /* step *(/        (prev, evt) -> {
+ *             Pointer eventTbox = evt.toMeosTbox();
+ *             Pointer merged = (prev == null) ? eventTbox
+ *                                              : MeosOpsFreeCore.union_tbox_tbox(prev, eventTbox);
+ *             RunningTbox result = new RunningTbox(evt.vehicleId(), MeosOpsTBox.tbox_as_hexwkb(merged, (byte) 4, null));
+ *             return new MeosStep<>(merged, result);
+ *         }));
+ * }
+ * + *

The first event for a key sees {@code prev == null} (no prior + * state); the wiring handles that case by skipping the + * {@code deserialize} call. On subsequent events, the state is + * re-hydrated, mutated, re-serialized. + * + *

Coverage: bounded-state is the second-largest tier in the + * v4 baseline (797 of 2,097 emitted methods — 513 OO-classified + 284 + * free-fn). Any of them can be wrapped through this single class — + * adopters provide the three lambdas, the wiring handles all of the + * Flink state plumbing. + * + *

State serializer: this implementation uses Flink's built-in + * {@code byte[]} primitive-array serializer (no custom Kryo / Avro / Pojo + * registration needed). The state size per key is bounded by the + * MEOS-WKB size of the running value — sub-KB for typical + * accumulator scenarios. + * + * @param the key type ({@code keyBy} extractor return type) + * @param the input event type + * @param the output type emitted per event + */ +public final class MeosBoundedStateMap + extends KeyedProcessFunction { + + /** Serializable Pointer → bytes serializer (typically MEOS-WKB). */ + @FunctionalInterface + public interface PointerSerialize extends Serializable { + byte[] toBytes(Pointer pointer) throws Exception; + } + + /** Serializable bytes → Pointer deserializer (typically MEOS-WKB). */ + @FunctionalInterface + public interface PointerDeserialize extends Serializable { + Pointer fromBytes(byte[] bytes) throws Exception; + } + + /** Per-event step: (prior MEOS handle, event) → (new handle, output). */ + @FunctionalInterface + public interface MeosStepFn extends Serializable { + MeosStep apply(Pointer prior, IN event) throws Exception; + } + + /** Tuple returned by the step lambda. */ + public static final class MeosStep implements Serializable { + private static final long serialVersionUID = 1L; + public final Pointer newState; + public final OUT output; + public MeosStep(Pointer newState, OUT output) { + this.newState = newState; + this.output = output; + } + } + + private final PointerSerialize serialize; + private final PointerDeserialize deserialize; + private final MeosStepFn step; + + private transient ValueState handleState; + + public MeosBoundedStateMap(PointerSerialize serialize, + PointerDeserialize deserialize, + MeosStepFn step) { + this.serialize = serialize; + this.deserialize = deserialize; + this.step = step; + } + + @Override + public void open(Configuration parameters) throws Exception { + super.open(parameters); + MeosWiringRuntime.ensureInitializedOnThread(); + ValueStateDescriptor descriptor = new ValueStateDescriptor<>( + "meos-bounded-state", + PrimitiveArrayTypeInfo.BYTE_PRIMITIVE_ARRAY_TYPE_INFO); + handleState = getRuntimeContext().getState(descriptor); + } + + @Override + public void processElement(IN event, + KeyedProcessFunction.Context ctx, + Collector out) throws Exception { + byte[] priorBytes = handleState.value(); + Pointer prior = (priorBytes == null) ? null : deserialize.fromBytes(priorBytes); + + MeosStep stepResult = step.apply(prior, event); + + byte[] newBytes = serialize.toBytes(stepResult.newState); + handleState.update(newBytes); + + if (stepResult.output != null) { + out.collect(stepResult.output); + } + } +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/MeosCrossStreamJoin.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/MeosCrossStreamJoin.java new file mode 100644 index 0000000..24c5ce1 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/MeosCrossStreamJoin.java @@ -0,0 +1,115 @@ +package org.mobilitydb.flink.meos.wirings; + +import org.apache.flink.configuration.Configuration; +import org.apache.flink.streaming.api.functions.co.ProcessJoinFunction; +import org.apache.flink.util.Collector; + +import java.io.Serializable; + +/** + * DataStream wiring for the {@code cross-stream} streaming tier of + * the generated {@code org.mobilitydb.flink.meos.MeosOps*} facades. + * + *

The {@code cross-stream} tier is "pairwise across two streams, + * pre-keyed by the same K, time-bounded match window". Canonical + * examples are spatial-relations between two trajectories + * ({@code edwithin_tgeo_tgeo}, {@code eintersects_tgeo_tgeo}) and + * distance functions on two temporals + * ({@code nad_tgeo_tgeo}, {@code mindistance_tgeo_tgeo}). + * + *

Wraps any cross-stream MeosOps call as a Flink + * {@link ProcessJoinFunction} (the operator backing + * {@code KeyedStream.intervalJoin(other)}). The wiring receives one + * left event and one right event per match, both already paired by + * Flink's interval-join machinery, and the adopter's lambda computes + * the pairwise output via the matching MeosOps call. + * + *

Typical usage — per-vehicle-pair "did they come within + * 100m of each other in the last 5 minutes?" via + * {@code MeosOpsTGeo.edwithin_tgeo_tgeo} (tier = {@code cross-stream}): + * + * 

{@code
+ * KeyedStream a = streamA.keyBy(VehiclePosition::regionId);
+ * KeyedStream b = streamB.keyBy(VehiclePosition::regionId);
+ *
+ * DataStream meetings = a
+ *     .intervalJoin(b)
+ *         .between(Time.minutes(-5), Time.minutes(5))
+ *         .process(new MeosCrossStreamJoin(
+ *             (left, right, ctx) -> {
+ *                 Pointer leftT  = left.toTGeoPointer();
+ *                 Pointer rightT = right.toTGeoPointer();
+ *                 if (MeosOpsTGeo.edwithin_tgeo_tgeo(leftT, rightT, 100.0) != 0) {
+ *                     return new MeetingEvent(left.id(), right.id(), ctx.getLeftTimestamp());
+ *                 }
+ *                 return null;  // no output for non-matches
+ *             }));
+ * }
+ * + *

The interval-join is keyed (both streams must be pre-keyed by + * the same K, and only events sharing a key are considered for + * pairing). The match window is time-bounded + * ({@code .between(lowerBound, upperBound)}) and event-time aware — + * watermarks drive when matches are emitted. + * + *

Slim adopter signature — same {@code ContextLike}-style + * pattern as {@link MeosWindowedAggregate}: the lambda receives the + * matched left + right events and a slim context exposing the + * left/right timestamps (the bits a MEOS cross-stream call typically + * needs), keeping the wiring lambda free of Flink internals. + * + *

Coverage: 140 of the 2,097 emitted methods (~7%) qualify + * as {@code cross-stream} per the v4 baseline — all of them wrappable + * through this single class. With this PR, every streamable tier in + * the baseline has a generic wiring class; 1,957 of 2,097 (93%) of + * the generated MeosOps* methods are wirable through 4 classes + * without per-method registration. + * + * @param the left-stream event type + * @param the right-stream event type + * @param the per-match output type + */ +public final class MeosCrossStreamJoin + extends ProcessJoinFunction { + + /** Serializable per-match MEOS pairwise call. */ + @FunctionalInterface + public interface JoinFn extends Serializable { + OUT join(L left, R right, ContextLike ctx) throws Exception; + } + + /** + * Slimmer alternative to Flink's {@code ProcessJoinFunction.Context} + * — exposes only the bits a MEOS pairwise call typically needs. + */ + public interface ContextLike { + long getLeftTimestamp(); + long getRightTimestamp(); + } + + private final JoinFn joinFn; + + public MeosCrossStreamJoin(JoinFn joinFn) { + this.joinFn = joinFn; + } + + @Override + public void open(Configuration parameters) throws Exception { + super.open(parameters); + MeosWiringRuntime.ensureInitializedOnThread(); + } + + @Override + public void processElement(L left, R right, + ProcessJoinFunction.Context context, + Collector out) throws Exception { + ContextLike ctx = new ContextLike() { + @Override public long getLeftTimestamp() { return context.getLeftTimestamp(); } + @Override public long getRightTimestamp() { return context.getRightTimestamp(); } + }; + OUT result = joinFn.join(left, right, ctx); + if (result != null) { + out.collect(result); + } + } +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/MeosStatelessFilter.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/MeosStatelessFilter.java new file mode 100644 index 0000000..080d2a6 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/MeosStatelessFilter.java @@ -0,0 +1,87 @@ +package org.mobilitydb.flink.meos.wirings; + +import org.apache.flink.api.common.functions.FilterFunction; +import org.apache.flink.api.common.functions.RichFilterFunction; +import org.apache.flink.configuration.Configuration; + +import java.io.Serializable; + +/** + * DataStream wiring for the {@code stateless} streaming tier of the + * generated {@code org.mobilitydb.flink.meos.MeosOps*} facades — the + * predicate-shaped sibling of {@link MeosStatelessMap}. + * + *

Wraps any {@code MeosOps*.f(...)} call that returns {@code boolean} + * (or {@code int} interpreted as a 0/1 flag, common in JMEOS' int-coded + * predicates) and whose streaming tier is {@code stateless} (per + * {@code tools/codegen/meos-ops-manifest.json}) as a Flink + * {@link FilterFunction}. No per-key state; each event filtered + * independently. + * + *

Typical usage: scalar-predicate filter against the + * generated {@code MeosOpsTBox.overlaps_tbox_tbox} (tier = + * {@code stateless}): + * + * 

{@code
+ * DataStream in = ...;
+ * DataStream overlapping = in.filter(
+ *     new MeosStatelessFilter<>(
+ *         pair -> MeosOpsTBox.overlaps_tbox_tbox(pair.a, pair.b)));
+ * }
+ * + *

For int-coded predicates (JMEOS returns {@code int} for some MEOS + * predicates rather than {@code boolean}), use + * {@link #fromIntPredicate}: + * + * 

{@code
+ * DataStream in = ...;
+ * DataStream adj = in.filter(
+ *     MeosStatelessFilter.fromIntPredicate(
+ *         pair -> MeosOpsFreeGeo.adjacent_stbox_stbox(pair.a, pair.b)));
+ * }
+ * + * @param the record type being filtered + */ +public final class MeosStatelessFilter extends RichFilterFunction { + + /** Serializable boolean-returning per-event MEOS predicate. */ + @FunctionalInterface + public interface MeosPredicate extends Serializable { + boolean test(IN event) throws Exception; + } + + /** Serializable int-returning per-event MEOS predicate (0/1 flag). */ + @FunctionalInterface + public interface MeosIntPredicate extends Serializable { + int test(IN event) throws Exception; + } + + private final MeosPredicate predicate; + + public MeosStatelessFilter(MeosPredicate predicate) { + this.predicate = predicate; + } + + /** + * Adapt an {@code int}-returning generated MEOS predicate (treating + * non-zero as {@code true}) into a Flink {@code FilterFunction}. + */ + public static MeosStatelessFilter fromIntPredicate(MeosIntPredicate p) { + return new MeosStatelessFilter<>(event -> p.test(event) != 0); + } + + @Override + public void open(Configuration parameters) throws Exception { + super.open(parameters); + MeosWiringRuntime.ensureInitializedOnThread(); + } + + @Override + public boolean filter(IN event) throws Exception { + // When chained to a legacy source, records are processed on the source's + // emitter thread rather than the thread open() ran on; the ThreadLocal + // guard makes this a cheap no-op after the first call per thread. + MeosWiringRuntime.ensureInitializedOnThread(); + return predicate.test(event); + } +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/MeosStatelessMap.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/MeosStatelessMap.java new file mode 100644 index 0000000..aadb4ac --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/MeosStatelessMap.java @@ -0,0 +1,93 @@ +package org.mobilitydb.flink.meos.wirings; + +import org.apache.flink.api.common.functions.MapFunction; +import org.apache.flink.api.common.functions.RichMapFunction; +import org.apache.flink.configuration.Configuration; + +import java.io.Serializable; + +/** + * DataStream wiring for the {@code stateless} streaming tier of the + * generated {@code org.mobilitydb.flink.meos.MeosOps*} facades. + * + *

Wraps any {@code MeosOps*.f(...)} call whose streaming tier is + * {@code stateless} (per {@code tools/codegen/meos-ops-manifest.json} + * or {@code meos-ops-free-manifest.json}) as a Flink + * {@link MapFunction}. No per-key state is allocated; each event is + * mapped independently. The wrapped call: + * + *

    + *
  • does no MEOS-handle state across events (per the + * {@code stateless} tier contract);
    • + *
  • does not touch the time domain (no window required);
    • + *
  • may delegate to MEOS via the bundled JMEOS jar when + * {@code MeosOpsRuntime.MEOS_AVAILABLE} — otherwise the + * generated facade throws {@code UnsupportedOperationException}.
    • + *
+ * + *

Typical usage: register a stateless MEOS predicate / arithmetic + * call as a per-event map step in a DataStream pipeline. Example with + * the generated {@code MeosOpsTBox.overlaps_tbox_tbox} (tier = + * {@code stateless}, per the codegen manifest): + * + * 

{@code
+ * DataStream in = ...;            // (tboxA, tboxB)
+ * DataStream overlap = in.map(
+ *     new MeosStatelessMap<>(
+ *         pair -> MeosOpsTBox.overlaps_tbox_tbox(pair.a, pair.b)));
+ * }
+ * + *

Tier coverage: as of the codegen state on the parent PR, + * 804 of the 2,097 generated methods are {@code stateless} (92 OO- + * classified + 712 free-fn). Any of those can be wrapped through this + * single class without per-method boilerplate. + * + *

Coexistence with {@code berlinmod.MEOSBridge}: this is the + * low-level catalog-shaped wiring; {@code MEOSBridge} stays as + * the high-level query-shaped wiring for the BerlinMOD-9 suite. + * Both share the same {@code MeosOpsRuntime.MEOS_AVAILABLE} discipline. + * + * @param the input record type + * @param the output type returned by the wrapped MEOS call + */ +public final class MeosStatelessMap extends RichMapFunction { + + /** + * Serializable per-event MEOS call. Implementations forward to a + * generated {@code MeosOps*.f(...)} static method, returning the + * Java type that the generated facade exposes. + */ + @FunctionalInterface + public interface MeosCall extends Serializable { + OUT apply(IN event) throws Exception; + } + + private final MeosCall call; + + /** + * @param call serializable lambda forwarding to a stateless + * generated MEOS facade method. The lambda must be + * serializable (Java 8+ lambdas implementing a + * {@link Serializable} functional interface are). + */ + public MeosStatelessMap(MeosCall call) { + this.call = call; + } + + @Override + public void open(Configuration parameters) throws Exception { + super.open(parameters); + // No per-key state in the stateless tier; the only per-operator + // concern is MEOS' per-thread session, initialized on this task thread. + MeosWiringRuntime.ensureInitializedOnThread(); + } + + @Override + public OUT map(IN event) throws Exception { + // When chained to a legacy source, records are processed on the source's + // emitter thread rather than the thread open() ran on; the ThreadLocal + // guard makes this a cheap no-op after the first call per thread. + MeosWiringRuntime.ensureInitializedOnThread(); + return call.apply(event); + } +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/MeosWindowedAggregate.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/MeosWindowedAggregate.java new file mode 100644 index 0000000..7196708 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/MeosWindowedAggregate.java @@ -0,0 +1,123 @@ +package org.mobilitydb.flink.meos.wirings; + +import org.apache.flink.configuration.Configuration; +import org.apache.flink.streaming.api.functions.windowing.ProcessWindowFunction; +import org.apache.flink.streaming.api.windowing.windows.Window; +import org.apache.flink.util.Collector; + +import java.io.Serializable; + +/** + * DataStream wiring for the {@code windowed} streaming tier of the + * generated {@code org.mobilitydb.flink.meos.MeosOps*} facades. + * + *

The {@code windowed} tier is "output cardinality changes; needs a + * window". The canonical examples are + * {@code temporal_length(tgeo)} (one length per trajectory window), + * {@code temporal_twavg(tnumber)} (one time-weighted average per + * window), and the per-class {@code _trajectory} / {@code _time} / + * {@code _timespan} accessors that reduce a full sequence to a single + * derived value. + * + *

Wraps any windowed MeosOps call as a Flink + * {@link ProcessWindowFunction}: per-window, the adopter receives the + * full iterable of events in the window, applies whatever MEOS + * sequence-derived operation is appropriate, and emits a single + * per-window output. The wiring handles the + * {@code ProcessWindowFunction} boilerplate (context, collector) so + * adopters write a single serializable lambda. + * + *

State considerations: unlike + * {@link MeosBoundedStateMap}, the {@code windowed} tier does not + * keep MEOS handles across event boundaries — each window's MEOS + * value is built fresh from the iterable on window close (or + * watermark trigger), used to compute the output, and discarded. The + * iterable's events are Flink-side data; MEOS handles are short-lived + * per-window. + * + *

Typical usage — per-vehicle per-tumbling-window + * trajectory length via {@code MeosOpsTemporal.temporal_length} (tier + * = {@code windowed}): + * + * 

{@code
+ * DataStream events = ...;     // (vehicleId, lon, lat, timestamp)
+ * DataStream lengths = events
+ *     .assignTimestampsAndWatermarks(...)
+ *     .keyBy(VehiclePoint::vehicleId)
+ *     .window(TumblingEventTimeWindows.of(Time.minutes(10)))
+ *     .process(new MeosWindowedAggregate(
+ *         (window, events, ctx) -> {
+ *             Pointer trajectory = buildTrajectoryFromPoints(events);  // adopter helper
+ *             double length = MeosOpsTemporal.temporal_length(trajectory);
+ *             return new VehicleLength(ctx.getCurrentKey(), window.getStart(), length);
+ *         }));
+ * }
+ * + *

The window-close path is event-time-aware: when Flink determines + * the window is complete (via watermark), it invokes the lambda once + * with the full iterable, the window metadata, and a context giving + * access to the key. The adopter returns a single output value. + * + *

Coverage: 161 of the 2,097 emitted methods (~8%) qualify + * as {@code windowed} per the v4 baseline — all of them wrappable + * through this single class. + * + * @param the key type + * @param the input event type within the window + * @param the per-window output type + * @param the window type ({@code TimeWindow}, {@code GlobalWindow}, etc.) + */ +public final class MeosWindowedAggregate + extends ProcessWindowFunction { + + /** + * Serializable per-window MEOS aggregate. The lambda receives the + * window metadata, the full iterable of in-window events, and a + * context (for key access). It returns a single per-window output + * value, or {@code null} to emit nothing. + */ + @FunctionalInterface + public interface WindowFn extends Serializable { + OUT aggregate(W window, Iterable events, ContextLike ctx) throws Exception; + } + + /** + * Slimmer alternative to Flink's {@code ProcessWindowFunction.Context} + * — exposes only the bits a MEOS aggregate typically needs (key + + * current processing time + current watermark). Keeps the wiring + * lambda free of Flink internals. + */ + public interface ContextLike { + K getCurrentKey(); + long getCurrentProcessingTime(); + long getCurrentWatermark(); + } + + private final WindowFn windowFn; + + public MeosWindowedAggregate(WindowFn windowFn) { + this.windowFn = windowFn; + } + + @Override + public void open(Configuration parameters) throws Exception { + super.open(parameters); + MeosWiringRuntime.ensureInitializedOnThread(); + } + + @Override + public void process(K key, + ProcessWindowFunction.Context context, + Iterable elements, + Collector out) throws Exception { + ContextLike ctx = new ContextLike() { + @Override public K getCurrentKey() { return key; } + @Override public long getCurrentProcessingTime() { return context.currentProcessingTime(); } + @Override public long getCurrentWatermark() { return context.currentWatermark(); } + }; + OUT result = windowFn.aggregate(context.window(), elements, ctx); + if (result != null) { + out.collect(result); + } + } +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/MeosWiringRuntime.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/MeosWiringRuntime.java new file mode 100644 index 0000000..51840ae --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/MeosWiringRuntime.java @@ -0,0 +1,37 @@ +package org.mobilitydb.flink.meos.wirings; + +import functions.GeneratedFunctions; + +/** + * Per-thread MEOS initialization for the {@code org.mobilitydb.flink.meos.wirings} + * operators. + * + *

MEOS keeps its timezone / session state per OS thread. Each Flink + * subtask runs on its own task thread, so every wiring operator must + * initialize MEOS on that thread from its {@code open()} — the JVM-wide + * probe in {@code MeosOpsRuntime} only covers the thread that first + * touches a facade class (typically the job's main thread), not the task + * threads where the operators actually run. + * + *

{@link #ensureInitializedOnThread()} is idempotent per thread (guarded + * by a {@link ThreadLocal}), so it is safe to call from every operator's + * {@code open()} even when operators are chained onto the same thread. It + * installs a no-op error handler so a MEOS-side error surfaces as a thrown + * exception rather than terminating the JVM. + */ +public final class MeosWiringRuntime { + + private static final ThreadLocal INITIALIZED = + ThreadLocal.withInitial(() -> Boolean.FALSE); + + private MeosWiringRuntime() { /* utility */ } + + /** Initialize MEOS on the calling thread exactly once. */ + public static void ensureInitializedOnThread() { + if (!INITIALIZED.get()) { + GeneratedFunctions.meos_initialize_error_handler((level, code, message) -> { }); + GeneratedFunctions.meos_initialize(); + INITIALIZED.set(Boolean.TRUE); + } + } +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/README.md b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/README.md new file mode 100644 index 0000000..cf210d1 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/README.md @@ -0,0 +1,89 @@ +# DataStream wirings for the generated MEOS facades + +This package supplies thin, generic Flink-DataStream wrappers around +the generated `org.mobilitydb.flink.meos.MeosOps*` facades, organized +per **streaming tier** (per +`tools/codegen/meos-ops-manifest.json` + `tools/codegen/meos-ops-free-manifest.json`): + +| Tier | Wiring class(es) here | Status in this package | +|---|---|---| +| `stateless` | [`MeosStatelessMap`](MeosStatelessMap.java) (generic `MapFunction`) · [`MeosStatelessFilter`](MeosStatelessFilter.java) (generic `FilterFunction`) | ✅ shipped | +| `bounded-state` | [`MeosBoundedStateMap`](MeosBoundedStateMap.java) (generic `KeyedProcessFunction` with `ValueState` per key — state crosses the operator boundary as MEOS-WKB/WKT bytes so checkpoints/rescaling/savepoints are safe; raw `Pointer` never leaves the JVM-local operator instance) | ✅ shipped | +| `windowed` | [`MeosWindowedAggregate`](MeosWindowedAggregate.java) (generic `ProcessWindowFunction`; window-close-only aggregation; no MEOS handles persist across window boundaries) | ✅ shipped | +| `cross-stream` | [`MeosCrossStreamJoin`](MeosCrossStreamJoin.java) (generic `ProcessJoinFunction` over `KeyedStream.intervalJoin(other)`; time-bounded match window; same-key pairing) | ✅ shipped | +| `io-meta` | covered transitively by the stateless wirings (no state, no window) | n/a | +| `sequence-only` | inherently non-streamable — no wiring | n/a | + +The wirings are **generic**: each takes a serializable lambda +forwarding to whichever generated `MeosOps*.f(...)` method the adopter +needs. No per-method boilerplate, no per-method registration — +adopters wire the entire ~800-method `stateless` slice through +`MeosStatelessMap` / `MeosStatelessFilter` without touching this +package. + +## Why DataStream rather than Table API + +The repo's existing pipeline (`berlinmod/`, `aisdata/`) is +DataStream-API only. Sticking to DataStream avoids adding the +~50 MB `flink-table-planner` runtime dependency to the build matrix. +A Table-API-shaped sibling +(`MeosOpsTableCatalogRegistrar` / `MeosScalarUDF` / `MeosAggregateFunction`) +is a clean follow-up if/when the repo adopts Table API for other +reasons. + +## How a generated MEOS call becomes a Flink operator + +The pattern is the same across all four tiers: + +```java +// 1. Pick the generated MeosOps method +// (Javadoc tier marker tells you which wiring to use) +boolean overlap = MeosOpsTBox.overlaps_tbox_tbox(boxA, boxB); // tier = stateless + +// 2. Wrap with the matching wiring +MeosStatelessFilter filter = MeosStatelessFilter.fromIntPredicate( + pair -> MeosOpsTBox.overlaps_tbox_tbox(pair.a, pair.b)); + +// 3. Apply to the DataStream +DataStream overlapping = stream.filter(filter); +``` + +`MEOS_AVAILABLE` is probed once per JVM by `MeosOpsRuntime`'s static +initializer (shared across all `MeosOps*` and `MeosOpsFree*` +facades). When unavailable, every generated method throws +`UnsupportedOperationException` with a clear message — the wiring +layer doesn't have to handle that itself. + +## End-to-end runnable demo + +[`demo/MeosWiringsDemoJob.java`](demo/MeosWiringsDemoJob.java) walks +through a 3-stage DataStream pipeline using two of the generated +facades wired through `MeosStatelessMap` + `MeosStatelessFilter`: + +1. Parse a stream of TBox WKT strings via + `MeosOpsFreeCore.tbox_in` (io-meta, no state). +2. Filter to those overlapping a fixed query box via + `MeosOpsTBox.overlaps_tbox_tbox` (stateless predicate). +3. Serialize each survivor to hex-WKB via + `MeosOpsTBox.tbox_as_hexwkb` (io-meta, no state). + +Run with: + +```bash +mvn -q exec:java \ + -Dexec.mainClass=org.mobilitydb.flink.meos.wirings.demo.MeosWiringsDemoJob \ + -Dmobilityflink.meos.enabled=true +``` + +Output (expected): two `overlapping-tbox-hex` lines (the two input +boxes that overlap the query box), one disjoint box dropped, one +`MeosWirings stateless tier demo` job completion line. + +## Coexistence with `berlinmod.MEOSBridge` + +`MEOSBridge.java` is the BerlinMOD-specific, hand-written bridge for +the 9-query streaming-form parity matrix — high-level and +query-shaped. The wirings here are low-level and catalog-shaped — +applicable to any of the ~800 stateless or 800 bounded-state +generated facade methods, not just the BerlinMOD-9 subset. Both +share the same `MEOS_AVAILABLE` discipline (`MeosOpsRuntime`). diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/demo/MeosAllTiersCapstoneDemo.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/demo/MeosAllTiersCapstoneDemo.java new file mode 100644 index 0000000..7defc80 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/demo/MeosAllTiersCapstoneDemo.java @@ -0,0 +1,221 @@ +package org.mobilitydb.flink.meos.wirings.demo; + +import jnr.ffi.Pointer; +import org.apache.flink.api.common.eventtime.WatermarkStrategy; +import org.apache.flink.api.java.tuple.Tuple2; +import org.apache.flink.api.java.tuple.Tuple4; +import org.apache.flink.api.java.tuple.Tuple5; +import org.apache.flink.streaming.api.datastream.DataStream; +import org.apache.flink.streaming.api.datastream.KeyedStream; +import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment; +import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows; +import org.apache.flink.streaming.api.windowing.time.Time; +import org.apache.flink.streaming.api.windowing.windows.TimeWindow; +import org.mobilitydb.flink.meos.MeosOpsFreeCore; +import org.mobilitydb.flink.meos.MeosOpsTBox; +import org.mobilitydb.flink.meos.wirings.MeosBoundedStateMap; +import org.mobilitydb.flink.meos.wirings.MeosCrossStreamJoin; +import org.mobilitydb.flink.meos.wirings.MeosStatelessFilter; +import org.mobilitydb.flink.meos.wirings.MeosWindowedAggregate; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.nio.charset.StandardCharsets; +import java.time.Duration; +import java.util.Arrays; + +/** + * Capstone end-to-end demo composing ALL FOUR tier wirings in a single + * Flink DataStream pipeline. + * + *

Proves the wirings compose into a realistic pipeline shape, not + * just work in isolation. Each tier-wiring class drives one stage of + * the pipeline: + * + * 

{@code
+ *  Stream A (vehicles)                Stream B (queries)
+ *       │                                  │
+ *  ① MeosStatelessFilter                   │
+ *      (keep events in regions of interest)│
+ *       │                                  │
+ *  ② MeosBoundedStateMap                   │
+ *      (per-vehicle running tbox union)    │
+ *       │                                  │
+ *  ③ MeosWindowedAggregate                 │
+ *      (30s tumbling per-vehicle aggregate)│
+ *       │                                  │
+ *  └─────────────┐                  ┌──────┘
+ *                ↓                  ↓
+ *  ④ MeosCrossStreamJoin
+ *       (interval-join: vehicle aggregates vs region queries
+ *        within ±1m time bound, match by region key)
+ *                ↓
+ *           output
+ * }
+ * + *

The pipeline answers: "for each region, which vehicles had an + * aggregate trajectory (running union) overlapping the region's + * query bbox during the latest 30-second window?" + * + *

Tier per stage: + *

    + *
  1. Stateless filter — drop events outside any region of + * interest (per-event predicate, no state).
    2. + *
  2. Bounded-state map — per-vehicle running tbox union + * (MEOS handle persisted across events as byte[] state).
    3. + *
  3. Windowed aggregate — per-vehicle 30s tumbling tbox + * (window-close-only aggregation, no handle persistence across + * windows).
    4. + *
  4. Cross-stream join — interval-join vehicle aggregates + * against region queries (pre-keyed by region, ±1m bound).
    5. + *
+ * + *

Run with: + * + * 

{@code
+ * mvn -q exec:java \
+ *     -Dexec.mainClass=org.mobilitydb.flink.meos.wirings.demo.MeosAllTiersCapstoneDemo \
+ *     -Dmobilityflink.meos.enabled=true
+ * }
+ */ +public final class MeosAllTiersCapstoneDemo { + + private static final Logger LOG = LoggerFactory.getLogger(MeosAllTiersCapstoneDemo.class); + + /** Region IDs we care about — the stateless filter drops events outside this set. */ + private static final java.util.Set REGIONS_OF_INTEREST = + new java.util.HashSet<>(Arrays.asList(1, 2)); + + /** Vehicle event stream — (vehicleId, regionId, eventTboxWKT, eventTimeMs). */ + private static final Tuple4[] VEHICLE_EVENTS = new Tuple4[]{ + // window 1: [0s, 30s) + Tuple4.of(10, 1, "TBOX XT([0,2],[2026-01-01,2026-01-01 00:00:15])", ts("00:00:00")), + Tuple4.of(10, 1, "TBOX XT([1,3],[2026-01-01 00:00:15,2026-01-01 00:00:25])", ts("00:00:15")), + Tuple4.of(20, 2, "TBOX XT([10,12],[2026-01-01,2026-01-01 00:00:15])", ts("00:00:05")), + Tuple4.of(99, 9, "TBOX XT([90,92],[2026-01-01,2026-01-01 00:00:15])", ts("00:00:08")), // region 9 — dropped by stage 1 + Tuple4.of(20, 2, "TBOX XT([11,13],[2026-01-01 00:00:15,2026-01-01 00:00:25])", ts("00:00:20")), + // window 2: [30s, 60s) + Tuple4.of(10, 1, "TBOX XT([0,4],[2026-01-01 00:00:30,2026-01-01 00:00:45])", ts("00:00:30")), + Tuple4.of(20, 2, "TBOX XT([10,15],[2026-01-01 00:00:30,2026-01-01 00:00:45])", ts("00:00:35")), + }; + + /** Region query stream — (regionId, queryTboxWKT, eventTimeMs). */ + private static final Tuple2[] REGION_QUERIES = new Tuple2[]{ + Tuple2.of(1, "TBOX XT([1,3],[2026-01-01 00:00:10,2026-01-01 00:00:25])"), + Tuple2.of(2, "TBOX XT([11,13],[2026-01-01 00:00:10,2026-01-01 00:00:25])"), + Tuple2.of(1, "TBOX XT([2,4],[2026-01-01 00:00:35,2026-01-01 00:00:50])"), + Tuple2.of(2, "TBOX XT([12,14],[2026-01-01 00:00:35,2026-01-01 00:00:50])"), + }; + + private static long ts(String hms) { + String[] parts = hms.split(":"); + long secs = Integer.parseInt(parts[0]) * 3600L + + Integer.parseInt(parts[1]) * 60L + + Integer.parseInt(parts[2]); + return 1767225600000L + secs * 1000L; + } + + public static void main(String[] args) throws Exception { + if (!MeosOpsTBox.MEOS_AVAILABLE) { + LOG.error("MEOS not available — the demo requires libmeos."); + System.exit(1); + } + + StreamExecutionEnvironment env = + StreamExecutionEnvironment.getExecutionEnvironment(); + env.setParallelism(1); + + // ── Stream A: vehicle events ──────────────────────────────────────── + DataStream> rawEvents = + env.fromCollection(Arrays.asList(VEHICLE_EVENTS)) + .assignTimestampsAndWatermarks( + WatermarkStrategy + .>forBoundedOutOfOrderness(Duration.ofSeconds(1)) + .withTimestampAssigner((e, t) -> e.f3)); + + // ── ① STATELESS FILTER ── keep only events in regions of interest ── + DataStream> inRegion = + rawEvents.filter(new MeosStatelessFilter>( + evt -> REGIONS_OF_INTEREST.contains(evt.f1))); + + // ── ② BOUNDED-STATE MAP ── per-vehicle running tbox union ────────── + // State holds the MEOS-WKT text of the per-vehicle running union; + // emit (vehicleId, regionId, runningUnionWKT, eventTimeMs) per event. + DataStream> runningUnion = inRegion + .keyBy(t -> t.f0) // key by vehicleId + .process(new MeosBoundedStateMap, Tuple4>( + ptr -> MeosOpsTBox.tbox_out(ptr, 6).getBytes(StandardCharsets.UTF_8), + bytes -> MeosOpsTBox.tbox_in(new String(bytes, StandardCharsets.UTF_8)), + (prior, evt) -> { + Pointer eventTbox = MeosOpsTBox.tbox_in(evt.f2); + Pointer newUnion = (prior == null) + ? eventTbox + : MeosOpsFreeCore.union_tbox_tbox(prior, eventTbox, /*strict=*/false); + Tuple4 output = + Tuple4.of(evt.f0, evt.f1, MeosOpsTBox.tbox_out(newUnion, 6), evt.f3); + return new MeosBoundedStateMap.MeosStep<>(newUnion, output); + })) + .returns(org.apache.flink.api.common.typeinfo.TypeInformation.of( + new org.apache.flink.api.common.typeinfo.TypeHint>() {})); + + // ── ③ WINDOWED AGGREGATE ── per-vehicle 30s tumbling tbox union ───── + // Within each 30s window: take the FINAL running-union value per + // vehicle as the per-window summary. + DataStream> windowed = runningUnion + .keyBy(t -> t.f0) // key by vehicleId + .window(TumblingEventTimeWindows.of(Time.seconds(30))) + .process(new MeosWindowedAggregate< + Integer, + Tuple4, + Tuple4, + TimeWindow + >((window, events, ctx) -> { + // Emit the LAST event in the window (the running union at window close). + Tuple4 last = null; + for (Tuple4 e : events) { + last = e; + } + return last; + })) + .returns(org.apache.flink.api.common.typeinfo.TypeInformation.of( + new org.apache.flink.api.common.typeinfo.TypeHint>() {})); + + // ── Stream B: region queries (keyed by regionId for the join) ─────── + DataStream> queryStream = + env.fromCollection(Arrays.asList(REGION_QUERIES)) + .assignTimestampsAndWatermarks( + WatermarkStrategy + .>forBoundedOutOfOrderness(Duration.ofSeconds(1)) + .withTimestampAssigner((e, t) -> ts("00:00:20"))); // single query-time + + // ── ④ CROSS-STREAM JOIN ── vehicle aggregates × region queries ────── + // Pre-key both by regionId; interval-join within ±1m time bound. + // Per matched pair, emit (regionId, vehicleId, aggUnionWKT, queryWKT, vehicleTs). + KeyedStream, Integer> vehiclesKeyed = + windowed.keyBy(t -> t.f1); // key by regionId + KeyedStream, Integer> queriesKeyed = + queryStream.keyBy(q -> q.f0); + + DataStream> overlaps = + vehiclesKeyed.intervalJoin(queriesKeyed) + .between(Time.minutes(-1), Time.minutes(1)) + .process(new MeosCrossStreamJoin< + Tuple4, + Tuple2, + Tuple5 + >((vehAgg, query, ctx) -> { + Pointer aggTbox = MeosOpsTBox.tbox_in(vehAgg.f2); + Pointer queryTbox = MeosOpsTBox.tbox_in(query.f1); + if (MeosOpsFreeCore.overlaps_tbox_tbox(aggTbox, queryTbox)) { + return Tuple5.of(vehAgg.f1, vehAgg.f0, vehAgg.f2, query.f1, vehAgg.f3); + } + return null; + })) + .returns(org.apache.flink.api.common.typeinfo.TypeInformation.of( + new org.apache.flink.api.common.typeinfo.TypeHint>() {})); + + overlaps.print("capstone-output"); + + env.execute("MeosWirings capstone (all 4 tiers composed)"); + } +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/demo/MeosBoundedStateDemoJob.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/demo/MeosBoundedStateDemoJob.java new file mode 100644 index 0000000..a36db73 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/demo/MeosBoundedStateDemoJob.java @@ -0,0 +1,114 @@ +package org.mobilitydb.flink.meos.wirings.demo; + +import jnr.ffi.Pointer; +import org.apache.flink.api.java.tuple.Tuple2; +import org.apache.flink.streaming.api.datastream.DataStream; +import org.apache.flink.streaming.api.datastream.KeyedStream; +import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment; +import org.mobilitydb.flink.meos.MeosOpsFreeCore; +import org.mobilitydb.flink.meos.MeosOpsTBox; +import org.mobilitydb.flink.meos.wirings.MeosBoundedStateMap; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.nio.charset.StandardCharsets; +import java.util.Arrays; + +/** + * End-to-end runnable demo of the {@code bounded-state} tier wiring. + * + *

Pipeline: + *

    + *
  1. Stream of {@code (vehicleId, eventTboxWKT)} for 2 vehicles, 3 + * events each.
    2. + *
  2. {@code keyBy(vehicleId)} so per-vehicle state isolates.
    3. + *
  3. Per-vehicle running tbox union via + * {@link MeosBoundedStateMap}: state holds the MEOS-WKT text of + * the current union; on each event, deserialize → call + * {@code MeosOpsFreeCore.union_tbox_tbox} → re-serialize.
    4. + *
  4. Emit {@code (vehicleId, runningUnionTboxWKT)} per event.
    5. + *
+ * + *

What the demo proves: + *

    + *
  • Checkpoint-safe state — state crosses the operator + * boundary as {@code byte[]} (MEOS-WKT here, MEOS-WKB in + * production); no raw native pointers in checkpoints.
    • + *
  • Per-key isolation — vehicle 1's running union does not + * leak into vehicle 2's, and vice versa.
    • + *
  • First-event correctness — the wiring handles + * {@code prior == null} on the first event for each key by + * skipping deserialize and seeding state with the first event's + * tbox.
    • + *
+ * + *

Run with: + * + * 

{@code
+ * mvn -q exec:java \
+ *     -Dexec.mainClass=org.mobilitydb.flink.meos.wirings.demo.MeosBoundedStateDemoJob \
+ *     -Dmobilityflink.meos.enabled=true
+ * }
+ * + *

Expected output: 6 lines (3 per vehicle), each showing the growing + * union tbox after that event. + */ +public final class MeosBoundedStateDemoJob { + + private static final Logger LOG = LoggerFactory.getLogger(MeosBoundedStateDemoJob.class); + + /** 6 events across 2 vehicles — the running union grows monotonically per key. */ + private static final Tuple2[] EVENTS = new Tuple2[]{ + Tuple2.of(1, "TBOX XT([0,2],[2026-01-01,2026-01-01 01:00])"), + Tuple2.of(2, "TBOX XT([10,12],[2026-01-01,2026-01-01 01:00])"), + Tuple2.of(1, "TBOX XT([3,5],[2026-01-01 01:00,2026-01-01 02:00])"), + Tuple2.of(2, "TBOX XT([13,15],[2026-01-01 01:00,2026-01-01 02:00])"), + Tuple2.of(1, "TBOX XT([1,4],[2026-01-01 02:00,2026-01-01 03:00])"), + Tuple2.of(2, "TBOX XT([11,14],[2026-01-01 02:00,2026-01-01 03:00])"), + }; + + public static void main(String[] args) throws Exception { + if (!MeosOpsTBox.MEOS_AVAILABLE) { + LOG.error("MEOS not available — the demo requires libmeos."); + System.exit(1); + } + + StreamExecutionEnvironment env = + StreamExecutionEnvironment.getExecutionEnvironment(); + env.setParallelism(1); + + DataStream> events = + env.fromCollection(Arrays.asList(EVENTS)); + + KeyedStream, Integer> keyed = + events.keyBy(t -> t.f0); + + // Wire the per-vehicle running union via MeosBoundedStateMap. + // State is the MEOS-WKT text of the current union (byte[] form); + // each event deserializes, unions with the event tbox, re-serializes. + DataStream> runningUnion = keyed.process( + new MeosBoundedStateMap, Tuple2>( + /* serialize: Pointer → byte[] */ + ptr -> MeosOpsTBox.tbox_out(ptr, 6).getBytes(StandardCharsets.UTF_8), + /* deserialize: byte[] → Pointer */ + bytes -> MeosOpsTBox.tbox_in(new String(bytes, StandardCharsets.UTF_8)), + /* step: (prior union, this event) → (new union, output) */ + (prior, evt) -> { + Pointer eventTbox = MeosOpsTBox.tbox_in(evt.f1); + // First event for a key: prior is null — seed with the event's tbox. + // Subsequent events: union prior with the new event's tbox. + Pointer newUnion = (prior == null) + ? eventTbox + : MeosOpsFreeCore.union_tbox_tbox(prior, eventTbox, /*strict=*/false); + Tuple2 output = + Tuple2.of(evt.f0, MeosOpsTBox.tbox_out(newUnion, 6)); + return new MeosBoundedStateMap.MeosStep<>(newUnion, output); + })) + .returns(org.apache.flink.api.common.typeinfo.TypeInformation.of( + new org.apache.flink.api.common.typeinfo.TypeHint>() {})); + + runningUnion.print("running-union"); + + env.execute("MeosWirings bounded-state tier demo"); + } +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/demo/MeosCrossStreamDemoJob.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/demo/MeosCrossStreamDemoJob.java new file mode 100644 index 0000000..45a23d0 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/demo/MeosCrossStreamDemoJob.java @@ -0,0 +1,135 @@ +package org.mobilitydb.flink.meos.wirings.demo; + +import jnr.ffi.Pointer; +import org.apache.flink.api.common.eventtime.WatermarkStrategy; +import org.apache.flink.api.java.tuple.Tuple4; +import org.apache.flink.api.java.tuple.Tuple5; +import org.apache.flink.streaming.api.datastream.DataStream; +import org.apache.flink.streaming.api.datastream.KeyedStream; +import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment; +import org.apache.flink.streaming.api.windowing.time.Time; +import org.mobilitydb.flink.meos.MeosOpsFreeCore; +import org.mobilitydb.flink.meos.MeosOpsTBox; +import org.mobilitydb.flink.meos.wirings.MeosCrossStreamJoin; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.time.Duration; +import java.util.Arrays; + +/** + * End-to-end runnable demo of the {@code cross-stream} tier wiring. + * + *

Pipeline: + *

    + *
  1. Two parallel streams, each carrying {@code (regionId, + * vehicleId, tboxWKT, eventTimeMs)}, sharing the {@code regionId} + * key so cross-stream pairing is per-region.
    2. + *
  2. {@code keyBy(regionId)} on both, then + * {@code .intervalJoin().between(-1m, +1m)} so each event in + * stream A is matched with events in stream B within ±1 minute + * in the same region.
    3. + *
  3. {@link MeosCrossStreamJoin}: for each matched pair, test + * whether the two tboxes overlap via + * {@code MeosOpsFreeCore.overlaps_tbox_tbox}; if yes, emit + * {@code (regionId, vehAId, vehBId, leftTs, rightTs)}.
    4. + *
+ * + *

What the demo proves: + *

    + *
  • Interval-join semantics — only pairs within the time + * bound are matched; outside-window events are skipped.
    • + *
  • Per-key isolation — events in region 1 don't match + * events in region 2, even if their timestamps overlap.
    • + *
  • Pairwise MEOS call — the wiring lambda receives both + * matched events; the adopter calls any cross-stream MeosOps + * method on the pair (here {@code overlaps_tbox_tbox}, which + * is technically stateless on box pairs but the join-pairing + * is what makes it cross-stream).
    • + *
+ * + *

Run with: + * + * 

{@code
+ * mvn -q exec:java \
+ *     -Dexec.mainClass=org.mobilitydb.flink.meos.wirings.demo.MeosCrossStreamDemoJob \
+ *     -Dmobilityflink.meos.enabled=true
+ * }
+ */ +public final class MeosCrossStreamDemoJob { + + private static final Logger LOG = LoggerFactory.getLogger(MeosCrossStreamDemoJob.class); + + /** Stream A — vehicle events, 3 per region across 2 regions. */ + private static final Tuple4[] EVENTS_A = new Tuple4[]{ + Tuple4.of(1, 10, "TBOX XT([0,5],[2026-01-01,2026-01-01 00:00:30])", ts("00:00:00")), + Tuple4.of(2, 20, "TBOX XT([100,105],[2026-01-01,2026-01-01 00:00:30])", ts("00:00:05")), + Tuple4.of(1, 11, "TBOX XT([10,15],[2026-01-01 00:00:30,2026-01-01 00:01:00])", ts("00:00:30")), + }; + + /** Stream B — different vehicles, 3 per region across 2 regions. */ + private static final Tuple4[] EVENTS_B = new Tuple4[]{ + Tuple4.of(1, 30, "TBOX XT([3,8],[2026-01-01,2026-01-01 00:00:30])", ts("00:00:10")), // overlaps with A:(1,10) + Tuple4.of(2, 40, "TBOX XT([200,205],[2026-01-01,2026-01-01 00:00:30])", ts("00:00:15")), // disjoint from A:(2,20) + Tuple4.of(1, 31, "TBOX XT([12,17],[2026-01-01 00:00:30,2026-01-01 00:01:00])", ts("00:00:40")), // overlaps with A:(1,11) + }; + + private static long ts(String hms) { + String[] parts = hms.split(":"); + long secs = Integer.parseInt(parts[0]) * 3600L + + Integer.parseInt(parts[1]) * 60L + + Integer.parseInt(parts[2]); + return 1767225600000L + secs * 1000L; // 2026-01-01T00:00:00 UTC in ms + } + + public static void main(String[] args) throws Exception { + if (!MeosOpsTBox.MEOS_AVAILABLE) { + LOG.error("MEOS not available — the demo requires libmeos."); + System.exit(1); + } + + StreamExecutionEnvironment env = + StreamExecutionEnvironment.getExecutionEnvironment(); + env.setParallelism(1); + + DataStream> a = + env.fromCollection(Arrays.asList(EVENTS_A)) + .assignTimestampsAndWatermarks( + WatermarkStrategy + .>forBoundedOutOfOrderness(Duration.ofSeconds(1)) + .withTimestampAssigner((e, ts) -> e.f3)); + DataStream> b = + env.fromCollection(Arrays.asList(EVENTS_B)) + .assignTimestampsAndWatermarks( + WatermarkStrategy + .>forBoundedOutOfOrderness(Duration.ofSeconds(1)) + .withTimestampAssigner((e, ts) -> e.f3)); + + KeyedStream, Integer> aKeyed = a.keyBy(t -> t.f0); + KeyedStream, Integer> bKeyed = b.keyBy(t -> t.f0); + + // Interval-join: pair events in A with events in B within ±1 minute, same region key. + DataStream> overlaps = + aKeyed.intervalJoin(bKeyed) + .between(Time.minutes(-1), Time.minutes(1)) + .process(new MeosCrossStreamJoin< + Tuple4, // L + Tuple4, // R + Tuple5 // OUT: (region, vehA, vehB, lts, rts) + >((left, right, ctx) -> { + Pointer leftTbox = MeosOpsTBox.tbox_in(left.f2); + Pointer rightTbox = MeosOpsTBox.tbox_in(right.f2); + if (MeosOpsFreeCore.overlaps_tbox_tbox(leftTbox, rightTbox)) { + return Tuple5.of(left.f0, left.f1, right.f1, + ctx.getLeftTimestamp(), ctx.getRightTimestamp()); + } + return null; + })) + .returns(org.apache.flink.api.common.typeinfo.TypeInformation.of( + new org.apache.flink.api.common.typeinfo.TypeHint>() {})); + + overlaps.print("cross-stream-overlap"); + + env.execute("MeosWirings cross-stream tier demo"); + } +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/demo/MeosWindowedDemoJob.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/demo/MeosWindowedDemoJob.java new file mode 100644 index 0000000..246a53e --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/demo/MeosWindowedDemoJob.java @@ -0,0 +1,132 @@ +package org.mobilitydb.flink.meos.wirings.demo; + +import jnr.ffi.Pointer; +import org.apache.flink.api.common.eventtime.WatermarkStrategy; +import org.apache.flink.api.java.tuple.Tuple3; +import org.apache.flink.api.java.tuple.Tuple4; +import org.apache.flink.streaming.api.datastream.DataStream; +import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment; +import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows; +import org.apache.flink.streaming.api.windowing.time.Time; +import org.apache.flink.streaming.api.windowing.windows.TimeWindow; +import org.mobilitydb.flink.meos.MeosOpsFreeCore; +import org.mobilitydb.flink.meos.MeosOpsTBox; +import org.mobilitydb.flink.meos.wirings.MeosWindowedAggregate; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.time.Duration; +import java.util.Arrays; + +/** + * End-to-end runnable demo of the {@code windowed} tier wiring. + * + *

Pipeline: + *

    + *
  1. Stream of {@code (vehicleId, tboxWKT, eventTimeMs)} for 2 + * vehicles, 4 events each.
    2. + *
  2. {@code assignTimestampsAndWatermarks} so event-time windows + * fire on a bounded-out-of-orderness schedule.
    3. + *
  3. {@code keyBy(vehicleId)} → 30-second tumbling event-time + * window.
    4. + *
  4. Per-window {@link MeosWindowedAggregate}: union all in-window + * event tboxes into a single per-window aggregate tbox via + * repeated {@code MeosOpsFreeCore.union_tbox_tbox}, emit + * {@code (vehicleId, windowStart, eventCount, aggregateTboxWKT)}.
    5. + *
+ * + *

What the demo proves: + *

    + *
  • Window-close timing — events outside the window are + * excluded; events within are aggregated together.
    • + *
  • Per-key isolation — vehicle 1's window aggregate does + * not include vehicle 2's events, and vice versa.
    • + *
  • Stateless aggregation — unlike {@code bounded-state}, + * no MEOS handle persists across window boundaries; each window + * builds its aggregate from scratch from the iterable.
    • + *
+ * + *

Run with: + * + * 

{@code
+ * mvn -q exec:java \
+ *     -Dexec.mainClass=org.mobilitydb.flink.meos.wirings.demo.MeosWindowedDemoJob \
+ *     -Dmobilityflink.meos.enabled=true
+ * }
+ * + *

Expected output: 4 lines (2 windows × 2 vehicles), each showing + * the aggregate tbox spanning that window's events for that vehicle. + */ +public final class MeosWindowedDemoJob { + + private static final Logger LOG = LoggerFactory.getLogger(MeosWindowedDemoJob.class); + + /** 8 events across 2 vehicles, two 30s windows each. */ + private static final Tuple3[] EVENTS = new Tuple3[]{ + // window 1: [0s, 30s) + Tuple3.of(1, "TBOX XT([0,2],[2026-01-01,2026-01-01 00:00:10])", ts("00:00:00")), + Tuple3.of(2, "TBOX XT([10,12],[2026-01-01,2026-01-01 00:00:10])", ts("00:00:05")), + Tuple3.of(1, "TBOX XT([3,5],[2026-01-01 00:00:10,2026-01-01 00:00:20])", ts("00:00:10")), + Tuple3.of(2, "TBOX XT([13,15],[2026-01-01 00:00:10,2026-01-01 00:00:20])", ts("00:00:15")), + // window 2: [30s, 60s) + Tuple3.of(1, "TBOX XT([1,4],[2026-01-01 00:00:30,2026-01-01 00:00:40])", ts("00:00:30")), + Tuple3.of(2, "TBOX XT([11,14],[2026-01-01 00:00:30,2026-01-01 00:00:40])", ts("00:00:35")), + Tuple3.of(1, "TBOX XT([2,3],[2026-01-01 00:00:40,2026-01-01 00:00:50])", ts("00:00:40")), + Tuple3.of(2, "TBOX XT([12,13],[2026-01-01 00:00:40,2026-01-01 00:00:50])", ts("00:00:45")), + }; + + /** Convert "HH:MM:SS" relative to 2026-01-01T00:00:00 into epoch milliseconds. */ + private static long ts(String hms) { + String[] parts = hms.split(":"); + long secs = Integer.parseInt(parts[0]) * 3600L + + Integer.parseInt(parts[1]) * 60L + + Integer.parseInt(parts[2]); + return 1767225600000L + secs * 1000L; // 2026-01-01T00:00:00 UTC in ms + } + + public static void main(String[] args) throws Exception { + if (!MeosOpsTBox.MEOS_AVAILABLE) { + LOG.error("MEOS not available — the demo requires libmeos."); + System.exit(1); + } + + StreamExecutionEnvironment env = + StreamExecutionEnvironment.getExecutionEnvironment(); + env.setParallelism(1); + + DataStream> events = + env.fromCollection(Arrays.asList(EVENTS)) + .assignTimestampsAndWatermarks( + WatermarkStrategy + .>forBoundedOutOfOrderness(Duration.ofSeconds(1)) + .withTimestampAssigner((e, ts) -> e.f2)); + + DataStream> aggregates = events + .keyBy(t -> t.f0) + .window(TumblingEventTimeWindows.of(Time.seconds(30))) + .process(new MeosWindowedAggregate< + Integer, // K + Tuple3, // IN + Tuple4, // OUT + TimeWindow // W + >((window, inWindowEvents, ctx) -> { + Pointer agg = null; + int count = 0; + for (Tuple3 evt : inWindowEvents) { + Pointer evtTbox = MeosOpsTBox.tbox_in(evt.f1); + agg = (agg == null) + ? evtTbox + : MeosOpsFreeCore.union_tbox_tbox(agg, evtTbox, /*strict=*/false); + count++; + } + String aggWkt = (agg == null) ? "(empty)" : MeosOpsTBox.tbox_out(agg, 6); + return Tuple4.of(ctx.getCurrentKey(), window.getStart(), count, aggWkt); + })) + .returns(org.apache.flink.api.common.typeinfo.TypeInformation.of( + new org.apache.flink.api.common.typeinfo.TypeHint>() {})); + + aggregates.print("window-aggregate"); + + env.execute("MeosWirings windowed tier demo"); + } +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/demo/MeosWiringsDemoJob.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/demo/MeosWiringsDemoJob.java new file mode 100644 index 0000000..78883ce --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/demo/MeosWiringsDemoJob.java @@ -0,0 +1,101 @@ +package org.mobilitydb.flink.meos.wirings.demo; + +import org.apache.flink.api.common.typeinfo.Types; +import org.apache.flink.streaming.api.datastream.DataStream; +import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment; +import org.mobilitydb.flink.meos.MeosOpsFreeCore; +import org.mobilitydb.flink.meos.MeosOpsTBox; +import org.mobilitydb.flink.meos.wirings.MeosStatelessFilter; +import org.mobilitydb.flink.meos.wirings.MeosStatelessMap; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.Arrays; + +/** + * End-to-end runnable demo showing how the generated + * {@code org.mobilitydb.flink.meos.MeosOps*} facades wire into a Flink + * {@code DataStream} pipeline through the + * {@code org.mobilitydb.flink.meos.wirings} helpers. + * + *

The demo: + *

    + *
  1. Builds a small in-memory stream of TBox-WKT strings.
    2. + *
  2. Parses each into a JMEOS {@code Pointer} via + * {@code MeosOpsTBox.tbox_in} (tier = {@code io-meta}).
    3. + *
  3. Filters to those that overlap with a fixed query TBox via + * {@code MeosOpsTBox.overlaps_tbox_tbox} wrapped as a + * {@link MeosStatelessFilter} (tier = {@code stateless}).
    4. + *
  4. Maps each surviving TBox to its serialized WKB hex via + * {@code MeosOpsTBox.tbox_as_hexwkb} wrapped as a + * {@link MeosStatelessMap} (tier = {@code io-meta} but no per-key + * state, so the {@code stateless} wiring works for it too).
    5. + *
+ * + *

Run with: + * + * 

{@code
+ * mvn -q exec:java \
+ *     -Dexec.mainClass=org.mobilitydb.flink.meos.wirings.demo.MeosWiringsDemoJob \
+ *     -Dmobilityflink.meos.enabled=true   # require libmeos loadable
+ * }
+ * + *

If libmeos is not loadable on the runtime (or + * {@code -Dmobilityflink.meos.enabled=false}), every wrapped MeosOps + * call throws {@code UnsupportedOperationException} with a clear + * message — the demo prints the throw shape and exits non-zero. + */ +public final class MeosWiringsDemoJob { + + private static final Logger LOG = LoggerFactory.getLogger(MeosWiringsDemoJob.class); + + /** A small box covering (xmin=0, ymin=0, xmax=10, ymax=10). */ + private static final String QUERY_TBOX_WKT = "TBOX XT([0,10],[2026-01-01,2026-01-02])"; + + /** Three input boxes — two overlap the query box, one doesn't. */ + private static final String[] INPUT_TBOX_WKTS = { + "TBOX XT([5,15],[2026-01-01,2026-01-02])", // overlaps + "TBOX XT([20,30],[2026-01-01,2026-01-02])", // disjoint + "TBOX XT([3,8],[2026-01-01,2026-01-02])", // overlaps + }; + + public static void main(String[] args) throws Exception { + // Probe MEOS availability (the static initializer in MeosOpsRuntime + // fires the first time any MeosOps class is touched). + if (!MeosOpsTBox.MEOS_AVAILABLE) { + LOG.error("MEOS not available — the demo requires libmeos. " + + "Set -Dmobilityflink.meos.enabled=true and ensure libmeos is loadable."); + System.exit(1); + } + + StreamExecutionEnvironment env = + StreamExecutionEnvironment.getExecutionEnvironment(); + env.setParallelism(1); + + DataStream tboxWkts = env.fromCollection(Arrays.asList(INPUT_TBOX_WKTS)); + + // The records crossing operator boundaries are serialized MEOS values + // (WKT text) — never raw native pointers, which are process-local and + // not serializable across Flink tasks. Each operator parses to a + // transient MEOS handle, calls MEOS, and re-serializes. + + // Stage 1: parse each WKT and re-serialize via tbox_out (stateless io-meta). + DataStream normalized = tboxWkts.map( + new MeosStatelessMap( + wkt -> MeosOpsTBox.tbox_out(MeosOpsTBox.tbox_in(wkt), 6))) + .returns(Types.STRING); + + // Stage 2: filter to those overlapping the query box (stateless). + // The query box is the constant WKT operand, parsed inside the predicate; + // overlaps_tbox_tbox lives on MeosOpsFreeCore (free fn, not OO-classified). + DataStream overlapping = normalized.filter( + new MeosStatelessFilter( + wkt -> MeosOpsFreeCore.overlaps_tbox_tbox( + MeosOpsTBox.tbox_in(wkt), + MeosOpsTBox.tbox_in(QUERY_TBOX_WKT)))); + + overlapping.print("overlapping-tbox"); + + env.execute("MeosWirings stateless tier demo"); + } +} diff --git a/flink-processor/src/test/java/org/mobilitydb/flink/meos/MeosCbufferSmokeTest.java b/flink-processor/src/test/java/org/mobilitydb/flink/meos/MeosCbufferSmokeTest.java new file mode 100644 index 0000000..7573d36 --- /dev/null +++ b/flink-processor/src/test/java/org/mobilitydb/flink/meos/MeosCbufferSmokeTest.java @@ -0,0 +1,40 @@ +package org.mobilitydb.flink.meos; + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.condition.EnabledIfSystemProperty; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; + +/** + * Runtime check that the cbuffer facade family calls into libmeos and returns + * correct results. Compiled and run only when the build includes the cbuffer + * family ({@code -DCBUFFER=ON}); the family requires a libmeos built with + * {@code -DCBUFFER=ON}. + */ +@EnabledIfSystemProperty(named = "mobilityflink.meos.enabled", matches = "true") +class MeosCbufferSmokeTest { + + @BeforeAll + static void init() { + GeneratedFunctions.meos_initialize_error_handler((level, code, message) -> { }); + GeneratedFunctions.meos_initialize(); + } + + @AfterAll + static void finalizeMeos() { + GeneratedFunctions.meos_finalize(); + } + + @Test + void cbuffer() { + Pointer cb = MeosOpsFreeCbuffer.cbuffer_make(MeosOpsFreeGeo.geom_in("POINT(1 1)", 0), 0.5); + assertNotNull(cb); + assertEquals(0.5, MeosOpsFreeCbuffer.cbuffer_radius(cb), 1e-9); + assertNotNull(MeosOpsFreeCbuffer.cbuffer_out(cb, 6)); + } +} diff --git a/flink-processor/src/test/java/org/mobilitydb/flink/meos/MeosFacadeSmokeTest.java b/flink-processor/src/test/java/org/mobilitydb/flink/meos/MeosFacadeSmokeTest.java new file mode 100644 index 0000000..395e5cf --- /dev/null +++ b/flink-processor/src/test/java/org/mobilitydb/flink/meos/MeosFacadeSmokeTest.java @@ -0,0 +1,66 @@ +package org.mobilitydb.flink.meos; + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.condition.EnabledIfSystemProperty; + +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * Runtime check that the always-built MEOS facade families (core and geo) call + * into libmeos and return correct results. Each constructs a value through a + * {@code MeosOps*} facade method and reads it back. Runs only with + * {@code -Dmobilityflink.meos.enabled=true} and a libmeos on the load path. The + * optional families have their own gated smoke tests + * ({@link MeosCbufferSmokeTest}, {@link MeosNpointSmokeTest}, + * {@link MeosPoseSmokeTest}), each compiled only when its build flag includes + * the family. + */ +@EnabledIfSystemProperty(named = "mobilityflink.meos.enabled", matches = "true") +class MeosFacadeSmokeTest { + + @BeforeAll + static void init() { + // No-op error handler so a parse error returns rather than terminating the JVM. + GeneratedFunctions.meos_initialize_error_handler((level, code, message) -> { }); + GeneratedFunctions.meos_initialize(); + } + + @AfterAll + static void finalizeMeos() { + GeneratedFunctions.meos_finalize(); + } + + @Test + void coreTbox() { + Pointer tbox = MeosOpsTBox.tbox_in("TBOX X([1, 2])"); + assertNotNull(tbox); + assertTrue(MeosOpsTBox.tbox_out(tbox, 6).contains("TBOX")); + } + + @Test + void coreIntspan() { + Pointer span = MeosOpsIntSpan.intspan_in("[1, 5)"); + assertNotNull(span); + String out = MeosOpsIntSpan.intspan_out(span); + assertTrue(out.contains("1") && out.contains("5")); + } + + @Test + void geoStbox() { + Pointer stbox = MeosOpsSTBox.stbox_in("STBOX X((1,1),(2,2))"); + assertNotNull(stbox); + assertTrue(MeosOpsSTBox.stbox_out(stbox, 6).contains("STBOX")); + } + + @Test + void geoGeometry() { + Pointer geom = MeosOpsFreeGeo.geom_in("POINT(1 1)", 0); + assertNotNull(geom); + assertTrue(MeosOpsFreeGeo.geo_as_text(geom, 6).toUpperCase().contains("POINT")); + } +} diff --git a/flink-processor/src/test/java/org/mobilitydb/flink/meos/MeosNpointSmokeTest.java b/flink-processor/src/test/java/org/mobilitydb/flink/meos/MeosNpointSmokeTest.java new file mode 100644 index 0000000..6af10d7 --- /dev/null +++ b/flink-processor/src/test/java/org/mobilitydb/flink/meos/MeosNpointSmokeTest.java @@ -0,0 +1,39 @@ +package org.mobilitydb.flink.meos; + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.condition.EnabledIfSystemProperty; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; + +/** + * Runtime check that the npoint facade family calls into libmeos and returns + * correct results. Compiled and run when the build includes the npoint family + * (the default; dropped with {@code -DNPOINT=OFF}). + */ +@EnabledIfSystemProperty(named = "mobilityflink.meos.enabled", matches = "true") +class MeosNpointSmokeTest { + + @BeforeAll + static void init() { + GeneratedFunctions.meos_initialize_error_handler((level, code, message) -> { }); + GeneratedFunctions.meos_initialize(); + } + + @AfterAll + static void finalizeMeos() { + GeneratedFunctions.meos_finalize(); + } + + @Test + void npoint() { + Pointer np = MeosOpsFreeNpoint.npoint_make(1, 0.5); + assertNotNull(np); + assertEquals(1, MeosOpsFreeNpoint.npoint_route(np)); + assertEquals(0.5, MeosOpsFreeNpoint.npoint_position(np), 1e-9); + } +} diff --git a/flink-processor/src/test/java/org/mobilitydb/flink/meos/MeosPoseSmokeTest.java b/flink-processor/src/test/java/org/mobilitydb/flink/meos/MeosPoseSmokeTest.java new file mode 100644 index 0000000..c4e13c9 --- /dev/null +++ b/flink-processor/src/test/java/org/mobilitydb/flink/meos/MeosPoseSmokeTest.java @@ -0,0 +1,40 @@ +package org.mobilitydb.flink.meos; + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.condition.EnabledIfSystemProperty; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; + +/** + * Runtime check that the pose facade family calls into libmeos and returns + * correct results. Compiled and run only when the build includes the pose + * family ({@code -DPOSE=ON}); the family requires a libmeos built with + * {@code -DPOSE=ON}. + */ +@EnabledIfSystemProperty(named = "mobilityflink.meos.enabled", matches = "true") +class MeosPoseSmokeTest { + + @BeforeAll + static void init() { + GeneratedFunctions.meos_initialize_error_handler((level, code, message) -> { }); + GeneratedFunctions.meos_initialize(); + } + + @AfterAll + static void finalizeMeos() { + GeneratedFunctions.meos_finalize(); + } + + @Test + void pose() { + Pointer pose = MeosOpsFreePose.pose_in("Pose(Point(1 1), 0.5)"); + assertNotNull(pose); + assertNotNull(MeosOpsFreePose.pose_out(pose, 6)); + assertEquals(0.5, MeosOpsFreePose.pose_rotation(pose), 1e-9); + } +} diff --git a/flink-processor/target/classes/aisdata/AISData.class b/flink-processor/target/classes/aisdata/AISData.class deleted file mode 100644 index 32b9d60..0000000 Binary files a/flink-processor/target/classes/aisdata/AISData.class and /dev/null differ diff --git a/flink-processor/target/classes/aisdata/AISDataDeserializationSchema.class b/flink-processor/target/classes/aisdata/AISDataDeserializationSchema.class deleted file mode 100644 index 8ed1fde..0000000 Binary files a/flink-processor/target/classes/aisdata/AISDataDeserializationSchema.class and /dev/null differ diff --git a/flink-processor/target/classes/aisdata/AISTestSource.class b/flink-processor/target/classes/aisdata/AISTestSource.class deleted file mode 100644 index a372cbe..0000000 Binary files a/flink-processor/target/classes/aisdata/AISTestSource.class and /dev/null differ diff --git a/flink-processor/target/classes/aisdata/Main$AISDataTimestampAssigner.class b/flink-processor/target/classes/aisdata/Main$AISDataTimestampAssigner.class deleted file mode 100644 index 2c88edc..0000000 Binary files a/flink-processor/target/classes/aisdata/Main$AISDataTimestampAssigner.class and /dev/null differ diff --git a/flink-processor/target/classes/aisdata/Main$AISDataToTuple4MapFunction.class b/flink-processor/target/classes/aisdata/Main$AISDataToTuple4MapFunction.class deleted file mode 100644 index 9762130..0000000 Binary files a/flink-processor/target/classes/aisdata/Main$AISDataToTuple4MapFunction.class and /dev/null differ diff --git a/flink-processor/target/classes/aisdata/Main$DeserializeAISDataMapFunction.class b/flink-processor/target/classes/aisdata/Main$DeserializeAISDataMapFunction.class deleted file mode 100644 index d4f3c47..0000000 Binary files a/flink-processor/target/classes/aisdata/Main$DeserializeAISDataMapFunction.class and /dev/null differ diff --git a/flink-processor/target/classes/aisdata/Main$LogKafkaMessagesMapFunction.class b/flink-processor/target/classes/aisdata/Main$LogKafkaMessagesMapFunction.class deleted file mode 100644 index 2b7b258..0000000 Binary files a/flink-processor/target/classes/aisdata/Main$LogKafkaMessagesMapFunction.class and /dev/null differ diff --git a/flink-processor/target/classes/aisdata/Main.class b/flink-processor/target/classes/aisdata/Main.class deleted file mode 100644 index 26e68e2..0000000 Binary files a/flink-processor/target/classes/aisdata/Main.class and /dev/null differ diff --git a/flink-processor/target/classes/aisdata/TrajectoryWindowFunction.class b/flink-processor/target/classes/aisdata/TrajectoryWindowFunction.class deleted file mode 100644 index 95fc00d..0000000 Binary files a/flink-processor/target/classes/aisdata/TrajectoryWindowFunction.class and /dev/null differ diff --git a/flink-processor/target/classes/log4j.properties b/flink-processor/target/classes/log4j.properties deleted file mode 100644 index 0db67fa..0000000 --- a/flink-processor/target/classes/log4j.properties +++ /dev/null @@ -1,5 +0,0 @@ -log4j.rootLogger= INFO, console - -log4j.appender.console=org.apache.log4j.ConsoleAppender -log4j.appender.console.layout=org.apache.log4j.PatternLayout -log4j.appender.console.layout.ConversionPattern=%d{ISO8601} [%t] %-5p %c %x - %m%n \ No newline at end of file diff --git a/flink-processor/target/maven-archiver/pom.properties b/flink-processor/target/maven-archiver/pom.properties deleted file mode 100644 index f358c8c..0000000 --- a/flink-processor/target/maven-archiver/pom.properties +++ /dev/null @@ -1,3 +0,0 @@ -artifactId=flink-kafka2postgres -groupId=Mariana -version=1.0-SNAPSHOT diff --git a/flink-processor/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst b/flink-processor/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst deleted file mode 100644 index b76b8d5..0000000 --- a/flink-processor/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst +++ /dev/null @@ -1,9 +0,0 @@ -aisdata/TrajectoryWindowFunction.class -aisdata/Main$DeserializeAISDataMapFunction.class -aisdata/Main$AISDataToTuple4MapFunction.class -aisdata/AISTestSource.class -aisdata/Main$AISDataTimestampAssigner.class -aisdata/Main.class -aisdata/AISData.class -aisdata/Main$LogKafkaMessagesMapFunction.class -aisdata/AISDataDeserializationSchema.class diff --git a/flink-processor/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst b/flink-processor/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst deleted file mode 100644 index 7e01bde..0000000 --- a/flink-processor/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst +++ /dev/null @@ -1,5 +0,0 @@ -/Users/marianaduarte/MobilityFlink/flink-processor/src/main/java/aisdata/AISData.java -/Users/marianaduarte/MobilityFlink/flink-processor/src/main/java/aisdata/AISDataDeserializationSchema.java -/Users/marianaduarte/MobilityFlink/flink-processor/src/main/java/aisdata/AISTestSource.java -/Users/marianaduarte/MobilityFlink/flink-processor/src/main/java/aisdata/Main.java -/Users/marianaduarte/MobilityFlink/flink-processor/src/main/java/aisdata/TrajectoryWindowFunction.java diff --git a/flink-processor/tools/codegen/README.md b/flink-processor/tools/codegen/README.md new file mode 100644 index 0000000..94ec1cd --- /dev/null +++ b/flink-processor/tools/codegen/README.md @@ -0,0 +1,106 @@ +# MEOS-API → MobilityFlink codegen + +`org.mobilitydb.flink.meos.MeosOps*` is a generated, tier-aware Java +facade over the MEOS public API. Two siblings of classes: + +- `MeosOps` — one per MEOS object-model class (50 classes, 751 + methods). Source: `codegen-oo.py`. +- `MeosOpsFree

` — one per public MEOS header for functions + *not* assigned to any OO class (6 headers, 1,346 methods). Source: + `codegen-free.py`. + +Both generators share the same per-method discipline: read JMEOS' actual +exported surface via `javap -p functions.GeneratedFunctions`, +inner-join with the streaming-relevance baseline v4 (tier +classification of every MEOS public function), emit one static method +per matched function whose body forwards to the JMEOS native binding +after probing the shared `MeosOpsRuntime.MEOS_AVAILABLE` flag. + +## What is generated + +For every MEOS public function `f` that + +1. lives in one of the five public-API streaming tiers + (`stateless`, `bounded-state`, `windowed`, `cross-stream`, + `io-meta`), and +2. is exposed by JMEOS as a static method on + `functions.GeneratedFunctions`, + +the generator emits `MeosOps.f(...)` or +`MeosOpsFree
.f(...)` whose body delegates to +`GeneratedFunctions.f(...)` after probing +`MeosOpsRuntime.MEOS_AVAILABLE`. Each method carries a Javadoc tier +marker so consumers know the per-method wiring shape (scalar UDF for +`stateless`/`bounded-state`, windowed aggregate for `windowed`, etc.). + +## Why generated rather than hand-written + +- **One source of truth.** Method signatures, classification, and tier + semantics come from the MEOS-API catalog + the streaming-relevance + baseline; no hand-written facade can drift from MEOS' actual surface. +- **Audit by regeneration.** Reviewing the diff is reviewing the + catalog change; each generator is ~250 lines, the runtime is ~30, + the rest is mechanical. +- **Bump-safe.** When the JMEOS jar regenerates against a new MEOS + release, re-running the generators absorbs the new surface with zero + hand edits. + +## How to regenerate + +```bash +# 1. Regenerate the MEOS-API catalog from MobilityDB headers +git clone --branch feat/object-model https://github.com/MobilityDB/MEOS-API.git +cd MEOS-API && pip install -r requirements.txt +python run.py /path/to/MobilityDB/meos/include /path/to/MobilityDB/mobilitydb/src +# → output/meos-idl.json + +# 2. Produce the streaming-relevance baseline (v4 classifier) +# → streaming-relevance-baseline.json + +# 3. Extract JMEOS PR #19 method signatures +jar xf flink-processor/jar/JMEOS.jar functions/GeneratedFunctions.class +javap -p functions.GeneratedFunctions > jmeos_signatures.txt + +# 4. Run both generators +python flink-processor/tools/codegen/codegen-oo.py # → MeosOps.java +python flink-processor/tools/codegen/codegen-free.py # → MeosOpsFree
.java +``` + +## Manifests + +`meos-ops-manifest.json` (OO-classified) and +`meos-ops-free-manifest.json` (free fns) record the regeneration +provenance: total JMEOS method count, baseline target count, emit +count, per-tier breakdown, per-class/per-header method count, sample +of functions absent from JMEOS. + +## Tier vocabulary + +| Tier | Meaning | Flink wiring shape | +|---|---|---| +| `stateless` | Pure per-event, no state | `ScalarFunction` (Table API) or direct call in `MapFunction` | +| `bounded-state` | Per-event with bounded per-key state | `ScalarFunction` (state lives in the MEOS handle) | +| `windowed` | Output cardinality changes; needs a window | `AggregateFunction` over `TUMBLE`/`HOP` | +| `cross-stream` | Pairwise across streams; needs interval-overlap join | `CoProcessFunction` or `IntervalJoin` | +| `io-meta` | I/O, catalog, lifecycle helpers | Helper / `format` clause | + +The current emission excludes `sequence-only` (functions requiring the +full sequence offline; ~14 fns) and `ambiguous` corner cases (~59 fns +where the mechanical classifier couldn't decide). Both are surfaced +separately for design decisions before emit. + +## Coexistence with `MEOSBridge.java` + +`berlinmod.MEOSBridge` is the hand-written, BerlinMOD-scoped bridge +introduced on `feat/jmeos-bridge-swap`. The generated `MeosOps*` +facades are the catalog-driven equivalent for the *whole* MEOS +surface; they coexist without redesigning `MEOSBridge`: + +- `MEOSBridge` keeps the per-BerlinMOD-query intent (Haversine + fallback, `dwithinSegmentMetres`, etc.) — high-level, query-shaped. +- `MeosOps*` exposes the raw MEOS surface tier-by-tier — low-level, + catalog-shaped. + +Both share the same `MEOS_AVAILABLE` discipline (via +`MeosOpsRuntime`) and the same `functions.GeneratedFunctions` +delegation. diff --git a/flink-processor/tools/codegen/codegen-free.py b/flink-processor/tools/codegen/codegen-free.py new file mode 100644 index 0000000..d40a61d --- /dev/null +++ b/flink-processor/tools/codegen/codegen-free.py @@ -0,0 +1,187 @@ +#!/usr/bin/env python3 +"""Free-fns expansion: emit Flink-side static facades for the streamable +MEOS public functions that are NOT assigned to an OO class in the +object model. Organized per source header (one Java class per header) +to keep navigability close to MEOS' own source layout. + +Reads: +- JMEOS PR #19's functions.GeneratedFunctions surface (2,699 methods) +- streaming-relevance baseline v4 (2,240 public-API fns, classified) + +Emits: +- MeosOpsFree.java — one per public header +- Shares MeosOpsRuntime (single MEOS_AVAILABLE flag across all facades) +""" +import json, re, sys, datetime +from pathlib import Path +from collections import Counter, defaultdict + +SIG_PATH = Path("/home/esteban/src/_flink_codegen/jmeos_pr19_signatures.txt") +BL_PATH = Path("/home/esteban/src/_streaming_relevance/out/streaming-relevance-baseline.json") +OUT_ROOT = Path("/home/esteban/src/_flink_codegen/generated") +OUT_PKG = "org.mobilitydb.flink.meos" +OUT_DIR = OUT_ROOT / "src/main/java" / OUT_PKG.replace('.', '/') + +SIG_RE = re.compile(r'^\s*public\s+static\s+(?P[\w\.<>\[\]]+)\s+(?P\w+)\((?P[^)]*)\)') +jmeos = {} +with open(SIG_PATH) as f: + for line in f: + m = SIG_RE.match(line.rstrip(';\n')) + if m: + jmeos[m.group('name')] = { + 'ret': m.group('ret'), + 'arg_types': [a.strip() for a in m.group('args').strip().split(',')] if m.group('args').strip() else [] + } +print(f'JMEOS methods parsed: {len(jmeos)}') + +with open(BL_PATH) as f: bl = json.load(f) + +# Emit-tier set (same as v4) +EMIT_TIERS = {'stateless', 'bounded-state', 'windowed', 'cross-stream', 'io-meta'} + +# Free fns = streamable + NOT classified into any OO class + public header +free_rows = [r for r in bl['functions'] + if r['tier'] in EMIT_TIERS + and not r.get('class') # no OO class + and r['tier'] != 'internal'] + +print(f'free-fn target (baseline streamable + no OO class): {len(free_rows)}') + +# Inner-join with JMEOS PR #19 +emit_rows = [] +not_in_jmeos = [] +for r in free_rows: + if r['name'] in jmeos: + sig = jmeos[r['name']] + emit_rows.append({**r, + 'java_ret': sig['ret'], + 'java_params': [(t, f'arg{i}') for i, t in enumerate(sig['arg_types'])]}) + else: + not_in_jmeos.append(r['name']) + +print(f'JMEOS inner-join: {len(emit_rows)} emit / {len(not_in_jmeos)} absent') + +# Group by header — produce one Java class per header +by_header = defaultdict(list) +for r in emit_rows: + by_header[r['file']].append(r) + +# Header → Java class name +def header_to_class(h): + # meos.h → MeosOpsFreeCore + # meos_geo.h → MeosOpsFreeGeo + # meos_cbuffer.h → MeosOpsFreeCbuffer + base = h.replace('.h', '').replace('meos_', '').replace('meos', 'core') + if base in ('', 'core'): + return 'MeosOpsFreeCore' + parts = base.split('_') + return 'MeosOpsFree' + ''.join(p.capitalize() for p in parts) + +TIER_DOC = { + 'stateless': 'Pure per-event; safe in any Flink scalar position.', + 'bounded-state': 'Per-event with bounded per-key state (MEOS handle).', + 'windowed': 'Requires window operator — caller wraps in AggregateFunction.', + 'cross-stream': 'Pairwise across streams — caller wraps in a join.', + 'sequence-only': 'Inherently non-streamable; honest marker.', + 'io-meta': 'I/O / catalog / lifecycle helper.', +} + +def short_type(t): + if t.startswith('java.lang.'): + return t[len('java.lang.'):] + return t.split('.')[-1] if '.' in t else t + +def emit(cls_name, rows, header): + imports = set(['functions.GeneratedFunctions']) + for r in rows: + for t in [r['java_ret']] + [a[0] for a in r['java_params']]: + if '.' in t and not t.startswith('java.lang.'): + imports.add(t.replace('[]', '')) + imports = sorted(i for i in imports if '.' in i) + + tier_cnt = Counter(r['tier'] for r in rows) + L = [ + f'package {OUT_PKG};', + '', + f'/* AUTO-GENERATED by codegen_flink_free.py — do not edit by hand.', + f' * Source header: {header}', + f' * Methods emitted: {len(rows)} (' + ' · '.join(f'{t}={c}' for t, c in tier_cnt.most_common()) + ')', + f' * Scope: MEOS public functions NOT classified into any object-model class', + f' * (free functions, not methods on a class).', + f' * Source: JMEOS PR #19 (functions.GeneratedFunctions) ∩ streaming-relevance baseline v4.', + ' */', + '', + ] + for i in imports: + L.append(f'import {i};') + L += [ + '', + f'public final class {cls_name} {{', + '', + ' public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE;', + '', + f' private {cls_name}() {{ /* utility */ }}', + '', + ] + + TIER_ORDER = {'stateless':0, 'bounded-state':1, 'windowed':2, 'cross-stream':3, 'io-meta':4, 'sequence-only':5} + for r in sorted(rows, key=lambda r: (TIER_ORDER.get(r['tier'], 99), r['name'])): + fname = r['name'] + args = ', '.join(f'{short_type(t)} {n}' for (t, n) in r['java_params']) + call_args = ', '.join(n for (t, n) in r['java_params']) + ret_short = short_type(r['java_ret']) + L += [ + ' /**', + f' * MEOS {{@code {fname}}} — tier {r["tier"]}.', + f' *

{TIER_DOC.get(r["tier"], "")}

', + f' *

Free function (not class-classified). Classification rule: {r["reason"]}

', + ' */', + ] + if r['tier'] == 'sequence-only': + L += [ + f' public static {ret_short} {fname}({args}) {{', + f' throw new UnsupportedOperationException(', + f' "{fname} is sequence-only — not supported in a streaming context");', + ' }', '', + ] + else: + ret_stmt = '' if ret_short == 'void' else 'return ' + L += [ + f' public static {ret_short} {fname}({args}) {{', + ' if (!MEOS_AVAILABLE) {', + f' throw new UnsupportedOperationException(', + f' "{fname} requires libmeos — set -Dmobilityflink.meos.enabled=true");', + ' }', + f' {ret_stmt}GeneratedFunctions.{fname}({call_args});', + ' }', '', + ] + L.append('}') + return '\n'.join(L) + '\n' + +emitted_files = [] +for header, rows in sorted(by_header.items()): + cls = header_to_class(header) + (OUT_DIR / f'{cls}.java').write_text(emit(cls, rows, header)) + emitted_files.append((cls, header, len(rows))) + +print(f'\n=== emitted {len(emitted_files)} free-fn Java classes ===') +for cls, hdr, n in sorted(emitted_files, key=lambda x: -x[2]): + print(f' {cls:30s} ({hdr:25s}): {n} methods') + +# Manifest +manifest = { + 'generator': 'codegen_flink_free.py', + 'jmeos_method_total': len(jmeos), + 'baseline_free_fn_count': len(free_rows), + 'emitted_methods': len(emit_rows), + 'absent_from_jmeos': len(not_in_jmeos), + 'absent_from_jmeos_sample': not_in_jmeos[:20], + 'tier_breakdown': dict(Counter(r['tier'] for r in emit_rows)), + 'classes_emitted': sorted([cls for cls, _, _ in emitted_files]), + 'methods_per_header': {hdr: n for cls, hdr, n in emitted_files}, +} +(OUT_ROOT / 'meos-ops-free-manifest.json').write_text(json.dumps(manifest, indent=2)) +print(f'\nwrote meos-ops-free-manifest.json') +print(f'\ntier breakdown of emitted free fns:') +for t, c in Counter(r['tier'] for r in emit_rows).most_common(): + print(f' {t:18s}: {c}') diff --git a/flink-processor/tools/codegen/codegen-oo.py b/flink-processor/tools/codegen/codegen-oo.py new file mode 100644 index 0000000..6cea150 --- /dev/null +++ b/flink-processor/tools/codegen/codegen-oo.py @@ -0,0 +1,237 @@ +#!/usr/bin/env python3 +"""v3 generator: scale from TBox+STBox (87 fns) to all streamable tiers +across ALL object-model classes on Flink (target ~1,705 fns). + +Strategy: +- One Java class per MEOS object-model class (e.g. MeosOpsTFloat, + MeosOpsTBox, MeosOpsSet, ...) — keeps each file small and navigable. +- Functions appearing in multiple OO classes get emitted in each class + they're a member of (catalog of the OO model; mirrors PyMEOS multi-class + pattern). +- Same JMEOS-signature-forwarding pattern as v2. +- Same tier-aware Javadoc + emit rules. +""" +import json, re, sys +from pathlib import Path +from collections import Counter, defaultdict + +SIG_PATH = Path("/home/esteban/src/_flink_codegen/jmeos_pr19_signatures.txt") +BL_PATH = Path("/home/esteban/src/_streaming_relevance/out/streaming-relevance-baseline.json") +CAT_PATH = Path("/home/esteban/src/_streaming_relevance/meos-api/output/meos-idl.json") +OUT_ROOT = Path("/home/esteban/src/_flink_codegen/generated") +OUT_PKG = "org.mobilitydb.flink.meos" +OUT_DIR = OUT_ROOT / "src/main/java" / OUT_PKG.replace('.', '/') +OUT_DIR.mkdir(parents=True, exist_ok=True) + +SIG_RE = re.compile(r'^\s*public\s+static\s+(?P[\w\.<>\[\]]+)\s+(?P\w+)\((?P[^)]*)\)') +jmeos = {} +with open(SIG_PATH) as f: + for line in f: + m = SIG_RE.match(line.rstrip(';\n')) + if m: + ret = m.group('ret') + name = m.group('name') + raw = m.group('args').strip() + arg_types = [a.strip() for a in raw.split(',')] if raw else [] + jmeos[name] = {'ret': ret, 'arg_types': arg_types} +print(f'JMEOS methods parsed: {len(jmeos)}') + +with open(BL_PATH) as f: bl = json.load(f) +with open(CAT_PATH) as f: cat = json.load(f) +sig_by_name = {fn['name']: fn for fn in cat['functions']} + +# Scope: streamable + io-meta tiers across ALL OO classes (skip sequence-only +# and ambiguous for now — those need design decisions surfaced separately). +EMIT_TIERS = {'stateless', 'bounded-state', 'windowed', 'cross-stream', 'io-meta'} +target_rows = [r for r in bl['functions'] + if r['tier'] in EMIT_TIERS + and r.get('class') # must be classified into the OO model + and r['tier'] != 'internal'] + +# Inner-join with JMEOS +emit_rows = [] +not_in_jmeos = [] +for r in target_rows: + if r['name'] in jmeos: + sig = jmeos[r['name']] + emit_rows.append({**r, + 'java_ret': sig['ret'], + 'java_params': [(t, f'arg{i}') for i, t in enumerate(sig['arg_types'])]}) + else: + not_in_jmeos.append(r['name']) + +print(f'baseline target: {len(target_rows)} fns') +print(f'JMEOS inner-join: {len(emit_rows)} emit / {len(not_in_jmeos)} absent from JMEOS') + +# Group emit_rows by OO class +by_class = defaultdict(list) +for r in emit_rows: + for c in r['class']: + by_class[c].append(r) + +print(f'classes to emit: {len(by_class)}') + +TIER_DOC = { + 'stateless': 'Pure per-event; safe in any Flink scalar position.', + 'bounded-state': 'Per-event with bounded per-key state (MEOS handle).', + 'windowed': 'Requires window operator — caller wraps in AggregateFunction.', + 'cross-stream': 'Pairwise across streams — caller wraps in a join.', + 'sequence-only': 'Inherently non-streamable; honest marker.', + 'io-meta': 'I/O / catalog / lifecycle helper.', +} + +# ----- Per-class file emission --------------------------------------------- +def short_type(t): + if t.startswith('java.lang.'): + return t[len('java.lang.'):] + return t.split('.')[-1] if '.' in t else t + +def java_class_name(oo_class): + """Map OO class name → Java class name.""" + return f'MeosOps{oo_class}' + +def emit_class(oo_class, rows): + """Emit one Java class collecting all methods of `oo_class`.""" + imports = set(['functions.GeneratedFunctions']) + for r in rows: + for t in [r['java_ret']] + [a[0] for a in r['java_params']]: + if '.' in t and not t.startswith('java.lang.'): + imports.add(t.replace('[]', '')) + imports = sorted(i for i in imports if '.' in i) + + cls = java_class_name(oo_class) + tier_cnt = Counter(r['tier'] for r in rows) + L = [ + f'package {OUT_PKG};', + '', + f'/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand.', + f' * MEOS object-model class: {oo_class}', + f' * Methods emitted: {len(rows)} (' + ' · '.join(f'{t}={c}' for t, c in tier_cnt.most_common()) + ')', + f' * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4.', + ' */', + '', + ] + for i in imports: + L.append(f'import {i};') + L += [ + '', + f'public final class {cls} {{', + '', + ' public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE;', + '', + f' private {cls}() {{ /* utility */ }}', + '', + ] + + # Sort: by tier (stateless first → most-used) then by name + TIER_ORDER = {'stateless':0, 'bounded-state':1, 'windowed':2, 'cross-stream':3, 'io-meta':4, 'sequence-only':5} + for r in sorted(rows, key=lambda r: (TIER_ORDER.get(r['tier'], 99), r['name'])): + fname = r['name'] + args = ', '.join(f'{short_type(t)} {n}' for (t, n) in r['java_params']) + call_args = ', '.join(n for (t, n) in r['java_params']) + ret_short = short_type(r['java_ret']) + L += [ + ' /**', + f' * MEOS {{@code {fname}}} — tier {r["tier"]}.', + f' *

{TIER_DOC.get(r["tier"], "")}

', + ] + if r.get('role'): + L.append(f' *

Object-model role: {{@code {r["role"]}}}.

') + L.append(f' *

Classification: {r["reason"]}

') + L.append(' */') + if r['tier'] == 'sequence-only': + L += [ + f' public static {ret_short} {fname}({args}) {{', + f' throw new UnsupportedOperationException(', + f' "{fname} is sequence-only — not supported in a streaming context");', + ' }', + '', + ] + else: + ret_stmt = '' if ret_short == 'void' else 'return ' + L += [ + f' public static {ret_short} {fname}({args}) {{', + ' if (!MEOS_AVAILABLE) {', + f' throw new UnsupportedOperationException(', + f' "{fname} requires libmeos — set -Dmobilityflink.meos.enabled=true");', + ' }', + f' {ret_stmt}GeneratedFunctions.{fname}({call_args});', + ' }', + '', + ] + L.append('}') + return '\n'.join(L) + '\n' + +# Shared runtime helper (the MEOS_AVAILABLE static-init lives once) +runtime_src = f'''package {OUT_PKG}; + +import functions.GeneratedFunctions; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * Shared runtime helper: owns the single MEOS_AVAILABLE static-init across + * all generated MeosOps* facades, so libmeos is probed exactly once per + * JVM rather than 82 times. */ +final class MeosOpsRuntime {{ + + static final boolean MEOS_AVAILABLE; + + static {{ + boolean enabled = Boolean.parseBoolean( + System.getProperty("mobilityflink.meos.enabled", "true")); + boolean ok = false; + if (enabled) {{ + try {{ + GeneratedFunctions.meos_initialize(); + ok = true; + }} catch (Throwable t) {{ + ok = false; + }} + }} + MEOS_AVAILABLE = ok; + }} + + private MeosOpsRuntime() {{ /* utility */ }} +}} +''' +(OUT_DIR / 'MeosOpsRuntime.java').write_text(runtime_src) + +# Wipe stale class files from v2 run +for f in OUT_DIR.glob('MeosBoxOps.java'): + f.unlink() +for f in OUT_DIR.glob('MeosOps*.java'): + if f.name not in ('MeosOpsRuntime.java',): + f.unlink() + +# Write one file per OO class +emitted_files = [] +for oo_class, rows in sorted(by_class.items()): + src = emit_class(oo_class, rows) + fname = f'{java_class_name(oo_class)}.java' + (OUT_DIR / fname).write_text(src) + emitted_files.append((fname, len(rows))) + +print(f'emitted {len(emitted_files)} Java classes') +print('top by method count:') +for fn, c in sorted(emitted_files, key=lambda x: -x[1])[:10]: + print(f' {fn:35s}: {c}') + +# Manifest +manifest = { + 'generator': 'codegen_flink_v3.py', + 'package': OUT_PKG, + 'jmeos_method_total': len(jmeos), + 'baseline_target_count': len(target_rows), + 'emitted_methods': len(emit_rows), + 'emitted_files': len(emitted_files), + 'absent_from_jmeos': len(not_in_jmeos), + 'absent_from_jmeos_sample': not_in_jmeos[:20], + 'tier_breakdown': dict(Counter(r['tier'] for r in emit_rows)), + 'classes_emitted': sorted(by_class.keys()), + 'methods_per_class': {oo: len(rs) for oo, rs in sorted(by_class.items())}, +} +(OUT_ROOT / 'meos-ops-manifest.json').write_text(json.dumps(manifest, indent=2)) +print(f'wrote {OUT_ROOT / "meos-ops-manifest.json"}') +print() +print('tier breakdown of emitted (method-level, may multi-count if fn in 2 OO classes):') +for t, c in Counter(r['tier'] for r in emit_rows).most_common(): + print(f' {t:18s}: {c}') diff --git a/flink-processor/tools/codegen/emit_h3_facade.py b/flink-processor/tools/codegen/emit_h3_facade.py new file mode 100644 index 0000000..de5cd6a --- /dev/null +++ b/flink-processor/tools/codegen/emit_h3_facade.py @@ -0,0 +1,79 @@ +#!/usr/bin/env python3 +"""Emit the H3 / th3index family facade (MeosOpsTh3index + MeosOpsFreeH3). + +The unified functions.GeneratedFunctions jar carries the H3 temporal-index +family. This emits its user-facing surface as MeosOps* forwarders, mirroring the +other per-family facade classes: the numerator is the public meos_h3.h externs +intersected with the jar (Datum-bearing dispatchers and internal h3 helpers are +excluded by construction — they are not declared in meos_h3.h). th3index_* go to +the temporal-type class MeosOpsTh3index; the remaining H3 free functions (geo↔H3 +walkers, set ops, ever/always comparisons) go to MeosOpsFreeH3. + +Run from flink-processor/: + MEOS_INCLUDE= python3 tools/codegen/emit_h3_facade.py jar/JMEOS.jar +""" +import re, os, sys, subprocess + +HERE = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +FACADE = os.path.join(HERE, "src/main/java/org/mobilitydb/flink/meos") +INC = os.environ.get("MEOS_INCLUDE", "/home/esteban/src/MobilityDB/meos/include") +_SIG = re.compile(r'public static (\S+) ([a-z_][A-Za-z0-9_]*)\(([^)]*)\)') +_DECL = re.compile(r'^\s*extern\s+.+?\b([a-z][A-Za-z0-9_]*)\s*\(', re.M) + + +def jar_sigs(jar): + out = subprocess.run(["javap", "-classpath", jar, "-p", "functions.GeneratedFunctions"], + capture_output=True, text=True).stdout + sigs = {} + for line in out.splitlines(): + m = _SIG.search(line) + if m: + sigs[m.group(2)] = (m.group(1), + [a.strip() for a in m.group(3).strip().split(",")] if m.group(3).strip() else []) + return sigs + + +def method(name, sigs): + ret, types = sigs[name] + decl = ", ".join(f"{t} arg{i}" for i, t in enumerate(types)) + call = ", ".join(f"arg{i}" for i in range(len(types))) + retkw = "" if ret == "void" else "return " + return (f"\n /** MEOS {{@code {name}}} — H3 / th3index family. */\n" + f" public static {ret} {name}({decl}) {{\n" + f" if (!MEOS_AVAILABLE) {{\n" + f" throw new UnsupportedOperationException(\n" + f' "{name} requires libmeos — set -Dmobilityflink.meos.enabled=true");\n' + f" }}\n" + f" {retkw}GeneratedFunctions.{name}({call});\n" + f" }}\n") + + +def emit_class(cls, names, sigs): + body = "".join(method(n, sigs) for n in names) + txt = (f"package org.mobilitydb.flink.meos;\n\n" + f"/* AUTO-GENERATED by tools/codegen/emit_h3_facade.py — do not edit by hand.\n" + f" * H3 / th3index family facade over functions.GeneratedFunctions.\n */\n\n" + f"import functions.GeneratedFunctions;\n" + f"import jnr.ffi.Pointer;\n\n" + f"public final class {cls} {{\n\n" + f" public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE;\n\n" + f" private {cls}() {{ /* utility */ }}\n" + f"{body}}}\n") + open(os.path.join(FACADE, f"{cls}.java"), "w").write(txt) + return len(names) + + +def main(): + jar = sys.argv[1] if len(sys.argv) > 1 else os.path.join(HERE, "jar/JMEOS.jar") + sigs = jar_sigs(jar) + public = set(_DECL.findall(open(os.path.join(INC, "meos_h3.h")).read())) + facade = sorted(public & set(sigs)) + th3 = [n for n in facade if n.startswith("th3index")] + free = [n for n in facade if not n.startswith("th3index")] + a = emit_class("MeosOpsTh3index", th3, sigs) + b = emit_class("MeosOpsFreeH3", free, sigs) + print(f"MeosOpsTh3index: {a} methods; MeosOpsFreeH3: {b} methods") + + +if __name__ == "__main__": + main() diff --git a/flink-processor/tools/codegen/emit_tbigint_facade.py b/flink-processor/tools/codegen/emit_tbigint_facade.py new file mode 100644 index 0000000..87e5cfc --- /dev/null +++ b/flink-processor/tools/codegen/emit_tbigint_facade.py @@ -0,0 +1,69 @@ +#!/usr/bin/env python3 +"""Emit the tbigint temporal-type family facade (MeosOpsTBigint). + +The consolidated functions.GeneratedFunctions jar carries the tbigint temporal +type (MobilityDB #1044). The static bigint set/span types already have facade +classes (MeosOpsBigintSet/Span/SpanSet); this emits the temporal type's surface +— the numerator is the public meos.h externs whose name contains 'tbigint' +intersected with the jar (Datum-bearing dispatchers are excluded, not being +extern-declared in the public header). Mirrors the per-family facade classes +(MeosOpsTInt/TFloat/…) and the th3index family-port. + +Run from flink-processor/: + MEOS_INCLUDE= python3 tools/codegen/emit_tbigint_facade.py jar/JMEOS.jar +""" +import re, os, sys, subprocess + +HERE = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +FACADE = os.path.join(HERE, "src/main/java/org/mobilitydb/flink/meos") +INC = os.environ.get("MEOS_INCLUDE", "/home/esteban/src/MobilityDB/meos/include") +_SIG = re.compile(r'public static (\S+) ([a-z_][A-Za-z0-9_]*)\(([^)]*)\)') +_DECL = re.compile(r'^\s*extern\s+.+?\b([a-z][A-Za-z0-9_]*)\s*\(', re.M) + + +def jar_sigs(jar): + out = subprocess.run(["javap", "-classpath", jar, "-p", "functions.GeneratedFunctions"], + capture_output=True, text=True).stdout + sigs = {} + for line in out.splitlines(): + m = _SIG.search(line) + if m: + sigs[m.group(2)] = (m.group(1), + [a.strip() for a in m.group(3).strip().split(",")] if m.group(3).strip() else []) + return sigs + + +def main(): + jar = sys.argv[1] if len(sys.argv) > 1 else os.path.join(HERE, "jar/JMEOS.jar") + sigs = jar_sigs(jar) + public = set(_DECL.findall(open(os.path.join(INC, "meos.h")).read())) + names = sorted(n for n in public if "tbigint" in n and n in sigs) + body = "" + for name in names: + ret, types = sigs[name] + decl = ", ".join(f"{t} arg{i}" for i, t in enumerate(types)) + call = ", ".join(f"arg{i}" for i in range(len(types))) + retkw = "" if ret == "void" else "return " + body += (f"\n /** MEOS {{@code {name}}} — tbigint temporal family. */\n" + f" public static {ret} {name}({decl}) {{\n" + f" if (!MEOS_AVAILABLE) {{\n" + f" throw new UnsupportedOperationException(\n" + f' "{name} requires libmeos — set -Dmobilityflink.meos.enabled=true");\n' + f" }}\n" + f" {retkw}GeneratedFunctions.{name}({call});\n" + f" }}\n") + txt = ("package org.mobilitydb.flink.meos;\n\n" + "/* AUTO-GENERATED by tools/codegen/emit_tbigint_facade.py — do not edit by hand.\n" + " * tbigint temporal-type family facade over functions.GeneratedFunctions.\n */\n\n" + "import functions.GeneratedFunctions;\n" + "import jnr.ffi.Pointer;\n\n" + "public final class MeosOpsTBigint {\n\n" + " public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE;\n\n" + " private MeosOpsTBigint() { /* utility */ }\n" + f"{body}}}\n") + open(os.path.join(FACADE, "MeosOpsTBigint.java"), "w").write(txt) + print(f"MeosOpsTBigint: {len(names)} methods") + + +if __name__ == "__main__": + main() diff --git a/flink-processor/tools/codegen/meos-ops-free-manifest.json b/flink-processor/tools/codegen/meos-ops-free-manifest.json new file mode 100644 index 0000000..0780313 --- /dev/null +++ b/flink-processor/tools/codegen/meos-ops-free-manifest.json @@ -0,0 +1,52 @@ +{ + "generator": "codegen_flink_free.py", + "jmeos_method_total": 2699, + "baseline_free_fn_count": 1396, + "emitted_methods": 1346, + "absent_from_jmeos": 50, + "absent_from_jmeos_sample": [ + "temptype_subtype", + "temptype_subtype_all", + "tempsubtype_name", + "tempsubtype_from_string", + "meosoper_name", + "interptype_name", + "meostype_name", + "temptype_basetype", + "geo_basetype", + "meos_basetype", + "alphanum_basetype", + "alphanum_temptype", + "time_type", + "numset_type", + "ensure_numset_type", + "timeset_type", + "ensure_set_spantype", + "alphanumset_type", + "ensure_geoset_type", + "spatialset_type" + ], + "tier_breakdown": { + "io-meta": 96, + "stateless": 712, + "bounded-state": 284, + "windowed": 121, + "cross-stream": 133 + }, + "classes_emitted": [ + "MeosOpsFreeCbuffer", + "MeosOpsFreeCore", + "MeosOpsFreeGeo", + "MeosOpsFreeNpoint", + "MeosOpsFreePose", + "MeosOpsFreeRgeo" + ], + "methods_per_header": { + "meos.h": 746, + "meos_cbuffer.h": 149, + "meos_geo.h": 262, + "meos_npoint.h": 82, + "meos_pose.h": 76, + "meos_rgeo.h": 31 + } +} \ No newline at end of file diff --git a/flink-processor/tools/codegen/meos-ops-manifest.json b/flink-processor/tools/codegen/meos-ops-manifest.json new file mode 100644 index 0000000..e1a306b --- /dev/null +++ b/flink-processor/tools/codegen/meos-ops-manifest.json @@ -0,0 +1,142 @@ +{ + "generator": "codegen_flink_v3.py", + "package": "org.mobilitydb.flink.meos", + "jmeos_method_total": 2699, + "baseline_target_count": 771, + "emitted_methods": 751, + "emitted_files": 50, + "absent_from_jmeos": 20, + "absent_from_jmeos_sample": [ + "tnumber_basetype", + "set_basetype", + "set_type", + "set_spantype", + "geoset_type", + "span_basetype", + "span_canon_basetype", + "span_type", + "span_tbox_type", + "spanset_type", + "temporal_type", + "temporal_basetype", + "talpha_type", + "tnumber_type", + "tnumber_spantype", + "tspatial_type", + "tpoint_type", + "tgeo_type", + "tgeo_type_all", + "tgeometry_type" + ], + "tier_breakdown": { + "io-meta": 99, + "bounded-state": 513, + "stateless": 92, + "windowed": 40, + "cross-stream": 7 + }, + "classes_emitted": [ + "BigintSet", + "BigintSpan", + "BigintSpanSet", + "CbufferSet", + "DateSet", + "DateSpan", + "DateSpanSet", + "FloatSet", + "FloatSpan", + "FloatSpanSet", + "GeogSet", + "GeomSet", + "IntSet", + "IntSpan", + "IntSpanSet", + "NpointSet", + "PoseSet", + "STBox", + "Set", + "Span", + "SpanSet", + "TBool", + "TBoolInst", + "TBox", + "TCbuffer", + "TFloat", + "TFloatInst", + "TGeo", + "TGeogPoint", + "TGeography", + "TGeomPoint", + "TGeometry", + "TInt", + "TIntInst", + "TNpoint", + "TNpointInst", + "TNumber", + "TPoint", + "TPose", + "TRGeometry", + "TRGeometryInst", + "TSequenceSet", + "TSpatial", + "TText", + "TTextInst", + "Temporal", + "TextSet", + "TstzSet", + "TstzSpan", + "TstzSpanSet" + ], + "methods_per_class": { + "BigintSet": 8, + "BigintSpan": 9, + "BigintSpanSet": 7, + "CbufferSet": 7, + "DateSet": 9, + "DateSpan": 9, + "DateSpanSet": 11, + "FloatSet": 13, + "FloatSpan": 15, + "FloatSpanSet": 13, + "GeogSet": 1, + "GeomSet": 6, + "IntSet": 9, + "IntSpan": 10, + "IntSpanSet": 8, + "NpointSet": 8, + "PoseSet": 7, + "STBox": 54, + "Set": 25, + "Span": 20, + "SpanSet": 30, + "TBool": 15, + "TBoolInst": 1, + "TBox": 33, + "TCbuffer": 15, + "TFloat": 37, + "TFloatInst": 1, + "TGeo": 24, + "TGeogPoint": 3, + "TGeography": 4, + "TGeomPoint": 4, + "TGeometry": 5, + "TInt": 29, + "TIntInst": 1, + "TNpoint": 21, + "TNpointInst": 1, + "TNumber": 23, + "TPoint": 24, + "TPose": 17, + "TRGeometry": 36, + "TRGeometryInst": 1, + "TSequenceSet": 1, + "TSpatial": 9, + "TText": 18, + "TTextInst": 1, + "Temporal": 97, + "TextSet": 10, + "TstzSet": 12, + "TstzSpan": 13, + "TstzSpanSet": 16 + } +} \ No newline at end of file diff --git a/flink-processor/tools/codegen/regen_facade_from_jar.py b/flink-processor/tools/codegen/regen_facade_from_jar.py new file mode 100644 index 0000000..e8f5957 --- /dev/null +++ b/flink-processor/tools/codegen/regen_facade_from_jar.py @@ -0,0 +1,78 @@ +#!/usr/bin/env python3 +"""Re-derive the MeosOps* facade signatures from a JMEOS jar. + +The tier-aware generators (codegen-oo.py / codegen-free.py) emit the facade +from the MEOS-API streaming-relevance baseline. When only the binding jar is +available (e.g. bumping to a newly generated functions.GeneratedFunctions whose +type lowering changed), this tool re-emits each existing facade method with the +jar's current signature — preserving the per-class tier classification and the +Javadoc, changing only the parameter / return types to match the jar. It is the +signature-migration complement to the baseline generators, not a replacement. + +Run from flink-processor/: + python3 tools/codegen/regen_facade_from_jar.py \\ + src/main/java/org/mobilitydb/flink/meos jar/JMEOS.jar + +Forwarder facades emitted by their own scripts are left untouched here +(MeosOpsParityGaps via emit_gap_methods.py, MeosOpsSqlSurface via +emit_sql_surface.py, MeosOpsRuntime hand-maintained); re-run those against the +same jar afterwards. +""" +import re, glob, os, sys, subprocess + +EXCLUDE = {"MeosOpsParityGaps.java", "MeosOpsSqlSurface.java", "MeosOpsRuntime.java"} +_SIG = re.compile(r'public static (\S+) ([a-z_][A-Za-z0-9_]*)\(([^)]*)\)') +# method block: optional Javadoc + `public static (...) {` ... 4-space `}` +_BLOCK = re.compile( + r'(?P(?:[ ]{4}/\*\*.*?\*/\n)?)' + r'[ ]{4}public static [^\n;{]*?\b(?P[a-z_][A-Za-z0-9_]*)\([^)]*\)\s*\{' + r'.*?\n[ ]{4}\}\n', + re.S) + + +def jar_signatures(jar): + out = subprocess.run(["javap", "-classpath", jar, "-p", + "functions.GeneratedFunctions"], + capture_output=True, text=True).stdout + sigs = {} + for line in out.splitlines(): + m = _SIG.search(line) + if m: + ret, name, args = m.group(1), m.group(2), m.group(3).strip() + sigs[name] = (ret, [a.strip() for a in args.split(",")] if args else []) + return sigs + + +def emit(jd, name, sigs): + if name not in sigs: + return None + ret, types = sigs[name] + decl = ", ".join(f"{t} arg{i}" for i, t in enumerate(types)) + call = ", ".join(f"arg{i}" for i in range(len(types))) + retkw = "" if ret == "void" else "return " + return (f'{jd} public static {ret} {name}({decl}) {{\n' + f' if (!MEOS_AVAILABLE) {{\n' + f' throw new UnsupportedOperationException(\n' + f' "{name} requires libmeos — set -Dmobilityflink.meos.enabled=true");\n' + f' }}\n' + f' {retkw}GeneratedFunctions.{name}({call});\n' + f' }}\n') + + +def main(): + facade_dir, jar = sys.argv[1], sys.argv[2] + sigs = jar_signatures(jar) + changed = 0 + for f in sorted(glob.glob(os.path.join(facade_dir, "MeosOps*.java"))): + if os.path.basename(f) in EXCLUDE: + continue + txt = open(f).read() + new = _BLOCK.sub(lambda m: emit(m.group("jd"), m.group("name"), sigs) or m.group(0), txt) + if new != txt: + open(f, "w").write(new) + changed += 1 + print(f"jar signatures: {len(sigs)}; facade files rewritten: {changed}") + + +if __name__ == "__main__": + main() diff --git a/flink-processor/tools/parity/emit_gap_methods.py b/flink-processor/tools/parity/emit_gap_methods.py new file mode 100644 index 0000000..a229cbd --- /dev/null +++ b/flink-processor/tools/parity/emit_gap_methods.py @@ -0,0 +1,94 @@ +#!/usr/bin/env python3 +"""Emit forwarding facade methods for MEOS public-surface functions that the +generated MeosOps* facade does not yet expose. + +Each method forwards to its `functions.GeneratedFunctions` export using the +exact JMEOS signature (captured via `javap`), so the output compiles by +construction. Family and nature (scalar / sequence-constructor / tiling) are +recorded in the Javadoc; the wiring tier is governed by the wirings layer, not +by the presence of the forwarder. + +Run from flink-processor/: + javap -classpath jar/JMEOS.jar -p functions.GeneratedFunctions > /tmp/gen_sigs.txt + python3 tools/parity/emit_gap_methods.py /tmp/gen_sigs.txt +""" +import re, os, sys, glob + +HERE = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +INC = os.environ.get("MEOS_INCLUDE", "/home/esteban/src/MobilityDB/meos/include") +PUBLIC_HEADERS = ["meos.h", "meos_geo.h", "meos_cbuffer.h", "meos_npoint.h", "meos_pose.h", "meos_rgeo.h", "meos_h3.h"] +FACADE = os.path.join(HERE, "src/main/java/org/mobilitydb/flink/meos") +OUT = os.path.join(FACADE, "MeosOpsParityGaps.java") +# Forwarder facades are themselves derived; the "already covered" baseline is the +# tier-aware generated OO classes only, so the generator reproduces idempotently. +DERIVED = {"MeosOpsParityGaps.java", "MeosOpsSqlSurface.java"} + +_DECL = re.compile(r'^\s*extern\s+.+?\b([a-z][A-Za-z0-9_]*)\s*\(', re.M) +_PUBSTATIC = re.compile(r'public static [A-Za-z0-9_.<>\[\]]+ ([a-z0-9_]+)\(') +_SIG = re.compile(r'public static (\S+) (\w+)\(([^)]*)\);') + + +def family(name, fam): + return fam.get(name, "meos.h") + + +def nature(name): + if name.endswith("_make") or "_from_base_" in name or name.endswith("make_coords"): + return "whole-sequence constructor — not a per-event op" + if name.endswith("_tiles"): + return "multidimensional tiling (windowed)" + return "scalar / stateless" + + +def main(): + sigfile = sys.argv[1] if len(sys.argv) > 1 else "/tmp/parity/gen_sigs.txt" + fam, pub = {}, set() + for h in PUBLIC_HEADERS: + for n in set(_DECL.findall(open(os.path.join(INC, h)).read())): + pub.add(n); fam.setdefault(n, h) + facade = set() + for f in glob.glob(os.path.join(FACADE, "MeosOps*.java")): + if os.path.basename(f) in DERIVED: + continue + facade |= set(_PUBSTATIC.findall(open(f).read())) + # all JMEOS signatures, grouped by name + sigs = {} + for line in open(sigfile): + m = _SIG.search(line) + if m: + ret, name, args = m.group(1), m.group(2), m.group(3).strip() + sigs.setdefault(name, []).append((ret, args)) + missing = sorted(n for n in (pub & set(sigs)) - facade) + + L = ["package org.mobilitydb.flink.meos;", "", + "/**", " * Forwarding facade methods for MEOS public-surface functions not emitted", + " * by the tier-aware code generator. Each method delegates to its JMEOS", + " * {@code functions.GeneratedFunctions} export under the shared", + " * {@link MeosOpsRuntime#MEOS_AVAILABLE} guard.", + " */", + "public final class MeosOpsParityGaps {", "", + " private MeosOpsParityGaps() { /* utility */ }", ""] + count = 0 + for name in missing: + for ret, args in sigs[name]: + params = [a.strip() for a in args.split(",")] if args else [] + decl = ", ".join(f"{t} arg{i}" for i, t in enumerate(params)) + call = ", ".join(f"arg{i}" for i in range(len(params))) + ret_kw = "" if ret == "void" else "return " + L += [f" /** MEOS {{@code {name}}} — {family(name, fam)} · {nature(name)}. */", + f" public static {ret} {name}({decl}) {{", + f" if (!MeosOpsRuntime.MEOS_AVAILABLE)", + f' throw new UnsupportedOperationException("{name} requires libmeos' + f' — set -Dmobilityflink.meos.enabled=true");', + f" {ret_kw}functions.GeneratedFunctions.{name}({call});", + " }", ""] + count += 1 + L.append("}") + open(OUT, "w").write("\n".join(L) + "\n") + print(f"missing public-surface functions: {len(missing)}") + print(f"forwarding methods emitted: {count}") + print(f"wrote {OUT}") + + +if __name__ == "__main__": + main() diff --git a/flink-processor/tools/parity/emit_sql_surface.py b/flink-processor/tools/parity/emit_sql_surface.py new file mode 100644 index 0000000..75392bb --- /dev/null +++ b/flink-processor/tools/parity/emit_sql_surface.py @@ -0,0 +1,115 @@ +#!/usr/bin/env python3 +"""Emit forwarding facade methods for MEOS functions that the MobilityDB SQL +layer exposes as user functions but whose implementation lives in the internal +headers (`meos_internal*.h`). JMEOS binds them; exposing them here makes the +Flink facade match the SQL user surface as well as the public MEOS API. + +Each method forwards to its `functions.GeneratedFunctions` export using the +exact JMEOS signature, so the output compiles by construction. + +Run from flink-processor/: + javap -classpath jar/JMEOS.jar -p functions.GeneratedFunctions > /tmp/gen_sigs.txt + python3 tools/parity/emit_sql_surface.py /tmp/gen_sigs.txt +""" +import re, os, sys, glob + +HERE = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +INC = os.environ.get("MEOS_INCLUDE", "/home/esteban/src/MobilityDB/meos/include") +MDB_SQL = os.environ.get("MDB_SQL", "/home/esteban/src/MobilityDB/mobilitydb/sql") +FACADE = os.path.join(HERE, "src/main/java/org/mobilitydb/flink/meos") +OUT = os.path.join(FACADE, "MeosOpsSqlSurface.java") + +_PUBSTATIC = re.compile(r'public static [A-Za-z0-9_.<>\[\]]+ ([a-z0-9_]+)\(') +_SIG = re.compile(r'public static (\S+) (\w+)\(([^)]*)\);') +_CREATE = re.compile(r'CREATE\s+(?:OR\s+REPLACE\s+)?FUNCTION\s+([A-Za-z0-9_]+)\s*\(', re.I) +_CSYM = re.compile(r"AS\s+'[^']*'\s*,\s*'([A-Za-z0-9_]+)'", re.I) + +OOS_SECTIONS = { + "temporal/011_span_indexes.in.sql", "temporal/012_spanset_indexes.in.sql", + "temporal/013_set_indexes.in.sql", "temporal/019_geo_constructors.in.sql", + "temporal/043_temporal_gist.in.sql", "temporal/044_temporal_spgist.in.sql", + "temporal/999_oid_cache.in.sql", "geo/073_tgeo_gist.in.sql", + "geo/073_tpoint_gist.in.sql", "geo/074_tgeo_spgist.in.sql", + "geo/074_tpoint_spgist.in.sql", "cbuffer/166_tcbuffer_indexes.in.sql", + "npoint/092_tnpoint_gin.in.sql", "npoint/098_tnpoint_indexes.in.sql", + "pose/114_tpose_indexes.in.sql", "rgeo/134_trgeo_indexes.in.sql", +} +OOS_SUFFIXES = ("_in", "_out", "_recv", "_send", "_typmod_in", "_typmod_out", + "_transfn", "_combinefn", "_finalfn", "_serialize", "_deserialize", + "_sel", "_joinsel", "_supportfn", "_analyze", + "_cmp", "_eq", "_ne", "_lt", "_le", "_gt", "_ge", "_hash", "_hash_extended") +OOS_NAMES = {"range", "multirange", "create_trip", "transform_gk"} + + +def header_names(*headers): + names = set() + for h in headers: + names |= set(re.findall(r'^\s*extern\s+.+?\b([a-z][A-Za-z0-9_]*)\s*\(', open(os.path.join(INC, h)).read(), re.M)) + return names + + +def sql_addressable(): + addr = set() + for path in glob.glob(os.path.join(MDB_SQL, "**", "*.in.sql"), recursive=True): + section = os.path.relpath(path, MDB_SQL).replace(os.sep, "/") + txt = open(path, encoding="utf-8", errors="replace").read() + for m in _CREATE.finditer(txt): + name = m.group(1); tail = txt[m.end():m.end() + 1200].split(';')[0] + cm = _CSYM.search(tail); sym = cm.group(1) if cm else None + key = (sym or name).lower() + if section in OOS_SECTIONS or key in OOS_NAMES or key.endswith(OOS_SUFFIXES): + continue + if sym is not None: + addr.add(key) + return addr + + +def main(): + sigfile = sys.argv[1] if len(sys.argv) > 1 else "/tmp/parity/gen_sigs.txt" + sigs = {} + for line in open(sigfile): + m = _SIG.search(line) + if m: + sigs.setdefault(m.group(2), []).append((m.group(1), m.group(3).strip())) + facade = set() + for f in glob.glob(os.path.join(FACADE, "MeosOps*.java")): + facade |= set(_PUBSTATIC.findall(open(f).read())) + pub = header_names("meos.h", "meos_geo.h", "meos_cbuffer.h", "meos_npoint.h", "meos_pose.h", "meos_rgeo.h") + addr = sql_addressable() + # SQL-addressable, bound by JMEOS, not in the public-surface facade, not already exposed + targets = sorted((addr & set(sigs)) - facade - pub) + + L = ["package org.mobilitydb.flink.meos;", "", + "/**", " * Forwarding facade methods for MEOS functions that the MobilityDB SQL layer", + " * exposes as user functions but whose implementation lives in the internal headers", + " * ({@code meos_internal*.h}). JMEOS binds them; they are exposed here so the facade", + " * matches the SQL user surface as well as the public MEOS API. Each method delegates", + " * to its {@code functions.GeneratedFunctions} export under the", + " * {@link MeosOpsRuntime#MEOS_AVAILABLE} guard.", + " */", + "public final class MeosOpsSqlSurface {", "", + " private MeosOpsSqlSurface() { /* utility */ }", ""] + count = 0 + for name in targets: + for ret, args in sigs[name]: + params = [a.strip() for a in args.split(",")] if args else [] + decl = ", ".join(f"{t} arg{i}" for i, t in enumerate(params)) + call = ", ".join(f"arg{i}" for i in range(len(params))) + ret_kw = "" if ret == "void" else "return " + L += [f" /** MEOS {{@code {name}}} — SQL-surface function (meos_internal). */", + f" public static {ret} {name}({decl}) {{", + f" if (!MeosOpsRuntime.MEOS_AVAILABLE)", + f' throw new UnsupportedOperationException("{name} requires libmeos' + f' — set -Dmobilityflink.meos.enabled=true");', + f" {ret_kw}functions.GeneratedFunctions.{name}({call});", + " }", ""] + count += 1 + L.append("}") + open(OUT, "w").write("\n".join(L) + "\n") + print(f"SQL-surface (internal-backed) functions to expose: {len(targets)}") + print(f"forwarding methods emitted: {count}") + print(f"wrote {OUT}") + + +if __name__ == "__main__": + main() diff --git a/flink-processor/tools/parity/parity_audit.py b/flink-processor/tools/parity/parity_audit.py new file mode 100644 index 0000000..e5e2005 --- /dev/null +++ b/flink-processor/tools/parity/parity_audit.py @@ -0,0 +1,234 @@ +#!/usr/bin/env python3 +"""Symbol-level parity audit for the MobilityFlink generated MEOS facade. + +Measures, per type family, how much of the MEOS public-header function surface +the generated facade (org.mobilitydb.flink.meos.MeosOps*) exposes, cross-checked +against the JMEOS jar export set so a method only counts when it is genuinely +bindable. + +Reference surface = the MEOS public C API (meos/include/meos*.h, excluding the +meos_internal*.h headers). This is the surface JMEOS mirrors and the facade +delegates to, so it is the exact denominator for a Flink binding. A second view +maps the facade against the MobilityDB SQL layer's underlying C symbols for +comparability with the SQL-surface bindings. + +Coverage reported here is STATIC: the facade method exists and binds a JMEOS +symbol of matching arity. Runtime behaviour is exercised separately by the +per-family smoke tests. + +Usage: + python3 tools/parity/parity_audit.py \ + --meos-include /path/to/MobilityDB/meos/include \ + --jar jar/JMEOS.jar \ + --facade src/main/java/org/mobilitydb/flink/meos \ + --mdb-sql /path/to/MobilityDB/mobilitydb/sql \ + --out docs/parity-status.md +""" +import argparse, re, os, glob, subprocess, collections +from datetime import date + +PUBLIC_HEADERS = ["meos.h", "meos_geo.h", "meos_cbuffer.h", + "meos_npoint.h", "meos_pose.h", "meos_rgeo.h", +"meos_h3.h"] +FAMILY = {"meos.h": "core temporal / set / span / spanset / tbox", + "meos_geo.h": "geo (tgeo / tpoint / stbox)", + "meos_cbuffer.h": "cbuffer", "meos_npoint.h": "npoint", + "meos_pose.h": "pose", "meos_rgeo.h": "rgeo", + "meos_h3.h": "h3 / th3index"} + +_DECL = re.compile(r'^\s*extern\s+.+?\b([a-z][A-Za-z0-9_]*)\s*\(', re.M) +_PUBSTATIC = re.compile(r'public static [A-Za-z0-9_.<>\[\]]+ ([a-z0-9_]+)\(') + +# MobilityDB SQL out-of-scope bucketing (PG-only; no MEOS/Flink equivalent). +OOS_SECTIONS = { + "temporal/011_span_indexes.in.sql", "temporal/012_spanset_indexes.in.sql", + "temporal/013_set_indexes.in.sql", "temporal/019_geo_constructors.in.sql", + "temporal/043_temporal_gist.in.sql", "temporal/044_temporal_spgist.in.sql", + "temporal/999_oid_cache.in.sql", "geo/073_tgeo_gist.in.sql", + "geo/073_tpoint_gist.in.sql", "geo/074_tgeo_spgist.in.sql", + "geo/074_tpoint_spgist.in.sql", "cbuffer/166_tcbuffer_indexes.in.sql", + "npoint/092_tnpoint_gin.in.sql", "npoint/098_tnpoint_indexes.in.sql", + "pose/114_tpose_indexes.in.sql", "rgeo/134_trgeo_indexes.in.sql", +} +OOS_SUFFIXES = ("_in", "_out", "_recv", "_send", "_typmod_in", "_typmod_out", + "_transfn", "_combinefn", "_finalfn", "_serialize", "_deserialize", + "_sel", "_joinsel", "_supportfn", "_analyze", + "_cmp", "_eq", "_ne", "_lt", "_le", "_gt", "_ge", "_hash", "_hash_extended") +OOS_NAMES = {"range", "multirange", "create_trip", "transform_gk"} + + +def jmeos_symbols(jar): + out = subprocess.run(["javap", "-classpath", jar, "-p", + "functions.GeneratedFunctions"], + capture_output=True, text=True).stdout + return set(re.findall(r'\b([a-z][a-z0-9_]+)\(', out)) + + +def facade_methods(d): + syms = set() + for f in glob.glob(os.path.join(d, "MeosOps*.java")): + syms |= set(_PUBSTATIC.findall(open(f).read())) + return syms + + +def libmeos_symbols(path): + out = subprocess.run(["nm", "-D", path], capture_output=True, text=True).stdout + return {line.split()[-1] for line in out.splitlines() if line.strip()} + + +def public_surface(inc): + fam, allpub = {}, set() + for h in PUBLIC_HEADERS: + names = set(_DECL.findall(open(os.path.join(inc, h)).read())) + for n in names: + allpub.add(n); fam.setdefault(n, h) + return allpub, fam + + +def sql_csymbols(root): + create = re.compile(r'CREATE\s+(?:OR\s+REPLACE\s+)?FUNCTION\s+([A-Za-z0-9_]+)\s*\(', re.I) + csym = re.compile(r"AS\s+'[^']*'\s*,\s*'([A-Za-z0-9_]+)'", re.I) + langsql = re.compile(r"LANGUAGE\s+'?(?:sql|plpgsql)'?", re.I) + addressable, oos, sqlc = set(), 0, 0 + for path in glob.glob(os.path.join(root, "**", "*.in.sql"), recursive=True): + section = os.path.relpath(path, root).replace(os.sep, "/") + txt = open(path, encoding="utf-8", errors="replace").read() + for m in create.finditer(txt): + name = m.group(1); tail = txt[m.end():m.end() + 1200].split(';')[0] + cm = csym.search(tail); sym = cm.group(1) if cm else None + key = (sym or name).lower() + if section in OOS_SECTIONS or key in OOS_NAMES or key.endswith(OOS_SUFFIXES): + oos += 1; continue + if sym is None: + sqlc += 1; continue + addressable.add(sym.lower()) + return addressable, oos, sqlc + + +def main(): + ap = argparse.ArgumentParser() + here = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + ap.add_argument("--meos-include", default="/home/esteban/src/MobilityDB/meos/include") + ap.add_argument("--jar", default=os.path.join(here, "jar", "JMEOS.jar")) + ap.add_argument("--facade", default=os.path.join(here, "src/main/java/org/mobilitydb/flink/meos")) + ap.add_argument("--mdb-sql", default="/home/esteban/src/MobilityDB/mobilitydb/sql") + ap.add_argument("--out", default=os.path.join(here, "docs", "parity-status.md")) + ap.add_argument("--libmeos", default=None, + help="path to a built libmeos.so; cross-checks that every facade method " + "resolves to an exported symbol (runtime resolution check)") + a = ap.parse_args() + + jm = jmeos_symbols(a.jar) + fa_all = facade_methods(a.facade) + fa = fa_all & jm + pub, fam = public_surface(a.meos_include) + bindable = pub & jm + covered = bindable & fa + missing = sorted(bindable - fa) + + bc, cc = collections.Counter(), collections.Counter() + for n in bindable: + bc[fam[n]] += 1 + if n in covered: + cc[fam[n]] += 1 + + addr, oos, sqlc = sql_csymbols(a.mdb_sql) + sql_cov = len(addr & fa); sql_bindable = len(addr & jm) + + pct = lambda c, t: (100.0 * c / t) if t else 0.0 + L = [] + L.append("# MobilityFlink parity status — MEOS surface audit\n") + L.append(f"Generated {date.today().isoformat()} by `tools/parity/parity_audit.py`.\n") + L.append("The MobilityFlink MEOS facade (`org.mobilitydb.flink.meos.MeosOps*`) exposes " + "MEOS C functions to Flink through JMEOS. This audit measures, per type family, " + "the share of the **MEOS public C API** that the facade exposes and that JMEOS binds.\n") + L.append(f"**Headline.** The facade exposes **{len(covered)} of {len(bindable)} " + f"public MEOS functions ({pct(len(covered), len(bindable)):.1f}%)**. " + f"The MEOS public surface (`meos/include/meos*.h`, excluding internal headers) is " + f"{len(pub)} functions; JMEOS binds {len(bindable)} of them. " + f"{len(missing)} bindable functions are not exposed (listed in §3).\n") + L.append("Coverage is **static**: a function counts as covered when the facade declares a " + "method of the same name and arity that delegates to a JMEOS export.\n") + L.append("Per-family runtime behaviour is asserted by " + "`src/test/java/org/mobilitydb/flink/meos/MeosFacadeSmokeTest.java`, which constructs " + "and reads back a value in the core, geo, cbuffer, npoint and pose families through the " + "facade against libmeos. The cbuffer, npoint and pose families require a libmeos built " + "with the extended modules (`-DCBUFFER=ON -DNPOINT=ON -DPOSE=ON -DRGEO=ON`); the stock " + "library carries the core and geo surfaces only.\n") + L.append("## 1. Reference surface and method\n") + L.append("- **Denominator**: distinct function names declared `extern` in the MEOS public " + "headers `meos.h`, `meos_geo.h`, `meos_cbuffer.h`, `meos_npoint.h`, `meos_pose.h`, " + "`meos_rgeo.h`. Internal headers (`meos_internal*.h`) are excluded.\n") + L.append("- **Numerator**: `public static` methods on the generated `MeosOps*` facade whose " + "name is also a `functions.GeneratedFunctions` export in the bundled JMEOS jar.\n") + L.append(f"- **JMEOS jar**: {os.path.relpath(a.jar, here)} exports {len(jm)} static methods.\n") + L.append("## 2. Per-family coverage of the public MEOS surface\n") + L.append("| Family (header) | Public ∩ JMEOS | Exposed | Missing | Coverage |") + L.append("|---|---:|---:|---:|---:|") + for h in PUBLIC_HEADERS: + b, c = bc[h], cc[h] + L.append(f"| {FAMILY[h]} (`{h}`) | {b} | {c} | {b - c} | {pct(c, b):.1f}% |") + L.append(f"| **total** | **{len(bindable)}** | **{len(covered)}** | " + f"**{len(bindable) - len(covered)}** | **{pct(len(covered), len(bindable)):.1f}%** |\n") + L.append("## 3. Bindable MEOS functions not exposed by the facade\n") + L.append(f"{len(missing)} functions are present in the public MEOS headers and bound by " + "JMEOS but not generated into the facade:\n") + for h in PUBLIC_HEADERS: + ms = [n for n in missing if fam[n] == h] + if ms: + L.append(f"- **`{h}`** ({len(ms)}): " + ", ".join(f"`{n}`" for n in ms)) + L.append("") + L.append("## 4. MobilityDB SQL-surface cross-check\n") + L.append("The facade is also matched against the underlying MEOS C symbol of each addressable " + "`CREATE FUNCTION` in `mobilitydb/sql/**/*.in.sql` (PG-only sections and helper symbols " + f"bucketed out; {oos} out-of-scope, {sqlc} SQL/plpgsql-composed functions with no single " + "C symbol). Functions the SQL layer implements through the internal MEOS headers " + "(`meos_internal*.h`) are exposed via `MeosOpsSqlSurface`.\n") + L.append(f"- Addressable distinct C symbols: **{len(addr)}**; bound by JMEOS: **{sql_bindable}**; " + f"exposed by the facade: **{sql_cov}** " + f"({pct(sql_cov, sql_bindable):.1f}% of the JMEOS-bindable SQL surface).\n") + L.append(f"- The remaining **{len(addr) - sql_bindable}** addressable C symbols are not exported " + "by JMEOS under the name the SQL layer's extension wrapper uses; the wrapper names " + "differ from the MEOS function names they call.\n") + + if a.libmeos: + libsyms = libmeos_symbols(a.libmeos) + resolved = fa_all & libsyms + unresolved = sorted(fa_all - libsyms) + L.append("## 5. Runtime symbol resolution\n") + L.append("Every facade method delegates to a libmeos symbol of the same name. Against a " + "MEOS shared library built with the extended modules (`-DCBUFFER=ON -DNPOINT=ON " + "-DPOSE=ON -DRGEO=ON`), " + f"**{len(resolved)} of {len(fa_all)}** facade methods resolve to an exported " + "symbol.\n") + if unresolved: + hdr_only = sorted(n for n in unresolved if n in pub) + jmeos_only = sorted(n for n in unresolved if n not in pub) + L.append(f"The remaining {len(unresolved)} are present in the JMEOS jar but not " + "exported by the MEOS shared library (a JMEOS-jar / library version skew):\n") + if hdr_only: + L.append(f"- declared in the public headers, not exported by this build " + f"({len(hdr_only)}): " + ", ".join(f"`{n}`" for n in hdr_only)) + if jmeos_only: + L.append(f"- not declared in the current public headers, JMEOS jar ahead of the " + f"library ({len(jmeos_only)}): " + ", ".join(f"`{n}`" for n in jmeos_only)) + L.append("") + else: + L.append("All facade methods resolve.\n") + print(f"libmeos resolution: {len(resolved)}/{len(fa_all)} " + f"({len(unresolved)} unresolved)") + + md = "\n".join(L) + "\n" + os.makedirs(os.path.dirname(a.out), exist_ok=True) + open(a.out, "w").write(md) + + print(f"public MEOS surface: {len(pub)}") + print(f" bound by JMEOS: {len(bindable)}") + print(f" exposed by facade: {len(covered)} ({pct(len(covered), len(bindable)):.1f}%)") + print(f" missing (bindable): {len(missing)}") + print(f"SQL addressable C-symbols: {len(addr)} (bindable {sql_bindable}, exposed {sql_cov})") + print(f"wrote {a.out}") + + +if __name__ == "__main__": + main() diff --git a/kafka-producer/python-producer-berlinmod.py b/kafka-producer/python-producer-berlinmod.py new file mode 100644 index 0000000..83cb1fb --- /dev/null +++ b/kafka-producer/python-producer-berlinmod.py @@ -0,0 +1,46 @@ +""" +BerlinMOD Kafka producer for the MobilityFlink BerlinMOD-Q3 scaffold. + +Reads a BerlinMOD CSV (produced by the BerlinMOD generator — +`meos/examples/data/generate_berlinmod_trips.sql` in MobilityDB, at any +scale factor) and emits one JSON record per row to the Kafka topic +`berlinmod`. + +Expected CSV columns (in order): + t -- "YYYY-MM-DD HH:MM:SS" + vehicle_id -- int + lon -- float + lat -- float + +Companion of `python-producer.py` (the existing AIS producer) — same +shape, different schema and topic. +""" + +from json import dumps +from kafka import KafkaProducer +import pandas as pd + +KAFKA_BOOTSTRAP = "kafka:29092" +TOPIC = "berlinmod" +CSV_PATH = "berlinmod-trips.csv" + + +def gen_data(): + df = pd.read_csv(CSV_PATH) + producer = KafkaProducer( + bootstrap_servers=KAFKA_BOOTSTRAP, + value_serializer=lambda x: dumps(x).encode("utf-8"), + ) + for _, row in df.iterrows(): + record = { + "t": row["t"], + "vehicle_id": int(row["vehicle_id"]), + "lon": float(row["lon"]), + "lat": float(row["lat"]), + } + producer.send(topic=TOPIC, value=record) + producer.flush() + + +if __name__ == "__main__": + gen_data()