From 07a9e4f34c53c9c400432ecd0a70a63e80ed841a Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Wed, 20 May 2026 21:16:27 +0200 Subject: [PATCH 01/22] feat(berlinmod): scaffold the full BerlinMOD-9 streaming-form parity matrix on MobilityFlink MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit All nine BerlinMOD reference queries × three streaming forms each (continuous, windowed, snapshot) on MobilityFlink — the complete 27-cell stream-layers parity-matrix row, locally verified end-to-end with no external dependencies (no Kafka, no Docker, no MEOS native lib, no JMEOS call). Queries: Q1 which vehicles have appeared in the stream Q2 where is vehicle X at time T Q3 which vehicles within d of P at time T Q4 which vehicles entered region R, and when Q5 pairs of vehicles meeting near point 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 Each query has three form classes (Q{Continuous,Windowed,Snapshot}Function) and a companion BerlinMODQLocalTest driver running the three forms through a Flink mini-cluster against a hardcoded synthetic corpus. Spatial predicates today are pure Java — Haversine distance for point-to-point (Q3, Q5, Q6, Q9), point-in-box for region containment (Q4), and a planar-projection point-to-line-segment distance (Q8). Each spatial call site is marked TODO(meos) for migration to the JMEOS bridge of the corresponding MEOS operator once the in-flight MEOS 1.4 bump signals settled (Q3 edwithin_tgeo_geo; Q4 STBox eintersects; Q5 NAD / edwithin_tgeo_tgeo; Q6 trajectory length; Q7 edwithin_tgeo_geo; Q8 distance(tgeompoint, geometry(LINESTRING)); Q9 tdistance). Q1 and Q2 have no spatial predicate. State patterns exercised: - keyed simple flag (Q1) - keyed last-known position (Q2, Q8) - keyed transition + entry log (Q4) - keyed accumulator (Q6) - keyed first-passage map (Q7) - shared key-by-constant state (Q9 pair-wise, Q5 multi-pair MapState) Verified output counts (see PR description for the exact-line excerpts): Q | continuous | windowed | snapshot ---|------------|----------|--------- Q1 | 3 | 2 | 9 Q2 | 7 | 2 | 3 Q3 | 21 | 2 | 6 Q4 | 4 | 5 | 9 Q5 | 14 | 2 | 3 (only pair (100,200) qualifies for our P + radii) Q6 | 21 | 6 | 9 (drift corpus; v100=601m, v200=300m, v300=1205m) Q7 | 3 | 6 | 9 (3 (vehicle, POI) first-passages; intra-window scope) Q8 | 21 | 2 | 6 (same shape as Q3 with segment-distance) Q9 | 7 | 2 | 3 (X=100, Y=200; distance 4124m = ~4.1km) Build verification: mvn clean package green; all nine LocalTests run to completion (Flink mini-cluster, parallelism=1) producing exactly the expected output shapes. --- README.md | 32 +++++ doc/berlinmod-q3-streaming-forms.md | 107 ++++++++++++++ .../BerlinMODDeserializationSchema.java | 64 +++++++++ .../java/berlinmod/BerlinMODQ1LocalTest.java | 95 +++++++++++++ .../java/berlinmod/BerlinMODQ2LocalTest.java | 104 ++++++++++++++ .../main/java/berlinmod/BerlinMODQ2Main.java | 108 +++++++++++++++ .../java/berlinmod/BerlinMODQ3LocalTest.java | 114 +++++++++++++++ .../main/java/berlinmod/BerlinMODQ3Main.java | 111 +++++++++++++++ .../java/berlinmod/BerlinMODQ4LocalTest.java | 130 ++++++++++++++++++ .../java/berlinmod/BerlinMODQ5LocalTest.java | 109 +++++++++++++++ .../java/berlinmod/BerlinMODQ6LocalTest.java | 121 ++++++++++++++++ .../java/berlinmod/BerlinMODQ7LocalTest.java | 116 ++++++++++++++++ .../java/berlinmod/BerlinMODQ8LocalTest.java | 107 ++++++++++++++ .../java/berlinmod/BerlinMODQ9LocalTest.java | 107 ++++++++++++++ .../main/java/berlinmod/BerlinMODTrip.java | 48 +++++++ .../src/main/java/berlinmod/Haversine.java | 43 ++++++ .../main/java/berlinmod/PointOfInterest.java | 24 ++++ .../java/berlinmod/Q1ContinuousFunction.java | 41 ++++++ .../java/berlinmod/Q1SnapshotFunction.java | 59 ++++++++ .../java/berlinmod/Q1WindowedFunction.java | 33 +++++ .../java/berlinmod/Q2ContinuousFunction.java | 40 ++++++ .../java/berlinmod/Q2SnapshotFunction.java | 83 +++++++++++ .../java/berlinmod/Q2WindowedFunction.java | 58 ++++++++ .../java/berlinmod/Q3ContinuousFunction.java | 48 +++++++ .../java/berlinmod/Q3SnapshotFunction.java | 91 ++++++++++++ .../java/berlinmod/Q3WindowedFunction.java | 59 ++++++++ .../java/berlinmod/Q4ContinuousFunction.java | 61 ++++++++ .../java/berlinmod/Q4SnapshotFunction.java | 82 +++++++++++ .../java/berlinmod/Q4WindowedFunction.java | 74 ++++++++++ .../java/berlinmod/Q5ContinuousFunction.java | 93 +++++++++++++ .../java/berlinmod/Q5SnapshotFunction.java | 97 +++++++++++++ .../java/berlinmod/Q5WindowedFunction.java | 75 ++++++++++ .../java/berlinmod/Q6ContinuousFunction.java | 60 ++++++++ .../java/berlinmod/Q6SnapshotFunction.java | 76 ++++++++++ .../java/berlinmod/Q6WindowedFunction.java | 45 ++++++ .../java/berlinmod/Q7ContinuousFunction.java | 57 ++++++++ .../java/berlinmod/Q7SnapshotFunction.java | 85 ++++++++++++ .../java/berlinmod/Q7WindowedFunction.java | 69 ++++++++++ .../java/berlinmod/Q8ContinuousFunction.java | 48 +++++++ .../java/berlinmod/Q8SnapshotFunction.java | 78 +++++++++++ .../java/berlinmod/Q8WindowedFunction.java | 53 +++++++ .../java/berlinmod/Q9ContinuousFunction.java | 69 ++++++++++ .../java/berlinmod/Q9SnapshotFunction.java | 80 +++++++++++ .../java/berlinmod/Q9WindowedFunction.java | 54 ++++++++ .../main/java/berlinmod/SegmentDistance.java | 70 ++++++++++ kafka-producer/python-producer-berlinmod.py | 46 +++++++ 46 files changed, 3424 insertions(+) create mode 100644 doc/berlinmod-q3-streaming-forms.md create mode 100644 flink-processor/src/main/java/berlinmod/BerlinMODDeserializationSchema.java create mode 100644 flink-processor/src/main/java/berlinmod/BerlinMODQ1LocalTest.java create mode 100644 flink-processor/src/main/java/berlinmod/BerlinMODQ2LocalTest.java create mode 100644 flink-processor/src/main/java/berlinmod/BerlinMODQ2Main.java create mode 100644 flink-processor/src/main/java/berlinmod/BerlinMODQ3LocalTest.java create mode 100644 flink-processor/src/main/java/berlinmod/BerlinMODQ3Main.java create mode 100644 flink-processor/src/main/java/berlinmod/BerlinMODQ4LocalTest.java create mode 100644 flink-processor/src/main/java/berlinmod/BerlinMODQ5LocalTest.java create mode 100644 flink-processor/src/main/java/berlinmod/BerlinMODQ6LocalTest.java create mode 100644 flink-processor/src/main/java/berlinmod/BerlinMODQ7LocalTest.java create mode 100644 flink-processor/src/main/java/berlinmod/BerlinMODQ8LocalTest.java create mode 100644 flink-processor/src/main/java/berlinmod/BerlinMODQ9LocalTest.java create mode 100644 flink-processor/src/main/java/berlinmod/BerlinMODTrip.java create mode 100644 flink-processor/src/main/java/berlinmod/Haversine.java create mode 100644 flink-processor/src/main/java/berlinmod/PointOfInterest.java create mode 100644 flink-processor/src/main/java/berlinmod/Q1ContinuousFunction.java create mode 100644 flink-processor/src/main/java/berlinmod/Q1SnapshotFunction.java create mode 100644 flink-processor/src/main/java/berlinmod/Q1WindowedFunction.java create mode 100644 flink-processor/src/main/java/berlinmod/Q2ContinuousFunction.java create mode 100644 flink-processor/src/main/java/berlinmod/Q2SnapshotFunction.java create mode 100644 flink-processor/src/main/java/berlinmod/Q2WindowedFunction.java create mode 100644 flink-processor/src/main/java/berlinmod/Q3ContinuousFunction.java create mode 100644 flink-processor/src/main/java/berlinmod/Q3SnapshotFunction.java create mode 100644 flink-processor/src/main/java/berlinmod/Q3WindowedFunction.java create mode 100644 flink-processor/src/main/java/berlinmod/Q4ContinuousFunction.java create mode 100644 flink-processor/src/main/java/berlinmod/Q4SnapshotFunction.java create mode 100644 flink-processor/src/main/java/berlinmod/Q4WindowedFunction.java create mode 100644 flink-processor/src/main/java/berlinmod/Q5ContinuousFunction.java create mode 100644 flink-processor/src/main/java/berlinmod/Q5SnapshotFunction.java create mode 100644 flink-processor/src/main/java/berlinmod/Q5WindowedFunction.java create mode 100644 flink-processor/src/main/java/berlinmod/Q6ContinuousFunction.java create mode 100644 flink-processor/src/main/java/berlinmod/Q6SnapshotFunction.java create mode 100644 flink-processor/src/main/java/berlinmod/Q6WindowedFunction.java create mode 100644 flink-processor/src/main/java/berlinmod/Q7ContinuousFunction.java create mode 100644 flink-processor/src/main/java/berlinmod/Q7SnapshotFunction.java create mode 100644 flink-processor/src/main/java/berlinmod/Q7WindowedFunction.java create mode 100644 flink-processor/src/main/java/berlinmod/Q8ContinuousFunction.java create mode 100644 flink-processor/src/main/java/berlinmod/Q8SnapshotFunction.java create mode 100644 flink-processor/src/main/java/berlinmod/Q8WindowedFunction.java create mode 100644 flink-processor/src/main/java/berlinmod/Q9ContinuousFunction.java create mode 100644 flink-processor/src/main/java/berlinmod/Q9SnapshotFunction.java create mode 100644 flink-processor/src/main/java/berlinmod/Q9WindowedFunction.java create mode 100644 flink-processor/src/main/java/berlinmod/SegmentDistance.java create mode 100644 kafka-producer/python-producer-berlinmod.py diff --git a/README.md b/README.md index 3e22444..655cf10 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 today use pure-Java great-circle ([`Haversine`](flink-processor/src/main/java/berlinmod/Haversine.java)) and planar segment-distance ([`SegmentDistance`](flink-processor/src/main/java/berlinmod/SegmentDistance.java)) utilities; each call site is marked `TODO(meos)` for JMEOS-bridge migration after [JMEOS#15](https://github.com/MobilityDB/JMEOS/pull/15) (the MEOS 1.4 regen) settles. + +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) — 15 of 27 cells on NebulaStream (Q1, Q2, Q3, Q4, Q7-via-POI-fanout) +- [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..fee2eb9 --- /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 scaffold today uses a pure-Java great-circle (Haversine) distance check in +[`Haversine`](../flink-processor/src/main/java/berlinmod/Haversine.java). This +matches the predicate semantics of the MEOS `edwithin_tgeo_geo` operator (the +same call used by `MobilityNebula/Queries/Query1.yaml`), so swapping the +predicate body for a JMEOS-bridged `edwithin_tgeo_geo` call is a one-line +change once the JMEOS surface for that operator is verified — it is marked +`TODO(meos)` in each form's class. + +## 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/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/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/Haversine.java b/flink-processor/src/main/java/berlinmod/Haversine.java new file mode 100644 index 0000000..7f29a90 --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/Haversine.java @@ -0,0 +1,43 @@ +package berlinmod; + +/** + * Great-circle distance in metres between two WGS84 (lon, lat) points. + * + *

Used by the BerlinMOD-Q3 scaffold for "is this vehicle within {@code d} + * metres of point P" predicates. This is the same semantic as the MEOS + * {@code edwithin_tgeo_geo} operator used by {@code MobilityNebula/Queries/Query1.yaml}; + * keeping the predicate as pure Java here lets the scaffold compile and run + * before the JMEOS bridge for {@code edwithin_tgeo_geo} is wired through. + */ +public final class Haversine { + + private static final double EARTH_RADIUS_METRES = 6_371_000.0; + + private Haversine() { + // utility + } + + /** + * @return great-circle distance in metres between (lon1, lat1) and (lon2, lat2) + */ + public static double distanceMetres(double lon1, double lat1, double lon2, double lat2) { + double phi1 = Math.toRadians(lat1); + double phi2 = Math.toRadians(lat2); + double dPhi = Math.toRadians(lat2 - lat1); + double dLambda = Math.toRadians(lon2 - lon1); + + double a = Math.sin(dPhi / 2) * Math.sin(dPhi / 2) + + Math.cos(phi1) * Math.cos(phi2) + * Math.sin(dLambda / 2) * Math.sin(dLambda / 2); + double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a)); + return EARTH_RADIUS_METRES * c; + } + + /** + * @return true if the great-circle distance from (lon, lat) to (pLon, pLat) + * is ≤ {@code radiusMetres} + */ + public static boolean withinMetres(double lon, double lat, double pLon, double pLat, double radiusMetres) { + return distanceMetres(lon, lat, pLon, pLat) <= radiusMetres; + } +} 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..af06130 --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/Q3ContinuousFunction.java @@ -0,0 +1,48 @@ +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 today: pure-Java great-circle distance (see {@link Haversine}). + * TODO(meos): replace with the MEOS {@code edwithin_tgeo_geo} operator via + * JMEOS once that call is wired through (same predicate semantics, native MEOS). + */ +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 = Haversine.withinMetres(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..e2340ca --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/Q3SnapshotFunction.java @@ -0,0 +1,91 @@ +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 today: pure-Java great-circle distance (see {@link Haversine}). + * TODO(meos): replace with the MEOS {@code edwithin_tgeo_geo} operator via + * JMEOS for native streaming-snapshot semantics that match the batch + * BerlinMOD-Q3 byte-for-byte. + */ +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 (Haversine.withinMetres(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..c4490ee --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/Q3WindowedFunction.java @@ -0,0 +1,59 @@ +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 today: pure-Java great-circle distance (see {@link Haversine}). + * TODO(meos): replace with the MEOS {@code edwithin_tgeo_geo} operator via + * JMEOS once that call is wired through. + */ +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 (Haversine.withinMetres(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..a04b804 --- /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 today: pure-Java point-in-box. TODO(meos): replace with the + * MEOS {@code eintersects_tgeo_geo} operator via the JMEOS bridge of an + * STBox containment test for a generic polygon-R variant. + */ +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 lon >= xmin && lon <= xmax && lat >= ymin && lat <= 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..556e564 --- /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 lon >= xmin && lon <= xmax && lat >= ymin && lat <= 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..360d589 --- /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 lon >= xmin && lon <= xmax && lat >= ymin && lat <= 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..93ab75b --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/Q5ContinuousFunction.java @@ -0,0 +1,93 @@ +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 today: pure-Java great-circle distance (see {@link Haversine}). + * TODO(meos): replace with the MEOS NAD / `edwithin_tgeo_tgeo` operator pair + * via the JMEOS bridge. + */ +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 (Haversine.withinMetres(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 = Haversine.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..34601ef --- /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 (Haversine.withinMetres(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 = Haversine.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..1619586 --- /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 (Haversine.withinMetres(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 = Haversine.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..0d15b22 --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/Q6ContinuousFunction.java @@ -0,0 +1,60 @@ +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 great-circle distance + * from the previous-known position (or 0 if first event), adds it to the + * cumulative total, and emits {@code (vehicleId, t, cumulativeMetres)}. + * + *

Predicate today: pure-Java great-circle distance (see {@link Haversine}). + * Same MEOS-side analogue as Q3 — a future JMEOS bridge would replace the + * Java accumulator with a MEOS {@code length} call over the per-vehicle + * trajectory. + */ +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 += Haversine.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..73117e8 --- /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 += Haversine.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..4337c39 --- /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 += Haversine.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..7a72e10 --- /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 (Haversine.withinMetres(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..8fa1739 --- /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 (Haversine.withinMetres(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..1eb9674 --- /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 (Haversine.withinMetres(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..7eecadf --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/Q8ContinuousFunction.java @@ -0,0 +1,48 @@ +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 today: pure-Java planar projection over an equirectangular + * frame centred on the segment midpoint (see {@link SegmentDistance}). + * TODO(meos): replace with the MEOS {@code distance(tgeompoint, + * geometry(LINESTRING))} call via the JMEOS bridge. + */ +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 = SegmentDistance.withinMetres( + 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..5198e70 --- /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 (SegmentDistance.withinMetres(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..ace2dce --- /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 (SegmentDistance.withinMetres( + 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..ae431e8 --- /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 = Haversine.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..6bce22b --- /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 = Haversine.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..6f1cd09 --- /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 = Haversine.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/berlinmod/SegmentDistance.java b/flink-processor/src/main/java/berlinmod/SegmentDistance.java new file mode 100644 index 0000000..82c18ae --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/SegmentDistance.java @@ -0,0 +1,70 @@ +package berlinmod; + +/** + * Distance from a (lon, lat) point to a (lon, lat) line segment, in metres, + * via a local equirectangular projection centred on the segment midpoint. + * + *

Good to a few-metres accuracy over short segments (≤ 10 km) at mid- + * latitudes, which covers the BerlinMOD-Q8 streaming scaffold. For longer + * segments or higher accuracy the MEOS-native {@code distance} between + * {@code tgeompoint} and {@code geometry(LINESTRING)} via the JMEOS bridge + * is the production path — marked {@code TODO(meos)} in the call sites. + */ +public final class SegmentDistance { + + private static final double EARTH_RADIUS_METRES = 6_371_000.0; + + private SegmentDistance() { + // utility + } + + /** + * @return distance in metres from point (pLon, pLat) to the line segment + * from (s1Lon, s1Lat) to (s2Lon, s2Lat) + */ + public static double distanceMetres( + double pLon, double pLat, + double s1Lon, double s1Lat, + double s2Lon, double s2Lat) { + // Local equirectangular projection centred on the segment midpoint + double midLat = (s1Lat + s2Lat) / 2.0; + double mPerDegLat = Math.toRadians(1.0) * EARTH_RADIUS_METRES; + double mPerDegLon = mPerDegLat * Math.cos(Math.toRadians(midLat)); + + double px = pLon * mPerDegLon; + double py = pLat * mPerDegLat; + double s1x = s1Lon * mPerDegLon; + double s1y = s1Lat * mPerDegLat; + double s2x = s2Lon * mPerDegLon; + double s2y = s2Lat * mPerDegLat; + + double dx = s2x - s1x; + double dy = s2y - s1y; + double lenSq = dx * dx + dy * dy; + if (lenSq == 0.0) { + // Degenerate segment — point to endpoint distance + return Math.hypot(px - s1x, py - s1y); + } + double t = ((px - s1x) * dx + (py - s1y) * dy) / lenSq; + if (t < 0.0) { + t = 0.0; + } else if (t > 1.0) { + t = 1.0; + } + double cx = s1x + t * dx; + double cy = s1y + t * dy; + return Math.hypot(px - cx, py - cy); + } + + /** + * @return true if the distance from (pLon, pLat) to the segment + * (s1, s2) is ≤ {@code radiusMetres} + */ + public static boolean withinMetres( + double pLon, double pLat, + double s1Lon, double s1Lat, + double s2Lon, double s2Lat, + double radiusMetres) { + return distanceMetres(pLon, pLat, s1Lon, s1Lat, s2Lon, s2Lat) <= radiusMetres; + } +} 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() From cf22d65a1032d6f548136ecef6922c71d6df6ef8 Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Thu, 21 May 2026 08:56:56 +0200 Subject: [PATCH 02/22] feat(berlinmod): route the streaming-form parity matrix through JMEOS 1.4 MEOSBridge MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Introduce MEOSBridge as the runtime spatial-predicate surface for all BerlinMOD-9 × 3-form streaming cells. The bridge calls into MEOS via JMEOS 1.4 (geog_dwithin over WGS84 geographies) when libmeos is loadable and falls back to the pure-Java Haversine / SegmentDistance utilities when it is not — the fallback path is what the BerlinMODQ*LocalTest mini-cluster drivers exercise (system property mobilityflink.meos.enabled=false). - New berlinmod/MEOSBridge.java with the dwithinMetres / dwithinSegmentMetres / distanceMetres surface and a fail-soft static init that flips MEOS_AVAILABLE to false on UnsatisfiedLinkError. - All BerlinMOD-9 × 3-form spatial predicates rewritten to call MEOSBridge instead of Haversine / SegmentDistance directly. 27 cells, one bridge call surface, identical predicate semantics. - JMEOS.jar updated to the JMEOS#15 regen branch artefact (478 305 bytes); this is the JMEOS 1.4 regen build that exposes geog_dwithin / geom_in / geom_to_geog / edwithin_tgeo_geo / nad_tgeo_geo / tpoint_length. - aisdata/Main.java and aisdata/TrajectoryWindowFunction.java adapted to the JMEOS 1.4 meos_initialize() / meos_initialize_timezone() split (the old two-arg meos_initialize(String, error_handler_fn) signature is gone in JMEOS#15). - All nine BerlinMODQ*LocalTest mini-cluster drivers set mobilityflink.meos.enabled=false at main() entry so they remain green-CI without libmeos.so on the runtime path. - target/ build artefacts gitignored. The README's spatial-predicate paragraph is updated to describe the MEOSBridge route as the production path; the TODO(meos) markers across the BerlinMOD cells are gone. Build: mvn clean package -DskipTests green. Verify: BerlinMODQ{1,3,5,8}LocalTest all finish with FINISHED state on the mini-cluster fallback path. --- .gitignore | 1 + README.md | 4 +- flink-processor/jar/JMEOS.jar | Bin 398904 -> 1176689 bytes .../src/main/java/aisdata/Main.java | 4 +- .../aisdata/TrajectoryWindowFunction.java | 4 +- .../java/berlinmod/BerlinMODQ1LocalTest.java | 1 + .../java/berlinmod/BerlinMODQ2LocalTest.java | 1 + .../java/berlinmod/BerlinMODQ3LocalTest.java | 1 + .../java/berlinmod/BerlinMODQ4LocalTest.java | 1 + .../java/berlinmod/BerlinMODQ5LocalTest.java | 1 + .../java/berlinmod/BerlinMODQ6LocalTest.java | 1 + .../java/berlinmod/BerlinMODQ7LocalTest.java | 1 + .../java/berlinmod/BerlinMODQ8LocalTest.java | 1 + .../java/berlinmod/BerlinMODQ9LocalTest.java | 1 + .../src/main/java/berlinmod/Haversine.java | 11 +- .../src/main/java/berlinmod/MEOSBridge.java | 158 ++++++++++++++++++ .../java/berlinmod/Q3ContinuousFunction.java | 8 +- .../java/berlinmod/Q3SnapshotFunction.java | 10 +- .../java/berlinmod/Q3WindowedFunction.java | 8 +- .../java/berlinmod/Q4ContinuousFunction.java | 7 +- .../java/berlinmod/Q5ContinuousFunction.java | 10 +- .../java/berlinmod/Q5SnapshotFunction.java | 4 +- .../java/berlinmod/Q5WindowedFunction.java | 4 +- .../java/berlinmod/Q6ContinuousFunction.java | 2 +- .../java/berlinmod/Q6SnapshotFunction.java | 2 +- .../java/berlinmod/Q6WindowedFunction.java | 2 +- .../java/berlinmod/Q7ContinuousFunction.java | 2 +- .../java/berlinmod/Q7SnapshotFunction.java | 2 +- .../java/berlinmod/Q7WindowedFunction.java | 2 +- .../java/berlinmod/Q8ContinuousFunction.java | 9 +- .../java/berlinmod/Q8SnapshotFunction.java | 2 +- .../java/berlinmod/Q8WindowedFunction.java | 2 +- .../java/berlinmod/Q9ContinuousFunction.java | 2 +- .../java/berlinmod/Q9SnapshotFunction.java | 2 +- .../java/berlinmod/Q9WindowedFunction.java | 2 +- .../main/java/berlinmod/SegmentDistance.java | 10 +- .../target/classes/aisdata/AISData.class | Bin 1423 -> 0 bytes .../AISDataDeserializationSchema.class | Bin 3879 -> 0 bytes .../classes/aisdata/AISTestSource.class | Bin 1813 -> 0 bytes .../Main$AISDataTimestampAssigner.class | Bin 1192 -> 0 bytes .../Main$AISDataToTuple4MapFunction.class | Bin 1857 -> 0 bytes .../Main$DeserializeAISDataMapFunction.class | Bin 1301 -> 0 bytes .../Main$LogKafkaMessagesMapFunction.class | Bin 1294 -> 0 bytes .../target/classes/aisdata/Main.class | Bin 9166 -> 0 bytes .../aisdata/TrajectoryWindowFunction.class | Bin 8314 -> 0 bytes .../target/classes/log4j.properties | 5 - .../target/maven-archiver/pom.properties | 3 - .../compile/default-compile/createdFiles.lst | 9 - .../compile/default-compile/inputFiles.lst | 5 - 49 files changed, 228 insertions(+), 77 deletions(-) create mode 100644 flink-processor/src/main/java/berlinmod/MEOSBridge.java delete mode 100644 flink-processor/target/classes/aisdata/AISData.class delete mode 100644 flink-processor/target/classes/aisdata/AISDataDeserializationSchema.class delete mode 100644 flink-processor/target/classes/aisdata/AISTestSource.class delete mode 100644 flink-processor/target/classes/aisdata/Main$AISDataTimestampAssigner.class delete mode 100644 flink-processor/target/classes/aisdata/Main$AISDataToTuple4MapFunction.class delete mode 100644 flink-processor/target/classes/aisdata/Main$DeserializeAISDataMapFunction.class delete mode 100644 flink-processor/target/classes/aisdata/Main$LogKafkaMessagesMapFunction.class delete mode 100644 flink-processor/target/classes/aisdata/Main.class delete mode 100644 flink-processor/target/classes/aisdata/TrajectoryWindowFunction.class delete mode 100644 flink-processor/target/classes/log4j.properties delete mode 100644 flink-processor/target/maven-archiver/pom.properties delete mode 100644 flink-processor/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst delete mode 100644 flink-processor/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst 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 655cf10..bc97098 100644 --- a/README.md +++ b/README.md @@ -83,14 +83,14 @@ The streaming-side parity matrix runs all nine BerlinMOD reference queries (Q1.. 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 today use pure-Java great-circle ([`Haversine`](flink-processor/src/main/java/berlinmod/Haversine.java)) and planar segment-distance ([`SegmentDistance`](flink-processor/src/main/java/berlinmod/SegmentDistance.java)) utilities; each call site is marked `TODO(meos)` for JMEOS-bridge migration after [JMEOS#15](https://github.com/MobilityDB/JMEOS/pull/15) (the MEOS 1.4 regen) settles. +Spatial predicates route through [`MEOSBridge`](flink-processor/src/main/java/berlinmod/MEOSBridge.java), which calls MEOS' `geog_dwithin` over WGS84 geographies via [JMEOS#18](https://github.com/MobilityDB/JMEOS/pull/18) (the geodesic-wrapper PR, branched off the MEOS 1.4 regen at JMEOS#15) when libmeos is loadable on the runtime path. The distance entry points use [JMEOS#18](https://github.com/MobilityDB/JMEOS/pull/18)'s `utils.spatial.Haversine.distance` (MEOS `geog_distance` over POINT/POINT) and `utils.spatial.PointToSegment.distance` (MEOS `geog_distance` over POINT/LINESTRING). When libmeos is not present (e.g. on the mini-cluster local-test runs where `-Dmobilityflink.meos.enabled=false` is set), the bridge falls back to pure-Java great-circle (`Haversine`) and planar segment-distance (`SegmentDistance`) — same semantics, identical predicate truth values to within float-precision at BerlinMOD scale. 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) — 15 of 27 cells on NebulaStream (Q1, Q2, Q3, Q4, Q7-via-POI-fanout) +- [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/flink-processor/jar/JMEOS.jar b/flink-processor/jar/JMEOS.jar index 3c22044e8bafb2a712fd77286c627663586d7503..f0db3a0390f47506019d6597d83b7544abe042d8 100644 GIT binary patch delta 1069917 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

B4l|IXO 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 z f>w&VnV^&7HQjbX>b-6lAI+;+jy5*DBkumHfZ#kd&h+ohz|PXeukn?i=Su>u(I zG+$qvx-K+{Yes%V&7u^9 zYG(*U1|)tv5R_biE#@xi)qbos3bb-L5nZdv_PTr@s}G;a?qS&*)ABU;T^|+FH}Es* z^`bJIdR*H}B}w79oC%WWFvXQSemy<6tmM zpslEXj~423+Jq$s=%fyW!VIr<1Wl8HMR5ORSb@Xr4r>Cl7wXKu0lix^-Q6XFl`$v3 zXehrZI!x=MNBClg`KrHVfS%2+Q10Ik^n(=MQz zL>AueAh~1WGbk+bBoGOMU*Ezw*iF-}$A_)uAe>x@0gPA^Jqt{@s+_e7w=J#0S`Vu? zHu7hCUjjZI?G@}nv9(7PSoRik63Znm>b*9dAlpoesQcEYOC+;r%70$kSM zo&vGB!)!#Yx6lC@$uDUY7oN{=D6;9RQVxnQHLGg}eopPb_-hYl__X?7|Eos#T7M4i zZv0=Z|E$P~*FT@u-~E5I{=CN|5vF{Vw1}{OoYmP~LivfKMOGP850cd1BT2G<@*CHu z*=wzj)$ba0yx99G)0Z2#7in~+aEXhCJ|e4lx9=1yFO^&UDbU=q=YDj9{PH13s!H#r zQEcMP*Eq@5n9N>o{BY@E2?pmz9}5m%q2KoCtmwRu34n$O#I6eN!4Nsw?8xjAJFYUB zBIr91IX5I*Ww=DkRW@FsWwGsl`;z*M?;JA3WPTApSeEKfV0-VjYe{bYy!ZF0AB*21 z>tssmS7*fYQeY&U(s1qhaxJiOob(l-6Yh(!{Bi}e!{yw5h}S&;Ba#%q>Kr&5{A5Rp zvWrRHlPO6yGy=R_{PnDY+Q_WtY%ghScaV}kd$k+7nbiMlnp`1TlxpCA`k_~dx?)j| z+06{;DD1S|2%&{w~wM2&iM%`WGj&qL-KAznA!Z&3^S!w1&xAlJ6}$ z>0LyB{z4-a`okDF-+0Og$ zE#ACxV>l;da0jV&;kj7ulkWf*R`0<0BICr}^r-QA;JXg4gY@lHYk`GY9vl4~xETDS zS|US6E0GPNKi;q<6|a77EDtR8IrcO9ypon6-rdc3#r|tU#=V|@R1Iv}wN%8VxQx+d zgqj@bb_ap}(4Z%fXumcOSpi%i0c8~3w4IX&d0;fe?smzR7U%2eAFyZwSsE@2sim0_ zOKcCDD8DgHdY zEBU6A&147`jV{Bb({F%aSXZA=%^I@^YE|0gm7P&2F#Z;<$2i(HE) znRUU}(q74bJ}%2~^GBe4f-!suI#r0(Kj$_Tt19Y}k^8s{#)^=4AlFfMzRWWZti|J& z(6@MG^$SGXn~|usfUiVV!k{uprVy!GCdS-Blqrzb&qPwLH~T5979FLw^Ic1}V=tDP{TS_eAy;0Ec##c^>jAz$gFeH5YFi@%<4Y#n=yUo{WgXnbmuKKj z*<9kIY8JVO2>;;h@Yy)icA`!OC&Z#~DslRc4?tsY0qq*Ha0*0GhDP^2#J-@8H1STF z&Ekj*e~?av0{|05Yp$ih*$%|UyU_ivzNEwdD)v}g*ru_Up*xaaf2+#ha9pMTv<(a> z+iG@y^$QelE7RX!?k`>)P(BET>$UJY+V*f#D8$_5qL+pY-b(o2#gGvq6>r!I(lu z!D=az0u7#WXJD8doU#q$dw3=gsM$5spw``gjJzh&LLSGqF|JDb4uKhn)dMZEl5G$M z|H#;k{EoV$S_l3w*&fGQF5?!V@97(BcK1VvP_=G6eOpzxE^?~=URA?UwW=XLP+5yE zp=*~HH=>FKgF`N9q|u`}BSSozvO|J=*!_Qd?=;V$z>)=CRmvqA^CPRQdNN*Dq-dLe zzP2fObOQT}zX)M9!&`!+I%@2iYpLMw1WG*Rr&35vx6(=n^?Zh=5BeIS!mo4(^drSb zSczEakcDi6u*uW_0t;&2Q5zEdFlAULmew0l4 zDSMKz`~;rtRLIXS`SdeID9g{NOH8U@U6|x&2ju5C7i#$#OWx#THPB#IWDeqgHYb_# zQ>)poFohc?r?3oHTz(??i3!Hb(&t#F{7l+dI_rDiR(^I~W~0yXDHeU+ zo03T%s6JXvvpa)E3l>TmU56ab*sU&EN`Ed?-Gz{{3pj=MKWTDpuR0OAxPE*%=Yn>? zX>*3$Kj?S327MDV2sSl?V2t8_-GgAQ%>0ozDuJB7e%*nLWrC z&_A=&PnndWUx)8&>330Pw!3K?+!QR7196Kc&=?9 zUTd#+XqRiWKeU{yn$q#2UKfD}B^8@k0D?@GdhV=P^Gwt<z=Zy3lp zdJ^~2K%*Bwm@As+uUX&)lda4_P1F<*S2}WFqZu(F*$emj`7-W9yl|y|@xs#`kvzbg zp5{>N{*nX7^8)W2)_+ldYcvOmEou8SlYL@p3BW07iP;KimQmhZz}RJEc#|fFkFVIHxT6qdcXmCZVEDF zO0I*OVa|lLFbd@#z?p#>LI0L!$$tYNg_U8chrE?(`fxqEuUlPz`UEB$o8cX0)+m*hjo0HaVNl{YF{uYx;|S=-ekGSvjOP2a3D(kzV+& zC7SwV?;P>Px$G#KQ_>0#>-(qhr+_Bg50H`FP%4e=_>a15{pc-_K9o0uG)1(dD%}C@ zNMnrrqTCr7;0c8_mx-NGN*6{h_DnGHHej=r!@i{Tn4u{xqCQ~aU?8cxu(qC|`PACS z6b?d|^+&XS`a?L5I8ZLAM=|||Cb8zz3NlS(n{qvSi@#>I5`V3K%VsA6NrH$5rYYBlZ;Ur*;K8AQ zq3*#h%o(#^h`+EdwQb$3D@G;ws4?H1Jx4T|6cVle614BgA;OHM!DhEu);-ZBD@B*0 zu_=5K4y~zmOX=Yy_3`VDr^gwd1|`63X_4ic%BAFmu8<2orPo3a#6l0XE%Yzv z_2W)|rhP0lFQ{#yQyp0m6ibYU_(Nx5Y$7^Z1H9h4Q^VpKW3v!-LL;&Gy$SATEFFqD zXLKbO&&zSrNqr2uYKwSm0vYG?j#)SnBqCi>W*Q?KEqTfOBa7NKM845vDa<|+#K7@; z_8`qDCy{!{^tE4uJo=+1T-6m=k~wY^@rJd3JPQndrtJC{8bM1Ea7nKPt<)@W|J;6# z^lISTnAy{3L8~E-m2>KYXswXp^Eq!it-}S+nHSQZ@q%PRQE7(1J}Ue5V3|s}-L}7` z4HYS>@iU?>PdOM~==SRkEP%?2KOmFiXfS*{$lmJgqgpu6TcHS|!doTlmIY%ATqJjY zwrceM`se{#O@k}sTSsyy&#N@(YsrGc+Mjux`#T0wCj^}<=J65FI-XhYYsbI(%BK6d zMCp}M_k;VO%(Raq_sZ@+PI32HCL$dfPAeRyR+r>rI#kd}we4W4d!VvY%)Hs`8c33r z(Wmt6O;X{Dx~iKs#*6PJ-5ectQmV{+@BfWs_LLK%s3)p1!cjx+7xAfQ9Z9r3hAM9aY z$G*WRJb`^(l)0#vgiU?bMyDM%I<<>Q9v-_|iySKKpGV7k4H5WO-_Ab0&#GgFbF#?S z*JM-ljelaRf4At#mJZVt49^|I5ro+(Vsm890mn~hXV?79r3BQKH|MIgl}_l#n!bTU z!03( z0S5eU!jmfl#*n_6|8@LXp??hZmQOa>H;L53wrdc-%k~D0GCGM4VEjBli4~?72r{PJ zA^ia3mZPr$AUm^5%AEy&Bg~d|%{0un0x`{1=G(05)gx z$V2wi_uH#Er~Fi&z6{}{*-u~YEFQ3(H;f)>9>5{){PVMb)N&YqCJ-va2v%}Q$sq-2 zE4yy&`GEk3@$FtT4tN)&1eNLQ>3Q8{#d~ObZV84r(n`J$#OIKbENP|n4*~7-0~=0E z(ASDMXhT`??lOHXUK$|7hsZoboLRt1>

WI`Yg+Ci@gNCGKxH}r@1Wa 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 z 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

-BT>R1zX#BEOzi5Xl&8z7CSMqT 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

wC>m}#tuV>0#>7kYP)%_goX2}_^v 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%0Ds`pi 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

YoVzV|__%o?e(LybjCHH%K2cq> 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 by the BerlinMOD-Q3 scaffold for "is this vehicle within {@code d} - * metres of point P" predicates. This is the same semantic as the MEOS - * {@code edwithin_tgeo_geo} operator used by {@code MobilityNebula/Queries/Query1.yaml}; - * keeping the predicate as pure Java here lets the scaffold compile and run - * before the JMEOS bridge for {@code edwithin_tgeo_geo} is wired through. + *

Pure-Java fallback for {@link MEOSBridge#dwithinMetres} and + * {@link MEOSBridge#distanceMetres}, used by the BerlinMOD-9 × 3-form + * streaming scaffold when libmeos is not loadable on the runtime path + * (e.g. the mini-cluster local tests in {@code BerlinMODQ*LocalTest}). The + * primary spatial-predicate surface is {@link MEOSBridge}; this class is a + * fallback only. */ public final class Haversine { 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..12570e0 --- /dev/null +++ b/flink-processor/src/main/java/berlinmod/MEOSBridge.java @@ -0,0 +1,158 @@ +package berlinmod; + +import functions.functions; +import jnr.ffi.Pointer; +import utils.spatial.PointToSegment; + +/** + * Runtime bridge from MobilityFlink BerlinMOD streaming-form predicates to + * MEOS via JMEOS. + * + *

All spatial predicates exercised by the BerlinMOD-9 × 3-form scaffold + * flow through this class. When the JMEOS native libmeos shared object is + * present and loadable, each predicate evaluates through MEOS' WGS84 + * geography surface ({@code geom_to_geog} + {@code geog_dwithin}). When + * libmeos is not available, each predicate falls back to the corresponding + * pure-Java implementation in {@link Haversine} or {@link SegmentDistance} + * so the BerlinMOD mini-cluster local tests stay runnable on systems + * without a MEOS install. + * + *

The fallback is gated by the {@link #MEOS_AVAILABLE} static flag, set + * once at class-load time: + *

    + *
  • {@code -Dmobilityflink.meos.enabled=false} forces the pure-Java path + * even when libmeos is present (used by {@code BerlinMODQ*LocalTest}). + *
  • Otherwise {@code MEOS_AVAILABLE} is {@code true} iff + * {@code functions.meos_initialize()} returns without throwing. + *
+ */ +public final class MEOSBridge { + + /** + * {@code true} iff MEOS is available on this runtime and the bridge + * routes through it; {@code false} iff the bridge will use the pure-Java + * fallbacks. + */ + public static final boolean MEOS_AVAILABLE; + + static { + boolean enabled = + Boolean.parseBoolean(System.getProperty("mobilityflink.meos.enabled", "true")); + boolean ok = false; + if (enabled) { + try { + functions.meos_initialize(); + ok = true; + } catch (Throwable t) { + // libmeos shared object not loadable on this runtime — fall back. + ok = false; + } + } + MEOS_AVAILABLE = ok; + } + + private MEOSBridge() { + // utility + } + + // ---------------------------------------------------------------------- + // Public bridge surface — same shape as Haversine + SegmentDistance. + // ---------------------------------------------------------------------- + + /** + * @return {@code true} if the great-circle distance from {@code (lon1, lat1)} + * to {@code (lon2, lat2)} on the WGS84 spheroid is at most + * {@code radiusMetres}. MEOS-backed via {@code geog_dwithin} when + * available, else pure-Java {@link Haversine#withinMetres}. + */ + public static boolean dwithinMetres(double lon1, double lat1, + double lon2, double lat2, + double radiusMetres) { + if (!MEOS_AVAILABLE) { + return Haversine.withinMetres(lon1, lat1, lon2, lat2, radiusMetres); + } + Pointer g1 = pointGeog(lon1, lat1); + Pointer g2 = pointGeog(lon2, lat2); + if (g1 == null || g2 == null) { + return Haversine.withinMetres(lon1, lat1, lon2, lat2, radiusMetres); + } + return functions.geog_dwithin(g1, g2, radiusMetres, true); + } + + /** + * @return {@code true} if the spheroidal distance from {@code (pLon, pLat)} + * to the LineString {@code (s1, s2)} is at most {@code radiusMetres}. + * MEOS-backed via {@code geog_dwithin} on geographies built from + * the point and line WKTs, else pure-Java + * {@link SegmentDistance#withinMetres}. + */ + public static boolean dwithinSegmentMetres(double pLon, double pLat, + double s1Lon, double s1Lat, + double s2Lon, double s2Lat, + double radiusMetres) { + if (!MEOS_AVAILABLE) { + return SegmentDistance.withinMetres(pLon, pLat, s1Lon, s1Lat, s2Lon, s2Lat, radiusMetres); + } + Pointer pg = pointGeog(pLon, pLat); + Pointer lg = lineGeog(s1Lon, s1Lat, s2Lon, s2Lat); + if (pg == null || lg == null) { + return SegmentDistance.withinMetres(pLon, pLat, s1Lon, s1Lat, s2Lon, s2Lat, radiusMetres); + } + return functions.geog_dwithin(pg, lg, radiusMetres, true); + } + + /** + * @return the spheroidal distance in metres between two WGS84 points. + * MEOS-backed via {@code utils.spatial.Haversine.distance} + * (which calls MEOS' {@code geog_distance} over two POINT + * geographies) when libmeos is loadable, else pure-Java + * {@link Haversine#distanceMetres}. + */ + public static double distanceMetres(double lon1, double lat1, + double lon2, double lat2) { + if (!MEOS_AVAILABLE) { + return Haversine.distanceMetres(lon1, lat1, lon2, lat2); + } + return utils.spatial.Haversine.distance(lon1, lat1, lon2, lat2); + } + + /** + * @return the spheroidal distance in metres from {@code (pLon, pLat)} to + * the LineString {@code (s1, s2)}. MEOS-backed via + * {@code utils.spatial.PointToSegment.distance} when libmeos is + * loadable, else pure-Java + * {@link SegmentDistance#distanceMetres}. + */ + public static double distanceSegmentMetres(double pLon, double pLat, + double s1Lon, double s1Lat, + double s2Lon, double s2Lat) { + if (!MEOS_AVAILABLE) { + return SegmentDistance.distanceMetres(pLon, pLat, s1Lon, s1Lat, s2Lon, s2Lat); + } + return PointToSegment.distance(pLon, pLat, s1Lon, s1Lat, s2Lon, s2Lat); + } + + // ---------------------------------------------------------------------- + // Internal helpers — WKT → geometry → geography in one MEOS-side step. + // ---------------------------------------------------------------------- + + private static Pointer pointGeog(double lon, double lat) { + String wkt = String.format("SRID=4326;Point(%.7f %.7f)", lon, lat); + Pointer g = functions.geom_in(wkt, -1); + if (g == null) { + return null; + } + return functions.geom_to_geog(g); + } + + private static Pointer lineGeog(double s1Lon, double s1Lat, + double s2Lon, double s2Lat) { + String wkt = String.format("SRID=4326;LineString(%.7f %.7f, %.7f %.7f)", + s1Lon, s1Lat, s2Lon, s2Lat); + Pointer g = functions.geom_in(wkt, -1); + if (g == null) { + return null; + } + return functions.geom_to_geog(g); + } +} diff --git a/flink-processor/src/main/java/berlinmod/Q3ContinuousFunction.java b/flink-processor/src/main/java/berlinmod/Q3ContinuousFunction.java index af06130..6628d05 100644 --- a/flink-processor/src/main/java/berlinmod/Q3ContinuousFunction.java +++ b/flink-processor/src/main/java/berlinmod/Q3ContinuousFunction.java @@ -16,9 +16,9 @@ * predicate and emit {@code (vehicleId, eventTimeMillis, isNear)} per event. * No windowing — output updates per event, watermark-independent. * - *

Predicate today: pure-Java great-circle distance (see {@link Haversine}). - * TODO(meos): replace with the MEOS {@code edwithin_tgeo_geo} operator via - * JMEOS once that call is wired through (same predicate semantics, native MEOS). + *

Predicate: {@link MEOSBridge#dwithinMetres} — MEOS' {@code geog_dwithin} + * over WGS84 geographies when libmeos is loadable, with a pure-Java great-circle + * fallback ({@link Haversine}) for runtimes without MEOS. */ public class Q3ContinuousFunction extends ProcessFunction> { @@ -39,7 +39,7 @@ public void processElement( BerlinMODTrip trip, Context ctx, Collector> out) { - boolean near = Haversine.withinMetres(trip.getLon(), trip.getLat(), pLon, pLat, radiusMetres); + 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 index e2340ca..479854d 100644 --- a/flink-processor/src/main/java/berlinmod/Q3SnapshotFunction.java +++ b/flink-processor/src/main/java/berlinmod/Q3SnapshotFunction.java @@ -27,10 +27,10 @@ * {@code (T, vehicleId)} if the vehicle is within {@code d} of P at that * snapshot. * - *

Predicate today: pure-Java great-circle distance (see {@link Haversine}). - * TODO(meos): replace with the MEOS {@code edwithin_tgeo_geo} operator via - * JMEOS for native streaming-snapshot semantics that match the batch - * BerlinMOD-Q3 byte-for-byte. + *

Predicate: {@link MEOSBridge#dwithinMetres} — MEOS {@code geog_dwithin} + * when libmeos is loadable, with {@link Haversine} fallback otherwise. The + * snapshot-form output at watermark T is equal to the batch BerlinMOD-Q3 + * result up to T regardless of which path is active. */ public class Q3SnapshotFunction extends KeyedProcessFunction> { @@ -80,7 +80,7 @@ public void onTimer( if (p == null) { return; } - if (Haversine.withinMetres(p.f0, p.f1, pLon, pLat, radiusMetres)) { + if (MEOSBridge.dwithinMetres(p.f0, p.f1, pLon, pLat, radiusMetres)) { Integer vehicleId = ctx.getCurrentKey(); out.collect(new Tuple2<>(timestamp, vehicleId)); if (LOG.isDebugEnabled()) { diff --git a/flink-processor/src/main/java/berlinmod/Q3WindowedFunction.java b/flink-processor/src/main/java/berlinmod/Q3WindowedFunction.java index c4490ee..c6dfa98 100644 --- a/flink-processor/src/main/java/berlinmod/Q3WindowedFunction.java +++ b/flink-processor/src/main/java/berlinmod/Q3WindowedFunction.java @@ -21,9 +21,9 @@ * for which at least one event satisfies the radius predicate, and emit * {@code (windowStart, windowEnd, distinctCount)}. * - *

Predicate today: pure-Java great-circle distance (see {@link Haversine}). - * TODO(meos): replace with the MEOS {@code edwithin_tgeo_geo} operator via - * JMEOS once that call is wired through. + *

Predicate: {@link MEOSBridge#dwithinMetres} — MEOS {@code geog_dwithin} + * over WGS84 geographies when libmeos is loadable, with {@link Haversine} + * fallback otherwise. */ public class Q3WindowedFunction extends ProcessAllWindowFunction, TimeWindow> { @@ -47,7 +47,7 @@ public void process( Collector> out) { Set distinctNear = new HashSet<>(); for (BerlinMODTrip trip : elements) { - if (Haversine.withinMetres(trip.getLon(), trip.getLat(), pLon, pLat, radiusMetres)) { + if (MEOSBridge.dwithinMetres(trip.getLon(), trip.getLat(), pLon, pLat, radiusMetres)) { distinctNear.add(trip.getVehicleId()); } } diff --git a/flink-processor/src/main/java/berlinmod/Q4ContinuousFunction.java b/flink-processor/src/main/java/berlinmod/Q4ContinuousFunction.java index a04b804..5a2ece9 100644 --- a/flink-processor/src/main/java/berlinmod/Q4ContinuousFunction.java +++ b/flink-processor/src/main/java/berlinmod/Q4ContinuousFunction.java @@ -18,9 +18,10 @@ * inside-or-outside, and if the transition is outside→inside, emits * {@code (vehicleId, entryTime)}. * - *

Predicate today: pure-Java point-in-box. TODO(meos): replace with the - * MEOS {@code eintersects_tgeo_geo} operator via the JMEOS bridge of an - * STBox containment test for a generic polygon-R variant. + *

Predicate: pure-Java axis-aligned point-in-box. The rectangular region + * is degenerate as a geographic predicate (no projection needed); a generic + * polygon-R variant would route through {@link MEOSBridge} for MEOS + * {@code eintersects_tgeo_geo}. */ public class Q4ContinuousFunction extends KeyedProcessFunction> { diff --git a/flink-processor/src/main/java/berlinmod/Q5ContinuousFunction.java b/flink-processor/src/main/java/berlinmod/Q5ContinuousFunction.java index 93ab75b..d14f272 100644 --- a/flink-processor/src/main/java/berlinmod/Q5ContinuousFunction.java +++ b/flink-processor/src/main/java/berlinmod/Q5ContinuousFunction.java @@ -31,9 +31,9 @@ * known pairs and emit {@code (a, b, eventTime, distanceMetres)} for every * currently-meeting pair (with {@code a < b} for stable identity). * - *

Predicate today: pure-Java great-circle distance (see {@link Haversine}). - * TODO(meos): replace with the MEOS NAD / `edwithin_tgeo_tgeo` operator pair - * via the JMEOS bridge. + *

Predicate: {@link MEOSBridge#dwithinMetres} for the near-P filter and + * for the pairwise meeting predicate — MEOS {@code geog_dwithin} when + * libmeos is loadable, with {@link Haversine} fallback otherwise. */ public class Q5ContinuousFunction extends KeyedProcessFunction> { @@ -71,7 +71,7 @@ public void processElement( List>> nearP = new ArrayList<>(); for (Map.Entry> e : snap.entrySet()) { Tuple2 p = e.getValue(); - if (Haversine.withinMetres(p.f0, p.f1, pLon, pLat, dPMetres)) { + if (MEOSBridge.dwithinMetres(p.f0, p.f1, pLon, pLat, dPMetres)) { nearP.add(e); } } @@ -81,7 +81,7 @@ public void processElement( for (int j = i + 1; j < nearP.size(); j++) { Tuple2 a = nearP.get(i).getValue(); Tuple2 b = nearP.get(j).getValue(); - double d = Haversine.distanceMetres(a.f0, a.f1, b.f0, b.f1); + 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(), diff --git a/flink-processor/src/main/java/berlinmod/Q5SnapshotFunction.java b/flink-processor/src/main/java/berlinmod/Q5SnapshotFunction.java index 34601ef..b2f2758 100644 --- a/flink-processor/src/main/java/berlinmod/Q5SnapshotFunction.java +++ b/flink-processor/src/main/java/berlinmod/Q5SnapshotFunction.java @@ -76,7 +76,7 @@ public void onTimer( List>> nearP = new ArrayList<>(); for (Map.Entry> e : snap.entrySet()) { Tuple2 p = e.getValue(); - if (Haversine.withinMetres(p.f0, p.f1, pLon, pLat, dPMetres)) { + if (MEOSBridge.dwithinMetres(p.f0, p.f1, pLon, pLat, dPMetres)) { nearP.add(e); } } @@ -86,7 +86,7 @@ public void onTimer( for (int j = i + 1; j < nearP.size(); j++) { Tuple2 a = nearP.get(i).getValue(); Tuple2 b = nearP.get(j).getValue(); - double d = Haversine.distanceMetres(a.f0, a.f1, b.f0, b.f1); + 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 index 1619586..8140d0f 100644 --- a/flink-processor/src/main/java/berlinmod/Q5WindowedFunction.java +++ b/flink-processor/src/main/java/berlinmod/Q5WindowedFunction.java @@ -53,7 +53,7 @@ public void process( List>> nearP = new ArrayList<>(); for (Map.Entry e : latest.entrySet()) { BerlinMODTrip t = e.getValue(); - if (Haversine.withinMetres(t.getLon(), t.getLat(), pLon, pLat, dPMetres)) { + if (MEOSBridge.dwithinMetres(t.getLon(), t.getLat(), pLon, pLat, dPMetres)) { nearP.add(new HashMap.SimpleEntry<>(e.getKey(), new Tuple2<>(t.getLon(), t.getLat()))); } } @@ -63,7 +63,7 @@ public void process( for (int j = i + 1; j < nearP.size(); j++) { Tuple2 a = nearP.get(i).getValue(); Tuple2 b = nearP.get(j).getValue(); - double d = Haversine.distanceMetres(a.f0, a.f1, b.f0, b.f1); + 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(), diff --git a/flink-processor/src/main/java/berlinmod/Q6ContinuousFunction.java b/flink-processor/src/main/java/berlinmod/Q6ContinuousFunction.java index 0d15b22..85204f3 100644 --- a/flink-processor/src/main/java/berlinmod/Q6ContinuousFunction.java +++ b/flink-processor/src/main/java/berlinmod/Q6ContinuousFunction.java @@ -51,7 +51,7 @@ public void processElement( total = 0.0; } if (prev != null) { - total += Haversine.distanceMetres(prev.f0, prev.f1, trip.getLon(), trip.getLat()); + total += MEOSBridge.distanceMetres(prev.f0, prev.f1, trip.getLon(), trip.getLat()); } lastPos.update(new Tuple2<>(trip.getLon(), trip.getLat())); totalDist.update(total); diff --git a/flink-processor/src/main/java/berlinmod/Q6SnapshotFunction.java b/flink-processor/src/main/java/berlinmod/Q6SnapshotFunction.java index 73117e8..4270f67 100644 --- a/flink-processor/src/main/java/berlinmod/Q6SnapshotFunction.java +++ b/flink-processor/src/main/java/berlinmod/Q6SnapshotFunction.java @@ -55,7 +55,7 @@ public void processElement( total = 0.0; } if (prev != null) { - total += Haversine.distanceMetres(prev.f0, prev.f1, trip.getLon(), trip.getLat()); + total += MEOSBridge.distanceMetres(prev.f0, prev.f1, trip.getLon(), trip.getLat()); } lastPos.update(new Tuple2<>(trip.getLon(), trip.getLat())); totalDist.update(total); diff --git a/flink-processor/src/main/java/berlinmod/Q6WindowedFunction.java b/flink-processor/src/main/java/berlinmod/Q6WindowedFunction.java index 4337c39..0fc9501 100644 --- a/flink-processor/src/main/java/berlinmod/Q6WindowedFunction.java +++ b/flink-processor/src/main/java/berlinmod/Q6WindowedFunction.java @@ -37,7 +37,7 @@ public void process( for (int i = 1; i < sorted.size(); i++) { BerlinMODTrip prev = sorted.get(i - 1); BerlinMODTrip curr = sorted.get(i); - total += Haversine.distanceMetres(prev.getLon(), prev.getLat(), + 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 index 7a72e10..bc4dc83 100644 --- a/flink-processor/src/main/java/berlinmod/Q7ContinuousFunction.java +++ b/flink-processor/src/main/java/berlinmod/Q7ContinuousFunction.java @@ -48,7 +48,7 @@ public void processElement( if (firstPassed.contains(poi.id)) { continue; } - if (Haversine.withinMetres(trip.getLon(), trip.getLat(), poi.lon, poi.lat, poi.radiusMetres)) { + 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 index 8fa1739..49637f6 100644 --- a/flink-processor/src/main/java/berlinmod/Q7SnapshotFunction.java +++ b/flink-processor/src/main/java/berlinmod/Q7SnapshotFunction.java @@ -57,7 +57,7 @@ public void processElement( if (firstPassed.contains(poi.id)) { continue; } - if (Haversine.withinMetres(trip.getLon(), trip.getLat(), + if (MEOSBridge.dwithinMetres(trip.getLon(), trip.getLat(), poi.lon, poi.lat, poi.radiusMetres)) { firstPassed.put(poi.id, trip.getTimestamp()); } diff --git a/flink-processor/src/main/java/berlinmod/Q7WindowedFunction.java b/flink-processor/src/main/java/berlinmod/Q7WindowedFunction.java index 1eb9674..e256c81 100644 --- a/flink-processor/src/main/java/berlinmod/Q7WindowedFunction.java +++ b/flink-processor/src/main/java/berlinmod/Q7WindowedFunction.java @@ -55,7 +55,7 @@ public void process( if (emittedPois.contains(poi.id)) { continue; } - if (Haversine.withinMetres(trip.getLon(), trip.getLat(), + if (MEOSBridge.dwithinMetres(trip.getLon(), trip.getLat(), poi.lon, poi.lat, poi.radiusMetres)) { emittedPois.add(poi.id); out.collect(new Tuple5<>( diff --git a/flink-processor/src/main/java/berlinmod/Q8ContinuousFunction.java b/flink-processor/src/main/java/berlinmod/Q8ContinuousFunction.java index 7eecadf..fac4f1a 100644 --- a/flink-processor/src/main/java/berlinmod/Q8ContinuousFunction.java +++ b/flink-processor/src/main/java/berlinmod/Q8ContinuousFunction.java @@ -15,10 +15,9 @@ * per event. No windowing — same shape as {@link Q3ContinuousFunction} but * with a segment-distance predicate instead of a point-radius one. * - *

Predicate today: pure-Java planar projection over an equirectangular - * frame centred on the segment midpoint (see {@link SegmentDistance}). - * TODO(meos): replace with the MEOS {@code distance(tgeompoint, - * geometry(LINESTRING))} call via the JMEOS bridge. + *

Predicate: {@link MEOSBridge#dwithinSegmentMetres} — MEOS + * {@code geog_dwithin} against a LineString geography when libmeos is + * loadable, with {@link SegmentDistance} fallback otherwise. */ public class Q8ContinuousFunction extends ProcessFunction> { @@ -39,7 +38,7 @@ public void processElement( BerlinMODTrip trip, Context ctx, Collector> out) { - boolean near = SegmentDistance.withinMetres( + boolean near = MEOSBridge.dwithinSegmentMetres( trip.getLon(), trip.getLat(), s1Lon, s1Lat, s2Lon, s2Lat, radiusMetres); diff --git a/flink-processor/src/main/java/berlinmod/Q8SnapshotFunction.java b/flink-processor/src/main/java/berlinmod/Q8SnapshotFunction.java index 5198e70..8f61c91 100644 --- a/flink-processor/src/main/java/berlinmod/Q8SnapshotFunction.java +++ b/flink-processor/src/main/java/berlinmod/Q8SnapshotFunction.java @@ -71,7 +71,7 @@ public void onTimer( if (p == null) { return; } - if (SegmentDistance.withinMetres(p.f0, p.f1, s1Lon, s1Lat, s2Lon, s2Lat, radiusMetres)) { + 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 index ace2dce..410a8bf 100644 --- a/flink-processor/src/main/java/berlinmod/Q8WindowedFunction.java +++ b/flink-processor/src/main/java/berlinmod/Q8WindowedFunction.java @@ -41,7 +41,7 @@ public void process( Collector> out) { Set distinctNear = new HashSet<>(); for (BerlinMODTrip trip : elements) { - if (SegmentDistance.withinMetres( + if (MEOSBridge.dwithinSegmentMetres( trip.getLon(), trip.getLat(), s1Lon, s1Lat, s2Lon, s2Lat, radiusMetres)) { diff --git a/flink-processor/src/main/java/berlinmod/Q9ContinuousFunction.java b/flink-processor/src/main/java/berlinmod/Q9ContinuousFunction.java index ae431e8..09e122c 100644 --- a/flink-processor/src/main/java/berlinmod/Q9ContinuousFunction.java +++ b/flink-processor/src/main/java/berlinmod/Q9ContinuousFunction.java @@ -62,7 +62,7 @@ public void processElement( } xy.update(s); if (!Double.isNaN(s.f0) && !Double.isNaN(s.f2)) { - double d = Haversine.distanceMetres(s.f0, s.f1, s.f2, s.f3); + 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 index 6bce22b..93498c0 100644 --- a/flink-processor/src/main/java/berlinmod/Q9SnapshotFunction.java +++ b/flink-processor/src/main/java/berlinmod/Q9SnapshotFunction.java @@ -73,7 +73,7 @@ public void onTimer( Collector> out) throws Exception { Tuple4 s = xy.value(); if (s != null && !Double.isNaN(s.f0) && !Double.isNaN(s.f2)) { - double d = Haversine.distanceMetres(s.f0, s.f1, s.f2, s.f3); + 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 index 6f1cd09..25c9688 100644 --- a/flink-processor/src/main/java/berlinmod/Q9WindowedFunction.java +++ b/flink-processor/src/main/java/berlinmod/Q9WindowedFunction.java @@ -45,7 +45,7 @@ public void process( } } if (latestX != null && latestY != null) { - double d = Haversine.distanceMetres( + 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/berlinmod/SegmentDistance.java b/flink-processor/src/main/java/berlinmod/SegmentDistance.java index 82c18ae..62db56b 100644 --- a/flink-processor/src/main/java/berlinmod/SegmentDistance.java +++ b/flink-processor/src/main/java/berlinmod/SegmentDistance.java @@ -4,11 +4,11 @@ * Distance from a (lon, lat) point to a (lon, lat) line segment, in metres, * via a local equirectangular projection centred on the segment midpoint. * - *

Good to a few-metres accuracy over short segments (≤ 10 km) at mid- - * latitudes, which covers the BerlinMOD-Q8 streaming scaffold. For longer - * segments or higher accuracy the MEOS-native {@code distance} between - * {@code tgeompoint} and {@code geometry(LINESTRING)} via the JMEOS bridge - * is the production path — marked {@code TODO(meos)} in the call sites. + *

` classes (1,346 methods): one per public MEOS header for functions not assigned to any object-model class (MeosOpsFreeCore, MeosOpsFreeGeo, MeosOpsFreeCbuffer, MeosOpsFreeNpoint, MeosOpsFreePose, MeosOpsFreeRgeo). - 1 shared `MeosOpsRuntime` (single `MEOS_AVAILABLE` static-init across all 56 facades). Each emitted method forwards to `functions.GeneratedFunctions.(...)` after probing the shared `MeosOpsRuntime.MEOS_AVAILABLE` flag. Each method carries a Javadoc tier marker (stateless / bounded-state / windowed / cross-stream / io-meta) so consumers know the per-method wiring shape. Total emit: 2,097 of JMEOS PR #19's 2,699-method surface (77.7%); remainder is the JMEOS-deliberately-omitted type-catalog helpers plus the streaming-relevance-baseline ambiguous (59) and sequence-only (14) buckets, both surfaced separately for design decisions before emit. Two generators under flink-processor/tools/codegen/: - codegen-oo.py: reads JMEOS jar signatures via javap-p + streaming-relevance baseline + MEOS object model → emits per-OO-class facades. - codegen-free.py: same shape, but for functions not in the OO model → emits per-header facades. Both are ~250 LOC, deterministic, audit-by-regeneration. Manifests record provenance (JMEOS method total, baseline target count, emit count, per-tier breakdown, per-class/per-header method count, sample of functions absent from JMEOS). Coexists with the existing berlinmod.MEOSBridge hand-written BerlinMOD-scoped bridge (high-level, query-shaped); the generated MeosOps* facades expose the raw MEOS surface tier-by-tier (low-level, catalog-shaped). Both share the same MEOS_AVAILABLE discipline and `functions.GeneratedFunctions` delegation. Stacks on feat/jmeos-bridge-swap; additive-only; touches no existing file. Locally compile-verified against the union of JMEOS PR #19's jmeos-core + PR #18's utils.spatial (the latter needed by MEOSBridge, separately tracked). --- .../flink/meos/MeosOpsBigintSet.java | 130 + .../flink/meos/MeosOpsBigintSpan.java | 144 + .../flink/meos/MeosOpsBigintSpanSet.java | 116 + .../flink/meos/MeosOpsCbufferSet.java | 116 + .../mobilitydb/flink/meos/MeosOpsDateSet.java | 144 + .../flink/meos/MeosOpsDateSpan.java | 144 + .../flink/meos/MeosOpsDateSpanSet.java | 172 + .../flink/meos/MeosOpsFloatSet.java | 200 + .../flink/meos/MeosOpsFloatSpan.java | 228 + .../flink/meos/MeosOpsFloatSpanSet.java | 200 + .../flink/meos/MeosOpsFreeCbuffer.java | 1957 ++++ .../flink/meos/MeosOpsFreeCore.java | 9719 +++++++++++++++++ .../mobilitydb/flink/meos/MeosOpsFreeGeo.java | 3426 ++++++ .../flink/meos/MeosOpsFreeNpoint.java | 1086 ++ .../flink/meos/MeosOpsFreePose.java | 1008 ++ .../flink/meos/MeosOpsFreeRgeo.java | 423 + .../mobilitydb/flink/meos/MeosOpsGeogSet.java | 32 + .../mobilitydb/flink/meos/MeosOpsGeomSet.java | 102 + .../mobilitydb/flink/meos/MeosOpsIntSet.java | 144 + .../mobilitydb/flink/meos/MeosOpsIntSpan.java | 158 + .../flink/meos/MeosOpsIntSpanSet.java | 130 + .../flink/meos/MeosOpsNpointSet.java | 130 + .../mobilitydb/flink/meos/MeosOpsPoseSet.java | 116 + .../mobilitydb/flink/meos/MeosOpsRuntime.java | 29 + .../mobilitydb/flink/meos/MeosOpsSTBox.java | 774 ++ .../org/mobilitydb/flink/meos/MeosOpsSet.java | 368 + .../mobilitydb/flink/meos/MeosOpsSpan.java | 298 + .../mobilitydb/flink/meos/MeosOpsSpanSet.java | 438 + .../mobilitydb/flink/meos/MeosOpsTBool.java | 228 + .../flink/meos/MeosOpsTBoolInst.java | 32 + .../mobilitydb/flink/meos/MeosOpsTBox.java | 480 + .../flink/meos/MeosOpsTCbuffer.java | 228 + .../mobilitydb/flink/meos/MeosOpsTFloat.java | 536 + .../flink/meos/MeosOpsTFloatInst.java | 32 + .../mobilitydb/flink/meos/MeosOpsTGeo.java | 354 + .../flink/meos/MeosOpsTGeogPoint.java | 60 + .../flink/meos/MeosOpsTGeography.java | 74 + .../flink/meos/MeosOpsTGeomPoint.java | 74 + .../flink/meos/MeosOpsTGeometry.java | 88 + .../mobilitydb/flink/meos/MeosOpsTInt.java | 424 + .../flink/meos/MeosOpsTIntInst.java | 32 + .../mobilitydb/flink/meos/MeosOpsTNpoint.java | 312 + .../flink/meos/MeosOpsTNpointInst.java | 32 + .../mobilitydb/flink/meos/MeosOpsTNumber.java | 340 + .../mobilitydb/flink/meos/MeosOpsTPoint.java | 354 + .../mobilitydb/flink/meos/MeosOpsTPose.java | 256 + .../flink/meos/MeosOpsTRGeometry.java | 522 + .../flink/meos/MeosOpsTRGeometryInst.java | 32 + .../flink/meos/MeosOpsTSequenceSet.java | 32 + .../flink/meos/MeosOpsTSpatial.java | 144 + .../mobilitydb/flink/meos/MeosOpsTText.java | 270 + .../flink/meos/MeosOpsTTextInst.java | 32 + .../flink/meos/MeosOpsTemporal.java | 1376 +++ .../mobilitydb/flink/meos/MeosOpsTextSet.java | 158 + .../mobilitydb/flink/meos/MeosOpsTstzSet.java | 186 + .../flink/meos/MeosOpsTstzSpan.java | 200 + .../flink/meos/MeosOpsTstzSpanSet.java | 242 + flink-processor/tools/codegen/README.md | 106 + flink-processor/tools/codegen/codegen-free.py | 187 + flink-processor/tools/codegen/codegen-oo.py | 237 + .../tools/codegen/meos-ops-free-manifest.json | 52 + .../tools/codegen/meos-ops-manifest.json | 142 + 62 files changed, 29786 insertions(+) create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsBigintSet.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsBigintSpan.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsBigintSpanSet.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsCbufferSet.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsDateSet.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsDateSpan.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsDateSpanSet.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFloatSet.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFloatSpan.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFloatSpanSet.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFreeCbuffer.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFreeCore.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFreeGeo.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFreeNpoint.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFreePose.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFreeRgeo.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsGeogSet.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsGeomSet.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsIntSet.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsIntSpan.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsIntSpanSet.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsNpointSet.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsPoseSet.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsRuntime.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsSTBox.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsSet.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsSpan.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsSpanSet.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTBool.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTBoolInst.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTBox.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTCbuffer.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTFloat.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTFloatInst.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTGeo.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTGeogPoint.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTGeography.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTGeomPoint.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTGeometry.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTInt.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTIntInst.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTNpoint.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTNpointInst.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTNumber.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTPoint.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTPose.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTRGeometry.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTRGeometryInst.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTSequenceSet.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTSpatial.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTText.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTTextInst.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTemporal.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTextSet.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTstzSet.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTstzSpan.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTstzSpanSet.java create mode 100644 flink-processor/tools/codegen/README.md create mode 100644 flink-processor/tools/codegen/codegen-free.py create mode 100644 flink-processor/tools/codegen/codegen-oo.py create mode 100644 flink-processor/tools/codegen/meos-ops-free-manifest.json create mode 100644 flink-processor/tools/codegen/meos-ops-manifest.json 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..b69d5a1 --- /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 Pointer bigintset_make(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 int bigintset_end_value(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 Pointer bigintset_shift_scale(Pointer arg0, int arg1, int arg2, int arg3, int 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 int bigintset_start_value(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 int bigintset_value_n(Pointer arg0, int arg1, Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bigintset_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bigintset_value_n(arg0, arg1, arg2); + } + + /** + * 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 Pointer bigintset_values(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 Pointer bigintset_in(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 String bigintset_out(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..44fc324 --- /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 Pointer bigintspan_make(int arg0, int arg1, int arg2, int 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 Pointer bigintspan_bins(Pointer arg0, int arg1, int arg2, 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 Pointer bigintspan_expand(Pointer arg0, int 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 int bigintspan_lower(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 Pointer bigintspan_shift_scale(Pointer arg0, int arg1, int arg2, int arg3, int 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 int bigintspan_upper(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 int bigintspan_width(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 Pointer bigintspan_in(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 String bigintspan_out(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..ede55b0 --- /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 Pointer bigintspanset_bins(Pointer arg0, int arg1, int arg2, 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 int bigintspanset_lower(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 Pointer bigintspanset_shift_scale(Pointer arg0, int arg1, int arg2, int arg3, int 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 int bigintspanset_upper(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 int bigintspanset_width(Pointer arg0, int 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 Pointer bigintspanset_in(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 String bigintspanset_out(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..a438f9e --- /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 Pointer cbufferset_make(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 Pointer cbufferset_end_value(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 Pointer cbufferset_start_value(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 int cbufferset_value_n(Pointer arg0, int arg1, Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbufferset_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbufferset_value_n(arg0, arg1, arg2); + } + + /** + * 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 Pointer cbufferset_values(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 Pointer cbufferset_in(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 String cbufferset_out(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..5daa468 --- /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 Pointer dateset_make(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 Pointer dateset_to_tstzset(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(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 Pointer dateset_shift_scale(Pointer arg0, int arg1, int arg2, int arg3, int 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(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 int dateset_value_n(Pointer arg0, int arg1, Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "dateset_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.dateset_value_n(arg0, arg1, arg2); + } + + /** + * 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 Pointer dateset_values(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 Pointer dateset_in(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 String dateset_out(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..c8bf3c0 --- /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 Pointer datespan_make(int arg0, int arg1, int arg2, int 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 Pointer datespan_to_tstzspan(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 Pointer datespan_bins(Pointer arg0, Pointer arg1, int arg2, 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 Pointer datespan_duration(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(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 Pointer datespan_shift_scale(Pointer arg0, int arg1, int arg2, int arg3, int 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(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 Pointer datespan_in(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 String datespan_out(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..56d1067 --- /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 Pointer datespanset_to_tstzspanset(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 Pointer datespanset_bins(Pointer arg0, Pointer arg1, int arg2, 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 int datespanset_date_n(Pointer arg0, int arg1, Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "datespanset_date_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.datespanset_date_n(arg0, arg1, arg2); + } + + /** + * 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 Pointer datespanset_dates(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 Pointer datespanset_duration(Pointer arg0, int 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(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(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 Pointer datespanset_shift_scale(Pointer arg0, int arg1, int arg2, int arg3, int 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(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 Pointer datespanset_in(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 String datespanset_out(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..59b190a --- /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 Pointer floatset_make(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 Pointer floatset_to_intset(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 Pointer floatset_ceil(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 Pointer floatset_degrees(Pointer arg0, int 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(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 Pointer floatset_floor(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 Pointer floatset_radians(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 Pointer floatset_shift_scale(Pointer arg0, double arg1, double arg2, int arg3, int 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(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 int floatset_value_n(Pointer arg0, int arg1, Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatset_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatset_value_n(arg0, arg1, arg2); + } + + /** + * 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 Pointer floatset_values(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 Pointer floatset_in(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 String floatset_out(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..c41d8ca --- /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 Pointer floatspan_make(double arg0, double arg1, int arg2, int 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 Pointer floatspan_to_intspan(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 Pointer floatspan_bins(Pointer arg0, double arg1, double arg2, 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 Pointer floatspan_ceil(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 Pointer floatspan_degrees(Pointer arg0, int 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 Pointer floatspan_expand(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 Pointer floatspan_floor(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(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 Pointer floatspan_radians(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 Pointer floatspan_round(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 Pointer floatspan_shift_scale(Pointer arg0, double arg1, double arg2, int arg3, int 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(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(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 Pointer floatspan_in(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 String floatspan_out(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..de8f76e --- /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 Pointer floatspanset_to_intspanset(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 Pointer floatspanset_bins(Pointer arg0, double arg1, double arg2, 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 Pointer floatspanset_ceil(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 Pointer floatspanset_degrees(Pointer arg0, int 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 Pointer floatspanset_floor(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(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 Pointer floatspanset_radians(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 Pointer floatspanset_round(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 Pointer floatspanset_shift_scale(Pointer arg0, double arg1, double arg2, int arg3, int 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(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(Pointer arg0, int 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 Pointer floatspanset_in(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 String floatspanset_out(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..9e554e8 --- /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(Pointer arg0, 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 Pointer cbuffer_copy(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 int cbuffer_eq(Pointer arg0, 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 int cbuffer_ge(Pointer arg0, 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 int cbuffer_gt(Pointer arg0, 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(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 int cbuffer_hash_extended(Pointer arg0, int 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 int cbuffer_le(Pointer arg0, 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 int cbuffer_lt(Pointer arg0, 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 Pointer cbuffer_make(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 int cbuffer_ne(Pointer arg0, 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 int cbuffer_nsame(Pointer arg0, 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 Pointer cbuffer_point(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(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 Pointer cbuffer_round(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 int cbuffer_same(Pointer arg0, 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(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(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 Pointer cbuffer_timestamptz_to_stbox(Pointer arg0, int 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 Pointer cbuffer_to_geom(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 Pointer cbuffer_to_set(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 Pointer cbuffer_to_stbox(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 Pointer cbuffer_transform(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 Pointer cbuffer_transform_pipeline(Pointer arg0, String arg1, int arg2, int 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 Pointer cbuffer_tstzspan_to_stbox(Pointer arg0, 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 Pointer cbuffer_union_transfn(Pointer arg0, 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 Pointer cbufferarr_round(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 Pointer cbufferarr_to_geom(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 int contained_cbuffer_set(Pointer arg0, 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(Pointer arg0, 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 int contains_set_cbuffer(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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 Pointer geom_to_cbuffer(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 Pointer intersection_set_cbuffer(Pointer arg0, 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(Pointer arg0, 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 Pointer teq_cbuffer_tcbuffer(Pointer arg0, 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 Pointer teq_tcbuffer_cbuffer(Pointer arg0, 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 Pointer tne_cbuffer_tcbuffer(Pointer arg0, 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 Pointer tne_tcbuffer_cbuffer(Pointer arg0, 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(Pointer arg0, 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 Pointer union_set_cbuffer(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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 Pointer minus_cbuffer_set(Pointer arg0, 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 Pointer minus_set_cbuffer(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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 Pointer nai_tcbuffer_cbuffer(Pointer arg0, 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 Pointer nai_tcbuffer_geo(Pointer arg0, 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 Pointer shortestline_tcbuffer_cbuffer(Pointer arg0, 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 Pointer shortestline_tcbuffer_geo(Pointer arg0, 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 Pointer tcontains_cbuffer_tcbuffer(Pointer arg0, 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 Pointer tcontains_geo_tcbuffer(Pointer arg0, 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 Pointer tcontains_tcbuffer_cbuffer(Pointer arg0, 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 Pointer tcontains_tcbuffer_geo(Pointer arg0, 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 Pointer tcovers_cbuffer_tcbuffer(Pointer arg0, 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 Pointer tcovers_geo_tcbuffer(Pointer arg0, 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 Pointer tcovers_tcbuffer_cbuffer(Pointer arg0, 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 Pointer tcovers_tcbuffer_geo(Pointer arg0, 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 Pointer tdisjoint_cbuffer_tcbuffer(Pointer arg0, 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 Pointer tdisjoint_geo_tcbuffer(Pointer arg0, 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 Pointer tdisjoint_tcbuffer_cbuffer(Pointer arg0, 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 Pointer tdisjoint_tcbuffer_geo(Pointer arg0, 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 Pointer tdistance_tcbuffer_cbuffer(Pointer arg0, 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 Pointer tdistance_tcbuffer_geo(Pointer arg0, 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 Pointer tdwithin_geo_tcbuffer(Pointer arg0, 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 Pointer tdwithin_tcbuffer_cbuffer(Pointer arg0, 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 Pointer tdwithin_tcbuffer_geo(Pointer arg0, 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 Pointer tintersects_cbuffer_tcbuffer(Pointer arg0, 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 Pointer tintersects_geo_tcbuffer(Pointer arg0, 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 Pointer tintersects_tcbuffer_cbuffer(Pointer arg0, 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 Pointer tintersects_tcbuffer_geo(Pointer arg0, 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 Pointer ttouches_cbuffer_tcbuffer(Pointer arg0, 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 Pointer ttouches_geo_tcbuffer(Pointer arg0, 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 Pointer ttouches_tcbuffer_cbuffer(Pointer arg0, 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 Pointer ttouches_tcbuffer_geo(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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 Pointer nai_tcbuffer_tcbuffer(Pointer arg0, 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 Pointer shortestline_tcbuffer_tcbuffer(Pointer arg0, 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 Pointer tcontains_tcbuffer_tcbuffer(Pointer arg0, 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 Pointer tcovers_tcbuffer_tcbuffer(Pointer arg0, 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 Pointer tdisjoint_tcbuffer_tcbuffer(Pointer arg0, 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 Pointer tdistance_tcbuffer_tcbuffer(Pointer arg0, 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 Pointer tdwithin_tcbuffer_tcbuffer(Pointer arg0, 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 Pointer tintersects_tcbuffer_tcbuffer(Pointer arg0, 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 Pointer ttouches_tcbuffer_tcbuffer(Pointer arg0, 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 String cbuffer_as_ewkt(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 String cbuffer_as_hexwkb(Pointer arg0, byte arg1, 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 String cbuffer_as_text(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 Pointer cbuffer_as_wkb(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 Pointer cbuffer_from_hexwkb(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 Pointer cbuffer_from_wkb(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 Pointer cbuffer_in(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 String cbuffer_out(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..d70fdcb --- /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 Pointer add_float_tfloat(double arg0, 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 Pointer add_int_tint(int arg0, 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 Pointer add_interval_interval(Pointer arg0, 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 Pointer add_tfloat_float(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 int add_timestamptz_interval(int arg0, 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 Pointer add_tint_int(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 Pointer add_tnumber_tnumber(Pointer arg0, 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 int adjacent_span_bigint(Pointer arg0, int 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 int adjacent_span_date(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 int adjacent_span_float(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 int adjacent_span_int(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 int adjacent_span_span(Pointer arg0, 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 int adjacent_span_spanset(Pointer arg0, 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 int adjacent_span_timestamptz(Pointer arg0, int 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 int adjacent_spanset_bigint(Pointer arg0, int 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 int adjacent_spanset_date(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 int adjacent_spanset_float(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 int adjacent_spanset_int(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 int adjacent_spanset_span(Pointer arg0, 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 int adjacent_spanset_spanset(Pointer arg0, 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 int adjacent_spanset_timestamptz(Pointer arg0, int 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 int adjacent_tbox_tbox(Pointer arg0, 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 int adjacent_tbox_tnumber(Pointer arg0, 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 int after_date_set(int arg0, 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 int after_date_span(int arg0, 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 int after_date_spanset(int arg0, 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 int after_set_date(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 int after_set_timestamptz(Pointer arg0, int 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 int after_span_date(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 int after_span_timestamptz(Pointer arg0, int 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 int after_spanset_date(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 int after_spanset_timestamptz(Pointer arg0, int 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 int after_tbox_tbox(Pointer arg0, 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 int after_tbox_tnumber(Pointer arg0, 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 int after_timestamptz_set(int arg0, 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 int after_timestamptz_span(int arg0, 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 int after_timestamptz_spanset(int arg0, 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 int before_date_set(int arg0, 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 int before_date_span(int arg0, 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 int before_date_spanset(int arg0, 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 int before_set_date(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 int before_set_timestamptz(Pointer arg0, int 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 int before_span_date(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 int before_span_timestamptz(Pointer arg0, int 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 int before_spanset_date(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 int before_spanset_timestamptz(Pointer arg0, int 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 int before_tbox_tbox(Pointer arg0, 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 int before_tbox_tnumber(Pointer arg0, 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 int before_timestamptz_set(int arg0, 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 int before_timestamptz_span(int arg0, 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 int before_timestamptz_spanset(int arg0, 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 Pointer bigint_extent_transfn(Pointer arg0, int 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 int bigint_get_bin(int arg0, int arg1, int 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 Pointer bigint_to_set(int 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 Pointer bigint_to_span(int 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 Pointer bigint_to_spanset(int 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 Pointer bigint_union_transfn(Pointer arg0, int 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 int contained_bigint_set(int arg0, 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 int contained_bigint_span(int arg0, 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 int contained_bigint_spanset(int arg0, 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 int contained_date_set(int arg0, 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 int contained_date_span(int arg0, 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 int contained_date_spanset(int arg0, 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 int contained_float_set(double arg0, 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 int contained_float_span(double arg0, 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 int contained_float_spanset(double arg0, 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 int contained_int_set(int arg0, 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 int contained_int_span(int arg0, 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 int contained_int_spanset(int arg0, 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 int contained_set_set(Pointer arg0, 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 int contained_span_span(Pointer arg0, 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 int contained_span_spanset(Pointer arg0, 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 int contained_spanset_span(Pointer arg0, 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 int contained_spanset_spanset(Pointer arg0, 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 int contained_tbox_tbox(Pointer arg0, 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 int contained_tbox_tnumber(Pointer arg0, 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 int contained_text_set(Pointer arg0, 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 int contained_timestamptz_set(int arg0, 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 int contained_timestamptz_span(int arg0, 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 int contained_timestamptz_spanset(int arg0, 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 int contains_set_bigint(Pointer arg0, int 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 int contains_set_date(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 int contains_set_float(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 int contains_set_int(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 int contains_set_set(Pointer arg0, 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 int contains_set_text(Pointer arg0, 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 int contains_set_timestamptz(Pointer arg0, int 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 int contains_span_bigint(Pointer arg0, int 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 int contains_span_date(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 int contains_span_float(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 int contains_span_int(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 int contains_span_span(Pointer arg0, 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 int contains_span_spanset(Pointer arg0, 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 int contains_span_timestamptz(Pointer arg0, int 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 int contains_spanset_bigint(Pointer arg0, int 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 int contains_spanset_date(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 int contains_spanset_float(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 int contains_spanset_int(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 int contains_spanset_span(Pointer arg0, 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 int contains_spanset_spanset(Pointer arg0, 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 int contains_spanset_timestamptz(Pointer arg0, int 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 int contains_tbox_tbox(Pointer arg0, 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 int contains_tbox_tnumber(Pointer arg0, 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 Pointer date_extent_transfn(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, 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 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 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 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 int 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 int 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 Pointer date_union_transfn(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 Pointer div_float_tfloat(double arg0, 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 Pointer div_int_tint(int arg0, 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 Pointer div_tfloat_float(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 Pointer div_tint_int(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 Pointer div_tnumber_tnumber(Pointer arg0, 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, int 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 Pointer float_extent_transfn(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 Pointer float_timestamptz_to_tbox(double arg0, int 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 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 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 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 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 Pointer float_tstzspan_to_tbox(double arg0, 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 Pointer float_union_transfn(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(int arg0, int 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 Pointer int_extent_transfn(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 Pointer int_timestamptz_to_tbox(int arg0, int 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 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 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 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 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 Pointer int_tstzspan_to_tbox(int arg0, 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 Pointer int_union_transfn(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 Pointer intersection_bigint_set(int arg0, 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 Pointer intersection_date_set(int arg0, 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 Pointer intersection_float_set(double arg0, 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 Pointer intersection_int_set(int arg0, 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 Pointer intersection_set_bigint(Pointer arg0, int 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 Pointer intersection_set_date(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 Pointer intersection_set_float(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 Pointer intersection_set_int(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 Pointer intersection_set_set(Pointer arg0, 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 Pointer intersection_set_text(Pointer arg0, 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 Pointer intersection_set_timestamptz(Pointer arg0, int 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 Pointer intersection_span_bigint(Pointer arg0, int 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 Pointer intersection_span_date(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 Pointer intersection_span_float(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 Pointer intersection_span_int(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 Pointer intersection_span_span(Pointer arg0, 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 Pointer intersection_span_spanset(Pointer arg0, 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 Pointer intersection_span_timestamptz(Pointer arg0, int 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 Pointer intersection_spanset_bigint(Pointer arg0, int 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 Pointer intersection_spanset_date(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 Pointer intersection_spanset_float(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 Pointer intersection_spanset_int(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 Pointer intersection_spanset_span(Pointer arg0, 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 Pointer intersection_spanset_spanset(Pointer arg0, 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 Pointer intersection_spanset_timestamptz(Pointer arg0, int 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 Pointer intersection_tbox_tbox(Pointer arg0, 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 Pointer intersection_text_set(Pointer arg0, 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 Pointer intersection_timestamptz_set(int arg0, 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 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 int left_bigint_set(int arg0, 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 int left_bigint_span(int arg0, 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 int left_bigint_spanset(int arg0, 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 int left_float_set(double arg0, 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 int left_float_span(double arg0, 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 int left_float_spanset(double arg0, 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 int left_int_set(int arg0, 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 int left_int_span(int arg0, 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 int left_int_spanset(int arg0, 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 int left_set_bigint(Pointer arg0, int 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 int left_set_float(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 int left_set_int(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 int left_set_set(Pointer arg0, 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 int left_set_text(Pointer arg0, 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 int left_span_bigint(Pointer arg0, int 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 int left_span_float(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 int left_span_int(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 int left_span_span(Pointer arg0, 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 int left_span_spanset(Pointer arg0, 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 int left_spanset_bigint(Pointer arg0, int 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 int left_spanset_float(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 int left_spanset_int(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 int left_spanset_span(Pointer arg0, 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 int left_spanset_spanset(Pointer arg0, 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 int left_tbox_tbox(Pointer arg0, 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 int left_tbox_tnumber(Pointer arg0, 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 int left_text_set(Pointer arg0, 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 Pointer mul_interval_double(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 Pointer numspan_timestamptz_to_tbox(Pointer arg0, int 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 Pointer numspan_tstzspan_to_tbox(Pointer arg0, 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 int overafter_date_set(int arg0, 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 int overafter_date_span(int arg0, 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 int overafter_date_spanset(int arg0, 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 int overafter_set_date(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 int overafter_set_timestamptz(Pointer arg0, int 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 int overafter_span_date(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 int overafter_span_timestamptz(Pointer arg0, int 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 int overafter_spanset_date(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 int overafter_spanset_timestamptz(Pointer arg0, int 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 int overafter_tbox_tbox(Pointer arg0, 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 int overafter_tbox_tnumber(Pointer arg0, 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 int overafter_timestamptz_set(int arg0, 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 int overafter_timestamptz_span(int arg0, 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 int overafter_timestamptz_spanset(int arg0, 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 int overbefore_date_set(int arg0, 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 int overbefore_date_span(int arg0, 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 int overbefore_date_spanset(int arg0, 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 int overbefore_set_date(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 int overbefore_set_timestamptz(Pointer arg0, int 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 int overbefore_span_date(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 int overbefore_span_timestamptz(Pointer arg0, int 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 int overbefore_spanset_date(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 int overbefore_spanset_timestamptz(Pointer arg0, int 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 int overbefore_tbox_tbox(Pointer arg0, 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 int overbefore_tbox_tnumber(Pointer arg0, 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 int overbefore_timestamptz_set(int arg0, 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 int overbefore_timestamptz_span(int arg0, 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 int overbefore_timestamptz_spanset(int arg0, 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 int overlaps_set_set(Pointer arg0, 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 int overlaps_span_span(Pointer arg0, 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 int overlaps_span_spanset(Pointer arg0, 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 int overlaps_spanset_span(Pointer arg0, 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 int overlaps_spanset_spanset(Pointer arg0, 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 int overlaps_tbox_tbox(Pointer arg0, 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 int overlaps_tbox_tnumber(Pointer arg0, 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 int overleft_bigint_set(int arg0, 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 int overleft_bigint_span(int arg0, 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 int overleft_bigint_spanset(int arg0, 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 int overleft_float_set(double arg0, 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 int overleft_float_span(double arg0, 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 int overleft_float_spanset(double arg0, 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 int overleft_int_set(int arg0, 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 int overleft_int_span(int arg0, 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 int overleft_int_spanset(int arg0, 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 int overleft_set_bigint(Pointer arg0, int 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 int overleft_set_float(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 int overleft_set_int(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 int overleft_set_set(Pointer arg0, 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 int overleft_set_text(Pointer arg0, 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 int overleft_span_bigint(Pointer arg0, int 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 int overleft_span_float(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 int overleft_span_int(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 int overleft_span_span(Pointer arg0, 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 int overleft_span_spanset(Pointer arg0, 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 int overleft_spanset_bigint(Pointer arg0, int 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 int overleft_spanset_float(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 int overleft_spanset_int(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 int overleft_spanset_span(Pointer arg0, 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 int overleft_spanset_spanset(Pointer arg0, 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 int overleft_tbox_tbox(Pointer arg0, 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 int overleft_tbox_tnumber(Pointer arg0, 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 int overleft_text_set(Pointer arg0, 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 int overright_bigint_set(int arg0, 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 int overright_bigint_span(int arg0, 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 int overright_bigint_spanset(int arg0, 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 int overright_float_set(double arg0, 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 int overright_float_span(double arg0, 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 int overright_float_spanset(double arg0, 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 int overright_int_set(int arg0, 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 int overright_int_span(int arg0, 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 int overright_int_spanset(int arg0, 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 int overright_set_bigint(Pointer arg0, int 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 int overright_set_float(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 int overright_set_int(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 int overright_set_set(Pointer arg0, 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 int overright_set_text(Pointer arg0, 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 int overright_span_bigint(Pointer arg0, int 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 int overright_span_float(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 int overright_span_int(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 int overright_span_span(Pointer arg0, 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 int overright_span_spanset(Pointer arg0, 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 int overright_spanset_bigint(Pointer arg0, int 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 int overright_spanset_float(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 int overright_spanset_int(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 int overright_spanset_span(Pointer arg0, 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 int overright_spanset_spanset(Pointer arg0, 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 int overright_tbox_tbox(Pointer arg0, 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 int overright_tbox_tnumber(Pointer arg0, 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 int overright_text_set(Pointer arg0, 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 int right_bigint_set(int arg0, 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 int right_bigint_span(int arg0, 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 int right_bigint_spanset(int arg0, 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 int right_float_set(double arg0, 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 int right_float_span(double arg0, 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 int right_float_spanset(double arg0, 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 int right_int_set(int arg0, 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 int right_int_span(int arg0, 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 int right_int_spanset(int arg0, 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 int right_set_bigint(Pointer arg0, int 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 int right_set_float(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 int right_set_int(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 int right_set_set(Pointer arg0, 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 int right_set_text(Pointer arg0, 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 int right_span_bigint(Pointer arg0, int 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 int right_span_float(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 int right_span_int(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 int right_span_span(Pointer arg0, 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 int right_span_spanset(Pointer arg0, 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 int right_spanset_bigint(Pointer arg0, int 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 int right_spanset_float(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 int right_spanset_int(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 int right_spanset_span(Pointer arg0, 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 int right_spanset_spanset(Pointer arg0, 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 int right_tbox_tbox(Pointer arg0, 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 int right_tbox_tnumber(Pointer arg0, 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 int right_text_set(Pointer arg0, 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 int same_numspan_tnumber(Pointer arg0, 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 int same_tbox_tbox(Pointer arg0, 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 int same_tbox_tnumber(Pointer arg0, 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 int same_temporal_tstzspan(Pointer arg0, 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 int same_tnumber_numspan(Pointer arg0, 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 int same_tnumber_tbox(Pointer arg0, 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 int same_tstzspan_temporal(Pointer arg0, 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 Pointer sub_float_tfloat(double arg0, 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 Pointer sub_int_tint(int arg0, 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 Pointer sub_tfloat_float(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 Pointer sub_tint_int(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 Pointer sub_tnumber_tnumber(Pointer arg0, 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 int tboxfloat_xmax(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tboxfloat_xmax requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tboxfloat_xmax(arg0, arg1); + } + + /** + * 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 int tboxfloat_xmin(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tboxfloat_xmin requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tboxfloat_xmin(arg0, arg1); + } + + /** + * 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 int tboxint_xmax(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tboxint_xmax requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tboxint_xmax(arg0, arg1); + } + + /** + * 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 int tboxint_xmin(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tboxint_xmin requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tboxint_xmin(arg0, arg1); + } + + /** + * 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 Pointer temparr_round(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 Pointer teq_bool_tbool(int arg0, 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 Pointer teq_float_tfloat(double arg0, 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 Pointer teq_int_tint(int arg0, 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 Pointer teq_tbool_bool(Pointer arg0, int 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 Pointer teq_temporal_temporal(Pointer arg0, 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 Pointer teq_text_ttext(Pointer arg0, 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 Pointer teq_tfloat_float(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 Pointer teq_tint_int(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 Pointer teq_ttext_text(Pointer arg0, 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(Pointer arg0, 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 Pointer text_copy(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 Pointer text_initcap(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 Pointer text_lower(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 Pointer text_to_set(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 Pointer text_union_transfn(Pointer arg0, 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 Pointer text_upper(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 Pointer textcat_text_text(Pointer arg0, 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 Pointer textcat_text_textset(Pointer arg0, 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 Pointer textcat_text_ttext(Pointer arg0, 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 Pointer textcat_textset_text(Pointer arg0, 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 Pointer textcat_ttext_text(Pointer arg0, 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 Pointer textcat_ttext_ttext(Pointer arg0, 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 Pointer tfloatbox_expand(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 Pointer tfloatbox_shift_scale(Pointer arg0, double arg1, double arg2, int arg3, int 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 Pointer tge_float_tfloat(double arg0, 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 Pointer tge_int_tint(int arg0, 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 Pointer tge_temporal_temporal(Pointer arg0, 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 Pointer tge_text_ttext(Pointer arg0, 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 Pointer tge_tfloat_float(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 Pointer tge_tint_int(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 Pointer tge_ttext_text(Pointer arg0, 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 Pointer tgt_float_tfloat(double arg0, 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 Pointer tgt_int_tint(int arg0, 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 Pointer tgt_temporal_temporal(Pointer arg0, 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 Pointer tgt_text_ttext(Pointer arg0, 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 Pointer tgt_tfloat_float(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 Pointer tgt_tint_int(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 Pointer tgt_ttext_text(Pointer arg0, 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(int 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 Pointer timestamptz_extent_transfn(Pointer arg0, int 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 int timestamptz_get_bin(int arg0, Pointer arg1, int 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 int timestamptz_shift(int arg0, 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 Pointer timestamptz_tcount_transfn(Pointer arg0, int 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(int 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 Pointer timestamptz_to_set(int 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 Pointer timestamptz_to_span(int 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 Pointer timestamptz_to_spanset(int 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 Pointer timestamptz_to_tbox(int 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 int timestamptz_tprecision(int arg0, Pointer arg1, int 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 Pointer timestamptz_union_transfn(Pointer arg0, int 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 Pointer tintbox_expand(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 Pointer tintbox_shift_scale(Pointer arg0, int arg1, int arg2, int arg3, int 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 Pointer tle_float_tfloat(double arg0, 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 Pointer tle_int_tint(int arg0, 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 Pointer tle_temporal_temporal(Pointer arg0, 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 Pointer tle_text_ttext(Pointer arg0, 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 Pointer tle_tfloat_float(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 Pointer tle_tint_int(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 Pointer tle_ttext_text(Pointer arg0, 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 Pointer tlt_float_tfloat(double arg0, 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 Pointer tlt_int_tint(int arg0, 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 Pointer tlt_temporal_temporal(Pointer arg0, 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 Pointer tlt_text_ttext(Pointer arg0, 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 Pointer tlt_tfloat_float(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 Pointer tlt_tint_int(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 Pointer tlt_ttext_text(Pointer arg0, 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 Pointer tne_bool_tbool(int arg0, 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 Pointer tne_float_tfloat(double arg0, 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 Pointer tne_int_tint(int arg0, 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 Pointer tne_tbool_bool(Pointer arg0, int 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 Pointer tne_temporal_temporal(Pointer arg0, 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 Pointer tne_text_ttext(Pointer arg0, 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 Pointer tne_tfloat_float(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 Pointer tne_tint_int(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 Pointer tne_ttext_text(Pointer arg0, 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 Pointer union_bigint_set(int arg0, 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 Pointer union_bigint_span(Pointer arg0, int 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 Pointer union_bigint_spanset(int arg0, 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 Pointer union_date_set(int arg0, 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 Pointer union_date_span(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 Pointer union_date_spanset(int arg0, 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 Pointer union_float_set(double arg0, 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 Pointer union_float_span(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 Pointer union_float_spanset(double arg0, 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 Pointer union_int_set(int arg0, 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 Pointer union_int_span(int arg0, 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 Pointer union_int_spanset(int arg0, 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 Pointer union_set_bigint(Pointer arg0, int 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 Pointer union_set_date(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 Pointer union_set_float(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 Pointer union_set_int(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 Pointer union_set_set(Pointer arg0, 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 Pointer union_set_text(Pointer arg0, 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 Pointer union_set_timestamptz(Pointer arg0, int 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 Pointer union_span_bigint(Pointer arg0, int 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 Pointer union_span_date(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 Pointer union_span_float(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 Pointer union_span_int(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 Pointer union_span_span(Pointer arg0, 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 Pointer union_span_spanset(Pointer arg0, 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 Pointer union_span_timestamptz(Pointer arg0, int 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 Pointer union_spanset_bigint(Pointer arg0, int 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 Pointer union_spanset_date(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 Pointer union_spanset_float(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 Pointer union_spanset_int(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 Pointer union_spanset_span(Pointer arg0, 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 Pointer union_spanset_spanset(Pointer arg0, 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 Pointer union_spanset_timestamptz(Pointer arg0, int 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 Pointer union_tbox_tbox(Pointer arg0, Pointer arg1, int 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 Pointer union_text_set(Pointer arg0, 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 Pointer union_timestamptz_set(int arg0, 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 Pointer union_timestamptz_span(int arg0, 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 Pointer union_timestamptz_spanset(int arg0, 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 int adjacent_numspan_tnumber(Pointer arg0, 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 int adjacent_temporal_tstzspan(Pointer arg0, 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 int adjacent_tnumber_numspan(Pointer arg0, 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 int adjacent_tnumber_tbox(Pointer arg0, 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 int adjacent_tstzspan_temporal(Pointer arg0, 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 int after_temporal_tstzspan(Pointer arg0, 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 int after_tnumber_tbox(Pointer arg0, 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 int after_tstzspan_temporal(Pointer arg0, 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 int before_temporal_tstzspan(Pointer arg0, 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 int before_tnumber_tbox(Pointer arg0, 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 int before_tstzspan_temporal(Pointer arg0, 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 int contained_numspan_tnumber(Pointer arg0, 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 int contained_temporal_tstzspan(Pointer arg0, 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 int contained_tnumber_numspan(Pointer arg0, 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 int contained_tnumber_tbox(Pointer arg0, 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 int contained_tstzspan_temporal(Pointer arg0, 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 int contains_numspan_tnumber(Pointer arg0, 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 int contains_temporal_tstzspan(Pointer arg0, 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 int contains_tnumber_numspan(Pointer arg0, 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 int contains_tnumber_tbox(Pointer arg0, 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 int contains_tstzspan_temporal(Pointer arg0, 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 int distance_bigintset_bigintset(Pointer arg0, 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 int distance_bigintspan_bigintspan(Pointer arg0, 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 int distance_bigintspanset_bigintspan(Pointer arg0, 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 int distance_bigintspanset_bigintspanset(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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 int distance_set_bigint(Pointer arg0, int 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(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(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(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(Pointer arg0, int 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 int distance_span_bigint(Pointer arg0, int 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(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(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(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(Pointer arg0, int 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 int distance_spanset_bigint(Pointer arg0, int 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(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(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(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(Pointer arg0, int 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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 int left_numspan_tnumber(Pointer arg0, 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 int left_tnumber_numspan(Pointer arg0, 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 int left_tnumber_tbox(Pointer arg0, 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 Pointer minus_bigint_set(int arg0, 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 Pointer minus_bigint_span(int arg0, 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 Pointer minus_bigint_spanset(int arg0, 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 Pointer minus_date_set(int arg0, 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 Pointer minus_date_span(int arg0, 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 Pointer minus_date_spanset(int arg0, 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 Pointer minus_float_set(double arg0, 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 Pointer minus_float_span(double arg0, 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 Pointer minus_float_spanset(double arg0, 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 Pointer minus_int_set(int arg0, 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 Pointer minus_int_span(int arg0, 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 Pointer minus_int_spanset(int arg0, 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 Pointer minus_set_bigint(Pointer arg0, int 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 Pointer minus_set_date(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 Pointer minus_set_float(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 Pointer minus_set_int(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 Pointer minus_set_set(Pointer arg0, 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 Pointer minus_set_text(Pointer arg0, 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 Pointer minus_set_timestamptz(Pointer arg0, int 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 Pointer minus_span_bigint(Pointer arg0, int 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 Pointer minus_span_date(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 Pointer minus_span_float(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 Pointer minus_span_int(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 Pointer minus_span_span(Pointer arg0, 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 Pointer minus_span_spanset(Pointer arg0, 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 Pointer minus_span_timestamptz(Pointer arg0, int 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 Pointer minus_spanset_bigint(Pointer arg0, int 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 Pointer minus_spanset_date(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 Pointer minus_spanset_float(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 Pointer minus_spanset_int(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 Pointer minus_spanset_span(Pointer arg0, 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 Pointer minus_spanset_spanset(Pointer arg0, 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 Pointer minus_spanset_timestamptz(Pointer arg0, int 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 Pointer minus_text_set(Pointer arg0, 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 int minus_timestamptz_interval(int arg0, 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 Pointer minus_timestamptz_set(int arg0, 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 Pointer minus_timestamptz_span(int arg0, 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 Pointer minus_timestamptz_spanset(int arg0, 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 Pointer minus_timestamptz_timestamptz(int arg0, int 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(Pointer arg0, 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(Pointer arg0, 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(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(Pointer arg0, 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(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(Pointer arg0, 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 int overafter_temporal_tstzspan(Pointer arg0, 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 int overafter_tnumber_tbox(Pointer arg0, 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 int overafter_tstzspan_temporal(Pointer arg0, 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 int overbefore_temporal_tstzspan(Pointer arg0, 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 int overbefore_tnumber_tbox(Pointer arg0, 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 int overbefore_tstzspan_temporal(Pointer arg0, 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 int overlaps_numspan_tnumber(Pointer arg0, 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 int overlaps_temporal_tstzspan(Pointer arg0, 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 int overlaps_tnumber_numspan(Pointer arg0, 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 int overlaps_tnumber_tbox(Pointer arg0, 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 int overlaps_tstzspan_temporal(Pointer arg0, 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 int overleft_numspan_tnumber(Pointer arg0, 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 int overleft_tnumber_numspan(Pointer arg0, 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 int overleft_tnumber_tbox(Pointer arg0, 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 int overright_numspan_tnumber(Pointer arg0, 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 int overright_tnumber_numspan(Pointer arg0, 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 int overright_tnumber_tbox(Pointer arg0, 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 int right_numspan_tnumber(Pointer arg0, 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 int right_tnumber_numspan(Pointer arg0, 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 int right_tnumber_tbox(Pointer arg0, 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 Pointer tdistance_tfloat_float(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 Pointer tdistance_tint_int(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(int arg0, 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, 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, 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(Pointer arg0, int 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(Pointer arg0, 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(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(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(Pointer arg0, 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, 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, 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(Pointer arg0, 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(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(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(Pointer arg0, 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, 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, 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(Pointer arg0, 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(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(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(Pointer arg0, 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, 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, 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(Pointer arg0, 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(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(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(Pointer arg0, 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, 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, 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(Pointer arg0, 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(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(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(Pointer arg0, 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(int arg0, 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, 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, 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(Pointer arg0, int 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(Pointer arg0, 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(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(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(Pointer arg0, 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(int arg0, 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, 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, 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(Pointer arg0, int 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(Pointer arg0, 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(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(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(Pointer arg0, 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, 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, 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(Pointer arg0, 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(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(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(Pointer arg0, 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, 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, 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(Pointer arg0, 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(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(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(Pointer arg0, 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, 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, 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(Pointer arg0, 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(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(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(Pointer arg0, 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, 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, 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(Pointer arg0, 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(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(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(Pointer arg0, 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(int arg0, 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, 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, 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(Pointer arg0, int 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(Pointer arg0, 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(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(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(Pointer arg0, 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 int adjacent_temporal_temporal(Pointer arg0, 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 int adjacent_tnumber_tnumber(Pointer arg0, 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 int after_temporal_temporal(Pointer arg0, 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 int after_tnumber_tnumber(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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 int before_temporal_temporal(Pointer arg0, 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 int before_tnumber_tnumber(Pointer arg0, 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 int contained_temporal_temporal(Pointer arg0, 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 int contained_tnumber_tnumber(Pointer arg0, 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 int contains_temporal_temporal(Pointer arg0, 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 int contains_tnumber_tnumber(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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 int left_tnumber_tnumber(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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 int overafter_temporal_temporal(Pointer arg0, 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 int overafter_tnumber_tnumber(Pointer arg0, 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 int overbefore_temporal_temporal(Pointer arg0, 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 int overbefore_tnumber_tnumber(Pointer arg0, 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 int overlaps_temporal_temporal(Pointer arg0, 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 int overlaps_tnumber_tnumber(Pointer arg0, 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 int overleft_tnumber_tnumber(Pointer arg0, 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 int overright_tnumber_tnumber(Pointer arg0, 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 int right_tnumber_tnumber(Pointer arg0, 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 int same_temporal_temporal(Pointer arg0, 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 int same_tnumber_tnumber(Pointer arg0, 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 Pointer tdistance_tnumber_tnumber(Pointer arg0, 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 int bool_in(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 String bool_out(int 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 Pointer cstring2text(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 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(Pointer arg0, 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(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 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(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(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 Pointer meos_array_get(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(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(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, 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 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 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(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(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 int meos_set_datestyle(String arg0, 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 int meos_set_intervalstyle(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(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(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 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(Pointer arg0, 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 Pointer pg_interval_in(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 String pg_interval_out(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 int pg_timestamp_in(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 String pg_timestamp_out(int 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 int pg_timestamptz_in(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 String pg_timestamptz_out(int 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 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 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 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 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 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 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 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(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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, int arg1, Pointer arg2, 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(Pointer arg0, int arg1, Pointer arg2, 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 String text2cstring(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 Pointer text_in(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 String text_out(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..1ffdba8 --- /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 int above_stbox_stbox(Pointer arg0, 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 int above_stbox_tspatial(Pointer arg0, 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 int adjacent_stbox_stbox(Pointer arg0, 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 int adjacent_stbox_tspatial(Pointer arg0, 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 int after_stbox_stbox(Pointer arg0, 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 int after_stbox_tspatial(Pointer arg0, 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 int back_stbox_stbox(Pointer arg0, 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 int back_stbox_tspatial(Pointer arg0, 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 int bearing_point_point(Pointer arg0, Pointer arg1, Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bearing_point_point requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bearing_point_point(arg0, arg1, arg2); + } + + /** + * 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 int before_stbox_stbox(Pointer arg0, 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 int before_stbox_tspatial(Pointer arg0, 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 int below_stbox_stbox(Pointer arg0, 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 int below_stbox_tspatial(Pointer arg0, 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 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 Pointer box3d_to_stbox(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 int contained_geo_set(Pointer arg0, 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 int contained_stbox_stbox(Pointer arg0, 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 int contained_stbox_tspatial(Pointer arg0, 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 int contains_set_geo(Pointer arg0, 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 int contains_stbox_stbox(Pointer arg0, 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 int contains_stbox_tspatial(Pointer arg0, 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 int front_stbox_stbox(Pointer arg0, 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 int front_stbox_tspatial(Pointer arg0, 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 Pointer gbox_make(int 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 Pointer gbox_to_stbox(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 Pointer geo_cluster_dbscan(Pointer arg0, int arg1, double arg2, int arg3, 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 Pointer geo_cluster_intersecting(Pointer arg0, int arg1, 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 Pointer geo_cluster_kmeans(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 Pointer geo_cluster_within(Pointer arg0, int arg1, double arg2, 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 Pointer geo_collect_garray(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 Pointer geo_copy(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(Pointer arg0, 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 Pointer geo_geo_n(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 int geo_is_empty(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 int geo_is_unitary(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 Pointer geo_makeline_garray(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(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(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 Pointer geo_pointarr(Pointer arg0, 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 Pointer geo_points(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 Pointer geo_reverse(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 Pointer geo_round(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 int geo_same(Pointer arg0, 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 Pointer geo_set_srid(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 Pointer geo_split_each_n_stboxes(Pointer arg0, int arg1, 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 Pointer geo_split_n_stboxes(Pointer arg0, int arg1, 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(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 Pointer geo_stboxes(Pointer arg0, 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 Pointer geo_timestamptz_to_stbox(Pointer arg0, int 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 Pointer geo_to_set(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 Pointer geo_to_stbox(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 Pointer geo_transform(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 Pointer geo_transform_pipeline(Pointer arg0, String arg1, int arg2, int 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 Pointer geo_tstzspan_to_stbox(Pointer arg0, 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 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 Pointer geo_union_transfn(Pointer arg0, 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(Pointer arg0, int 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 Pointer geog_centroid(Pointer arg0, int 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(Pointer arg0, 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 int geog_dwithin(Pointer arg0, Pointer arg1, double arg2, int 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 Pointer geog_from_binary(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 int geog_intersects(Pointer arg0, Pointer arg1, int 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(Pointer arg0, int 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(Pointer arg0, int 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 Pointer geog_to_geom(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 Pointer geom_array_union(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 int geom_azimuth(Pointer arg0, Pointer arg1, Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geom_azimuth requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geom_azimuth(arg0, arg1, arg2); + } + + /** + * 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 Pointer geom_boundary(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 Pointer geom_buffer(Pointer arg0, double arg1, 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 Pointer geom_centroid(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 int geom_contains(Pointer arg0, 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 Pointer geom_convex_hull(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 int geom_covers(Pointer arg0, 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 Pointer geom_difference2d(Pointer arg0, 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 int geom_disjoint2d(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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 int geom_dwithin2d(Pointer arg0, 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 int geom_dwithin3d(Pointer arg0, 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 Pointer geom_intersection2d(Pointer arg0, 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 Pointer geom_intersection2d_coll(Pointer arg0, 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 int geom_intersects2d(Pointer arg0, 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 int geom_intersects3d(Pointer arg0, 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(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 Pointer geom_min_bounding_radius(Pointer arg0, 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(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 int geom_relate_pattern(Pointer arg0, Pointer arg1, 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 Pointer geom_shortestline2d(Pointer arg0, 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 Pointer geom_shortestline3d(Pointer arg0, 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 Pointer geom_to_geog(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 int geom_touches(Pointer arg0, 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 Pointer geom_unary_union(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 Pointer intersection_geo_set(Pointer arg0, 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 Pointer intersection_set_geo(Pointer arg0, 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 Pointer intersection_stbox_stbox(Pointer arg0, 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 int left_stbox_stbox(Pointer arg0, 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 int left_stbox_tspatial(Pointer arg0, 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(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 int overabove_stbox_stbox(Pointer arg0, 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 int overabove_stbox_tspatial(Pointer arg0, 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 int overafter_stbox_stbox(Pointer arg0, 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 int overafter_stbox_tspatial(Pointer arg0, 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 int overback_stbox_stbox(Pointer arg0, 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 int overback_stbox_tspatial(Pointer arg0, 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 int overbefore_stbox_stbox(Pointer arg0, 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 int overbefore_stbox_tspatial(Pointer arg0, 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 int overbelow_stbox_stbox(Pointer arg0, 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 int overbelow_stbox_tspatial(Pointer arg0, 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 int overfront_stbox_stbox(Pointer arg0, 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 int overfront_stbox_tspatial(Pointer arg0, 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 int overlaps_stbox_stbox(Pointer arg0, 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 int overlaps_stbox_tspatial(Pointer arg0, 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 int overleft_stbox_stbox(Pointer arg0, 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 int overleft_stbox_tspatial(Pointer arg0, 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 int overright_stbox_stbox(Pointer arg0, 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 int overright_stbox_tspatial(Pointer arg0, 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 int right_stbox_stbox(Pointer arg0, 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 int right_stbox_tspatial(Pointer arg0, 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 int same_stbox_stbox(Pointer arg0, 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 int same_stbox_tspatial(Pointer arg0, 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 int same_tspatial_stbox(Pointer arg0, 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(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 Pointer spatialset_to_stbox(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 Pointer stboxarr_round(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 Pointer teq_geo_tgeo(Pointer arg0, 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 Pointer teq_tgeo_geo(Pointer arg0, 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 Pointer tgeoinst_make(Pointer arg0, int 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 Pointer timestamptz_to_stbox(int 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 Pointer tne_geo_tgeo(Pointer arg0, 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 Pointer tne_tgeo_geo(Pointer arg0, 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 Pointer tpointinst_make(Pointer arg0, int 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 Pointer union_geo_set(Pointer arg0, 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 Pointer union_set_geo(Pointer arg0, 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 Pointer union_stbox_stbox(Pointer arg0, Pointer arg1, int 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 int above_tspatial_stbox(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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 int adjacent_tspatial_stbox(Pointer arg0, 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(Pointer arg0, 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 int after_tspatial_stbox(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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 int back_tspatial_stbox(Pointer arg0, 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 int before_tspatial_stbox(Pointer arg0, 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 int below_tspatial_stbox(Pointer arg0, 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 int contained_tspatial_stbox(Pointer arg0, 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 int contains_tspatial_stbox(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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 int front_tspatial_stbox(Pointer arg0, 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 int left_tspatial_stbox(Pointer arg0, 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 Pointer minus_geo_set(Pointer arg0, 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 Pointer minus_set_geo(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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 Pointer nai_tgeo_geo(Pointer arg0, 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 int overabove_tspatial_stbox(Pointer arg0, 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 int overafter_tspatial_stbox(Pointer arg0, 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 int overback_tspatial_stbox(Pointer arg0, 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 int overbefore_tspatial_stbox(Pointer arg0, 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 int overbelow_tspatial_stbox(Pointer arg0, 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 int overfront_tspatial_stbox(Pointer arg0, 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 int overlaps_tspatial_stbox(Pointer arg0, 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 int overleft_tspatial_stbox(Pointer arg0, 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 int overright_tspatial_stbox(Pointer arg0, 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 int right_tspatial_stbox(Pointer arg0, 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 Pointer shortestline_tgeo_geo(Pointer arg0, 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 Pointer tcontains_geo_tgeo(Pointer arg0, 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 Pointer tcontains_tgeo_geo(Pointer arg0, 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 Pointer tcovers_geo_tgeo(Pointer arg0, 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 Pointer tcovers_tgeo_geo(Pointer arg0, 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 Pointer tdisjoint_geo_tgeo(Pointer arg0, 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 Pointer tdisjoint_tgeo_geo(Pointer arg0, 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 Pointer tdistance_tgeo_geo(Pointer arg0, 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 Pointer tdwithin_geo_tgeo(Pointer arg0, 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 Pointer tdwithin_tgeo_geo(Pointer arg0, 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 Pointer tintersects_geo_tgeo(Pointer arg0, 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 Pointer tintersects_tgeo_geo(Pointer arg0, 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 Pointer ttouches_geo_tgeo(Pointer arg0, 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 Pointer ttouches_tgeo_geo(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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 int above_tspatial_tspatial(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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 int adjacent_tspatial_tspatial(Pointer arg0, 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(Pointer arg0, 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 int after_tspatial_tspatial(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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 int back_tspatial_tspatial(Pointer arg0, 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 int before_tspatial_tspatial(Pointer arg0, 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 int below_tspatial_tspatial(Pointer arg0, 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 int contained_tspatial_tspatial(Pointer arg0, 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 int contains_tspatial_tspatial(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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 int front_tspatial_tspatial(Pointer arg0, 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 int left_tspatial_tspatial(Pointer arg0, 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(Pointer arg0, 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 Pointer nai_tgeo_tgeo(Pointer arg0, 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 int overabove_tspatial_tspatial(Pointer arg0, 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 int overafter_tspatial_tspatial(Pointer arg0, 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 int overback_tspatial_tspatial(Pointer arg0, 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 int overbefore_tspatial_tspatial(Pointer arg0, 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 int overbelow_tspatial_tspatial(Pointer arg0, 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 int overfront_tspatial_tspatial(Pointer arg0, 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 int overlaps_tspatial_tspatial(Pointer arg0, 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 int overleft_tspatial_tspatial(Pointer arg0, 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 int overright_tspatial_tspatial(Pointer arg0, 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 int right_tspatial_tspatial(Pointer arg0, 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 int same_tspatial_tspatial(Pointer arg0, 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 Pointer shortestline_tgeo_tgeo(Pointer arg0, 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 Pointer tcontains_tgeo_tgeo(Pointer arg0, 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 Pointer tcovers_tgeo_tgeo(Pointer arg0, 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 Pointer tdisjoint_tgeo_tgeo(Pointer arg0, 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 Pointer tdistance_tgeo_tgeo(Pointer arg0, 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 Pointer tdwithin_tgeo_tgeo(Pointer arg0, 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 Pointer tintersects_tgeo_tgeo(Pointer arg0, 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 Pointer ttouches_tgeo_tgeo(Pointer arg0, 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 String box3d_out(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 String gbox_out(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 Pointer geo_as_ewkb(Pointer arg0, String arg1, 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 String geo_as_ewkt(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 String geo_as_geojson(Pointer arg0, int arg1, int arg2, 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 String geo_as_hexewkb(Pointer arg0, 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 String geo_as_text(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 Pointer geo_from_ewkb(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 Pointer geo_from_geojson(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 Pointer geo_from_text(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 String geo_out(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 Pointer geog_from_hexewkb(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 Pointer geog_in(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 Pointer geom_from_hexewkb(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 Pointer geom_in(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 String spatialset_as_ewkt(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 String spatialset_as_text(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/MeosOpsFreeNpoint.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsFreeNpoint.java new file mode 100644 index 0000000..735b32f --- /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 int contained_npoint_set(Pointer arg0, 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 int contains_set_npoint(Pointer arg0, 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 Pointer geom_to_nsegment(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 Pointer intersection_set_npoint(Pointer arg0, 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(Pointer arg0, 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 int npoint_eq(Pointer arg0, 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 int npoint_ge(Pointer arg0, 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 int npoint_gt(Pointer arg0, 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(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 int npoint_hash_extended(Pointer arg0, int 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 int npoint_le(Pointer arg0, 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 int npoint_lt(Pointer arg0, 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 Pointer npoint_make(int 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 int npoint_ne(Pointer arg0, 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(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 Pointer npoint_round(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 int npoint_route(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 int npoint_same(Pointer arg0, 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(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 Pointer npoint_timestamptz_to_stbox(Pointer arg0, int 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 Pointer npoint_to_geompoint(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 Pointer npoint_to_nsegment(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 Pointer npoint_to_set(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 Pointer npoint_to_stbox(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 Pointer npoint_tstzspan_to_stbox(Pointer arg0, 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 Pointer npoint_union_transfn(Pointer arg0, 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(Pointer arg0, 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 int nsegment_eq(Pointer arg0, 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 int nsegment_ge(Pointer arg0, 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 int nsegment_gt(Pointer arg0, 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 int nsegment_le(Pointer arg0, 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 int nsegment_lt(Pointer arg0, 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 Pointer nsegment_make(int 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 int nsegment_ne(Pointer arg0, 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 Pointer nsegment_round(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 int nsegment_route(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(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 Pointer nsegment_to_geom(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 Pointer nsegment_to_stbox(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 int route_exists(int 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 Pointer teq_tnpoint_npoint(Pointer arg0, 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 Pointer tne_tnpoint_npoint(Pointer arg0, 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 Pointer union_set_npoint(Pointer arg0, 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 Pointer minus_npoint_set(Pointer arg0, 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 Pointer minus_set_npoint(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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 Pointer nai_tnpoint_geo(Pointer arg0, 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 Pointer nai_tnpoint_npoint(Pointer arg0, 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 Pointer shortestline_tnpoint_geo(Pointer arg0, 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 Pointer shortestline_tnpoint_npoint(Pointer arg0, 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 Pointer tdistance_tnpoint_npoint(Pointer arg0, 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 Pointer tdistance_tnpoint_point(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(int 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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 Pointer nai_tnpoint_tnpoint(Pointer arg0, 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 Pointer shortestline_tnpoint_tnpoint(Pointer arg0, 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 Pointer tdistance_tnpoint_tnpoint(Pointer arg0, 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 String npoint_as_ewkt(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 String npoint_as_hexwkb(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 String npoint_as_text(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 Pointer npoint_as_wkb(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 Pointer npoint_from_hexwkb(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 Pointer npoint_from_wkb(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 Pointer npoint_in(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 String npoint_out(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 Pointer nsegment_in(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 String nsegment_out(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..5d6c0ff --- /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 int contained_pose_set(Pointer arg0, 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 int contains_set_pose(Pointer arg0, 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 Pointer intersection_set_pose(Pointer arg0, 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(Pointer arg0, 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 Pointer pose_copy(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 int pose_eq(Pointer arg0, 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 int pose_ge(Pointer arg0, 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 int pose_gt(Pointer arg0, 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(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 int pose_hash_extended(Pointer arg0, int 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 int pose_le(Pointer arg0, 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 int pose_lt(Pointer arg0, 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 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 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 Pointer pose_make_point2d(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 Pointer pose_make_point3d(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 int pose_ne(Pointer arg0, 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 int pose_nsame(Pointer arg0, 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 Pointer pose_orientation(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(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 Pointer pose_round(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 int pose_same(Pointer arg0, 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(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(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 Pointer pose_timestamptz_to_stbox(Pointer arg0, int 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 Pointer pose_to_point(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 Pointer pose_to_set(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 Pointer pose_to_stbox(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 Pointer pose_transform(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 Pointer pose_transform_pipeline(Pointer arg0, String arg1, int arg2, int 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 Pointer pose_tstzspan_to_stbox(Pointer arg0, 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 Pointer pose_union_transfn(Pointer arg0, 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 Pointer posearr_round(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 Pointer teq_pose_tpose(Pointer arg0, 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 Pointer teq_tpose_pose(Pointer arg0, 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 Pointer tne_pose_tpose(Pointer arg0, 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 Pointer tne_tpose_pose(Pointer arg0, 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 Pointer union_set_pose(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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 Pointer minus_pose_set(Pointer arg0, 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 Pointer minus_set_pose(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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 Pointer nai_tpose_geo(Pointer arg0, 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 Pointer nai_tpose_pose(Pointer arg0, 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 Pointer shortestline_tpose_geo(Pointer arg0, 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 Pointer shortestline_tpose_pose(Pointer arg0, 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 Pointer tdistance_tpose_point(Pointer arg0, 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 Pointer tdistance_tpose_pose(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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 Pointer nai_tpose_tpose(Pointer arg0, 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 Pointer shortestline_tpose_tpose(Pointer arg0, 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 Pointer tdistance_tpose_tpose(Pointer arg0, 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 String pose_as_ewkt(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 String pose_as_hexwkb(Pointer arg0, byte arg1, 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 String pose_as_text(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 Pointer pose_as_wkb(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 Pointer pose_from_hexwkb(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 Pointer pose_from_wkb(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 Pointer pose_in(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 String pose_out(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..25a916a --- /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 Pointer geo_tpose_to_trgeo(Pointer arg0, 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 Pointer teq_geo_trgeo(Pointer arg0, 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 Pointer teq_trgeo_geo(Pointer arg0, 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 Pointer tne_geo_trgeo(Pointer arg0, 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 Pointer tne_trgeo_geo(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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 Pointer nai_trgeo_geo(Pointer arg0, 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 Pointer shortestline_trgeo_geo(Pointer arg0, 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 Pointer tdistance_trgeo_geo(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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(Pointer arg0, 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 Pointer nai_trgeo_tpoint(Pointer arg0, 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 Pointer nai_trgeo_trgeo(Pointer arg0, 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 Pointer shortestline_trgeo_tpoint(Pointer arg0, 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 Pointer shortestline_trgeo_trgeo(Pointer arg0, 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 Pointer tdistance_trgeo_tpoint(Pointer arg0, 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 Pointer tdistance_trgeo_trgeo(Pointer arg0, 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..1aec3dd --- /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 Pointer geogset_in(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..576fb83 --- /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 Pointer geoset_make(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 Pointer geoset_end_value(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 Pointer geoset_start_value(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 int geoset_value_n(Pointer arg0, int arg1, Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geoset_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geoset_value_n(arg0, arg1, arg2); + } + + /** + * 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 Pointer geoset_values(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 Pointer geomset_in(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..dba93b0 --- /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 Pointer intset_make(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 Pointer intset_to_floatset(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(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 Pointer intset_shift_scale(Pointer arg0, int arg1, int arg2, int arg3, int 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(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 int intset_value_n(Pointer arg0, int arg1, Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intset_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intset_value_n(arg0, arg1, arg2); + } + + /** + * 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 Pointer intset_values(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 Pointer intset_in(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 String intset_out(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..f3c941e --- /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 Pointer intspan_make(int arg0, int arg1, int arg2, int 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 Pointer intspan_to_floatspan(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 Pointer intspan_bins(Pointer arg0, int arg1, int arg2, 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 Pointer intspan_expand(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(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 Pointer intspan_shift_scale(Pointer arg0, int arg1, int arg2, int arg3, int 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(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(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 Pointer intspan_in(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 String intspan_out(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..076c8b5 --- /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 Pointer intspanset_to_floatspanset(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 Pointer intspanset_bins(Pointer arg0, int arg1, int arg2, 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(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 Pointer intspanset_shift_scale(Pointer arg0, int arg1, int arg2, int arg3, int 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(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(Pointer arg0, int 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 Pointer intspanset_in(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 String intspanset_out(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..fa076d2 --- /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 Pointer npointset_make(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 Pointer npointset_end_value(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 Pointer npointset_routes(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 Pointer npointset_start_value(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 int npointset_value_n(Pointer arg0, int arg1, Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npointset_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npointset_value_n(arg0, arg1, arg2); + } + + /** + * 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 Pointer npointset_values(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 Pointer npointset_in(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 String npointset_out(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/MeosOpsPoseSet.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsPoseSet.java new file mode 100644 index 0000000..9fe36d8 --- /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 Pointer poseset_make(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 Pointer poseset_end_value(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 Pointer poseset_start_value(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 int poseset_value_n(Pointer arg0, int arg1, Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "poseset_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.poseset_value_n(arg0, arg1, arg2); + } + + /** + * 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 Pointer poseset_values(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 Pointer poseset_in(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 String poseset_out(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..f4c767b --- /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 Pointer stbox_copy(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 Pointer stbox_make(int arg0, int arg1, int arg2, int arg3, double arg4, double arg5, double arg6, double arg7, double arg8, double arg9, 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 Pointer stbox_to_box3d(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 Pointer stbox_to_gbox(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 Pointer stbox_to_geo(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 Pointer stbox_to_tstzspan(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(Pointer arg0, int 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(Pointer arg0, 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 int stbox_eq(Pointer arg0, 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 Pointer stbox_expand_space(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 Pointer stbox_expand_time(Pointer arg0, 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 int stbox_ge(Pointer arg0, 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 Pointer stbox_get_space(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 Pointer stbox_get_space_tile(Pointer arg0, double arg1, double arg2, double arg3, 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 Pointer stbox_get_space_time_tile(Pointer arg0, int arg1, double arg2, double arg3, double arg4, Pointer arg5, Pointer arg6, int 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 Pointer stbox_get_time_tile(int arg0, Pointer arg1, int 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 int stbox_gt(Pointer arg0, 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(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 int stbox_hash_extended(Pointer arg0, int 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 int stbox_hast(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 int stbox_hasx(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 int stbox_hasz(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 int stbox_isgeodetic(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 int stbox_le(Pointer arg0, 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 int stbox_lt(Pointer arg0, 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 int stbox_ne(Pointer arg0, 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(Pointer arg0, int 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 Pointer stbox_quad_split(Pointer arg0, 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 Pointer stbox_round(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 Pointer stbox_set_srid(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 Pointer stbox_shift_scale_time(Pointer arg0, Pointer arg1, 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 Pointer stbox_space_tiles(Pointer arg0, double arg1, double arg2, double arg3, Pointer arg4, int arg5, 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 Pointer stbox_space_time_tiles(Pointer arg0, double arg1, double arg2, double arg3, Pointer arg4, Pointer arg5, int arg6, int arg7, 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(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 Pointer stbox_time_tiles(Pointer arg0, Pointer arg1, int arg2, int arg3, 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 int stbox_tmax(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_tmax requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_tmax(arg0, arg1); + } + + /** + * 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 int stbox_tmax_inc(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_tmax_inc requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_tmax_inc(arg0, arg1); + } + + /** + * 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 int stbox_tmin(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_tmin requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_tmin(arg0, arg1); + } + + /** + * 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 int stbox_tmin_inc(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_tmin_inc requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_tmin_inc(arg0, arg1); + } + + /** + * 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 Pointer stbox_transform(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 Pointer stbox_transform_pipeline(Pointer arg0, String arg1, int arg2, int 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(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 int stbox_xmax(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_xmax requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_xmax(arg0, arg1); + } + + /** + * 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 int stbox_xmin(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_xmin requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_xmin(arg0, arg1); + } + + /** + * 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 int stbox_ymax(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_ymax requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_ymax(arg0, arg1); + } + + /** + * 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 int stbox_ymin(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_ymin requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_ymin(arg0, arg1); + } + + /** + * 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 int stbox_zmax(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_zmax requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_zmax(arg0, arg1); + } + + /** + * 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 int stbox_zmin(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_zmin requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_zmin(arg0, arg1); + } + + /** + * MEOS {@code stbox_as_hexwkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static String stbox_as_hexwkb(Pointer arg0, byte arg1, 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 Pointer stbox_as_wkb(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 Pointer stbox_from_hexwkb(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 Pointer stbox_from_wkb(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 Pointer stbox_in(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 String stbox_out(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..bb386bb --- /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 Pointer set_copy(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 Pointer set_to_span(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 Pointer set_to_spanset(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 Pointer set_to_tbox(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(Pointer arg0, 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 int set_eq(Pointer arg0, 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 int set_ge(Pointer arg0, 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 int set_gt(Pointer arg0, 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(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 int set_hash_extended(Pointer arg0, int 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 int set_le(Pointer arg0, 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 int set_lt(Pointer arg0, 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 int set_ne(Pointer arg0, 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(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 Pointer set_round(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 Pointer set_spans(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 Pointer set_split_each_n_spans(Pointer arg0, int arg1, 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 Pointer set_split_n_spans(Pointer arg0, int arg1, 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 Pointer set_extent_transfn(Pointer arg0, 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 Pointer set_union_finalfn(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 Pointer set_union_transfn(Pointer arg0, 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 String set_as_hexwkb(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 Pointer set_as_wkb(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 Pointer set_from_hexwkb(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 Pointer set_from_wkb(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..25ea23d --- /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 Pointer span_copy(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 Pointer span_to_spanset(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 Pointer span_to_tbox(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(Pointer arg0, 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 int span_eq(Pointer arg0, 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 int span_ge(Pointer arg0, 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 int span_gt(Pointer arg0, 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(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 int span_hash_extended(Pointer arg0, int 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 int span_le(Pointer arg0, 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 int span_lower_inc(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 int span_lt(Pointer arg0, 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 int span_ne(Pointer arg0, 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 int span_upper_inc(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 Pointer span_extent_transfn(Pointer arg0, 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 Pointer span_union_transfn(Pointer arg0, 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 String span_as_hexwkb(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 Pointer span_as_wkb(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 Pointer span_from_hexwkb(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 Pointer span_from_wkb(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..6908fa7 --- /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 Pointer spanset_copy(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 Pointer spanset_make(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 Pointer spanset_to_tbox(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(Pointer arg0, 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 Pointer spanset_end_span(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 int spanset_eq(Pointer arg0, 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 int spanset_ge(Pointer arg0, 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 int spanset_gt(Pointer arg0, 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(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 int spanset_hash_extended(Pointer arg0, int 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 int spanset_le(Pointer arg0, 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 int spanset_lower_inc(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 int spanset_lt(Pointer arg0, 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 int spanset_ne(Pointer arg0, 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(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 Pointer spanset_span(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 Pointer spanset_span_n(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 Pointer spanset_spanarr(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 Pointer spanset_spans(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 Pointer spanset_split_each_n_spans(Pointer arg0, int arg1, 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 Pointer spanset_split_n_spans(Pointer arg0, int arg1, 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 Pointer spanset_start_span(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 int spanset_upper_inc(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 Pointer spanset_extent_transfn(Pointer arg0, 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 Pointer spanset_union_finalfn(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 Pointer spanset_union_transfn(Pointer arg0, 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 String spanset_as_hexwkb(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 Pointer spanset_as_wkb(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 Pointer spanset_from_hexwkb(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 Pointer spanset_from_wkb(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/MeosOpsTBool.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTBool.java new file mode 100644 index 0000000..26b4709 --- /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 Pointer tbool_from_base_temp(int arg0, 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 Pointer tbool_to_tint(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 Pointer tbool_at_value(Pointer arg0, int 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 int tbool_end_value(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 Pointer tbool_minus_value(Pointer arg0, int 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 int tbool_start_value(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 int tbool_value_at_timestamptz(Pointer arg0, int arg1, int arg2, 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 int tbool_value_n(Pointer arg0, int arg1, Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbool_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbool_value_n(arg0, arg1, arg2); + } + + /** + * 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 Pointer tbool_values(Pointer arg0, 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 Pointer tbool_when_true(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 Pointer tbool_tand_transfn(Pointer arg0, 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 Pointer tbool_tor_transfn(Pointer arg0, 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 Pointer tbool_from_mfjson(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 Pointer tbool_in(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 String tbool_out(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..c1e3caf --- /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 Pointer tboolinst_make(int arg0, int 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..47c83d4 --- /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 Pointer tbox_copy(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 Pointer tbox_make(Pointer arg0, 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 Pointer tbox_to_floatspan(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 Pointer tbox_to_intspan(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 Pointer tbox_to_tstzspan(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(Pointer arg0, 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 int tbox_eq(Pointer arg0, 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 Pointer tbox_expand_time(Pointer arg0, 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 int tbox_ge(Pointer arg0, 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 int tbox_gt(Pointer arg0, 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(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 int tbox_hash_extended(Pointer arg0, int 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 int tbox_hast(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 int tbox_hasx(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 int tbox_le(Pointer arg0, 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 int tbox_lt(Pointer arg0, 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 int tbox_ne(Pointer arg0, 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 Pointer tbox_round(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 Pointer tbox_shift_scale_time(Pointer arg0, Pointer arg1, 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 int tbox_tmax(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_tmax requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_tmax(arg0, arg1); + } + + /** + * 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 int tbox_tmax_inc(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_tmax_inc requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_tmax_inc(arg0, arg1); + } + + /** + * 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 int tbox_tmin(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_tmin requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_tmin(arg0, arg1); + } + + /** + * 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 int tbox_tmin_inc(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_tmin_inc requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_tmin_inc(arg0, arg1); + } + + /** + * 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 int tbox_xmax(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_xmax requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_xmax(arg0, arg1); + } + + /** + * 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 int tbox_xmax_inc(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_xmax_inc requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_xmax_inc(arg0, arg1); + } + + /** + * 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 int tbox_xmin(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_xmin requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_xmin(arg0, arg1); + } + + /** + * 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 int tbox_xmin_inc(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_xmin_inc requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_xmin_inc(arg0, arg1); + } + + /** + * MEOS {@code tbox_as_hexwkb} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static String tbox_as_hexwkb(Pointer arg0, byte arg1, 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 Pointer tbox_as_wkb(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 Pointer tbox_from_hexwkb(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 Pointer tbox_from_wkb(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 Pointer tbox_in(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 String tbox_out(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..b994baf --- /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 Pointer tcbuffer_make(Pointer arg0, 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 Pointer tcbuffer_to_tfloat(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 Pointer tcbuffer_to_tgeompoint(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 Pointer tcbuffer_at_cbuffer(Pointer arg0, 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 Pointer tcbuffer_at_geom(Pointer arg0, 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 Pointer tcbuffer_at_stbox(Pointer arg0, Pointer arg1, int 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 Pointer tcbuffer_expand(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 Pointer tcbuffer_minus_cbuffer(Pointer arg0, 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 Pointer tcbuffer_minus_geom(Pointer arg0, 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 Pointer tcbuffer_minus_stbox(Pointer arg0, Pointer arg1, int 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 Pointer tcbuffer_points(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 Pointer tcbuffer_radius(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 Pointer tcbuffer_trav_area(Pointer arg0, int 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 Pointer tcbuffer_from_mfjson(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 Pointer tcbuffer_in(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..bce6400 --- /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 Pointer tfloat_from_base_temp(double arg0, 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 Pointer tfloat_to_tint(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 Pointer tfloat_at_value(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(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 Pointer tfloat_ceil(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 Pointer tfloat_degrees(Pointer arg0, int 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(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 Pointer tfloat_exp(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 Pointer tfloat_floor(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 Pointer tfloat_ln(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 Pointer tfloat_log10(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(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(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 Pointer tfloat_minus_value(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 Pointer tfloat_radians(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 Pointer tfloat_scale_value(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 Pointer tfloat_shift_scale_value(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 Pointer tfloat_shift_value(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(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 Pointer tfloat_time_boxes(Pointer arg0, Pointer arg1, int arg2, 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 int tfloat_value_at_timestamptz(Pointer arg0, int arg1, int arg2, 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 Pointer tfloat_value_bins(Pointer arg0, double arg1, double arg2, 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 Pointer tfloat_value_boxes(Pointer arg0, double arg1, double arg2, 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 int tfloat_value_n(Pointer arg0, int arg1, Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_value_n(arg0, arg1, arg2); + } + + /** + * 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 Pointer tfloat_value_split(Pointer arg0, double arg1, double arg2, Pointer arg3, 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 Pointer tfloat_value_time_boxes(Pointer arg0, double arg1, Pointer arg2, double arg3, int arg4, 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 Pointer tfloat_value_time_split(Pointer arg0, double arg1, Pointer arg2, double arg3, int arg4, Pointer arg5, Pointer arg6, 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 Pointer tfloat_values(Pointer arg0, 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 Pointer tfloat_tmax_transfn(Pointer arg0, 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 Pointer tfloat_tmin_transfn(Pointer arg0, 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 Pointer tfloat_tsum_transfn(Pointer arg0, 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 Pointer tfloat_wmax_transfn(Pointer arg0, Pointer arg1, 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 Pointer tfloat_wmin_transfn(Pointer arg0, Pointer arg1, 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 Pointer tfloat_wsum_transfn(Pointer arg0, Pointer arg1, 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 Pointer tfloat_from_mfjson(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 Pointer tfloat_in(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 String tfloat_out(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..75de4ce --- /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 Pointer tfloatinst_make(double arg0, int 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..8cd5f65 --- /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 Pointer tgeo_from_base_temp(Pointer arg0, 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 Pointer tgeo_affine(Pointer arg0, 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 Pointer tgeo_at_geom(Pointer arg0, 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 Pointer tgeo_at_stbox(Pointer arg0, Pointer arg1, int 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 Pointer tgeo_at_value(Pointer arg0, 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 Pointer tgeo_centroid(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 Pointer tgeo_convex_hull(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 Pointer tgeo_end_value(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 Pointer tgeo_minus_geom(Pointer arg0, 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 Pointer tgeo_minus_stbox(Pointer arg0, Pointer arg1, int 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 Pointer tgeo_minus_value(Pointer arg0, 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 Pointer tgeo_scale(Pointer arg0, Pointer arg1, 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 Pointer tgeo_space_boxes(Pointer arg0, double arg1, double arg2, double arg3, Pointer arg4, int arg5, int arg6, 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 Pointer tgeo_space_split(Pointer arg0, double arg1, double arg2, double arg3, Pointer arg4, int arg5, int arg6, Pointer arg7, 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 Pointer tgeo_space_time_boxes(Pointer arg0, double arg1, double arg2, double arg3, Pointer arg4, Pointer arg5, int arg6, int arg7, int arg8, 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 Pointer tgeo_space_time_split(Pointer arg0, double arg1, double arg2, double arg3, Pointer arg4, Pointer arg5, int arg6, int arg7, int arg8, Pointer arg9, Pointer arg10, 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 Pointer tgeo_split_each_n_stboxes(Pointer arg0, int arg1, 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 Pointer tgeo_split_n_stboxes(Pointer arg0, int arg1, 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 Pointer tgeo_start_value(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 Pointer tgeo_stboxes(Pointer arg0, 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 Pointer tgeo_traversed_area(Pointer arg0, int 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 int tgeo_value_at_timestamptz(Pointer arg0, int arg1, int arg2, 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 int tgeo_value_n(Pointer arg0, int arg1, Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeo_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeo_value_n(arg0, arg1, arg2); + } + + /** + * 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 Pointer tgeo_values(Pointer arg0, 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..b6a6cfc --- /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 Pointer tgeogpoint_to_tgeography(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 Pointer tgeogpoint_from_mfjson(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 Pointer tgeogpoint_in(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..708551e --- /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 Pointer tgeography_to_tgeogpoint(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 Pointer tgeography_to_tgeometry(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 Pointer tgeography_from_mfjson(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 Pointer tgeography_in(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..6a257af --- /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 Pointer tgeompoint_to_tgeometry(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 Pointer tgeompoint_to_tnpoint(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 Pointer tgeompoint_from_mfjson(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 Pointer tgeompoint_in(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..08b877f --- /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 Pointer tgeometry_to_tcbuffer(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 Pointer tgeometry_to_tgeography(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 Pointer tgeometry_to_tgeompoint(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 Pointer tgeometry_from_mfjson(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 Pointer tgeometry_in(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..60264a6 --- /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 Pointer tint_from_base_temp(int arg0, 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 Pointer tint_to_tfloat(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 Pointer tint_at_value(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(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(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(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 Pointer tint_minus_value(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 Pointer tint_scale_value(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 Pointer tint_shift_scale_value(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 Pointer tint_shift_value(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(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 Pointer tint_time_boxes(Pointer arg0, Pointer arg1, int arg2, 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 int tint_value_at_timestamptz(Pointer arg0, int arg1, int arg2, 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 Pointer tint_value_bins(Pointer arg0, int arg1, int arg2, 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 Pointer tint_value_boxes(Pointer arg0, int arg1, int arg2, 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 int tint_value_n(Pointer arg0, int arg1, Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tint_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tint_value_n(arg0, arg1, arg2); + } + + /** + * 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 Pointer tint_value_split(Pointer arg0, int arg1, int arg2, Pointer arg3, 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 Pointer tint_value_time_boxes(Pointer arg0, int arg1, Pointer arg2, int arg3, int arg4, 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 Pointer tint_value_time_split(Pointer arg0, long arg1, Pointer arg2, int arg3, int arg4, Pointer arg5, Pointer arg6, 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 Pointer tint_values(Pointer arg0, 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 Pointer tint_tmax_transfn(Pointer arg0, 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 Pointer tint_tmin_transfn(Pointer arg0, 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 Pointer tint_tsum_transfn(Pointer arg0, 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 Pointer tint_wmax_transfn(Pointer arg0, Pointer arg1, 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 Pointer tint_wmin_transfn(Pointer arg0, Pointer arg1, 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 Pointer tint_wsum_transfn(Pointer arg0, Pointer arg1, 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 Pointer tint_from_mfjson(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 Pointer tint_in(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 String tint_out(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..e46d6b3 --- /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 Pointer tintinst_make(int arg0, int 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..ecfa6da --- /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 Pointer tnpoint_to_tgeompoint(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 Pointer tnpoint_at_geom(Pointer arg0, 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 Pointer tnpoint_at_npoint(Pointer arg0, 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 Pointer tnpoint_at_npointset(Pointer arg0, 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 Pointer tnpoint_at_stbox(Pointer arg0, Pointer arg1, int 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 Pointer tnpoint_cumulative_length(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(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 Pointer tnpoint_minus_geom(Pointer arg0, 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 Pointer tnpoint_minus_npoint(Pointer arg0, 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 Pointer tnpoint_minus_npointset(Pointer arg0, 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 Pointer tnpoint_minus_stbox(Pointer arg0, Pointer arg1, int 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 Pointer tnpoint_positions(Pointer arg0, 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 int tnpoint_route(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 Pointer tnpoint_routes(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 Pointer tnpoint_speed(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 Pointer tnpoint_trajectory(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 Pointer tnpoint_twcentroid(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 Pointer tnpoint_tcentroid_transfn(Pointer arg0, 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 Pointer tnpoint_from_mfjson(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 Pointer tnpoint_in(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 String tnpoint_out(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..632bb84 --- /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 Pointer tnpointinst_make(Pointer arg0, int 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..3720190 --- /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 Pointer tnumber_to_span(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 Pointer tnumber_to_tbox(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 Pointer tnumber_abs(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 Pointer tnumber_angular_difference(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 Pointer tnumber_at_span(Pointer arg0, 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 Pointer tnumber_at_spanset(Pointer arg0, 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 Pointer tnumber_at_tbox(Pointer arg0, 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(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 Pointer tnumber_delta_value(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(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 Pointer tnumber_minus_span(Pointer arg0, 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 Pointer tnumber_minus_spanset(Pointer arg0, 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 Pointer tnumber_minus_tbox(Pointer arg0, 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 Pointer tnumber_split_each_n_tboxes(Pointer arg0, int arg1, 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 Pointer tnumber_split_n_tboxes(Pointer arg0, int arg1, 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 Pointer tnumber_tboxes(Pointer arg0, 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 Pointer tnumber_trend(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(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 Pointer tnumber_valuespans(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 Pointer tnumber_extent_transfn(Pointer arg0, 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 Pointer tnumber_tavg_finalfn(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 Pointer tnumber_tavg_transfn(Pointer arg0, 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 Pointer tnumber_wavg_transfn(Pointer arg0, Pointer arg1, 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..dfad9a8 --- /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 Pointer tpoint_from_base_temp(Pointer arg0, 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 int tpoint_tfloat_to_geomeas(Pointer arg0, Pointer arg1, int arg2, Pointer arg3) { + 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, arg3); + } + + /** + * 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 Pointer tpoint_angular_difference(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 int tpoint_as_mvtgeom(Pointer arg0, Pointer arg1, int arg2, int arg3, int arg4, Pointer arg5, Pointer arg6, 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 Pointer tpoint_at_elevation(Pointer arg0, 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 Pointer tpoint_at_geom(Pointer arg0, 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 Pointer tpoint_at_value(Pointer arg0, 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 Pointer tpoint_azimuth(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 Pointer tpoint_cumulative_length(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 int tpoint_direction(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpoint_direction requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpoint_direction(arg0, arg1); + } + + /** + * 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 Pointer tpoint_get_x(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 Pointer tpoint_get_y(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 Pointer tpoint_get_z(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 int tpoint_is_simple(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(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 Pointer tpoint_make_simple(Pointer arg0, 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 Pointer tpoint_minus_elevation(Pointer arg0, 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 Pointer tpoint_minus_geom(Pointer arg0, 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 Pointer tpoint_minus_value(Pointer arg0, 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 Pointer tpoint_speed(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 Pointer tpoint_trajectory(Pointer arg0, int 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 Pointer tpoint_twcentroid(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 Pointer tpoint_tcentroid_finalfn(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 Pointer tpoint_tcentroid_transfn(Pointer arg0, 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..47c74c7 --- /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 Pointer tpose_make(Pointer arg0, 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 Pointer tpose_to_tpoint(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 Pointer tpose_at_geom(Pointer arg0, 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 Pointer tpose_at_pose(Pointer arg0, 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 Pointer tpose_at_stbox(Pointer arg0, Pointer arg1, int 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 Pointer tpose_end_value(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 Pointer tpose_minus_geom(Pointer arg0, 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 Pointer tpose_minus_pose(Pointer arg0, 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 Pointer tpose_minus_stbox(Pointer arg0, Pointer arg1, int 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 Pointer tpose_points(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 Pointer tpose_rotation(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 Pointer tpose_start_value(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 Pointer tpose_trajectory(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 int tpose_value_at_timestamptz(Pointer arg0, int arg1, int arg2, 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 int tpose_value_n(Pointer arg0, int arg1, Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpose_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpose_value_n(arg0, arg1, arg2); + } + + /** + * 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 Pointer tpose_values(Pointer arg0, 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 Pointer tpose_in(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..f9a6d46 --- /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 Pointer trgeo_to_tinstant(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 Pointer trgeo_to_tpoint(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 Pointer trgeo_to_tpose(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 Pointer trgeo_after_timestamptz(Pointer arg0, int arg1, int 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 Pointer trgeo_append_tinstant(Pointer arg0, Pointer arg1, int arg2, double arg3, Pointer arg4, int 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 Pointer trgeo_append_tsequence(Pointer arg0, Pointer arg1, int 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 Pointer trgeo_before_timestamptz(Pointer arg0, int arg1, int 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 Pointer trgeo_delete_timestamptz(Pointer arg0, int arg1, int 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 Pointer trgeo_delete_tstzset(Pointer arg0, Pointer arg1, int 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 Pointer trgeo_delete_tstzspan(Pointer arg0, Pointer arg1, int 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 Pointer trgeo_delete_tstzspanset(Pointer arg0, Pointer arg1, int 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 Pointer trgeo_end_instant(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 Pointer trgeo_end_sequence(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 Pointer trgeo_end_value(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 Pointer trgeo_geom(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 Pointer trgeo_instant_n(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 Pointer trgeo_instants(Pointer arg0, 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 Pointer trgeo_points(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 Pointer trgeo_restrict_timestamptz(Pointer arg0, int arg1, int 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 Pointer trgeo_restrict_tstzset(Pointer arg0, Pointer arg1, int 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 Pointer trgeo_restrict_tstzspan(Pointer arg0, Pointer arg1, int 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 Pointer trgeo_restrict_tstzspanset(Pointer arg0, Pointer arg1, int 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 Pointer trgeo_restrict_value(Pointer arg0, Pointer arg1, int 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 Pointer trgeo_restrict_values(Pointer arg0, Pointer arg1, int 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 Pointer trgeo_rotation(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 Pointer trgeo_round(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 Pointer trgeo_segments(Pointer arg0, 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 Pointer trgeo_sequence_n(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 Pointer trgeo_sequences(Pointer arg0, 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 Pointer trgeo_set_interp(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 Pointer trgeo_start_instant(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 Pointer trgeo_start_sequence(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 Pointer trgeo_start_value(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 Pointer trgeo_traversed_area(Pointer arg0, int 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 int trgeo_value_n(Pointer arg0, int arg1, Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeo_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeo_value_n(arg0, arg1, arg2); + } + + /** + * MEOS {@code trgeo_out} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static String trgeo_out(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..49edea9 --- /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 Pointer trgeoinst_make(Pointer arg0, Pointer arg1, int 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..1358354 --- /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 Pointer tsequenceset_make_gaps(Pointer arg0, int arg1, int arg2, 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..9de6b9c --- /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 Pointer tspatial_to_stbox(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 Pointer tspatial_set_srid(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(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 Pointer tspatial_transform(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 Pointer tspatial_transform_pipeline(Pointer arg0, String arg1, int arg2, int 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 Pointer tspatial_extent_transfn(Pointer arg0, 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 String tspatial_as_ewkt(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 String tspatial_as_text(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 String tspatial_out(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..c70edb1 --- /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 Pointer ttext_from_base_temp(Pointer arg0, 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 Pointer ttext_at_value(Pointer arg0, 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 Pointer ttext_end_value(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 Pointer ttext_initcap(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 Pointer ttext_lower(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 Pointer ttext_max_value(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 Pointer ttext_min_value(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 Pointer ttext_minus_value(Pointer arg0, 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 Pointer ttext_start_value(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 Pointer ttext_upper(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 int ttext_value_at_timestamptz(Pointer arg0, int arg1, int arg2, 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 int ttext_value_n(Pointer arg0, int arg1, Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ttext_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ttext_value_n(arg0, arg1, arg2); + } + + /** + * 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 Pointer ttext_values(Pointer arg0, 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 Pointer ttext_tmax_transfn(Pointer arg0, 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 Pointer ttext_tmin_transfn(Pointer arg0, 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 Pointer ttext_from_mfjson(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 Pointer ttext_in(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 String ttext_out(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..c40a103 --- /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 Pointer ttextinst_make(Pointer arg0, int 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..3b7113b --- /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 Pointer temporal_copy(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 Pointer temporal_to_tinstant(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 Pointer temporal_to_tsequence(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 Pointer temporal_to_tsequenceset(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 Pointer temporal_to_tstzspan(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 Pointer temporal_after_timestamptz(Pointer arg0, int arg1, int 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 Pointer temporal_append_tinstant(Pointer arg0, Pointer arg1, int arg2, double arg3, Pointer arg4, int 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 Pointer temporal_append_tsequence(Pointer arg0, Pointer arg1, int 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 Pointer temporal_at_max(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 Pointer temporal_at_min(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 Pointer temporal_at_timestamptz(Pointer arg0, int 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 Pointer temporal_at_tstzset(Pointer arg0, 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 Pointer temporal_at_tstzspan(Pointer arg0, 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 Pointer temporal_at_tstzspanset(Pointer arg0, 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 Pointer temporal_at_values(Pointer arg0, 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 Pointer temporal_before_timestamptz(Pointer arg0, int arg1, int 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 Pointer temporal_delete_timestamptz(Pointer arg0, int arg1, int 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 Pointer temporal_delete_tstzset(Pointer arg0, Pointer arg1, int 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 Pointer temporal_delete_tstzspan(Pointer arg0, Pointer arg1, int 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 Pointer temporal_delete_tstzspanset(Pointer arg0, Pointer arg1, int 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 Pointer temporal_derivative(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 Pointer temporal_duration(Pointer arg0, int 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(Pointer arg0, 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 Pointer temporal_dyntimewarp_path(Pointer arg0, Pointer arg1, 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 Pointer temporal_end_instant(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 Pointer temporal_end_sequence(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 int temporal_end_timestamptz(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(Pointer arg0, 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 Pointer temporal_frechet_path(Pointer arg0, Pointer arg1, 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(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(Pointer arg0, 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 Pointer temporal_insert(Pointer arg0, Pointer arg1, int 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 Pointer temporal_instant_n(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 Pointer temporal_instants(Pointer arg0, 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 String temporal_interp(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 int temporal_lower_inc(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 Pointer temporal_max_instant(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 Pointer temporal_merge(Pointer arg0, 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 Pointer temporal_merge_array(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 Pointer temporal_min_instant(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 Pointer temporal_minus_max(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 Pointer temporal_minus_min(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 Pointer temporal_minus_timestamptz(Pointer arg0, int 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 Pointer temporal_minus_tstzset(Pointer arg0, 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 Pointer temporal_minus_tstzspan(Pointer arg0, 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 Pointer temporal_minus_tstzspanset(Pointer arg0, 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 Pointer temporal_minus_values(Pointer arg0, 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(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(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(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 Pointer temporal_round(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 Pointer temporal_scale_time(Pointer arg0, 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 Pointer temporal_segm_duration(Pointer arg0, Pointer arg1, int arg2, int 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 Pointer temporal_segments(Pointer arg0, 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 Pointer temporal_sequence_n(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 Pointer temporal_sequences(Pointer arg0, 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 Pointer temporal_set_interp(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 Pointer temporal_shift_scale_time(Pointer arg0, Pointer arg1, 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 Pointer temporal_shift_time(Pointer arg0, 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 Pointer temporal_simplify_dp(Pointer arg0, double arg1, int 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 Pointer temporal_simplify_max_dist(Pointer arg0, double arg1, int 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 Pointer temporal_simplify_min_dist(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 Pointer temporal_simplify_min_tdelta(Pointer arg0, 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 Pointer temporal_spans(Pointer arg0, 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 Pointer temporal_split_each_n_spans(Pointer arg0, int arg1, 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 Pointer temporal_split_n_spans(Pointer arg0, int arg1, 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 Pointer temporal_start_instant(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 Pointer temporal_start_sequence(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 int temporal_start_timestamptz(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 Pointer temporal_stops(Pointer arg0, double arg1, 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 String temporal_subtype(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 Pointer temporal_time(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 Pointer temporal_time_bins(Pointer arg0, Pointer arg1, int arg2, 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 Pointer temporal_time_split(Pointer arg0, Pointer arg1, int arg2, Pointer arg3, 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 Pointer temporal_timestamps(Pointer arg0, 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 int temporal_timestamptz_n(Pointer arg0, int arg1, Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_timestamptz_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_timestamptz_n(arg0, arg1, arg2); + } + + /** + * 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 Pointer temporal_tprecision(Pointer arg0, Pointer arg1, int 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 Pointer temporal_tsample(Pointer arg0, Pointer arg1, int 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 Pointer temporal_update(Pointer arg0, Pointer arg1, int 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 int temporal_upper_inc(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 Pointer temporal_extent_transfn(Pointer arg0, 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 Pointer temporal_merge_combinefn(Pointer arg0, 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 Pointer temporal_merge_transfn(Pointer arg0, 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 Pointer temporal_tagg_finalfn(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 Pointer temporal_tcount_transfn(Pointer arg0, 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(Pointer arg0, 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 int temporal_eq(Pointer arg0, 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 int temporal_ge(Pointer arg0, 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 int temporal_gt(Pointer arg0, 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 int temporal_le(Pointer arg0, 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 int temporal_lt(Pointer arg0, 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 int temporal_ne(Pointer arg0, 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 String temporal_as_hexwkb(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 String temporal_as_mfjson(Pointer arg0, int arg1, int arg2, int arg3, 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 Pointer temporal_as_wkb(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 Pointer temporal_from_hexwkb(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 Pointer temporal_from_wkb(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..6191b1b --- /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 Pointer textset_make(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 Pointer textset_end_value(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 Pointer textset_initcap(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 Pointer textset_lower(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 Pointer textset_start_value(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 Pointer textset_upper(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 int textset_value_n(Pointer arg0, int arg1, Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "textset_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.textset_value_n(arg0, arg1, arg2); + } + + /** + * 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 Pointer textset_values(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 Pointer textset_in(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 String textset_out(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/MeosOpsTstzSet.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsTstzSet.java new file mode 100644 index 0000000..1c4c3b3 --- /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 Pointer tstzset_make(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 Pointer tstzset_to_dateset(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 Pointer tstzset_to_stbox(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 int tstzset_end_value(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 Pointer tstzset_shift_scale(Pointer arg0, Pointer arg1, 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 int tstzset_start_value(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 Pointer tstzset_tprecision(Pointer arg0, Pointer arg1, int 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 int tstzset_value_n(Pointer arg0, int arg1, Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzset_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzset_value_n(arg0, arg1, arg2); + } + + /** + * 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 Pointer tstzset_values(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 Pointer tstzset_tcount_transfn(Pointer arg0, 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 Pointer tstzset_in(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 String tstzset_out(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..c53d734 --- /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 Pointer tstzspan_make(int arg0, int arg1, int arg2, int 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 Pointer tstzspan_to_datespan(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 Pointer tstzspan_to_stbox(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 Pointer tstzspan_bins(Pointer arg0, Pointer arg1, int arg2, 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 Pointer tstzspan_duration(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 Pointer tstzspan_expand(Pointer arg0, 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 int tstzspan_lower(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 Pointer tstzspan_shift_scale(Pointer arg0, Pointer arg1, 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 Pointer tstzspan_tprecision(Pointer arg0, Pointer arg1, int 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 int tstzspan_upper(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 Pointer tstzspan_tcount_transfn(Pointer arg0, 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 Pointer tstzspan_in(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 String tstzspan_out(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..81c0224 --- /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 Pointer tstzspanset_to_datespanset(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 Pointer tstzspanset_to_stbox(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 Pointer tstzspanset_bins(Pointer arg0, Pointer arg1, int arg2, 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 Pointer tstzspanset_duration(Pointer arg0, int 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 int tstzspanset_end_timestamptz(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 int tstzspanset_lower(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(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 Pointer tstzspanset_shift_scale(Pointer arg0, Pointer arg1, 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 int tstzspanset_start_timestamptz(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 Pointer tstzspanset_timestamps(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 int tstzspanset_timestamptz_n(Pointer arg0, int arg1, Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzspanset_timestamptz_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzspanset_timestamptz_n(arg0, arg1, arg2); + } + + /** + * 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 Pointer tstzspanset_tprecision(Pointer arg0, Pointer arg1, int 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 int tstzspanset_upper(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 Pointer tstzspanset_tcount_transfn(Pointer arg0, 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 Pointer tstzspanset_in(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 String tstzspanset_out(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/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/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 From 457987c935015ab373116414f513919d1812c366 Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Thu, 21 May 2026 13:14:06 +0200 Subject: [PATCH 05/22] feat(wirings): stateless tier DataStream wirings for the generated MEOS facades MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Adds the org.mobilitydb.flink.meos.wirings package — thin, generic Flink-DataStream wrappers around the generated MeosOps* facades from PR #5, organized per streaming tier. This PR ships the stateless tier: - MeosStatelessMap: generic MapFunction wrapping any stateless MeosOps* method (804 of the 2,097 generated methods qualify per the v4 baseline — 92 OO-classified + 712 free-fn) - MeosStatelessFilter: generic FilterFunction wrapping any stateless boolean-returning MeosOps* method, plus a .fromIntPredicate(...) adapter for JMEOS' int-coded predicates - demo/MeosWiringsDemoJob: runnable end-to-end DataStream pipeline parsing TBox WKT → filtering by overlap with a query box → serializing surviving boxes to hex-WKB, all through the generated facades wired via this package - README documenting tier vocabulary, the wrap-once-use-everywhere pattern, the DataStream-API-only design choice (Table API as future follow-up), and coexistence with berlinmod.MEOSBridge Future follow-ups (one PR per tier, mirroring this one's shape): - MeosBoundedStateMap (generic KeyedProcessFunction with ValueState for MEOS handle per key — covers 797 of the generated methods) - MeosWindowedAggregate (generic ProcessWindowFunction — 161 methods) - MeosCrossStreamJoin (generic KeyedCoProcessFunction or interval-join — 140 methods) - Optional: Table API sibling (MeosScalarUDF + MeosCatalogRegistrar) if the repo adopts Table API for other reasons Stacks on codegen/flink-meos-ops (PR #5). Additive-only; touches no existing file. Locally compile-verified: 129 .class files total (123 from the parent PR + 6 new from this package's classes + demo + their nested lambdas). --- .../meos/wirings/MeosStatelessFilter.java | 87 +++++++++++++++ .../flink/meos/wirings/MeosStatelessMap.java | 93 ++++++++++++++++ .../flink/meos/wirings/MeosWiringRuntime.java | 37 +++++++ .../mobilitydb/flink/meos/wirings/README.md | 89 +++++++++++++++ .../meos/wirings/demo/MeosWiringsDemoJob.java | 101 ++++++++++++++++++ 5 files changed, 407 insertions(+) create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/MeosStatelessFilter.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/MeosStatelessMap.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/MeosWiringRuntime.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/README.md create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/demo/MeosWiringsDemoJob.java 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/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..ffcb437 --- /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` (generic `KeyedProcessFunction` with `ValueState` per key) | next follow-up | +| `windowed` | `MeosWindowedAggregate` (generic `ProcessWindowFunction`) | next follow-up | +| `cross-stream` | `MeosCrossStreamJoin` (generic `KeyedCoProcessFunction` or interval-join) | next follow-up | +| `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/MeosWiringsDemoJob.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/demo/MeosWiringsDemoJob.java new file mode 100644 index 0000000..0597a86 --- /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( + MeosStatelessFilter.fromIntPredicate( + 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"); + } +} From a1f36cd245d33836f9112b9d7af4822a92eb45e2 Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Thu, 21 May 2026 13:26:50 +0200 Subject: [PATCH 06/22] feat(wirings): bounded-state tier DataStream wiring + runnable demo MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Adds MeosBoundedStateMap — the second tier-wiring class in the org.mobilitydb.flink.meos.wirings package, stacked on PR #6 (stateless wirings). Bounded-state is the second-largest streaming tier in the v4 baseline (797 of 2,097 emitted methods — 513 OO-classified + 284 free-fn). The canonical pattern is per-key MEOS-handle accumulation: a running tbox union, a running temporal value, a per-vehicle accumulator that keeps the MEOS value alive across events. ## Design — state lives as bytes, not as Pointer A jnr.ffi.Pointer is a raw native-memory address. It is not portable across JVM restarts; Flink could not checkpoint, savepoint, or replay state if the wiring stored raw pointers. MeosBoundedStateMap stores state as byte[] (MEOS-WKB or MEOS-WKT, adopter's choice) with three adopter-supplied lambdas mediating the round-trip: - PointerSerialize: Pointer → byte[] (called after each step) - PointerDeserialize: byte[] → Pointer (called before each step) - MeosStepFn: (prior Pointer, event) → (new Pointer, output) The first event for a key sees prior == null; the wiring handles that case by skipping deserialize and seeding state with the first event's result. Subsequent events re-hydrate, mutate, re-serialize. Net effect: state crossing the operator boundary is always byte[]; checkpoints, savepoints, and rescaling all work correctly. This is the same serde discipline MobilityDuck's persistent state machines use. ## Files - MeosBoundedStateMap.java — the generic wiring class - demo/MeosBoundedStateDemoJob.java — runnable per-vehicle running tbox union pipeline (6 events × 2 vehicles; demonstrates per-key isolation, first-event-null correctness, and checkpoint-safe state) - README — bounded-state row marked ✅ shipped ## Stacks on PR #6 Additive-only; touches no existing file. Locally compile-verified: 135 .class files total (129 from PR #6 base + 6 new — 1 wiring class + 3 nested lambda interfaces + MeosStep tuple + 1 demo class). --- .../meos/wirings/MeosBoundedStateMap.java | 158 ++++++++++++++++++ .../mobilitydb/flink/meos/wirings/README.md | 2 +- .../wirings/demo/MeosBoundedStateDemoJob.java | 114 +++++++++++++ 3 files changed, 273 insertions(+), 1 deletion(-) create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/MeosBoundedStateMap.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/demo/MeosBoundedStateDemoJob.java 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/README.md b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/README.md index ffcb437..e1ed310 100644 --- 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 @@ -8,7 +8,7 @@ per **streaming tier** (per | Tier | Wiring class(es) here | Status in this package | |---|---|---| | `stateless` | [`MeosStatelessMap`](MeosStatelessMap.java) (generic `MapFunction`) · [`MeosStatelessFilter`](MeosStatelessFilter.java) (generic `FilterFunction`) | ✅ shipped | -| `bounded-state` | `MeosBoundedStateMap` (generic `KeyedProcessFunction` with `ValueState` per key) | next follow-up | +| `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` (generic `ProcessWindowFunction`) | next follow-up | | `cross-stream` | `MeosCrossStreamJoin` (generic `KeyedCoProcessFunction` or interval-join) | next follow-up | | `io-meta` | covered transitively by the stateless wirings (no state, no window) | n/a | 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..c77b0e7 --- /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=*/0); + 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"); + } +} From ef477082ce3f69c9a4bf26fa2d06eeac46e46805 Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Thu, 21 May 2026 13:30:21 +0200 Subject: [PATCH 07/22] feat(wirings): windowed tier DataStream wiring + runnable demo MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Adds MeosWindowedAggregate — the third tier-wiring class in the org.mobilitydb.flink.meos.wirings package, stacked on PR #7 (bounded-state wirings). Windowed is the third streaming tier (161 of 2,097 emitted methods, ~8%) — output cardinality changes; one MEOS aggregate per window. Canonical examples: temporal_length(tgeo) for per-window trajectory length, temporal_twavg(tnumber) for time-weighted average per window, per-class _trajectory / _time / _timespan accessors. ## Design Wraps any windowed MeosOps call as a ProcessWindowFunction with a slim adopter-facing signature: the lambda receives the window metadata, the iterable of in-window events, and a slim Context exposing key + processing-time + watermark (free of Flink internals). Unlike bounded-state, NO MEOS handle persists across window boundaries — each window's MEOS value is built fresh from the iterable on window close, used to compute the output, discarded. The iterable's events are Flink-side data; MEOS handles are short-lived per-window. ## Files - MeosWindowedAggregate.java — the generic wiring class - demo/MeosWindowedDemoJob.java — runnable 30s-tumbling-window per-vehicle aggregate-tbox demo (8 events × 2 vehicles × 2 windows; demonstrates window-close timing, per-key isolation, fresh-per- window aggregation) - README — windowed row marked ✅ shipped ## Stacks on PR #7 Additive-only; touches no existing file beyond the README row. Locally compile-verified: 140 .class files total (135 from PR #7 base + 5 new — 1 wiring class + 2 nested lambda interfaces + 1 anonymous ContextLike + 1 demo class). --- .../meos/wirings/MeosWindowedAggregate.java | 123 ++++++++++++++++ .../mobilitydb/flink/meos/wirings/README.md | 2 +- .../wirings/demo/MeosWindowedDemoJob.java | 132 ++++++++++++++++++ 3 files changed, 256 insertions(+), 1 deletion(-) create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/MeosWindowedAggregate.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/demo/MeosWindowedDemoJob.java 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/README.md b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/README.md index e1ed310..906ab8b 100644 --- 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 @@ -9,7 +9,7 @@ per **streaming tier** (per |---|---|---| | `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` (generic `ProcessWindowFunction`) | next follow-up | +| `windowed` | [`MeosWindowedAggregate`](MeosWindowedAggregate.java) (generic `ProcessWindowFunction`; window-close-only aggregation; no MEOS handles persist across window boundaries) | ✅ shipped | | `cross-stream` | `MeosCrossStreamJoin` (generic `KeyedCoProcessFunction` or interval-join) | next follow-up | | `io-meta` | covered transitively by the stateless wirings (no state, no window) | n/a | | `sequence-only` | inherently non-streamable — no wiring | n/a | 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..8d5e1b6 --- /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=*/0); + 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"); + } +} From 10a03b6d0bc206e1c057ef2ca018c6d94ce7ebfc Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Thu, 21 May 2026 13:33:34 +0200 Subject: [PATCH 08/22] feat(wirings): cross-stream tier DataStream wiring + runnable demo (completes the 4-tier matrix) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Adds MeosCrossStreamJoin — the fourth and final tier-wiring class in the org.mobilitydb.flink.meos.wirings package, stacked on PR #8 (windowed wirings). Cross-stream is the smallest streamable tier (140 of 2,097 emitted methods, ~7%) — pairwise across two pre-keyed streams, time-bounded match window. Canonical examples: spatial-relations between two trajectories (edwithin_tgeo_tgeo, eintersects_tgeo_tgeo), distance on two temporals (nad_tgeo_tgeo, mindistance_tgeo_tgeo). ## Design Wraps any cross-stream MeosOps call as a ProcessJoinFunction — the operator backing KeyedStream.intervalJoin(other). Both streams must be pre-keyed by the same K; only events sharing a key are considered for pairing. The .between(lowerBound, upperBound) declaration bounds the time window for match-eligibility, and matches are emitted event-time-aware (watermark-driven). The adopter-facing signature keeps the slim ContextLike-pattern used in MeosWindowedAggregate: the lambda receives the matched (left, right) pair and a slim Context exposing left/right timestamps (the bits a MEOS cross-stream call typically needs), free of Flink internals. ## Files - MeosCrossStreamJoin.java — the generic wiring class - demo/MeosCrossStreamDemoJob.java — runnable interval-join demo matching two streams of (regionId, vehicleId, tboxWKT, ts) on shared regionId key within ±1 minute; emits per-pair overlap events via MeosOpsFreeCore.overlaps_tbox_tbox - README — cross-stream row marked ✅ shipped ## Completes the 4-tier wiring matrix After this PR, every streamable tier in the v4 baseline has a generic wiring class in this package: stateless 804 methods → MeosStatelessMap / MeosStatelessFilter (PR #6) bounded-state 797 methods → MeosBoundedStateMap (PR #7) windowed 161 methods → MeosWindowedAggregate (PR #8) cross-stream 140 methods → MeosCrossStreamJoin (THIS PR) io-meta 195 methods → covered by MeosStatelessMap sequence-only 14 methods → inherently non-streamable Total: 2,097 of 2,097 = 100% of streamable + io-meta generated MeosOps* methods are wirable through 4 (+ 1 filter sibling) generic classes; no per-method registration; adopters provide a serializable lambda per use site. ## Stacks on PR #8 Additive-only; touches no existing file beyond the README row. Locally compile-verified: 145 .class files total (140 from PR #8 base + 5 new — 1 wiring class + 2 nested lambda interfaces + 1 anonymous ContextLike + 1 demo class). --- .../meos/wirings/MeosCrossStreamJoin.java | 115 +++++++++++++++ .../mobilitydb/flink/meos/wirings/README.md | 2 +- .../wirings/demo/MeosCrossStreamDemoJob.java | 135 ++++++++++++++++++ 3 files changed, 251 insertions(+), 1 deletion(-) create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/MeosCrossStreamJoin.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/demo/MeosCrossStreamDemoJob.java 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/README.md b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/README.md index 906ab8b..cf210d1 100644 --- 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 @@ -10,7 +10,7 @@ per **streaming tier** (per | `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` (generic `KeyedCoProcessFunction` or interval-join) | next follow-up | +| `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 | 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..97c3223 --- /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) != 0) { + 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"); + } +} From d322b8ce3b0eeb9bbcf4e02eba91896d2dbb527d Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Thu, 21 May 2026 13:39:25 +0200 Subject: [PATCH 09/22] feat(wirings): capstone demo composing all 4 tier wirings into one pipeline MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Adds MeosAllTiersCapstoneDemo — a single Flink DataStream job that exercises all four tier-wiring classes from the PR #6→#7→#8→#9 stack in a coherent end-to-end pipeline. Pipeline (each stage uses one tier-wiring class from the stack): ① MeosStatelessFilter — drop events outside regions of interest ② MeosBoundedStateMap — per-vehicle running tbox union (byte[] state) ③ MeosWindowedAggregate — per-vehicle 30s tumbling tbox summary ④ MeosCrossStreamJoin — interval-join vehicle aggregates against region queries (±1m bound, regionId key) 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?' Proves the wirings compose into a realistic pipeline shape (not just work in isolation), each tier delivering its specific contract: stateless filter is per-event, bounded-state persists handle state across events as bytes, windowed aggregates window-close-only, cross- stream interval-joins on shared key. Stacks on PR #9; additive-only (1 new demo file). Locally compile- verified: 146 .class files total (145 from PR #9 base + 1 new demo). --- .../demo/MeosAllTiersCapstoneDemo.java | 221 ++++++++++++++++++ 1 file changed, 221 insertions(+) create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/demo/MeosAllTiersCapstoneDemo.java 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..420c613 --- /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=*/0); + 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) != 0) { + 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)"); + } +} From bc2b474e7dc1608b860f015c42e807f26ba1ede6 Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Thu, 28 May 2026 01:22:57 +0200 Subject: [PATCH 10/22] test(parity): audit and verify the MEOS facade surface per family Add a symbol-level parity audit measuring the generated MeosOps* facade against the MEOS public-header surface, the forwarding methods (MeosOpsParityGaps) that bring the facade to the full public surface, the parity-status report, and a JUnit smoke test that constructs and reads back a value in the core, geo, cbuffer, npoint and pose families through the facade against libmeos. --- flink-processor/docs/parity-status.md | 43 ++ .../flink/meos/MeosOpsParityGaps.java | 454 ++++++++++++++++++ .../flink/meos/MeosFacadeSmokeTest.java | 79 +++ .../tools/parity/emit_gap_methods.py | 89 ++++ flink-processor/tools/parity/parity_audit.py | 194 ++++++++ 5 files changed, 859 insertions(+) create mode 100644 flink-processor/docs/parity-status.md create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsParityGaps.java create mode 100644 flink-processor/src/test/java/org/mobilitydb/flink/meos/MeosFacadeSmokeTest.java create mode 100644 flink-processor/tools/parity/emit_gap_methods.py create mode 100644 flink-processor/tools/parity/parity_audit.py diff --git a/flink-processor/docs/parity-status.md b/flink-processor/docs/parity-status.md new file mode 100644 index 0000000..bf2650e --- /dev/null +++ b/flink-processor/docs/parity-status.md @@ -0,0 +1,43 @@ +# MobilityFlink parity status — MEOS surface audit + +Generated 2026-05-28 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 **2156 of 2156 public MEOS functions (100.0%)**. The MEOS public surface (`meos/include/meos*.h`, excluding internal headers) is 2156 functions; JMEOS binds 2156 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 2699 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`) | 1279 | 1279 | 0 | 100.0% | +| geo (tgeo / tpoint / stbox) (`meos_geo.h`) | 417 | 417 | 0 | 100.0% | +| cbuffer (`meos_cbuffer.h`) | 173 | 173 | 0 | 100.0% | +| npoint (`meos_npoint.h`) | 118 | 118 | 0 | 100.0% | +| pose (`meos_pose.h`) | 101 | 101 | 0 | 100.0% | +| rgeo (`meos_rgeo.h`) | 68 | 68 | 0 | 100.0% | +| **total** | **2156** | **2156** | **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 + +For comparability with the SQL-surface bindings, 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; 874 out-of-scope, 113 SQL/plpgsql-composed functions with no single C symbol). The extension wrapper occasionally renames the MEOS function it calls, so this view is a lower bound. + +- Addressable distinct C symbols: **1335**; bound by JMEOS: **1065**; exposed by the facade: **939** (88.2% of the JMEOS-bindable SQL surface). + 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..34a9d7b --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsParityGaps.java @@ -0,0 +1,454 @@ +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 bearing_tpoint_point} — meos_geo.h · scalar / stateless. */ + public static jnr.ffi.Pointer bearing_tpoint_point(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, int 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 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 line_interpolate_point} — meos_geo.h · scalar / stateless. */ + public static jnr.ffi.Pointer line_interpolate_point(jnr.ffi.Pointer arg0, double arg1, int 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 mult_float_tfloat} — meos.h · scalar / stateless. */ + public static jnr.ffi.Pointer mult_float_tfloat(double arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("mult_float_tfloat requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.mult_float_tfloat(arg0, arg1); + } + + /** MEOS {@code mult_int_tint} — meos.h · scalar / stateless. */ + public static jnr.ffi.Pointer mult_int_tint(int arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("mult_int_tint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.mult_int_tint(arg0, arg1); + } + + /** MEOS {@code mult_tfloat_float} — meos.h · scalar / stateless. */ + public static jnr.ffi.Pointer mult_tfloat_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("mult_tfloat_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.mult_tfloat_float(arg0, arg1); + } + + /** MEOS {@code mult_tint_int} — meos.h · scalar / stateless. */ + public static jnr.ffi.Pointer mult_tint_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("mult_tint_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.mult_tint_int(arg0, arg1); + } + + /** MEOS {@code mult_tnumber_tnumber} — meos.h · scalar / stateless. */ + public static jnr.ffi.Pointer mult_tnumber_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("mult_tnumber_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.mult_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(int 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, int 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(int 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, int 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(int 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(int 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(int 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 tfloatbox_time_tiles} — meos.h · multidimensional tiling (windowed). */ + public static jnr.ffi.Pointer tfloatbox_time_tiles(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, int 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, int 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 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, int 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, int 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(int 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, int 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, int arg6, int arg7, int arg8, int arg9, int 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, int arg2, int arg3, int arg4, int 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, int 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/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..93165d7 --- /dev/null +++ b/flink-processor/src/test/java/org/mobilitydb/flink/meos/MeosFacadeSmokeTest.java @@ -0,0 +1,79 @@ +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; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * Per-family runtime check that the generated MEOS facade calls into libmeos and + * returns correct results. Each family 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 extended families (cbuffer, npoint, pose) require a + * libmeos built with {@code -DCBUFFER=ON -DNPOINT=ON -DPOSE=ON -DRGEO=ON}. + */ +@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 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")); + } + + @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)); + } + + @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); + } + + @Test + void pose() { + Pointer pose = MeosOpsFreePose.pose_in("Pose(Point(1 1), 0.5)"); + assertNotNull(pose); + assertNotNull(MeosOpsFreePose.pose_out(pose, 6)); + } +} 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..ef895a5 --- /dev/null +++ b/flink-processor/tools/parity/emit_gap_methods.py @@ -0,0 +1,89 @@ +#!/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 = "/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"] +FACADE = os.path.join(HERE, "src/main/java/org/mobilitydb/flink/meos") +OUT = os.path.join(FACADE, "MeosOpsParityGaps.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")): + 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/parity_audit.py b/flink-processor/tools/parity/parity_audit.py new file mode 100644 index 0000000..7548738 --- /dev/null +++ b/flink-processor/tools/parity/parity_audit.py @@ -0,0 +1,194 @@ +#!/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"] +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"} + +_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 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")) + a = ap.parse_args() + + jm = jmeos_symbols(a.jar) + fa = facade_methods(a.facade) & 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("For comparability with the SQL-surface bindings, 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; " + f"{oos} out-of-scope, {sqlc} SQL/plpgsql-composed functions with no single C symbol). " + "The extension wrapper occasionally renames the MEOS function it calls, so this view " + "is a lower bound.\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") + + 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() From f1325be2f2299f59a610a444590b4e30d302034d Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Thu, 28 May 2026 02:21:26 +0200 Subject: [PATCH 11/22] test(parity): resolve facade methods against libmeos and broaden the smoke Add a --libmeos resolution check to parity_audit.py that confirms every MeosOps* facade method resolves to an exported symbol in a built libmeos and records it as section 5 of parity-status.md, and broaden MeosFacadeSmokeTest with an integer-span roundtrip and a pose-rotation assertion. --- flink-processor/docs/parity-status.md | 13 ++++++++++ .../flink/meos/MeosFacadeSmokeTest.java | 9 +++++++ flink-processor/tools/parity/parity_audit.py | 26 ++++++++++++++++++- 3 files changed, 47 insertions(+), 1 deletion(-) diff --git a/flink-processor/docs/parity-status.md b/flink-processor/docs/parity-status.md index bf2650e..ffe002e 100644 --- a/flink-processor/docs/parity-status.md +++ b/flink-processor/docs/parity-status.md @@ -41,3 +41,16 @@ For comparability with the SQL-surface bindings, the facade is also matched agai - Addressable distinct C symbols: **1335**; bound by JMEOS: **1065**; exposed by the facade: **939** (88.2% of the JMEOS-bindable SQL surface). +## 5. Runtime symbol resolution + +Every facade method delegates to a libmeos symbol of the same name. Against a libmeos built with the extended modules (`-DCBUFFER=ON -DNPOINT=ON -DPOSE=ON -DRGEO=ON`), **2152 of 2160** facade methods resolve to an exported symbol. The following require a libmeos built from current MEOS sources: + +- `geog_from_binary` +- `nad_stbox_trgeo` +- `tcbuffer_from_mfjson` +- `tfloat_avg_value` +- `tnpoint_from_mfjson` +- `trgeo_points` +- `trgeo_rotation` +- `trgeo_segments` + 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 index 93165d7..b116f65 100644 --- a/flink-processor/src/test/java/org/mobilitydb/flink/meos/MeosFacadeSmokeTest.java +++ b/flink-processor/src/test/java/org/mobilitydb/flink/meos/MeosFacadeSmokeTest.java @@ -40,6 +40,14 @@ void coreTbox() { 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))"); @@ -75,5 +83,6 @@ 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/tools/parity/parity_audit.py b/flink-processor/tools/parity/parity_audit.py index 7548738..5596e59 100644 --- a/flink-processor/tools/parity/parity_audit.py +++ b/flink-processor/tools/parity/parity_audit.py @@ -69,6 +69,11 @@ def facade_methods(d): 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: @@ -106,10 +111,14 @@ def main(): 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 = facade_methods(a.facade) & jm + fa_all = facade_methods(a.facade) + fa = fa_all & jm pub, fam = public_surface(a.meos_include) bindable = pub & jm covered = bindable & fa @@ -178,6 +187,21 @@ def main(): f"exposed by the facade: **{sql_cov}** " f"({pct(sql_cov, sql_bindable):.1f}% of the JMEOS-bindable SQL surface).\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 " + "libmeos 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. The following require a libmeos built from current MEOS sources:\n") + L.append(("\n".join(f"- `{n}`" for n in unresolved) if unresolved + else "- (none — 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) From fdb8315411e5998bffd8faf068bbd6da32ee5c9e Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Thu, 28 May 2026 02:26:13 +0200 Subject: [PATCH 12/22] feat(parity): expose SQL-surface functions backed by internal MEOS headers Add MeosOpsSqlSurface with forwarding methods for the MEOS functions that the MobilityDB SQL layer exposes as user functions but implements through meos_internal*.h (emitted by tools/parity/emit_sql_surface.py from the exact JMEOS signatures), bringing the facade to the full JMEOS-bindable SQL surface, and record the reconciliation in parity-status.md. --- flink-processor/docs/parity-status.md | 8 +- .../flink/meos/MeosOpsSqlSurface.java | 897 ++++++++++++++++++ .../tools/parity/emit_sql_surface.py | 115 +++ flink-processor/tools/parity/parity_audit.py | 14 +- 4 files changed, 1025 insertions(+), 9 deletions(-) create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsSqlSurface.java create mode 100644 flink-processor/tools/parity/emit_sql_surface.py diff --git a/flink-processor/docs/parity-status.md b/flink-processor/docs/parity-status.md index ffe002e..570226f 100644 --- a/flink-processor/docs/parity-status.md +++ b/flink-processor/docs/parity-status.md @@ -37,13 +37,15 @@ Per-family runtime behaviour is asserted by `src/test/java/org/mobilitydb/flink/ ## 4. MobilityDB SQL-surface cross-check -For comparability with the SQL-surface bindings, 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; 874 out-of-scope, 113 SQL/plpgsql-composed functions with no single C symbol). The extension wrapper occasionally renames the MEOS function it calls, so this view is a lower bound. +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; 874 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: **1335**; bound by JMEOS: **1065**; exposed by the facade: **939** (88.2% of the JMEOS-bindable SQL surface). +- Addressable distinct C symbols: **1335**; bound by JMEOS: **1065**; exposed by the facade: **1065** (100.0% of the JMEOS-bindable SQL surface). + +- The remaining **270** 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. ## 5. Runtime symbol resolution -Every facade method delegates to a libmeos symbol of the same name. Against a libmeos built with the extended modules (`-DCBUFFER=ON -DNPOINT=ON -DPOSE=ON -DRGEO=ON`), **2152 of 2160** facade methods resolve to an exported symbol. The following require a libmeos built from current MEOS sources: +Every facade method delegates to a libmeos symbol of the same name. Against a libmeos built with the extended modules (`-DCBUFFER=ON -DNPOINT=ON -DPOSE=ON -DRGEO=ON`), **2278 of 2286** facade methods resolve to an exported symbol. The following require a libmeos built from current MEOS sources: - `geog_from_binary` - `nad_stbox_trgeo` 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..b9a71de --- /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 int 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 int 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 int 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 int 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 int 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 int 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 int 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 int 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 int 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 int 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 int 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 int 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 int 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 int 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 int 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, int 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, int arg3, int 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, int arg3, int 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, int arg3, int 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, int 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 int 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 int 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 int 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 int 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 int 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 int 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 int 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 int 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 int 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 int 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 int 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 int 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 int 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 int 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 int 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 int 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 int 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 int 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 int set_value_n(jnr.ffi.Pointer arg0, int arg1, jnr.ffi.Pointer arg2) { + 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, arg2); + } + + /** 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, int arg1, jnr.ffi.Pointer arg2, jnr.ffi.Pointer arg3, jnr.ffi.Pointer arg4, int 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, int arg3, int 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 int 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 int temporal_value_at_timestamptz(jnr.ffi.Pointer arg0, int arg1, int arg2, jnr.ffi.Pointer arg3) { + 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, arg3); + } + + /** MEOS {@code temporal_value_n} — SQL-surface function (meos_internal). */ + public static int temporal_value_n(jnr.ffi.Pointer arg0, int arg1, jnr.ffi.Pointer arg2) { + 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, arg2); + } + + /** 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, int arg3, int 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, int 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, int 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/tools/parity/emit_sql_surface.py b/flink-processor/tools/parity/emit_sql_surface.py new file mode 100644 index 0000000..f9e3286 --- /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 = "/home/esteban/src/MobilityDB/meos/include" +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 index 5596e59..8e6b6c7 100644 --- a/flink-processor/tools/parity/parity_audit.py +++ b/flink-processor/tools/parity/parity_audit.py @@ -177,15 +177,17 @@ def main(): 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("For comparability with the SQL-surface bindings, 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; " - f"{oos} out-of-scope, {sqlc} SQL/plpgsql-composed functions with no single C symbol). " - "The extension wrapper occasionally renames the MEOS function it calls, so this view " - "is a lower bound.\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) From 8972cafe961bf9cbb155c1b967227a9850c382ab Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Thu, 28 May 2026 02:31:13 +0200 Subject: [PATCH 13/22] docs(parity): record the JMEOS-jar / MEOS-library resolution skew Section 5 of parity-status.md reports facade-method resolution against a built MEOS library (2277 of 2286) and splits the 9 unresolved into the seven symbols declared in the public headers that the build does not export and the two functions the JMEOS jar carries ahead of the current public headers. --- flink-processor/docs/parity-status.md | 16 ++++++-------- flink-processor/tools/parity/parity_audit.py | 22 +++++++++++++++----- 2 files changed, 23 insertions(+), 15 deletions(-) diff --git a/flink-processor/docs/parity-status.md b/flink-processor/docs/parity-status.md index 570226f..e26eba2 100644 --- a/flink-processor/docs/parity-status.md +++ b/flink-processor/docs/parity-status.md @@ -45,14 +45,10 @@ The facade is also matched against the underlying MEOS C symbol of each addressa ## 5. Runtime symbol resolution -Every facade method delegates to a libmeos symbol of the same name. Against a libmeos built with the extended modules (`-DCBUFFER=ON -DNPOINT=ON -DPOSE=ON -DRGEO=ON`), **2278 of 2286** facade methods resolve to an exported symbol. The following require a libmeos built from current MEOS sources: - -- `geog_from_binary` -- `nad_stbox_trgeo` -- `tcbuffer_from_mfjson` -- `tfloat_avg_value` -- `tnpoint_from_mfjson` -- `trgeo_points` -- `trgeo_rotation` -- `trgeo_segments` +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`), **2277 of 2286** facade methods resolve to an exported symbol. + +The remaining 9 are present in the JMEOS jar but not exported by the MEOS shared library (a JMEOS-jar / library version skew): + +- declared in the public headers, not exported by this build (7): `geog_from_binary`, `nad_stbox_trgeo`, `tfloat_avg_value`, `trgeo_points`, `trgeo_rotation`, `trgeo_segments`, `trgeo_traversed_area` +- not declared in the current public headers, JMEOS jar ahead of the library (2): `tcbuffer_from_mfjson`, `tnpoint_from_mfjson` diff --git a/flink-processor/tools/parity/parity_audit.py b/flink-processor/tools/parity/parity_audit.py index 8e6b6c7..263d507 100644 --- a/flink-processor/tools/parity/parity_audit.py +++ b/flink-processor/tools/parity/parity_audit.py @@ -195,12 +195,24 @@ def main(): 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 " - "libmeos built with the extended modules (`-DCBUFFER=ON -DNPOINT=ON -DPOSE=ON " - "-DRGEO=ON`), " + "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. The following require a libmeos built from current MEOS sources:\n") - L.append(("\n".join(f"- `{n}`" for n in unresolved) if unresolved - else "- (none — all facade methods resolve)") + "\n") + "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)") From 98ae6d52095a75037c47c9bfd4d108c16e995f27 Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Fri, 29 May 2026 13:50:23 +0200 Subject: [PATCH 14/22] feat(parity): expose the minDistance set-set distance functions in the parity-gap facade The parity-gap facade forwards to the public-surface MEOS functions that JMEOS binds and the tier-aware generator does not emit. The gap generator excludes the derived forwarder classes (MeosOpsParityGaps, MeosOpsSqlSurface) from its already-covered baseline so it reproduces idempotently, and reads its MEOS include directory from the MEOS_INCLUDE environment variable. The regenerated facade exposes mindistance_tgeo_tgeo and tgeoarr_tgeoarr_mindist, bringing the facade to 2153 of the 2153 JMEOS-bindable public MEOS functions. --- flink-processor/docs/parity-status.md | 25 ++++------- .../flink/meos/MeosOpsParityGaps.java | 43 +++++-------------- .../tools/parity/emit_gap_methods.py | 7 ++- 3 files changed, 25 insertions(+), 50 deletions(-) diff --git a/flink-processor/docs/parity-status.md b/flink-processor/docs/parity-status.md index e26eba2..05a0797 100644 --- a/flink-processor/docs/parity-status.md +++ b/flink-processor/docs/parity-status.md @@ -1,10 +1,10 @@ # MobilityFlink parity status — MEOS surface audit -Generated 2026-05-28 by `tools/parity/parity_audit.py`. +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 **2156 of 2156 public MEOS functions (100.0%)**. The MEOS public surface (`meos/include/meos*.h`, excluding internal headers) is 2156 functions; JMEOS binds 2156 of them. 0 bindable functions are not exposed (listed in §3). +**Headline.** The facade exposes **2153 of 2153 public MEOS functions (100.0%)**. The MEOS public surface (`meos/include/meos*.h`, excluding internal headers) is 2158 functions; JMEOS binds 2153 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. @@ -22,13 +22,13 @@ Per-family runtime behaviour is asserted by `src/test/java/org/mobilitydb/flink/ | Family (header) | Public ∩ JMEOS | Exposed | Missing | Coverage | |---|---:|---:|---:|---:| -| core temporal / set / span / spanset / tbox (`meos.h`) | 1279 | 1279 | 0 | 100.0% | -| geo (tgeo / tpoint / stbox) (`meos_geo.h`) | 417 | 417 | 0 | 100.0% | +| core temporal / set / span / spanset / tbox (`meos.h`) | 1274 | 1274 | 0 | 100.0% | +| geo (tgeo / tpoint / stbox) (`meos_geo.h`) | 419 | 419 | 0 | 100.0% | | cbuffer (`meos_cbuffer.h`) | 173 | 173 | 0 | 100.0% | | npoint (`meos_npoint.h`) | 118 | 118 | 0 | 100.0% | | pose (`meos_pose.h`) | 101 | 101 | 0 | 100.0% | | rgeo (`meos_rgeo.h`) | 68 | 68 | 0 | 100.0% | -| **total** | **2156** | **2156** | **0** | **100.0%** | +| **total** | **2153** | **2153** | **0** | **100.0%** | ## 3. Bindable MEOS functions not exposed by the facade @@ -37,18 +37,9 @@ Per-family runtime behaviour is asserted by `src/test/java/org/mobilitydb/flink/ ## 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; 874 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`. +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: **1335**; bound by JMEOS: **1065**; exposed by the facade: **1065** (100.0% of the JMEOS-bindable SQL surface). +- Addressable distinct C symbols: **1336**; bound by JMEOS: **1065**; exposed by the facade: **1065** (100.0% of the JMEOS-bindable SQL surface). -- The remaining **270** 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. - -## 5. Runtime symbol resolution - -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`), **2277 of 2286** facade methods resolve to an exported symbol. - -The remaining 9 are present in the JMEOS jar but not exported by the MEOS shared library (a JMEOS-jar / library version skew): - -- declared in the public headers, not exported by this build (7): `geog_from_binary`, `nad_stbox_trgeo`, `tfloat_avg_value`, `trgeo_points`, `trgeo_rotation`, `trgeo_segments`, `trgeo_traversed_area` -- not declared in the current public headers, JMEOS jar ahead of the library (2): `tcbuffer_from_mfjson`, `tnpoint_from_mfjson` +- The remaining **271** 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/src/main/java/org/mobilitydb/flink/meos/MeosOpsParityGaps.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsParityGaps.java index 34a9d7b..8132180 100644 --- a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsParityGaps.java +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsParityGaps.java @@ -115,39 +115,11 @@ public static jnr.ffi.Pointer line_substring(jnr.ffi.Pointer arg0, double arg1, return functions.GeneratedFunctions.line_substring(arg0, arg1, arg2); } - /** MEOS {@code mult_float_tfloat} — meos.h · scalar / stateless. */ - public static jnr.ffi.Pointer mult_float_tfloat(double arg0, jnr.ffi.Pointer arg1) { + /** 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("mult_float_tfloat requires libmeos — set -Dmobilityflink.meos.enabled=true"); - return functions.GeneratedFunctions.mult_float_tfloat(arg0, arg1); - } - - /** MEOS {@code mult_int_tint} — meos.h · scalar / stateless. */ - public static jnr.ffi.Pointer mult_int_tint(int arg0, jnr.ffi.Pointer arg1) { - if (!MeosOpsRuntime.MEOS_AVAILABLE) - throw new UnsupportedOperationException("mult_int_tint requires libmeos — set -Dmobilityflink.meos.enabled=true"); - return functions.GeneratedFunctions.mult_int_tint(arg0, arg1); - } - - /** MEOS {@code mult_tfloat_float} — meos.h · scalar / stateless. */ - public static jnr.ffi.Pointer mult_tfloat_float(jnr.ffi.Pointer arg0, double arg1) { - if (!MeosOpsRuntime.MEOS_AVAILABLE) - throw new UnsupportedOperationException("mult_tfloat_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); - return functions.GeneratedFunctions.mult_tfloat_float(arg0, arg1); - } - - /** MEOS {@code mult_tint_int} — meos.h · scalar / stateless. */ - public static jnr.ffi.Pointer mult_tint_int(jnr.ffi.Pointer arg0, int arg1) { - if (!MeosOpsRuntime.MEOS_AVAILABLE) - throw new UnsupportedOperationException("mult_tint_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); - return functions.GeneratedFunctions.mult_tint_int(arg0, arg1); - } - - /** MEOS {@code mult_tnumber_tnumber} — meos.h · scalar / stateless. */ - public static jnr.ffi.Pointer mult_tnumber_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { - if (!MeosOpsRuntime.MEOS_AVAILABLE) - throw new UnsupportedOperationException("mult_tnumber_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); - return functions.GeneratedFunctions.mult_tnumber_tnumber(arg0, arg1); + throw new UnsupportedOperationException("mindistance_tgeo_tgeo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.mindistance_tgeo_tgeo(arg0, arg1, arg2); } /** MEOS {@code nsegment_end_position} — meos_npoint.h · scalar / stateless. */ @@ -276,6 +248,13 @@ public static jnr.ffi.Pointer tfloatseqset_from_base_tstzspanset(double arg0, jn 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) diff --git a/flink-processor/tools/parity/emit_gap_methods.py b/flink-processor/tools/parity/emit_gap_methods.py index ef895a5..7d86776 100644 --- a/flink-processor/tools/parity/emit_gap_methods.py +++ b/flink-processor/tools/parity/emit_gap_methods.py @@ -15,10 +15,13 @@ import re, os, sys, glob HERE = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) -INC = "/home/esteban/src/MobilityDB/meos/include" +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"] 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_]+)\(') @@ -45,6 +48,8 @@ def main(): 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 = {} From d436ba5003097fbfd96c3dcf6c3983229436e6e6 Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Fri, 29 May 2026 15:25:08 +0200 Subject: [PATCH 15/22] build(meos): gate the extended temporal-type families behind per-family build flags The generated MEOS facade carries the extended temporal-type families (cbuffer, npoint, pose, rgeo) in per-family MeosOps* classes; Maven profiles mirror the MEOS/MobilityDB build flags (-DCBUFFER/-DNPOINT/-DPOSE/-DRGEO) so a subset jar can ship without a family. Each family is included by default; passing -Dcbuffer=false (and likewise npoint/pose/rgeo) drops that family's facade sources from compilation, and drops the cross-family facade smoke test for the families it exercises, leaving the other families intact. --- flink-processor/pom.xml | 97 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 97 insertions(+) diff --git a/flink-processor/pom.xml b/flink-processor/pom.xml index f4c288f..21e2cf6 100755 --- a/flink-processor/pom.xml +++ b/flink-processor/pom.xml @@ -216,4 +216,101 @@ + + + + + no-cbuffer + + cbufferfalse + + + + + maven-compiler-plugin + + + **/meos/MeosOpsTCbuffer.java + **/meos/MeosOpsFreeCbuffer.java + **/meos/MeosOpsCbufferSet.java + + + **/MeosFacadeSmokeTest.java + + + + + + + + no-npoint + + npointfalse + + + + + maven-compiler-plugin + + + **/meos/MeosOpsTNpoint.java + **/meos/MeosOpsTNpointInst.java + **/meos/MeosOpsFreeNpoint.java + **/meos/MeosOpsNpointSet.java + + + **/MeosFacadeSmokeTest.java + + + + + + + + no-pose + + posefalse + + + + + maven-compiler-plugin + + + **/meos/MeosOpsTPose.java + **/meos/MeosOpsFreePose.java + **/meos/MeosOpsPoseSet.java + + + **/MeosFacadeSmokeTest.java + + + + + + + + no-rgeo + + rgeofalse + + + + + maven-compiler-plugin + + + **/meos/MeosOpsTRGeometry.java + **/meos/MeosOpsTRGeometryInst.java + **/meos/MeosOpsFreeRgeo.java + + + + + + + \ No newline at end of file From e69e3ae787a760c14b636887fa819060e44bb6b0 Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Fri, 29 May 2026 17:50:32 +0200 Subject: [PATCH 16/22] feat(meos): converge the MEOS facade onto the MEOS-API-generated JMEOS jar The bundled flink-processor/jar/JMEOS.jar is the MEOS-API-generated functions.GeneratedFunctions surface (temporal multiplication mul_*, the set-set distance functions mindistance_tgeo_tgeo and tgeoarr_tgeoarr_mindist, the circular-buffer and network-point MF-JSON readers tcbuffer_from_mfjson and tnpoint_from_mfjson, the rigid-geometry trgeo_* accessors, plus utils.spatial). The org.mobilitydb.flink.meos.MeosOps* facade and the MeosOpsParityGaps / MeosOpsSqlSurface forwarders are regenerated to the jar's signatures (boolean predicates and flags, direct value_n returns); the tier-wiring demos pass boolean flags accordingly. The facade exposes 2158 of the 2158 JMEOS-bindable public MEOS functions and the SQL surface 1066 of 1066; the facade smoke and all four DataStream tier-wiring demos run end-to-end against libmeos. --- flink-processor/docs/parity-status.md | 12 +- flink-processor/jar/JMEOS.jar | Bin 1210863 -> 1228478 bytes .../flink/meos/MeosOpsBigintSet.java | 18 +- .../flink/meos/MeosOpsBigintSpan.java | 18 +- .../flink/meos/MeosOpsBigintSpanSet.java | 14 +- .../flink/meos/MeosOpsCbufferSet.java | 16 +- .../mobilitydb/flink/meos/MeosOpsDateSet.java | 20 +- .../flink/meos/MeosOpsDateSpan.java | 18 +- .../flink/meos/MeosOpsDateSpanSet.java | 24 +- .../flink/meos/MeosOpsFloatSet.java | 28 +- .../flink/meos/MeosOpsFloatSpan.java | 30 +- .../flink/meos/MeosOpsFloatSpanSet.java | 26 +- .../flink/meos/MeosOpsFreeCbuffer.java | 298 ++-- .../flink/meos/MeosOpsFreeCore.java | 1460 ++++++++--------- .../mobilitydb/flink/meos/MeosOpsFreeGeo.java | 528 +++--- .../flink/meos/MeosOpsFreeNpoint.java | 162 +- .../flink/meos/MeosOpsFreePose.java | 152 +- .../flink/meos/MeosOpsFreeRgeo.java | 62 +- .../mobilitydb/flink/meos/MeosOpsGeogSet.java | 2 +- .../mobilitydb/flink/meos/MeosOpsGeomSet.java | 14 +- .../mobilitydb/flink/meos/MeosOpsIntSet.java | 20 +- .../mobilitydb/flink/meos/MeosOpsIntSpan.java | 20 +- .../flink/meos/MeosOpsIntSpanSet.java | 16 +- .../flink/meos/MeosOpsNpointSet.java | 18 +- .../flink/meos/MeosOpsParityGaps.java | 71 +- .../mobilitydb/flink/meos/MeosOpsPoseSet.java | 16 +- .../mobilitydb/flink/meos/MeosOpsSTBox.java | 128 +- .../org/mobilitydb/flink/meos/MeosOpsSet.java | 50 +- .../mobilitydb/flink/meos/MeosOpsSpan.java | 40 +- .../mobilitydb/flink/meos/MeosOpsSpanSet.java | 60 +- .../flink/meos/MeosOpsSqlSurface.java | 100 +- .../mobilitydb/flink/meos/MeosOpsTBool.java | 32 +- .../flink/meos/MeosOpsTBoolInst.java | 2 +- .../mobilitydb/flink/meos/MeosOpsTBox.java | 82 +- .../flink/meos/MeosOpsTCbuffer.java | 30 +- .../mobilitydb/flink/meos/MeosOpsTFloat.java | 76 +- .../flink/meos/MeosOpsTFloatInst.java | 2 +- .../mobilitydb/flink/meos/MeosOpsTGeo.java | 50 +- .../flink/meos/MeosOpsTGeogPoint.java | 6 +- .../flink/meos/MeosOpsTGeography.java | 8 +- .../flink/meos/MeosOpsTGeomPoint.java | 8 +- .../flink/meos/MeosOpsTGeometry.java | 10 +- .../mobilitydb/flink/meos/MeosOpsTInt.java | 60 +- .../flink/meos/MeosOpsTIntInst.java | 2 +- .../mobilitydb/flink/meos/MeosOpsTNpoint.java | 42 +- .../flink/meos/MeosOpsTNpointInst.java | 2 +- .../mobilitydb/flink/meos/MeosOpsTNumber.java | 46 +- .../mobilitydb/flink/meos/MeosOpsTPoint.java | 52 +- .../mobilitydb/flink/meos/MeosOpsTPose.java | 36 +- .../flink/meos/MeosOpsTRGeometry.java | 74 +- .../flink/meos/MeosOpsTRGeometryInst.java | 2 +- .../flink/meos/MeosOpsTSequenceSet.java | 2 +- .../flink/meos/MeosOpsTSpatial.java | 18 +- .../mobilitydb/flink/meos/MeosOpsTText.java | 38 +- .../flink/meos/MeosOpsTTextInst.java | 2 +- .../flink/meos/MeosOpsTemporal.java | 196 +-- .../mobilitydb/flink/meos/MeosOpsTextSet.java | 22 +- .../mobilitydb/flink/meos/MeosOpsTstzSet.java | 26 +- .../flink/meos/MeosOpsTstzSpan.java | 26 +- .../flink/meos/MeosOpsTstzSpanSet.java | 34 +- .../demo/MeosAllTiersCapstoneDemo.java | 4 +- .../wirings/demo/MeosBoundedStateDemoJob.java | 2 +- .../wirings/demo/MeosCrossStreamDemoJob.java | 2 +- .../wirings/demo/MeosWindowedDemoJob.java | 2 +- .../meos/wirings/demo/MeosWiringsDemoJob.java | 2 +- .../tools/codegen/regen_facade_from_jar.py | 78 + .../tools/parity/emit_sql_surface.py | 4 +- 67 files changed, 2317 insertions(+), 2204 deletions(-) create mode 100644 flink-processor/tools/codegen/regen_facade_from_jar.py diff --git a/flink-processor/docs/parity-status.md b/flink-processor/docs/parity-status.md index 05a0797..bcfe7f4 100644 --- a/flink-processor/docs/parity-status.md +++ b/flink-processor/docs/parity-status.md @@ -4,7 +4,7 @@ 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 **2153 of 2153 public MEOS functions (100.0%)**. The MEOS public surface (`meos/include/meos*.h`, excluding internal headers) is 2158 functions; JMEOS binds 2153 of them. 0 bindable functions are not exposed (listed in §3). +**Headline.** The facade exposes **2158 of 2158 public MEOS functions (100.0%)**. The MEOS public surface (`meos/include/meos*.h`, excluding internal headers) is 2158 functions; JMEOS binds 2158 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. @@ -16,19 +16,19 @@ Per-family runtime behaviour is asserted by `src/test/java/org/mobilitydb/flink/ - **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 2699 static methods. +- **JMEOS jar**: jar/JMEOS.jar exports 2743 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`) | 1274 | 1274 | 0 | 100.0% | +| core temporal / set / span / spanset / tbox (`meos.h`) | 1279 | 1279 | 0 | 100.0% | | geo (tgeo / tpoint / stbox) (`meos_geo.h`) | 419 | 419 | 0 | 100.0% | | cbuffer (`meos_cbuffer.h`) | 173 | 173 | 0 | 100.0% | | npoint (`meos_npoint.h`) | 118 | 118 | 0 | 100.0% | | pose (`meos_pose.h`) | 101 | 101 | 0 | 100.0% | | rgeo (`meos_rgeo.h`) | 68 | 68 | 0 | 100.0% | -| **total** | **2153** | **2153** | **0** | **100.0%** | +| **total** | **2158** | **2158** | **0** | **100.0%** | ## 3. Bindable MEOS functions not exposed by the facade @@ -39,7 +39,7 @@ Per-family runtime behaviour is asserted by `src/test/java/org/mobilitydb/flink/ 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: **1065**; exposed by the facade: **1065** (100.0% of the JMEOS-bindable SQL surface). +- Addressable distinct C symbols: **1336**; bound by JMEOS: **1066**; exposed by the facade: **1066** (100.0% of the JMEOS-bindable SQL surface). -- The remaining **271** 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. +- The remaining **270** 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 2bc69e5cb0588e3a0d83dfe2aed2c99047f5a44b..b970140e16771c85d06ce4dda018b8527c8d2ac5 100644 GIT binary patch delta 138721 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
  • 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

    • Pure-Java fallback for {@link MEOSBridge#dwithinSegmentMetres}, used + * by the BerlinMOD-Q8 streaming scaffold when libmeos is not loadable on + * the runtime path. The primary point-to-line spatial predicate is + * {@link MEOSBridge#dwithinSegmentMetres}, which routes through MEOS' + * {@code geog_dwithin} on a LineString geography when available. */ public final class SegmentDistance { diff --git a/flink-processor/target/classes/aisdata/AISData.class b/flink-processor/target/classes/aisdata/AISData.class deleted file mode 100644 index 32b9d6047312ff357a968eca5129990197692f8b..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1423 zcmZ{j-)<675XQd)%TjPDg<7mdTWz%ks-Ugb#F{2ei3tStf`1dQu!_4pb1)uJtBY1JaL?CFSN!`1HpEXjSC-Wm<$-~RqUgQx^~AAw z=GnMUlWo}}>*MvXYfaA0?tn_ZHSU>%jybW#4@AxVY�MR*3po!ML#8^Eo+NZBlgp z6SY#a+)+p}^@G<6vl{f7<@;KxAqhGYTGAHdb-Ijuu2!ng!ln#X05j!@PJoviK=> zgW?k&A7_nT*_t9bzgj+1AWz0s?}UQq>%sMcCjAQa9!kMk^Db_X`5FQ#M1qu2nSsRo zD=Nh)GGUMnf)p2k$iM|;AJ1kW^NHlXhd?$XL7t;J1G$~Z-W0ho$TmTC7J$f$3rH;z zWGxJ`8wv6v8e}aDQX$Cx0ucG+1mtBT$a)y08VPa`4YD2vIUva40ucG;1>`Uiq!1mv~%F&zB^VHcTl diff --git a/flink-processor/target/classes/aisdata/AISDataDeserializationSchema.class b/flink-processor/target/classes/aisdata/AISDataDeserializationSchema.class deleted file mode 100644 index 8ed1fdefa36ed69628b935d13f7ad0fbace2bfa2..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3879 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 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 9762130f24ac028dff662a6321c6abc1bd676a1e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1857 zcmb_dSyR(c6#g!Yp)ty$qT-6Ow4g)**VY9oXrTp!%IM=ITuLxaI!Ws2yZ=F-{0%zJ zD5Eouull1L&%I6CAUZDNLvwRa&iT&vozt)1K70Z&g;gCbXw}eWpdEV{y0-WeZaUm8 znTu;%!U`GoWNgz*}7=}E*Wbz8PHifz2*zRMx*ru`!s})C>Mfsf6p<}NG z!@xf5XXxa1u+BqnPUTjzbTViq5f;jUt)O!{y3nnm$G`y`Waw^2l5;~*5@)zODz8jefw6Fbt(det>YFdRx|+)wmT5Dq3G4RRp6D`s%wR|Dp{FRI_YG- zZV@S`Q~5vZJ*6~>OBya4xPq$;hoxEIY)o#Md9OsxoaI*N`Og>76C*nFwksB@ zpvADC!eOulmVOzLq2Mno3t$tJ8G()@MF>$EBJfR0YAD{kh`4d4M{klAw`Lz<6B4qRAs@4(Ed#xaoU)tinj*jRk>3fjl715- zqo1L_!}%Y<&+LmH8KJ46`nS0NibLP&EpI^QKSVd7o3~>bs9Z3u@r0e{U8#Z@p z#23|2e9f+3ULE#=C6M;A0? zFsfio$0b~5$p7Bo;+8YjB_<-OTfDi^a!g5+1T}b*VLDsxif+>?{OO!4xT;`6$2DAM z7<0Xv;oJL5b))RoYQo##X5e~93@Qm~FZDsM+1&RDxxccYl7vYeH*t&1wnH?A;j?)P zrWqDwId5|E*x0u%=M_yX!*m-B*D>}ZX})nvXJXB*l7T~I%MshH#-8wA@I9MW=n#|J zJDe_$=FwszII!q8<~mmY+sXn%@{rrD5b}(f4BC^|rf5pjeFX-?NH?dm!!Xl(5$*0H zySk~-61CBm2oBupbMEnm2!uy$Q$>@^2-{SxST%xHir*2H#gP6I?uYRK9)@ul Ok11-Doxw5+P=5gzGBoP| 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 2b7b258ca2c2a6354f15f42969479abd813df225..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1294 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 diff --git a/flink-processor/target/classes/aisdata/TrajectoryWindowFunction.class b/flink-processor/target/classes/aisdata/TrajectoryWindowFunction.class deleted file mode 100644 index 95fc00dae1a7cbe7534a531127aba051948bbf1f..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 8314 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 P$1W;kf+&`Va}oLv*Y?N) 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 From 6676bbb4f5a0457a03b6529f41ddb12e4d74bc6a Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Thu, 21 May 2026 11:56:38 +0200 Subject: [PATCH 03/22] chore(jar): refresh bundled JMEOS.jar to PR #19 + PR #18 (2699 methods + extended types + utils.spatial) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Updates the bundled `flink-processor/jar/JMEOS.jar` to a combined build of JMEOS PR #19 (regen against MEOS-API meos-idl.json, 2,699 methods including extended types) AND PR #18 (utils.spatial.Haversine + utils.spatial.PointToSegment wrappers that MEOSBridge.java imports). Surface delta vs the previous bundled jar: - public static methods: 2 699 (was 1 685) - utils.spatial.Haversine.distance(lon1, lat1, lon2, lat2) → double - utils.spatial.PointToSegment.distance(pLon, pLat, s1Lon, s1Lat, s2Lon, s2Lat) → double - tnpoint_ methods: 50 - tcbuffer / tpose / trgeo: now exposed - sha: a5895c9b94… size: 1,210,863 B Unblocks the MEOSBridge.java import path (line 116) — previously the jar shipped PR #19's GeneratedFunctions but not PR #18's utils.spatial, so base-branch mvn compile was RED. Both PRs now coalesced into a single jar built by: mvn -pl codegen,jmeos-core compile -Dmaven.test.skip=true cd jmeos-core/target/classes && jar cf JMEOS.jar . Unblocks codegen/flink-meos-ops wedge stacked on this branch. --- flink-processor/jar/JMEOS.jar | Bin 1176689 -> 1210863 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/flink-processor/jar/JMEOS.jar b/flink-processor/jar/JMEOS.jar index f0db3a0390f47506019d6597d83b7544abe042d8..2bc69e5cb0588e3a0d83dfe2aed2c99047f5a44b 100644 GIT binary patch delta 120792 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 BxaI%= delta 86415 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ώR_B4`5eOOHhAjex3fB$ZQBqys={# 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 From e5707ac04b375d4d2dc43e5b6c442d19cd0e7afc Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Thu, 21 May 2026 12:13:11 +0200 Subject: [PATCH 04/22] codegen(meos): generate tier-aware MEOS facade for the full JMEOS 1.4 surface MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Add a generated, tier-aware Java facade over the MEOS public API, organized as one Java class per MEOS object-model class plus one per public-MEOS-header for free functions: - 50 `MeosOps` classes (751 methods): one per MEOS object-model class (TFloat, TInt, TBool, TText, TGeomPoint, TGeogPoint, TCbuffer, TNpoint, TPose, TRGeometry, TBox, STBox, Set, Span, SpanSet, …). - 6 `MeosOpsFree

    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 z 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 z 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

    6HfWokQPGLk3nDYq&uJk$q&ui+sm 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