From 116bed1a858a012c19c6b003bd6ec3af7d1083e2 Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Wed, 20 May 2026 21:16:27 +0200 Subject: [PATCH 1/5] 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. (cherry picked from commit 07a9e4f34c53c9c400432ecd0a70a63e80ed841a) --- 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 56e5cbf8123cad05c08b88e82b73523f3988ee51 Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Thu, 21 May 2026 08:56:56 +0200 Subject: [PATCH 2/5] 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 -> 1210863 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..2bc69e5cb0588e3a0d83dfe2aed2c99047f5a44b 100644 GIT binary patch delta 1107542 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

h>3vzpuj`c|(7~kNHJ_JD)5F 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

?9l53=M4 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 bjiND3C$p=I8g_r202+tP1aZNj9>- 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̀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

Mly`9iN`h8=0OR^fpA;a6HFr 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≷7w*yRk!LiQdK>h;Em2>s}Z!2^x^(F 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�MBD*sqkcQ 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

y!W(Wo~DP_B-HQbk|+M6u7@KslN&1kOrD zJ!20mIVXGzA#M5&-*f$?Soc-fzkiix0+OZ!SkO{Mn|OAmrB*c}1#D)O6?v?9wBoS< z84B=-nXM|sTg>J-%yCr--j?7|H;SxX8Q&kYpa#i#7tx=4X{CJ&EA4(-Y4>5J)zV7) zKeW;+X{C*G#MWV*QgX4JcLV)dMEU0<|8mN|1o@w&{Et%pDv|%i)c(p1vVWrX$_+!+ z%}%w=sjlxl=43ofh~tn{88TI=I|zex9;2sF`BXyQWxf7#-uAWf=t}dF(f*N)!SG~V zQsBRuksF>YO9uNfCXNC;6)Z9NE~;H=-=cQ#I)(sl7~U4*ZQ+uG{{46=!BfeSo&N2C zy++18K1{Zw6zQc)!v3{*a(~#j;Mu{(eDY5l>41&B9+wAI>5!HCzu7I;3?LJ5R_Txl zII9Xcd}(FDyP}@3>~7Tetv%e7Vjs*`XspTd@^?W_%Jn}NE5nT*RustJUCXI!^i;r6 zVP4|(kH@YC9B%89K|Is`Y@q~f($2Y!va7IdR)<^cMNMAB&-xYDv$~ zn8=`y-BfFOhF>Kz{C`BxP>`PC89l?2C33@MJ&ifOG00SynrZ%Q&M*}(O443b@(V{` zpOGiWcMGzVVr`^k8qS%n#486SvQBM&E-#=hG)YaoVhp;juhPsqu1wn7_nLJfq@~iz z!E}*$w^c_Umir0D;+>pWiJ$jcL@64f;=2n(X6kEkWr@g>Fn^y;&}S0_D&llB4@|0K z)GcTUAfR$S&vbp{1hY_FE-IymyUqHD7k4fKUb+`>%?2>LfQE~!EQ|8!&xC?S7jdbn zCGwBMO>ug6kfI)^G54sw>LztF5u=ABBH}{jPpjL3IF90BEKz-Br{(&$0HRZnLKX#M z)W*G{XQX0K6n|?n)ykcXy4ipHKH2Tl zf61Y8##yoqu@`z8CEqtdIb6*(2nb3RZAjLz=mX4qVr~DqC&TD_6PZgzX2+tRiv}?m z6%J}J7E0G|T%f;>wEkY7(%&mn`m6Uu^f=iQmV1S6|G_V~A4_EF$3Lg6=PFTerJ3uk zw1^dWrGJjgiz}^qy_Hx7RRz2jQ~8xjQNBu)2gWY06yjL#@wWPE`7ACxe-yR} z3b)O_Hol{)tn*qQcp*}it&PK=!~@M)-q0MFn}0NkIH#It%PC>gM~k+?tdwbT9pqt3 z=wUq)s&;*94lCvGElzoxllrz0Z||eG8T#8;XUba(-j=77-I)5e0B^5OdHYr;EDZ80 zN|ds>HnTsI@FV*zwI)1WHnBVgXn_S(AAFa)__}fN_Un`;b z�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

@sx-X9B26+Np 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

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

VAbuvLa+4VLSUzrRq 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,OkjEphdDiWhVazm*lIT?PK!cg)y)lw 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
(Rk3+4 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

i2Hnf6xPkGe>_`_A{Cdspk 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 K9cg-y!~7qOTB`s6 delta 288749 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

`uSimf15D(ZkKX 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�P=wH=S!>U@HN-)W_OmLo7 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

$IDcxSK`ke7 zD34cev>9q=*&UG9x@#qvaoiOD_=hS6SDy*l!fm~k&Mtu0%W70$z~5_%n`%SLa*?jY zT)olh&sU{T5Xf_~UpI0qSUY~Fn&^1^%(al@Q+bR<<36ne;Vl6M%jvm&-Y=Gy$l6xc za!t0R!>>1R&jSIlZaQ{Sq>PZY%*(!0^7kict^D!FiINlF z7&(24my-6S8Y37QASXoF@ZRH}GolrlMdxw! zBZ0Xdw{64sR?l3V4#!)Ax6-JFm>P3VyezC#6Kd3|A%HuE!d=&t`}w|$BKE`;^yq!$ zfjpoe^$|Ywm$qf1dH-s2q1 zg6)vE!=N?Q&6pFnmF8_azx+{ERQ>7XH2N&haxs#fA$%bZJU?t@m6#`lI^&&8L}mr@ zP}_M4@ZjMkJaWD0`ryrWZd**B#vN$y%2_pplpU(ibCS)TnKjV7qc5IsJsjMCt^ z3eLVrNt>jvlpR~_#cq$eOl1$F_VqLvQyPX37c0IdWif!eGO@wuBqBj>K9aw0Wc+FXivoj@R_fzl^TTSfTFuZxI6OXbntz-AJmt zT}}FDDb7(gHC>SrS{Fixq&MSXn{h5#E5{wFA2)FqPWuy9cJa&vF+TD1Y_j=rurFW^ zYpmGaAGUL$Im0-@MXMY9X$7byZeiK{G;E=EIz~!bV zy-nCd*xSY}j?&7UQkNLR*kHQI)`C9261#2rvpy}>v}Wf*T7M)DL$Fvdf_=V5D%-x; z(`X&#bTN!LoIT&KGrGK~5YcKB3!G@9$)B?rQsviB!;l~__EkwV_Kq*5w}wyp8`kpQ zTKVYEcUy8;BS1g<2lM7_O~WP)PIAB|(YJ^Dr^I1;y!x~<$$d|4#l+uT+dQi#ZZTYVvK)|Kl-nZy!6dzEbPo zlI5GG!r&o#$<#A_Wx$?JWIf+QORSU9+7UlVoq@g=EV5*=fT^|peMxL?buB4JOTZ|5 zv%){$7h(ErVNZ;imi*Z{gO{r47eYOXc|gZ9*D*M0((s;meDdj{x5r}wqb6oCZMH}H zVf$pE$Z5K^yyv!iz0LGb93>2$WGaH#{uzoLS5r*gKj#3~ji0%irqTFL%c2Gvx@(f{ z`dWQDwzsSq(45`Fwu@-lMXo_vf1o6#lLijHYd^#2MT$~5^gN2j1BS zgJuV?YVXa=W@O_R-5!mPZ53UzYy2uW;QKEIL!rDTy_I{L5r-u^MK;O;cSv!#+u5xM z25{9WDb!XGz- z2f0PXPF0@ega{otN?eRu#~8%6(F!TRGloQYq9M=a5#NNbE!w)RgSD)JL1H_iM5o)a zt{F)!L29FV+}C+O0wD}Kwc9)+5Lfs*W{mILtF~>*6dTU2bw`?MPP8_jBR`Z$1_YT3 z-38sFq)sOL*rLWqPXt<_BbnZ#ZJV~O!fnO-J+tqDv+t4fLR`Zk-)8#=0C=~9cRjic z+1%3svu;kGiHe?rOpyEKWLyPfOs3geTiAwQa+vg)P!rWU6nD%}^(E8iyS-LX@eQ4& zpGA+5`{N=Y!K#Q(-NGP6?=oN(k7XdwiyNRZm)$NYi;$Vd9sH~REVVWT z2DP1X1N0@S7ie%}hhe~iu0gttoW2YFB-u7zRxw{;vEs#Jnx!>)uLaea&KoZnCZCYx z{O1hY&%8Rq(C$=~zP%&Ab25NSRe6vU`nMC2`wJ3_-0O$?Rt{z|S}JH;m(|&{vs2zb zabNj+Gz6?xw~wY-4{5>WyYPh%YT5QF%@^uCO83xUry_uvQ^2hC_mvu|X{v(1ZmE0k z4D0!s@{mva@opY)AS%i5k5qN>3gXLY;(aNGL`o{D?)9*X0MW%)4i&W^76Ygb-WH+x z@Zvdz!*ndA-v-%UVb6^^Z#Hj|63@h}{3YeRHO9WdaR*`T>ByPeO7j!>~@-716KNlfIo?zzPG#7grm?+79J|MJH6&SyFa~=l_{bL}!UVm6JGI9Etua6zczu!|fYkz-qH1kx7^K zev?z)2tkL7!cGSPC5gCcRCwpK*4mz}g)bj%aJw(e<8Ghxee z&c}QN0h1!ND(5GETFZ*+ z4S9}W2ZdEhRAAg@Kt;G~Zg)T6M06;~v8P|dAXKEY$pAk&WJ7$61)nExwjlBYlg-Dc zYDWQ5Iiwx_NDB_*WGh99!0qTePH!Z?n>*x;XN!s@oxV=uPU8p-lS;{A<1?!+ zoAYmye{W0~3?=o-M@t zsmUkz2}|8;U~UN;qzR)AZ!Ct~Z#XlL?^B}KX(aofc<))A7SAd^WSce!^cg^N zc-;bREkuI71U6phr}jNZ(qbSPJMEPQ0+_*&0|ev=zY_E0>zc(lMislHa~HwEFn8H-0grWyaTn2 z0IjG9;b>5VbmwTI)6*sL;v-2>V#$o~(oy5LFYn+wZ;lrHEscsi0Zh5~;o<^eX{%zP z&sX2MgA5w-Lkxe0J4awif6ZpbDgMH3zg01;*xfAw|{I~tIG}pTheO>8KP`T%pF{>%zDuiYd-FGD)_>R7{zm^@^ zSTyHiDB6n8Tk;~SLtgm-Bb|>lHq*v!Ig~pi4dIk9af zo@6||gZvS?VziKud_vTQ?{>+tt_##knYjWP&M1^739)KxWhfmNfK=h?Uqd2!CDAo-K@h!OC)HVq7wt=DvgB$BBG=f@Uy&Rw-HF&h~|{ zE$P8!VwU@GJJ@zI^1RN)zfi>R+cUe#=T*tKzYz*m z+!%L&0V$ecQtu1Ocg|DrMq{|BEb(o{*dlgtRa;EFL2K1#PWt~rojI^%2LM6M4bn}s z4_aEgxa6(k8(POC`R>lJQCqcfoEDra6bHqSkBu_?o}x>#WODWmTXK&x1nJj|4Od>W z`0AEPDK1SRoAgLzKgHAu{XfXKG;Jpzy8&)>X@%OjLPdhpdR1*LI35}aZATdf=CG)z zs?NT`Jr)TcOjfGMt%!iGc>Jzn&urY;r@me&GPm)ZRnvy$j|al4v>3bXbz?tzkRPCB zK*JbS)0?{M@Yi5L2YQ&~(Zjuaazf?DN9FPHBjROtzuF-Nexm*$4ST}^ z)I0|HiK`6bh0hT#c+b}MD%B{_UO2Y*$ytH}IHmdPbN`UJJ-~!k4fjY)YC|_BtS?ZQ zvF`8?&Ap93cd95N`e!<$d+l%oEqh^H_Y73j=Ujr-5~Y^F=D3q83jSXwcT&k}&j_#t zFqXu7?xwUuS!+@1(>uOsAV7&qBID5KOD>s52v>V94^i}vmeihu5BZ!vXfmIoTLb`v zhbfGxZV40cg)2B)|H!AVckz3V3$7vIuwd~&Bc0~-v)&b z3ic^>J9GY~*kv4d&BOLdV^?F^Xx9D?QM3>6CH8lUr14`J8!>sLC?U@7p{NIKQ1BgX z00?xXWFIDP+W<}9mm@`QWt`nGg?ikiX@A)C18^HcjYMa;&p;a~t@{>7!>Z0MJMmow zDu0_+#*IbS)8nr^{cD12O78^j@}bvC%2cO26CJoKf^|zd6$ynitr|73_vm8w)#NV& z-ubg|D7Nv(O5UY_+glmeA6oH<@-5Tx!Q57uBe+IAzC&Z7#^m=yNyZkczW6Qhu^z$$ zoWuM>45zmm0O3f1>qvX^48nx)2w5GoiGi{6!mwgDWyQ^hZl~XJbdhg<(A=o>UFI&h zjbjx6O~gG)^7GBJ5cYyOC%~h91-BR4W`pjK2ZK&uPl z5CzLb4VPP;tv(oV8`(f>nzUGT7KySK1Q*n71L?L^?>ZD}@KdBS6i1fOUrh$YT+Dpfg{>_jN7E-B6 zZ|qs5say--Zen7P5NeA5z;O)r!OUMlfe2mN^;(l~oWl4I zSV0H`#VLBFMl;}oM^KLYuKN;u>X3!F5HSt_+M@m^l9qwEA7kmD`6%+r5AFDH$g%iv zlDY5SbHPiL{j+0G_W=ohoYOmWLO#m6psbkKN)^e}WbcxmO5C*KA2PN01nL99+@>4o zCasoFhnl@tb`G(?p_#J0P5c__amM;-ZG(#s8qeHni}V~q^Wi4HwoKr8R!advt5oc+ z*=*0Joz7dEMHPZ#S)4fgkXWbEI>JcjM!%<|h399Xp?38k#>Q8eMdn#*E+p%zT3L~PV=XChehpCWeh zqU(|o0Q>hk=|*Jzzf0HY7K>@;?m|O;>#@r<>7mo(?7EQX)VPcc$dC`}z>H~OM$;I! z70X@m+lJrv4c8FKX)aQOKiAphQi9UrmaQ`wl>_%1ldoD=6ZL5TuKp1)lhjlLBHOTf zjm#Wqi~0(H##gvh4t7)gF{QyzG#-AO#(k?w)h& zalppijt1y)!5?a%Y_lJX|Kmc^#Fv&!d=O6-U(6evwP@jWG16uuLyVtc`T?u zeg3}^Dszmsw8qW&;(bQ9UROkApWsVH`O6nQe38L~2E{H%KvJE~tDNU!7#3pl{YEvQ zrw?Ub-OSaee!(tf^F6#0xveiYogKrS>|TEMQZh!yr?Ua=23+sT*hWdCGK3GV)*0$d z*xDnG+)R_0Ka;fR(LOZpKJpd!8cd*Bk90;&1RGhSeHR>yR9xN9wE@afO&$T;!%KSJ z>!JU_T}lm{ZO7rs%!@9gl^2^G5qC~41<(k};Be45`Qr;{ ztKv!v*LGUP<|zVYaT|;NuD@zSxQm)DL!y1msXA8Ze3wqCJW7w8abwR`QDhTo4o|`{Dh?r|LVsv(xNkwllPDm+6G> ziBr&a*~Q3Pb*9wA#>7@VV5=r@`Kv@qElh_=cjw8u$c6e|8&!CJgAFsfb6G9wWQaA;@mP`o8o8B z%c<=<#qph|`73g3>CgKiQGlB3G=|qu#$IpSjf%3Kq$TNbD>WL)v-{|kwWeMtuX-$- zCJW-UMk+5km)~ApTY;^SnoSpYmWeq<8p@$(n%RHNrguY*F|@Z)wn#M=FMBjSaUM;t zb0<>hRt9zh0vG&tEq}BwrPBCFaU=sl0Bj$y%@#3_Skwyx8Shkqv1-iSI1!R`we{tF z^q@vvpn?%b`xUm4;i>4ipvy!&_id@@Z#~3CEm*rN)$*BOx5IQ)w;SL6=7wc*qs_|I zk=AFuL^kco;TXsourZ?c36w{~Y@D`>D`RiCYJm}y>5*=xInM_B8}r<{O7k``miK}r zW6u~be1p2oMZmQ2x7%$RrBvkiizDNv&b`UI9`RpXJ=6RBtqP^=+kt~(p)~s#cSK|HL4|ZW% zbttiGJ2tOWPom$n89V8hEBm?9XN7s$Bl!!0<5n#yPNmH*qj zNG0U2HWRQM&as!iV9b~m*+BoQV`q*`L`Y|^ej%lXtayKQ^Gz#89czZ}F=BusbjK99 zw3Sivo4BuGj8zY3!x(AdA^M2_d-_?^nV;)oB|*(9|T35|z<-i14@gqkm06IVc?9*>$N`;=>iY3>GqoHwL(?zV))Xn;%1E zDH4Cvjf~{?0_O(Ian}ZnkuZVkK95UhTN@O#&&chj$r*1XN9X^Ik(R|p5T=^a*Y*zM=lwK)Zi&~5?{zi~cZ>5rQ&wv+VoYzk%2c_Mg}gI02q6|G;SDO$hs zCe{IODOapPk6j<5Rg;SCv>iB!XlqWxs;C;@VY5=F;A@YFlHG!|NW1REzxjvx1#k@X z?LW@tfBlwAE_3hR)5o7hVih75{)cc)#*(g8Hm(+8JOXC499Jky`UALe}P8{qI%~ekj}+>pQ<3xVo+L zhs2Z5ISv=vWiJeVrI+08_NM}GHcD9${;M~R7f$OUKNbP)t>+adXXV$X2voB_1nS|% z$jUOF{C8rJ%0fu02<=yK%Qdk`fG`pM_p=PC$eWs=DB37_b6N=*U0VaGcJC zhs#Ar<)1Dql_V+-17Gno(#u3wkSs9oH*+$}I zj+|91I`D$jT?ViZK|5MY?HV|8xa#ySm*84ps}@Asa_Y5gzUjXLXBfsMLr}ASVY;;|a>zXo<+ z!UgjCV72jRCf?G5V^f`_6ys4(Cz$WOKDyP;81IF{lT)l=nfgRix<KfG zP-*=2mX~QASiZbr*AQ0fboNuPG{$cq(Eyd`j>A9lDymnW{&cORVa@dD1Np3T0(zjg ziB(&!kTZX=Gci|%%tJt1ib9P*{R8HmU}@!@@-{kH}Z>o~Z=xl;vtpVTByWgLh1U_*86L0PNOOGc#wG#6S-$?qM z_)D~4RziVnu~aU-7t}6<;0p+mJgl7qaW@A# zf2L>E1#AkDtDo~XK9PjCiG`^DRtZ4g^GA9x&bWSpQ}bT?XJY)Iv-<)+RCHM~C9!q# z_7qT4dhd0;1sq%pd&6Atm8)i-_i}I8JibsE0yc}tZqvMUm#U}_g9oF#f$|m`%Uyzz zJL@ccm;HQ<8X_dU5AHV)J8#D_brv?vbtd)D;J9AmMY592<~v+-aRASW1peL@{mt)5 z`3=xZ^X=x9)rz;I{7Wp{j?41U1M=hzKG8Pd41aicOM3Q%e(axw(l>MF@pGL7&j0Zi zu%1?!mVP~dx^qOC5X(Ju+J4%?ahvF`mhx8=GKuxC!QbC^qx<=M?$)eF(jhK_Q-$%E z2?0Xt@p}bj*|>!8x6%ptY#RQ!Im^dbMgEBP8x{Dt>JY@du^kf2k>PTkK8?QZI=)%C z6d{=U2Vi&x^5xom1kj#nUA&K74`+@748__zfhIN^ah%ktwxzy3dU^}zO>f!D*Da%| zP64q`iZX#=hwwc$Q7%V5I!3XV-=z`SU)!@Vc~rK&i7 z;?G;o8jmvqst?2{k8=A+1Hy-%Oo*PxDu=s|=g?&u*-v=24srQgUr+UFZU}>4YN-wP z-3^%BR1`o%jxGd+$VC$Z>fMN-*-qv_nc7bmBt8lqDi#d)6mD<6-5bMQkQ@i~*^W^D z!e#U?hv9B6iw%osH2Z_TJ6{xlm6_OZCPDneUUnsL*UVXQ%t()}8#vx7Q7Q+6!mT%2&WAQ_F20X|^Zk0EYtU1z zr{jq9fJ@ao<65MTkHh|6h3rFN&TxBzwzqFL;>a6~%vJWO^0qt1b(0~&ry%O9%7^|S zF@Bw9v^%LgmAa1&{FerDjg_A2=*OFmWALF4a_1gz^tcz2GPum&NjKhquZ?={YZ2bz zAZx$-7v#`W{|%`ldA)H1QVtO}D&2KD4gr*tJY*--R}t6%nrR1@?jg6LTDKfGX`E~0 zoA)uEcy9*otUbXvauH!y$n{+5Q5Hwph}!{~yd%N)fKLHl?7i6@66 zmF%ytTgz@A`v;qdCg0qpOF#Am|G8#WW<g zyqEU_+%*nN-(J*C@ArHkNMH8}<{p%~#k&k`%DaoXPu`+7|Gs=rA-(K@eZY7}dKB7F z`S-*K4jG6V-(?m8XF6GuuK-Ay7?fQ%;4l3z=#_QarunSTt8>HRpgZ~raq!{GhysWK z+)HFnVH=3KWdz$j-E!i(TvfJvX0AFK8)5&!uRnG@cp<#LF|0UeNf1)EHW}{^zG=q5 zx&bs~0Ka$rw#!zb0q%9wz+8}-$nLL8dEe0Wwq@Hi%|ieiR^$Y9UM14H4XP2D^gX#N zvv}IIxLE$Y(dZ#8a=H$`@z5N|KQppyDk5Uoe`5}FkANd=Cg6_hHqpXH*t+q9e+zBM zCwB|(y5k3fE($`QOL|J*9mGVu&gSZ`^Ba$aL&mp|b9;l8^cF535GS!`w8~(ku~jqn zm63(-?`}Y}>lCh#S9y!zp5w(Wed*=E{I>MbhFmt)E9`}K# z(04X(Kp>gx%qPu34}x!n0S8va3!+d zH3-~!vh<<^>?4n;jOX_ZP}dXrW1VU;+hyZJ1wN|Jh41o~s#?RYrw5Me)bRG-kVCsQ z?ojYL-?N?=Gb?}=GeQErYc|eCO2|M)q8%dcpD)H#Q2u(=NN?T9&|UhHyp&XM`IyY( zxMh+Q^S(;(s>H8E-?g(%BWwr`T!;FcnE*lAqxUTkw^vmjwf+?Q7@2}Yr!F}qP+Q&* z0~)BUzL!!gyXJ#^bK&Cc=_NEG%L?g`@M zgceOQsz_`4-0U}Ls%R=+TE_WUe^Bys3sCb5({WMr+11g=WTru~&C=yGDemQRp9A8B z5*l5U(B=t+4wh8KJ_Qbzehr4ERJL`y=CH?lc(VM;#%PvQC%%wVIR+IrrXENbJTi`o zU%%>C>98A*4d2JaDxDD!kt8NLO5hyI-CO!H7G2{J3*aF~jLF^?4NETLZaYOj)E?m% z^rh?JmDeAK7^<(dX0z^@H@s#Uu>#zGu*e}B3J#}n&5ZQJxE!#I3OnZs6hmE!`X^Xg zFDnM@u;#j@WHoKwiHs#>8?n#Ve|XOCNVT9KIPHWk6rWFQvBf#o1`w~ZH&~>hQxrL9 z%64Ltoh&ywpydZ_Y2Ezxj3_+&1h}xQdD@b!G1II6#KFr?kV}%LR?|JZfFLZ#{AgJ^G;;a~Pso)k#{7u*wa=ywK{x~}0I`t;6-yh0*5^>};Ctxo zC9htg!2mzhjV6j$bjU6{16bANOqdF#o+YI@I>iOhW)R!8BhI0B-O&S3OSem7Q&&kXnz$bP`a7z(Q0sH+Kh>J{DOVd)Nc*d zHzFtvSug}J_tc!K!xon8W&gj6wp|2?1e1p8k)*ysrBw^=aH2ID+Ej4=?Ho>{Q-TOeThU z<>;@7Kh|dXn}KLKikF>4n;oW-a47MpSpN6~k~oAI3!NAOnmC5weoROtPav6WLeQ(- z-YQ>J$6PJG<{x8vxn&ni9p#o~UJ50%C@`#cqZUIA?pw6ss^aSIGzW%bd82S6fm z;dxqc0j^JQDXzOrXdUw~=3)#F8J{PdY}nJE2B?&Y^9s)5#J6Hmba?(|zDxqOAg55D$x;wU zU9&tqv_umPL#LejOHm#3lmtbFj33)t^BkQ5Yl((TbsGPV`T@@Yoodd$G-n@s%n{f{ zB%S7epDa2OD&&K|qbAd1_G;6|qffQIJ|>*;<4}Ct`)&X1%ATOUsL&202TaKw8h>(K z2xyv?N^{1rAwM?!2@#tSH(Y;JSk_+Df$mwspy%&BT+;?~#VM?kX1{kFfx1Mskvu|h zG5(jU9$nCmE-FXPmfzXF8PWUieOTv>|G*|+_fCx<$W^DtrHuf@V|e)r`%B#@N@TJ4 zwTu2J!2&{~ylTe}WfN`a1sDZG-&_pK!6nqVhl1@ptHtB&*Tx_sw2@p0mTRDR?^T3% zUM&tZPj`^WR2D{;>>P+oSV=a2xA(?S#tl0-(Rpy?nGpDO>pt@xd_Pz5GnMehB0kB5 zeLRYH<9K+d-ob!T)y)nww%>LeYrZxo5|0jS5}N0|M&p`*nGawze{W_+HdQFT-a7AW z_MMd|+X#JJxy_!NRSay?6K>YN|HoDEu(B5r#PYwj{Acyru4DE5 zCt`mZsZuYdTl*QG=}qqICZQD6J3`NsX&=8JeXZ30X#4+Yd@LGHA)YS3i8Q|)z*$oO zSEq30yJ+E3tn5~JHaUNIn;Y+UR3ZUF(S2VBqwj^vts$)cF|GeG`aM*F zIIkZ0@C4v7a3}WJz_K|Z6Vska$JBQdZ?Ar-oSIQ47g3i#E_&8ugEN-P?AYhn&_R0M zZJu{Iw0N)BtF{{aY0-xR4EpD<-FM94%qjvMp^eTh1@e7Jq`abRSF75Mt*8V?oS&~f zx{}cD2)Qa4c8;Hp7j&c-+!xB~LQ4-zwJoIQ-RCR5qL$>8B6zm+X)$oZFVLSyV=fhk zC={n$6GHDeC-cLr&8Q`gyOu8yZP0uE*RiRacht)T+B8m(FOqt|DW_KP#o%y>Xa}B@iYiXQgE1`NuIucD7pj zsV4-4EYUCxyoji1hmCjJ(|weBQy0GjAh{%agF`Bvbw2-4+1yyUREDGavrKbSU%awt zs6E=p+t_RKV_cYDm|00J(^2``Xqii(cIA06wZnz$2XI4DCOiI~h^c@z6j!HJE;^_9 zSY`CTIA-e(iQEE`_bANxJVtuwVw*#YcayWY|LkRR$d$*IE`(fbzCM?hcJA5?X?cnbWWKXf?w`HuPkY1SRt`7C? zrz+;_Fp9PSp#~Qw#9&DbNwf!{M~PDk3;qx!B$nxjmo6f3gOKxFh0LdIFRP&^#iYVn zl!6W|IF7$T1H@-oZsQqkJn^19s4(5`M0ox>vTu<9B)bZB-eymi@Xy zj?XrZJy{|fbPM{?@-y0=I*Q0CS0>Ek40EogodX(!jD0X(&bG7cR|Immf7u$}KRY!1 zRY7vf@oQg8OP@dS{+#qT|4xfznFTjZ16MpHtD)e^hW%+;wfu7M zny=iMP}o4TRL-)%9&P|uV?=`ow=aS}_N4FEY*V1ute#LRBpWzi$t{{KJq%=xyjYf6 z0lCoIv%h*EBx+aK$}WGpoJftf%$aJlA>gTR9#a0dd?}GskV&L?nJBvSZ>jsflUlQ( zXFigFCX>!o*eJ5bjK+BZ97RP*Ok{Ni&lkcE4)1k484smWB#&hd*?zBq^>aaUOP;LF zDe6GZUuv655N{W{33~e4ivK=(*P<@NdQQ_%?MbFrY7T2Faj7givxl6`3D6rl+X2Nk z=aNQ#_&hO$xUndu=$iQbg{ofnmy+#v3uW3X!&xk7xmmcs zSPS2;Wv1PxtrRhiIK-W?E*g0)8v&j=(7Ib#G<{Fc*QSC*A|ROEX)|cNDI^}xv^nHO ztmQP1RKY;7arM~b#{9gX6h74#?tT>*0bi(b3S11|q&UIbd7AI$q*3))%8fQnq?zXa4Z~SI~O74>bQiH;`VA zuwAN2w$L3BUnXyIw=HtJ*!}A~%heGs$-5=vO!fukvkS?NlnXZYQg{0cH@CwgJ$aE9 zhuh=;liJTe5x)-9hEF#Vnh=p*NGNgErWpi4)hSct`foEw6|}h&Xv6X>2PsbEfdyZj zmh%%W(q>>mm7gx)3&cC5+W{MvIwKAo@AuAqC(=&qP5Pp@4{AJ-;AgDiIQ*RG=%#4G zVbHD$jJbUV$?Quhx|(h+gjZ7+8$}eNinX?W*oeH<_uHgbZb;Vxd3mLAbno@Z%Xma( zg&_kbl~gPRm4Mf?Tj(W(1r`vR`W-`al1@6~_3EzPG9^S2zg-(h>|wP27&Ly)t4q!GIa2@b zl~pB#XkBs)eC#t;nhzG=Jp>w$LA>Ncz-pAzd>Z^U@B&S)YW^IyBH2vhOyZm;RZn*; z93ayBU?4-GZ!zn@BqgtCf-;K>L4@_Z3qGeQ6JRXgH1W7z4=6!lWW|u!*9@=d>mhtg z5V2)sK|{rHL9bA-3>)sqPXrzQSnZkRnRPH<5)j0WGJCbEMH7`*Ao*0qxsIannKRey z-ua0zm!Q}%RwY{?_#abvX+4{CG&jM=0jnA8Xy3~9q)Nza!ROoq%eLr_1KeDH_Bt1r z!YVMf*P}s9CScXq?2t&Z{34S(*`$fF`C6VQduwSxVDYZ0iu)C^BP1Ge<1xAkQ$Zyr zmwpQhv<3}ba2(=t6bP(TehW^(OWb91jTUi?M`t&m!+=Y7svG@;g4m|cJ=vEOpS+=` z-TlR;GZmrjeN)nfkn%GN0Xg9jP%P$?iBd1ki&d+HxSnK=uD1r|a{k%XK~e z`YGu6S0FUOqn*g4kMqJ;n6#ImiZ+5H?E7vI|GWANIV4d-Obv{2*S4LFb_mxwa_a;PDB-^h&{5u!`8Q)U)V6?-Wa}Pk3jYv6&2&biZb5t ze_`nOlDcO5Z4yR7Wr%Y6v4K-5t%iou0wF$(ybMqfF6-8rb4AS;N_P34rf>c3ROuQd zncI>sLil@YvZ^mA=W#u!G}88J5CulXo&O2ob-$Zo`e5NQv9BGMM-RS((Fcj{|LZas z?{x_$Dp?e$Q-6d&rhG46@o|1vCxdHy0r>Oau(_c7J~SeUO-UZlMNRcB_Sk}W^AZTL zw1LGP-;$9H6n;IJz5MG^D5l=w*J26oHH-JJwpllL{RFq8SFiSb9pzGW67b8y<}&LJf^_yc(Ju{E;*AzRqPexeWJmtTlFchG~_?9N6P z?h)Ih29^gyQC0|95J`)7*yP@(IEU<^JTGd0h;6??*6S1VIX)?+KL_#3CzYh1)CVSp z9QcwEMQO`~~BT#>)|ZY>vK{FeO}@`~Li@kyTB!B=3r6T?P1# zEig~|DLfx_mZww=A*u(Dk}$|!;W#lz(Vj)kK);hm;9=H~V=^sY42e`c?2CMlrV<8* zuB@VYc#44$H3Rg=3-q{YV9{-nV7XhFXyc=XaNajMyRNzM(Jv*~rZ~5>0gc1IKFMOp zvj1YYs!)u9qlKEmj?kc7lczMF#*P3qP}k%+S?QP=X5}d%)_M~*#7R^^vLTwzr6^@C z6=L+QOK=|cbwGJbS^2GZWKgr^(Z4HVhl!P^%7_9o(XWwM zXCeHQS`qxsK$KBqps9{hcnM6GNiUH;s%r-0mkYQGPC-#Q`U|*9PeIXhov$LJdJ|L? zijl+0lGq^SGFyo4q6TdA{36J2iF5k0p;VtCvKSFMW7O9*!+w1(#;%wo#gISO#1nJR zby7q7ruoHOJ^g_cPu>hbN+1CiE99sn)#DW9d$1w5t0W}j9&!dD^1`_T!Vtieh?nOe5IAeX@RCQny6!?ttvK z{!<2@R%4g&hu#J+A$4t3~Rc^3>!mex)#eHlgDt!!{fWl^!WEy{^NqfwzUFOZ*Aq1 ziIJNUZ$9@4f;j@};Sx4p<|X&jO`pzRt=a@NMi+HQlj=EbN5ajWb~C$jax|%hV0CmY zwPw%u5f!cEW>2I66`kTm^Sb>Ldy6!}FI6E3jT}PU&8z7EbAsS8Ud~F9;y`V~fgO}- zvV=o&2Pj`_I!!coeXqNe>u3v6&s*`9%Og#- z2l3SFLE^js%3m;D>o2QU%0qryw7yXsm^>2-xWwiGBD<7O?xIsYL@;KtwIs9U6bG&^ z-t6+RW00}21#HQEJ^;UtctkP8|Fd~hY6vJ#_7!|E*YU(#~8 z+xjl_9YPJ#{*Xag$Q*MV_YK~M8JDy=e@+kgYa9&#q9I!dSV7RK7Sw{zd1f3NemoR5 z9g+XG`?NgRg05g4kBnMDYFTr`t3<7)&7-%x!v};%AxQ(4X0;^scIA3(#yU*Xgeq!u z=n&8+Icv*nre9x#dH<}p_9~G`qNg4sr5VUOcabi(2#Gp8So54qa&^G7s0 zwW_WI-J43MLr-i4+{g*XM~(|q$u+BV83Ii1s%*>8R?b_DO)Fh?M^M%v@$$NtmZrI% zizz0%sI07$VrFJpyq|amnq$WPnIL09;Ij%9dybH^)d@b6Jk<$C#A{QFWnos&jSc@6 zhjJ(-sW4Qb(zjToln?jREWr3lg~nfnxMCFs4F%|mD?2NBUs)~TYDIz#Q}62L>0(8m7N+^WCaaDn z#~{C#zPXpC$&sM<;{bgE;=X|cXXXYKg2CR+$JI&JVigAoBEetJT;e4t_{usAp~*ji zy}T0}vo#16>92|%i(enbrc(yQvHl!FWQ*sX(>@j32UA}8@GS2n>&O-QVx!jWL(YR_oI6xmgQh%_x| zizgTgzDy)Xtjf$4wC@%>iBy*$mY}#LfQd}3W?XRYCW1RWcvboOS>Fn3<~A5j zM!3qF8H$2lIZB((lV!!MUX-hGcsTwuxz|NxSGdK9C4TBDq|nA zkT?Zp>PKQ3Xc&CV#s=5GV1wpRG^ymi)0H2OV@5JnZ)O@b3Fz)S?>kXA>Lj$_G#cO; zY_f`I;z1?a{&0{kQr^mt#JiQ(xhyoc?-xiwP_jf;ZvHWSq6;TGuSEtJrR!rWcaXC( z%)|C9Z3^i9XbNT|XcbD+Ww02_r$KgZj?8`|#lG0LF4PQMVz{d_%bZE`Ak@+b8OkmG+p9n2k%!~l=KZlhYQv^xiY`QP= zcy6$-a8|h88s5gZ)tPzSD})p~)Pr#CR2RNlpB6~E(>S)E`w4n)+-B#=okx^MVbVMa z&;B}&yvw%vTQ0AXWK4JiKR69v6OqH#Wpy$Kos2U~__`SU$%`4)(%v7k?Yv9NdjrU}i@;y6*@27%_5;K)@dCPZ z0)7gpENL<9{WNZk8Nvrew_9gzE3~2HDfT0M%2b-hc|<5Lv2B+>%;vx2@uu<9Aorc* z-y@tq@}e{dcMwj__->v4R)RCWA2SNBFMgRd$w4DBuU_{)-&o4SwRtRu z{y6-Ik#C!W11kBjNQ;r0)$tD4ME6XYsxkYKVP&(<3X+Ep;b3Uby2u%Xy(K|Ezx~b< zB4Oy>+4uxc7(i42|IDAWHJyH|-3r?z4}=|6K^I+_MudgQ{%u4}UJ%4_YNTx)XZc)E zkC?iKK_;I`_UDBd8=1RN^3Z8?Va~KIjqOaAwfv`AJYW+t7yj$GXh+Ql$ty`v)?P%c zq?LqznS**8eOn@Fy8GK^DkD>UTUfy>Ix;NDH@nvc1 zMwjOQ?BVHz^hgGkcO{WV{zpEU1pWV-g9L02k^eQvarh?FtuelEWazqaNJh!?E?Js6R(3Hwc3-Wt6f>4@iMYoSr1~S7q=ZD#KZyu=`<$OGdPxR< z!#~aHhAEtfqZUu09=)L=z-8(c05=kr_I9j>leqU1X$wPTqm5$6;iDdNSG2FF0`kO^ z%_QXW>nO>mcoY7B9|EGvxTK7-M@eVr;IupX0PWZ zxi=V{8f|cGw?7g~m2$0GI=VCG^>QZU4s@cM=WbMX^2)7+-8crS<|iWKSHXB1wRzoa z0!Ad&2ux5g4XWXfxtom$mr;>G<{twtGM^{t-8%>aoZiwNy0I5lDX`xc}J2*-(ir4g{vY z#a%;&G2ZCwemrnPa_3Lqmb8xTUvUtXOVP>%wL&g->-~|x8pBjg%4}0STU1@yw>-SyU# zFiU#8Pk|uLUWw=aa%h49^mW-mIBzl(F=qy(kPrsFqI(rHk-`3LH6<>|B zZWQJLi-rXAgg47{>g>;29>|4z6bh_m(V(r|&-wwEB+a`}pLR>1k#aaE5FFi^upN77 z&S=yghauTH#7)upWDub^gK4AXilZi0IMo_gV5Ns(3NUi+BqqM6|K*s7-Ed+o<47U; z`1Z`F?$0FSvPb;6@s4^>&!%xQPW6*9HL0HwpcFmEnaZ}Of@SUnp*H2_3Nh>KU{}+S zZd@I6V@WlXQRxJ+Eo&J-CHZ=O)rYEatYQ9&@#mow9S!7lV<8X-JyUcg06&~7FKL~f zRAHS>Wb4_|u(%q`ZOO3CO55x9D`77WVnj?nHUydwj)4yu*_F_7X0{+CD!hfB1lMvA zkRS`RL6oY53ONkjVHFP!|GpuTp`43=h*)+)#^%020dlX}mcD`N!K%K)pe#lYw)lzY zuy=U*QoN09d4)Yn|Mt()zq+W+lW*zvD+C59Q?Uz{sW|kmZ0a}5vJcPC( zS%Snw#TPr#PrdQ-0eEt+uFvubcE{1ufZk+wt&)7A%^N4e=e~b-*fEq)Cj8%r)B~Pm zsq4WNxptuWnDxGgEO~%Ek#Xra`uV5+5^eey)(X$Otel1-rt^Av{Y_fy9hZ#c;EF(Q z3!-TIFseb`r&kC`is)H4k3ZFmACT%bFFLNQm7o5oPWb1?)NCp42YeA98~SGkz%zvR z%8(hV8~B0!41P{s_(G!g?WmhXOk8VUr+zmqrXYkmjdB=i!0`xbtUB*0Bk!FUArzAw z#U|*V!BrY$fjyA<-uMuUFP~t#CLqc|Ap){cmu^Q9(b#R3lCzXIf>p8ptT}&wcYg2r zKxf)Sa73;4cBC^l+wv*(mtZvpAS!m_GA*kLOYnnDwb*Mi)sX9bgY-U-1r#S1Va8i; z?Lm8&wU+YeNKMP z(nGL||3o>M+n(o!+Q4hc?UPn`{B@SnNSQAW6Ymp_yXoiN(^sSEg}{0E>Xqyc$xAn+ z&8yW13@;!vXmX#MgWw_edVICY2VDNgf;XUI$c`(80ylZ0>?Sr0pDq)dEGgbd-y1*x z-U}T`>?MjnrsGk7?5>JGXS~df86L1oLFF^2j%xDH3^s_rfQHrY`xm2IUCTuE-51M} z^gtfbZ@iy_#{vLSB&_{@52&(y%mQ<9=#u@)Lj;iouUqli zU`tCB&(ah}Q0Db%1)*Q`>7sM#*5qB3NSWbDep2j^5<)cS8GcI0Z}Vw+pH|co-VZM%%S{i* zz8+Y!2m=@fLaf@1%M=#%-P&R=PPOWj#*CG}rgD|Zxhq16V4_Pez=yuZ6aNm5)qm*s z!MYm$OitmdG-aB|P;Y|G(P{%by?l@me|&qJ*^Jcfn@;>YsYHfSomZ_}BXvG>dC4|T z^dk@KgWI#e+|5K>4^2ZCo`si<3X(hQR(_xU^2;xJArivAe9CTSKd3Av zhtk0+KfW?o!CcYW{M#JZGbA$-UC$a!t;ob^Y6Ux69zHDVRAdkt4WdW4Oer=)`)vJI zN1Dv2L4ao^)a*^Z=D7&xwP+Nw)q~9%0zl|a^ocy9BOn+KQOqa)+RaCPB(rCCM^kE6 zhbq%X$rSE9b@{p`n#;tQ@IkHGOGpp#n)Eh5A3_VGDDycHw}=YrLRzJl%;)(hTn!?G z&q@Zw^<*{L=%jq3ebi$)c3lu%DZEh0PMe)#b-i-lF*&K8Zul2B zU7-;M;>RcUK`cq`Uyyjhd4J=4C~r-C!~Pmclb zARuET+HkoY^w6IB@b-JgH<#-0cB?b?lus!@`j~u^(_^h{et7604}dJz+h{59em}R! zQx`$B##1b=max=(?PE{hag~xT;WzbiYYArzvclL4FAW+c6mZoQp4t<;$m%WHkyn5X*p8QU$qS9pm04Xw_t99h)WuH{9c{S1P?T=Ht8z;oRA&JZrrg z>aoXL3K^wzbdqMBB1H#pM7K=*4W=THBtbHx4J&VElA%=pisFMzypJ?pqtwSjA1Dp~ zO(UH1Qd0>xw6)^os_9ZosUasZv1(_Z(t@E>DTn>o(%EOwa?6!C0Ef<7^$eyvC*1EI zGir-nih1m02^d>W@Ik;bQqpc!w-8UxcirHqeAi4eO1O|4NpgtnY){0p@_U|NPCmP~ z@&M<@>y2Ko(Oge5^Y@FDwv|tt`2>@7-=6g+$&HsZ3=i&>aDh%kI-7Y$4i)bta3om`g zM@mGLd*_#wun>1`vqseUn6tsH>Tak4&ozGWO`3;| z_gOn>7O?g1sM>L}zNLgAk}K=2GpJ}7p&!8>(ogK!n|I(D^$J=yaAPW0Sh33($6JqZ{*!Fa7&iY zz|L&y+PUYyl`rJAZKZxsS(On1=EIW6t#RYB{O5;%jx4gbdvJ+;n=JU>=*biL$6UC7 zzWPK_{3BT2RrxB(GSSqqbr1I=&Ojj!snmzXX5(rFgUW4${60x;*a9tZ&uhcg-^OD& zKRzUXgnYM=AGB&AxDx=slrZ#!im2ixd|N}>c|)fA zBL}5xfFl>B?~mo7#O2l5G+Yh&j*qp!@Fxa2K@z{^UsF%4%v$*)Rz^o|W55?7=1TE6 z1%pyIP_^=2!m^!ViYI<*h4NlQ&3v0BnAFN1rV@$XYY>Xw(F|wHx-&zh5s2QYLbl*N zH$wzk2XK{xa0m2=hg~ZMaHpSH!xD*xUA4iAudHE>0@2Ck)5GIcGsEMSHWpUe;Ih_O z|F1JUCV31j11B>9#x=phC2(nItY@zTm#0{zAf#jS1a$*o-?M8MFq z4wk=y<^RBPu*^D;Tbo*dfT59}fFUtACK+#f_>W!J495{gX|J{41||VM@LCwcLHM?E zwNekBm)!R)26k;QX7lk%(Cc@y@TB2NfovReTl2jDB)!`hhNxzymM~7Efj?~}PusUb z1FkOVC`y}bh(9x7p8wps_YUst6zw(g+1j?nO>bNdrkiYY%)FQn6c-&I2GpCCS0wxm zh+{~ou*^6$vo+UZpSfWb?500H^ua9&r=NdiX6M`i13=pR=7~gFmPo$Oq2y-#3*?Vq z7>6>_zRXT4gkv+3x0p_tpn!6{<3(hqIxcl^p4cq`Q>rwjIa2J+>- zw5>8y&1@4SlK<*yrTb_X=f;@<0g;rAPl3vXSlific1Wty`32|)7>>>yt#3U z92k%rv2p*?1WL~dM>rjbb}b3V-5Hd@*_n)E?7v2#?>{C{4aFc)2;~p~V&P9EBESkL zJD72V{d&Uo@TbsWt|f2?JA)&i!8f4wN8Y@;9`FV6zKcomzClOTP5&K8Ke*l*qzmA^ zxfLQ5aYrf5Z4TE^Tp7?)UK-$6L9xjw496%v+?mw4aeb{4%nFhwUK;b^otG5M;)O%8 z$pOOmO1E}y=Pz8N@BnY#iB&IMnzbFp#5333SN<$tXQJ3#?eKY(@&W!#WSb1Ra15H+ zok@%%*Vhfcte`DIWi~5h8$KiCQ$@ZkyA(p@EYffemDqvnn_bsuJ~!RcfgMGS9oJn( z-Yj2O!r0u`uz8h$0lI_VJB){&X4xlU97^s3ksKSY2dhrJL4Y}dvPe17X#jVY9W%j_ zog?o&CU+LEKax#Od)OXL_0BEElIyM^SC(%M{t}%%@BA%imbo?l^jB^CrO$S}^Ol@h zyeMGhkT8tH_?=1jQPNqNsi6)CgQvqF1^ zHe9MkqbcmAcQ8#8RN-m4cV|(pVJ-ivcpf@6`o|xrA*+AXRl=T9>8`QuNvvk@d}wE8 z5?M;Be;ZrE&}4L@qRUA2K#J_-+r#U<8_b5%m3ww49m7Zel6cIx&5y1ET}AV9V`_gg zZ)$&U)3<<0)3?Al6I@QG99*uK1F12e>~-ROe74|GI=687m0C&3=)HW^8?cW$QJHFZ z($D~K0Q>u{+>8S7eqhJ91tfE>zgfSeSjC^h|m@|e)svkZY}bL=12X=q;-;qH>}^| zh*PoA3gE!;biwRrhpSqcXcLJOYMG@xrj~0w0>;9Sut6lHSv(?~)_HbrZg&2fYHrRz zjlGd;2pfA_OG|SBClBnY=#Qwdh4~-@Mqz{DA@y433j}y}CT!65!cVFtrcA5(Gaz%c z!HsL&ygr&B!;WQ`CB^N5lK6elYOlM8{4c&!x#BubkLF485RfS~{Fj}`+JrfCFUxX= zQ-G$!HH;#=&F~;*s)@y_ebS$>~c}mmC}~se<~7g$YCTIq3$$EW(kw;WE#70+q9_%L=v`ePQT2# zh|P5#hq`2s+Y?37sBA2E7N1LJbb8m&PTbH;y#aI0R=neKH1LLM2kx|g_sLf68`d=< zt0SwZe{NCcdQ;X=cJAf8YDU%2t-I5$R!Q|FGY{NTrvDja9<}eG%si#6B0txr%!WJW znX_sP8zl4+!{$qv$wAi!;@{ij_8ZB1XeSPj5+-N%4KNy4q9|u(hq|BGf1awm2k6#C zo#mh?u*WIrN_E&2B+Oi)>%=Ri3?2@A*Rs40&~1p!uOU63jR+93np0n~T5TqOcVMok zdd-<|Y@w{jeVv|jY$3DbB4-$@Am|_#VZ3ILb2mg^`h`nV86>$3B&z-zm1pOXT>9l| z%I-<2C8ExpejIEtH<0C5KN&ZgKwQm;J>j#6N1Q|jYK)xt5yFBN=TD$kEB7Hx{-W*P zZAA0P|J-!BypvXkEbpt-^4fHrzZD`dBqGd$3Q2><;ikS)Tk!CZ#E{D=mGBU8o5^7p zwV%UDCE*wiKk-WwSZ24MObZoxB;ugn%YBZ;!+7B7wiqsYJKfqU{;Oi=uUR5eKxC2o z8_(B3oz+}?yp?KoZtciabvQGX4MTZ8@J}WCS%|5oBgw6KMj$F9Q4flrR#>2EVF1Y| z3iV591N{dvR@yz`vI^w@9;=1>#Ge^pi8ZbkP<_Tym$@-HrrRHLglDHKj8B67(1J{rsJ#T42uPIG!a3Dd2T!b5q>)& zPO;v6nyQr#kOXiW3}z_49Xrks6v{|#P5Bgju!W5w0>99R@E%H0;^U7$Jfx+m2{P=f zkUn>ZQUAMkzxN-P3c2ivWVG)oHT38o{4A8oy4o|nLc6M@ba_Y|r|gqh@eeFIG`~D1z{yysO)Ufk z3egSx<3{)yBg@5rFg)nx!cwx@sJpi80^&$@JKt$rENyFV{OiB;S7)b?oc%;SCWb+u zl{Ii=SNaD=Sn+SXIFiE`a(4R7t)q6t0oRxyvB^?>nIhF$bxB?&hFzLN+{A92>!G1K z&g|?wV4a6-{$5G;s}csg@%+MdVo9ik#y}SdISG*LmRi(xv40xT4NW#?KleL{*M2-S za_^M|$+5jm2~gOv7?6XrY0H+wB~s=WyxXfDtt)z{_0se5uARNhV#}}K7u*_=X1)71 zn@F95ebPRLZ(^i}M}*}TEYH!#R~s0Qt}tu*f@jKY*Jvs?Ek{jq&nljdNH z_xsbf#iDT?mwR69K_W=N7|5Th{QUXK@EMUg`+^~u`nDU|ReW(@Uc^v{np{0D3S@-$ zFuO38{|m4S70dWhsu;nv{^Fk@5mnai2YCIZau~8?)R(yd0nTd?e^p~B!#ik|Mn9hjr z6%ecmG1q+emlv}f*69%V4mrq~MWuf!y9GWzBpCiS4BSVWB3GeXWi zp!_qonT0Ku1>huWW%>!MdH*1X+iV?uPSaaRrL6t-d}DlzDV$ncr~wH~hqoV9;(1VttA z9K)~2)!u$aPC$zr0;dQRX6X>&EWInQ?jq--es^?Dwi#Wf)QOb8PXuqZ9IW~eKn`s< z6-}6(t(@tA&MyK>7lQ}ugYNXaNRuj{^Bo0#c_7VBJt7mqQ=N;_Rw9QcdXr`u!S#;` zpib97%Sp@B3ZH_7UZh!CaOmJ?uvrautw0WKJQtnglH}PF@F2}$6{<>w2E! z9@WwxxN6O9broX`8l89`oICKYMQoyW;~Q_wUhBO{NpWlRp6yfPS+xYJ8=p>CaB#b3 z?S!wtS{N~VZ?)g5pO81><+3&W&=9Y4y+6(maUCze{BZsFitL=Dmn$~Q7q{$u+F$v? zDOt1ri))=n&%?d-#<~R_iLvfilbt{8V~+4C!e3tS)$8DdLB1DSM91lM8mRW1| zG+`C$4`(LZY>fI3i>X0_kw(!xgPL{U}bR>n`=O4{BdA>1FUrw*mXGhV&t@rP> zW%Bdyc?*2DMO|8}w<##uC}89M-q5?H7p<9us;_IrW;N&N3@836aiwoiE4uxt*1Wp>6XtL3ySQ6^{&B-Q(<90;rlwyM_$f#8 z-eS)RkyXvMicMD*`MGE6MmogrvzsO4Yww6Q)tubrGWqyqx%!u3y1t*PFBQq39ypn{ zsi~@2OFy%}iM!3wiW9aWP3yp0#)e)Z!9p=GUnziIA9`zP`HAy7Cv_7Kw0`XgZBAbu zw3)`#^i5w97pSK+u#Ep~%f&C5(^dRyrn8>ZRP*gOWkIc@T_1N9}{JUcu z;nVZU?5XBwQLl=m*t9Fv=OzAos^u1;;XXwhoeA#E71Hl^q>AA z{@1`j7d@rFelT{&p!`=Ca@myyGjka1n!)cA4%S??_$7tGSyUkO=CgTE++@k`G+So3 zMv5${Hj}yjakMh|dC!nXzUb^p)?8`NNtOrgzzDm_PU4tcIb&z_c$Z}zzh8_{p!d8X9017X81yU zMH0wxIV({e8C@e(9mk#~o*=5>MU=H17?KZRj3}PWv=H$G5}sK}`Y8G&ribW9Ts^kbX|evZuxuVIZernzXCAf#Eg%xe^VG}BE~DyT0} zI8KfdZxIa_?H1IR#g&nhn1;!<-X5nmJYci)gFpprD*rQ67Da^%H%PbT9mb&xMAkhZ3yuj8XIv z%vlg-gTS|0yPOk7SCR&b<_db6lgl^}3g!C8(!&{}iD@v5tKbwbxm^D^2d|RE8!exkAs_Nyz~h6bf&skNzlXV;3=1oW0*6= zES_>HCyX(U&=gM+r8LKtG343fq|@Lfd4W!IdKlkkQcvwlVFX(pktZ)0!Sf2mS78+q z8&`P|B?e^*VeC;b%zXiI8+t~Rb7knmrGBFG0{@ce2(}_~QLv);kf@;9rGzU_SA<8V zi-MZl%D8fbiTEfe_z^4x?l|^O(qW=7fkK)73C2(CsnVGuO#$o`MvP>th?4|WJiBI_ z61oi6iyco)&!>x5A%HDQ6hetf%n9Ocf)E}noS+Toj-^kQsvv?nh+zE_wDIJ0#7rB{ ztc?8=VrDI3#zXLy$2h?nMlOPzp1@6v<19IH9zrI)loLXzF-?Pw#KT1f&B|r$G3?RE zqdlS=gbX50AxSY@1JkPLeP-I5i~>@Cj>cY zDz-rY<9kt~Nqx~;I7GReRE1Ck97QU_HU_Xw0nes{kR!P1OTO5w5=OKs4vuKHIgWgq zhY+qo2&a#yk2IBK&Jj;TKGlZmhw&BY)0w)+ZnyI2P=+kRCSP!o=ZlC;mqkP#6uZ#fKjQmoQ1Vm6#$O3oKYezuLVP83c!IPvW47F0PY}E zz#=drF$MtJP%PM|VOV&CSPp=046q?1fm@96IE-JA5D{z$&AtK%mqd8MQ0dNO)gI{z za0~><0M-Gt0Q;cfc}#>)+3+bP7#9}jRs$d`_qnv(0D}2b0PTAqU=Xwl!gC1EAw0oC zIt;K9;WKPVft*0#4|t9o4VW{ez=ikdPo=a;J<;GG2MTRaYU7!VXEL7FpjH9cg2O}* zO$QhQh6C`~OG+U2V*p}FANFSK1|ZlNusZ{xP!ARcU}bAMKLARkD0i`0h-@=yW4i7Kf=^uVP~x-mDG{u5IPS({R( zaDpMvTp(^2tZw#gjwnkXMjwavW2;Dtt*!P1Z5Vr*c)jRwb47W&99_i}Er>W!u(-K4 zf;9###*1YHzC1z(1w0%D+~5RDfhEiSiC{XRf?q8`-5t%I%G`zue)R``OEWPZyARca z44{1FG}CTQpVDJjCXAp#TQ5lN1tGnt+&zKBM%3g$V*&x70L^lsIYG^V<@m516|qJX zATUrAJxBKwH0gST^)*QZ9eF@U z9?%fVG-yWUISo8%;AsPX+W6AkV{s%nfPgs}88r!6L=j+e1hk+Ei6Mp%jr8N-h4M#7 zs-(l`DHx_GXJdE~DCc1chFFzSqC5gh9)K)MFg6W%gw=0=kfL7%oB|63F=rnceR{wb zj8woV4-fzt0E|N7>w+oDFM*7ph*+>bRZT&}BdNLpJH$Z;$~F{>DgYhtaajZ@pp@$a z9~Om#v3wzr4uBFm1y46TWgy_rezx(Kboe$Mc|=tTFKFh4X!gP?s+eepiFSBWf_VVG z1JnQs5Dr6(U9S}lIA=FgBlMT)^08|unsoz+UGHx`0 zz{)iIX5s08@nnDtzy}NZ0^|TJ0tjk9rS?%O{MjH>qMlfQ1R)7^*ifqgzo~S%)JdL< zZFhEhK=TQx`>5dk~;zY%bDi3(za4g1a~TPm{?07$CE`v#+}SuDBdS9 zr)t7v)C6bLgeqRnF~%^qCf&O|KK}321mgFK!XK{*IEK`bPELQlCJ?_@6#h(25NKzT z6;J+hO~Cs9UKIXBP2h2MlhM%wDhQc80F`+pzl(Ko-ED>H}aia@-5Qxp=2GAu|A- zst@>WiKiZc3EKdRQT@@Skrbd)BeBs*%>g<9Hvj{KWAWtTNq~?<(cz*#G~#y-U}HbA z_eIYL;ZS+{aP0OwsD_~w4TBnULGXB-KbKMs!x;LwVl>X;om9gRj)q~pm_WyXb8%al zWjI3t9m60x2H6r$D3|IOI5_fojYh|?4jn^Jb6dF=j(ki-Gz=qf{`4A)hG8)p26_Zz zEPJ_lkti7bf?Y}aG42J%{Dt$rP`j@k1t@~`kd=)RDhJs;pgaTehu}$k2ZDh~^_XOY zNnudtEMPNW0*vAUPzKll3{a-gfpbx+$)(sxV(?CNUTB&~>R{rJjb~6ie3umUoiz@qge9@qgnG@q1?o9y*293kiHxlNbS@P9anefRhIoCnT!R=c2jh z5a=hoD1cR|EtZe{|0;}BKmjzSikS(Z2yhf2fq}q-#L17u$&Y;uyE8(9K=VzY`6dt& zUf3>aU`cZ!E1rs1Auh%MHUQ=VToFU)b>2hF4eF|XP zQxL)i!r0(hi)SsKe&8byut1#QxJ6C@AV#Gg05$NZ+6Xi^=xu1qJ?0?z&+P*0@1N=y zV1hV+4WJhA2igTue4BDd|Nm|m#8L)zw@`|^g{in(7%e8I;l86blqSQa;bKY`mzlU+ zIEKrG*|=P2!R3NBb-AF1%LNr&F1VE8azPfC3%)#qP~0tPhyrlA(8I&!!cVwdSVdhf zG~;q%94;3oiCDM_;$GvfmS-ujr!(b5N&>rXxm((g#WP?x6gDOb8-c$-o+ed>S8*I< zqm3oaF@QK{<19;3lc;2tg;CM-agi2WoL^~FyN~vkPdyPueB^^N{8a#dQAeu?D;PGXSDWcVTs^ z2q3S#+pHN3iHabQVm*f=Ucnh5>cz zA$lAI5dR5;&;g_X+yEVjT_f<40cat{LQTF6)e6)33@*EvI7;GcO_Gj(Ajk@-#8;v# z-4-a-mYBP=8Rrmf(SNNa`AQSii! zpKhP$v$-T?q&TYQ-Y`0^aA%3oFkM|BU%h-7zWlMSq-{mIir{XwWQ2Nap>;{b@^m$U zV|B;K!mOVBVP37*R0T5C9is}PdIpCPQjZwfUzlz3^VviXXFj_pJeC`vQN_RJGLT@9 zEv~+bvEx8(tKt`4ZuOVuwfZ+TbQ`tVG23)8J2sYWR2hO7Ys_)OoHLjc*6OeKKwMqF zli9`qlw!!JiZ9l|a1qE$yN#5AR?}toY>p+b&QZt^R~vyJ;Q&5qm~2qRx8FOE;GZL| zW|<`qD?4J4R@6%%LztPTt$ zC_o%ptVu}#O+2l|VpbGpMmJmb)CU)bxXpps>|Hk(vrcl3~k@ z5XgBTK^vnRVu`ge+Mw751t(YW3FDe>qX=EL?;{BFvfIcqOI-aHL*F3FILLAb=&Ej` zT5!n%dU-6#uu6n*oJZp7Hd|&}50IlE-1}}L#{Pi>{Y-K7VxZ=OGy_6-3?z^cqys8w zg5%aI@^DNWcvS&G!@O1k*s&1L3lpIL={}Iq1~GLowgW>4zz5#-gehx*?!cF-t%~6T zE|_}3WCjr7Dx^WIHBRW{pz)}vht3kUP(Q~rZpZTuaC6u^)HWCWIfi@=2M$i{9XefSUm`(zsdnrIAbV;KG; zU>JIqxGJd-@kU@dHkKoyEkPwqI(XG$T?Rr2c_c+lOQQklfTvg=%Xxv<#wyY_X6XK; z&;E{@%{JF;Kt~x1)aZj%&3Fq8`g6;}W9V$P0!i_962jjw(bqMphwqnjUu>DFAg9 z0=|TR97ym5Va^2w0x;*H*uhF2A(I2=+Cf4O%+a6E_B{?#L?ihI9D&4LiZQ+e% z{G z5Tq7XF^62YV@WToM5GH9s{{dgD4lgck3ucI2*`p6V4aR38xW;HjHQqsJQx%@OPuic zia^9aivR&Rhal9SDgx<$uLy+vOA$c*K^6FOML_cRih%jQ76Ib7D)8rufFp{)wEs&* zfavi@75E!PK<)1p0fJ9efxl4%{Qh1MAT+5e@Ry4KTj}o2~DFVh66WM4LU=Ibblm*M-*n-bt3r62Z#|A+|UDd_Rg+S-F z61tUgn4<{91|U#|nIEy$V_6q)%tB2)4^%Zs(Qh!YiRfbp(ugkrUDwT?)=KRpO6V2E zD85W=-)wBl^W0UQ>GI)c59kF8AzgJ~iL=s+W?^zf59@Qi@*SHjf0(D7oARmcz%)e$?T zZAr$|F@VA#qRlW-1Kk5oJ*L>OY3QLT6n6KX4A2@PP|@F~!9ChQE9#QIR_X|CGdTAm z=IqCgi>4t0ufO0G5f}}oium~))M)wbF*yZ4*I@KH(XAiVy%#JIgo%hWsunx|cd9Ia zp(}LAhaBiESyb1L9oYrwX&^vzYFg1vS8b&_1bZM7fk1P{Ks)CKJ;Q)TFJ+A8l!N9+ z8R1q3lma$#$i%=}Xl3#J;efM9Pn?ZNbjl2*02OzAm}m*$V0pxQG5R6~QXw5uQ6~`@ ztVZ=3)!jMk1_JRT1V2E|MdRUxIcGpR1!!bNB94?^=reM#yb+X6!18F9xZuXm7F(JT z0mYz2lg&kE!N)`)CZdjrk0H&FQTmWZ0UG0o)T05mRwyx4Ex^oZJ8AOGLd>DVGAvle z67!PbI4sMA2k79a3{)GI?E&d1aJ`8N15$mU<8;Z3R*nR^GX^p&9d@t9#16;@W3$1M z3zk&BWCvP(fCuPdt1d{y$86zzQqjs09V!>@rNJs}AQiAY4m{GU0F*sPgcKddCqYAl zVwPyK5T#O_Y0z;iuM5Z{@QXSUU_BCX!N!_Yx10`j*;pF|S?mQsb1P;5a2D%=fw@@f zQY`snj*xlK$CBB$V>t6kK+Q3hx1(-z&@~$ckxbjQWBR_18qK~5wc|wF+oZ#yeH?X~ z%dgdrKce4ucz9D?K;y9-pK5&ncSKv?aK|SBl4EpYe&q|% zTVUvCpwLt|QQ-oqy$~+c0dxvxn^$oswIa6ys1rYW_a=CN#F1GUmhr$GeE`y~FaZjq z$~933dFtRn74fqm)2<@-$3$Rq0uXvY*kCfus0Z^EV0i}M2GCSFRR!1qaKT^?{}HJ0 z!iVDMH32x$H=%U$k+MQKbqHpf1U4+7kr{FLNhx?73eG@yBG2>)Xh*HOT9+)hQinbY z6as5$U?TeaJgP7tSfgQe3bhclNbBHhNH(Zo15zrrBV)-MbE4tAB>dO_F{wKQ)FB*X z15)vdET{m}F`%ZBJqj6)$v9yX0SL*&y#vZ?0y4o82U+T@unl2^UC#z2Z^3X0(wM3M z5RZdMqI&x*L=u9*6!nhfG(bDuOj?Nl#rnxC~rP z3dYf)80P~nwf$p`0p_g3(x-riP8=9D2g_62s~V)*j4Vd2;Af)#`rAo|l8oUVF6_le zp%!A|5Db7*2os$t9W1FJq6%s`XeUCVUy;TzQ#58)=#oeO#&Lkar9jiaoCp5GaUk*U z90w48J^y+h`18jB!apX6ZJ43W?wL1?{i*OkiKSus6oE-~ifnL*@8*)Y<>?azdDU(* z!S{U0V`j_Kl?1!1-DC^ndR7eMcNP+!C3ef(WD1Y>1P)98RLCr0ag|z!A!x$gM&u#nH%k!KYMhlY{fJ z;k-D^L)tZA2O_bzdU+8z_#;%YSp}GZ>|!f>aph`Et_A{EFome)P3X<2I^Kxosk(^2 zhP5yPRRrNL#V#a8MbSfcvLQy$PN~sNV^k+TQdS7$5CZ2YVkr`AkQsbrhB;V3!2#5= z;B&ZtFh!!pfjzbAjaagO4%Guh070D#CSoG4`s|@*G{V{pVNIc?f);6Q3N>h8sRL3f zwbxV;b}?qiPAmMFjjVwMq7kPv@rq1|Mi#Vy=}1sh$&L#%8|wT!55w3!Ei=VEH;r){ z!osGK48iZ>wgu%a1thL82X!$3IV>Tb3r4AHK3fzh)L9nl9VbJavo0VUY>}!g{_|D<6XT#O6#L_s0%!ipr2qk| z`oq|`8hrWBTLBnl2y#lG-XFdhyfa51Qd>e5ZCGX-Jm88d15>i#0S-8>1!_5>8qFIM zrHYNZQcvAKngj1#ML5MMLt`5(n*zkrDq5?)^_1;L&%O1M=n5Zk7<}Fe-cH^$-htf? zjP<#za_w_B<*v#7C3k%;{;Ft0hM}dQjiFiYkmQJTW3GAbw%paZ4!IV&J95|N+U9P^ zwaQ(Y>zKPa*E)Ay?#|qehO_Nw+UwbC*%Pzu=iAS=pJPAcn*KHIYdY678j7}`WqZeY zCwoVD7kFRwPVqkFo#lPeJIOo5yU07i`@Z)X??>L3y#E^+OqNT_9Lf^P)XKh>d6eBR z(=B^hW>I#gOunqI>~PtmvZZA;Wjo4d^2YLf2;L&zB;Fq0EZ!>Ka9%Lam}k$M&g=4T z70LOJ@gM6yI!7*NOwQPx(FSq`V+_U`jINcd9aB5DcC?M0&6tQ#ozSYVs!;RLQ(>n< z<-+7bd%}7`eZzc13yePhF$Tnc`45#hSc{FhZTex zg&Bp`ht-GLh1rE(4Z9ku8m1cB5!Mmv7UmY35|$FWx=g98wamFpv+POP+On{+QDp;V z0cCk*%gY+Qp8rtpn$$J9Yl5e;r=q8l=S0sbo|8N$drnAGPE$-%N+TwwO-Y+HevHlN zIJvknaif*xl*cHKRUX|Y*EXhYY};sm{l9I7ZU3Dah(8if@_#&@em|W2{v!k8-y-t& zIn@5$fMi_!-EboQL_F>I?+p1z?5OnbW+47kV*b7vp8VZ_)UW!l0ZIH@ME*|!$(~)o z_!9;0-|JhW*1s?y{^t_;?;IpIrxQFq-e%r-o*!=+&zd)dw~wdATgQ{(1^%N-^XBo+ zd53xDd0+O9^v>`;?|sAjxOcI4qIa72S#P1-KkP{S)y(GnABOzXcBE@lW+49XPVw(% zC|dt_1JZUm@rQSc-w#NaKUnAgQ<*0U?EY?MvtoZYv;SCP6Tj^g8~?5$H~f2M|FOg- z{;}g~|4l;{C|Ca1%>H8mN&L%JL)ZJ4#QaNn8ULsAlK8KQ>3`}^bNH_egh~I%>_3*+ z#J}&^(a-*hA^+8m^Z&RV3G{&fp4pOff7cAd|6o88=mCE}vt|EoUeeC}fxIOCyAICt z?_@TW*u{+hDY1$Fsh2igF16CTuOs#6@NXYp&ghl8L@V(M-_$KO2)QL-D zx1MI2kcm;^9G8K%6RoEbJ0%=HZfx~V$HB+RL9wP8dmg>nkvR8gYrSBdiO&8rsn^NM z+fE@Jk!J~hkyPc$qaxN|R}DH#jX}x00@R;g*w#!lm%iq|xng^aR_V?r*=FGE|9^CwG zK(k6VrdrR|w1BIwNei#dX1FO^llR+loNs3hU8+tb7H1i3*MAx4*P4=M9?`33w<72W zQP6p&=@jFeZAa9b9yjY=IfbbC0fNrm7tLLS_TM`*m9jsZo0xY!^7(PCEwNj-vo8OQ zZH;-z%d0!Gk8o`@^8xw0Gx78MJS|ozm+qvxrTFHd_s5ni+1qk9 z-cuH)x?2&P$|1;v9B#HB(J^GiSpd=DgOkod{CI`<@Y>p<)>EqoBq_H5!o({lk1&|#`^Wg zzo|=69@nMTu=qe*m`TdcrwP&z#}dh);7f_5opsLs)=FYmTW#O_q~HKfY1W;X^r_qO zCF@EzmMyQ+3-)fUZ0o(Z$1WjwTTs-a`D~%lgiq_nzb%yIwBP;t!qPRu@`0tN2E+Wj zrPW_0i+)WU)N5a=AZxzHX!^)8l}8FCE*-lT?~BtVjx1$(*7X<&*L3~hjI+DXt#FfJ zkE(r>CC<)pQz6vt%{k*E?JqK(SES7T66u!P<+1lvN) zUDgWQvw37t;{2-gGj!WoNwY>I>JHrT*Vz{rtk{s6y1tMY6{(whAX_di@%sr$mV@`t z*>dA6{Ypu4lga%0Q7&RuWAy9#JNoarGjb2UQF*M~p)kkxUC{2mW6#$I?GsiinPf7q zYkk8bzD$kR5;bq#05;HZu>X{mc{`Ce5|W7CNKvPAM~t{}pzGqB;qZVB<>{rC>@ zt*2+c%Fbn1jfm#t#)ji`Z(mvI!>dMLWj(vDv;2Hz$ O7rwDs!pkB^S-9T0tr$h;CwH{b_V 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 T-(GAH_tB$oA=a+^>H`vdc%_R$#eQ@u) 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 diff --git a/flink-processor/src/main/java/aisdata/Main.java b/flink-processor/src/main/java/aisdata/Main.java index 148caa0..5a62273 100644 --- a/flink-processor/src/main/java/aisdata/Main.java +++ b/flink-processor/src/main/java/aisdata/Main.java @@ -56,7 +56,9 @@ public static void main(String[] args) throws Exception { // Initialize MEOS with proper error handling try { logger.info("Initializing MEOS library"); - functions.meos_initialize("UTC", errorHandler); + // JMEOS 1.4 split: no-arg meos_initialize() + separate tz + error-handler entry points + functions.meos_initialize(); + functions.meos_initialize_timezone("UTC"); final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(); diff --git a/flink-processor/src/main/java/aisdata/TrajectoryWindowFunction.java b/flink-processor/src/main/java/aisdata/TrajectoryWindowFunction.java index e047143..d5e1adb 100644 --- a/flink-processor/src/main/java/aisdata/TrajectoryWindowFunction.java +++ b/flink-processor/src/main/java/aisdata/TrajectoryWindowFunction.java @@ -31,7 +31,9 @@ public class TrajectoryWindowFunction extends public void open(Configuration parameters) throws Exception { super.open(parameters); errorHandler = new error_handler(); // Initialize error handler here - functions.meos_initialize("UTC", errorHandler); + // JMEOS 1.4 split: no-arg meos_initialize() + separate tz + error-handler entry points + functions.meos_initialize(); + functions.meos_initialize_timezone("UTC"); logger.info("MEOS initialized in TrajectoryWindowFunction.open()"); } diff --git a/flink-processor/src/main/java/berlinmod/BerlinMODQ1LocalTest.java b/flink-processor/src/main/java/berlinmod/BerlinMODQ1LocalTest.java index 9218e16..7b609b0 100644 --- a/flink-processor/src/main/java/berlinmod/BerlinMODQ1LocalTest.java +++ b/flink-processor/src/main/java/berlinmod/BerlinMODQ1LocalTest.java @@ -38,6 +38,7 @@ public class BerlinMODQ1LocalTest { private static final long T0 = 1_735_711_200_000L; public static void main(String[] args) throws Exception { + System.setProperty("mobilityflink.meos.enabled", "false"); LOG.info("BerlinMODQ1LocalTest starting; window={}s tick={}ms", WINDOW_SIZE_SECONDS, SNAPSHOT_TICK_MILLIS); diff --git a/flink-processor/src/main/java/berlinmod/BerlinMODQ2LocalTest.java b/flink-processor/src/main/java/berlinmod/BerlinMODQ2LocalTest.java index 84950c9..9446c30 100644 --- a/flink-processor/src/main/java/berlinmod/BerlinMODQ2LocalTest.java +++ b/flink-processor/src/main/java/berlinmod/BerlinMODQ2LocalTest.java @@ -44,6 +44,7 @@ public class BerlinMODQ2LocalTest { 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 { + System.setProperty("mobilityflink.meos.enabled", "false"); LOG.info("BerlinMODQ2LocalTest starting; X={} window={}s tick={}ms", TARGET_VEHICLE_ID, WINDOW_SIZE_SECONDS, SNAPSHOT_TICK_MILLIS); diff --git a/flink-processor/src/main/java/berlinmod/BerlinMODQ3LocalTest.java b/flink-processor/src/main/java/berlinmod/BerlinMODQ3LocalTest.java index 69e2022..e1b7128 100644 --- a/flink-processor/src/main/java/berlinmod/BerlinMODQ3LocalTest.java +++ b/flink-processor/src/main/java/berlinmod/BerlinMODQ3LocalTest.java @@ -55,6 +55,7 @@ public class BerlinMODQ3LocalTest { 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 { + System.setProperty("mobilityflink.meos.enabled", "false"); LOG.info("BerlinMODQ3LocalTest starting; P=({}, {}) radius={}m window={}s tick={}ms", P_LON, P_LAT, RADIUS_METRES, WINDOW_SIZE_SECONDS, SNAPSHOT_TICK_MILLIS); diff --git a/flink-processor/src/main/java/berlinmod/BerlinMODQ4LocalTest.java b/flink-processor/src/main/java/berlinmod/BerlinMODQ4LocalTest.java index 428e7fc..1f302a5 100644 --- a/flink-processor/src/main/java/berlinmod/BerlinMODQ4LocalTest.java +++ b/flink-processor/src/main/java/berlinmod/BerlinMODQ4LocalTest.java @@ -60,6 +60,7 @@ public class BerlinMODQ4LocalTest { private static final long T0 = 1_735_711_200_000L; public static void main(String[] args) throws Exception { + System.setProperty("mobilityflink.meos.enabled", "false"); LOG.info("BerlinMODQ4LocalTest starting; R=({},{},{},{}) window={}s tick={}ms", XMIN, YMIN, XMAX, YMAX, WINDOW_SIZE_SECONDS, SNAPSHOT_TICK_MILLIS); diff --git a/flink-processor/src/main/java/berlinmod/BerlinMODQ5LocalTest.java b/flink-processor/src/main/java/berlinmod/BerlinMODQ5LocalTest.java index 394932d..f54e102 100644 --- a/flink-processor/src/main/java/berlinmod/BerlinMODQ5LocalTest.java +++ b/flink-processor/src/main/java/berlinmod/BerlinMODQ5LocalTest.java @@ -52,6 +52,7 @@ public class BerlinMODQ5LocalTest { private static final long T0 = 1_735_711_200_000L; public static void main(String[] args) throws Exception { + System.setProperty("mobilityflink.meos.enabled", "false"); LOG.info("BerlinMODQ5LocalTest starting; P=({}, {}) dP={}m dMeet={}m", P_LON, P_LAT, D_P_METRES, D_MEET_METRES); diff --git a/flink-processor/src/main/java/berlinmod/BerlinMODQ6LocalTest.java b/flink-processor/src/main/java/berlinmod/BerlinMODQ6LocalTest.java index 6a6fd2b..4c18eb5 100644 --- a/flink-processor/src/main/java/berlinmod/BerlinMODQ6LocalTest.java +++ b/flink-processor/src/main/java/berlinmod/BerlinMODQ6LocalTest.java @@ -60,6 +60,7 @@ public class BerlinMODQ6LocalTest { 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 { + System.setProperty("mobilityflink.meos.enabled", "false"); LOG.info("BerlinMODQ6LocalTest starting; window={}s tick={}ms", WINDOW_SIZE_SECONDS, SNAPSHOT_TICK_MILLIS); diff --git a/flink-processor/src/main/java/berlinmod/BerlinMODQ7LocalTest.java b/flink-processor/src/main/java/berlinmod/BerlinMODQ7LocalTest.java index e7560c8..fe9f075 100644 --- a/flink-processor/src/main/java/berlinmod/BerlinMODQ7LocalTest.java +++ b/flink-processor/src/main/java/berlinmod/BerlinMODQ7LocalTest.java @@ -59,6 +59,7 @@ public class BerlinMODQ7LocalTest { new PointOfInterest(3, 4.2100, 50.7600, 2_000.0)); public static void main(String[] args) throws Exception { + System.setProperty("mobilityflink.meos.enabled", "false"); LOG.info("BerlinMODQ7LocalTest starting; #POIs={} window={}s tick={}ms", POIS.size(), WINDOW_SIZE_SECONDS, SNAPSHOT_TICK_MILLIS); diff --git a/flink-processor/src/main/java/berlinmod/BerlinMODQ8LocalTest.java b/flink-processor/src/main/java/berlinmod/BerlinMODQ8LocalTest.java index 9dc6709..c644860 100644 --- a/flink-processor/src/main/java/berlinmod/BerlinMODQ8LocalTest.java +++ b/flink-processor/src/main/java/berlinmod/BerlinMODQ8LocalTest.java @@ -51,6 +51,7 @@ public class BerlinMODQ8LocalTest { private static final long T0 = 1_735_711_200_000L; public static void main(String[] args) throws Exception { + System.setProperty("mobilityflink.meos.enabled", "false"); LOG.info("BerlinMODQ8LocalTest starting; segment=({},{}) → ({},{}) d={}m", S1_LON, S1_LAT, S2_LON, S2_LAT, RADIUS_METRES); diff --git a/flink-processor/src/main/java/berlinmod/BerlinMODQ9LocalTest.java b/flink-processor/src/main/java/berlinmod/BerlinMODQ9LocalTest.java index f990031..6468ba7 100644 --- a/flink-processor/src/main/java/berlinmod/BerlinMODQ9LocalTest.java +++ b/flink-processor/src/main/java/berlinmod/BerlinMODQ9LocalTest.java @@ -45,6 +45,7 @@ public class BerlinMODQ9LocalTest { private static final long T0 = 1_735_711_200_000L; public static void main(String[] args) throws Exception { + System.setProperty("mobilityflink.meos.enabled", "false"); LOG.info("BerlinMODQ9LocalTest starting; X={} Y={} window={}s tick={}ms", X_VEHICLE_ID, Y_VEHICLE_ID, WINDOW_SIZE_SECONDS, SNAPSHOT_TICK_MILLIS); diff --git a/flink-processor/src/main/java/berlinmod/Haversine.java b/flink-processor/src/main/java/berlinmod/Haversine.java index 7f29a90..cb6f888 100644 --- a/flink-processor/src/main/java/berlinmod/Haversine.java +++ b/flink-processor/src/main/java/berlinmod/Haversine.java @@ -3,11 +3,12 @@ /** * 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. + *

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: + *

+ */ +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. + *

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 b37ac885619d951f140cdd564750000124156363 Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Thu, 21 May 2026 12:13:11 +0200 Subject: [PATCH 3/5] 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

` 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). (cherry picked from commit e5707ac04b375d4d2dc43e5b6c442d19cd0e7afc) --- .../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 1b18a8e24f781257abb912ffce9e262db26d016e Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Thu, 21 May 2026 13:14:06 +0200 Subject: [PATCH 4/5] 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). (cherry picked from commit 457987c935015ab373116414f513919d1812c366) --- .../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 49e7824dbf4d7034a960a566327f8b05815d6053 Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Thu, 21 May 2026 13:26:50 +0200 Subject: [PATCH 5/5] 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). (cherry picked from commit a1f36cd245d33836f9112b9d7af4822a92eb45e2) --- .../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"); + } +}

bwq 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 |3Kovbj@oZe^nSt8IZ?L} za=Xq4(~*+^+ig#*Y!PgQE!1sDDRO`3$|Yv*LG?Ie26GZfm$?c5R< zZiz|=WrA^rc14(}q8+^AofbUI<`uTzHi$u|H?cw7hFHK!ZdE7)`20lJf#7m@ascQz zm-iu;7pD`vqAOW9ByU;^o9$^XGwX9_3jEz6_IbEWybs5gD}#d2HJ2t&(W6)z9(C?5K@g>&&B|5;v@bz*C?0O32r==tcSw9>P(8PWK{S%YO0@PlS!3Kx` zAz{=5DuNQE-zb?hr=0C+&hiFgiF~>))JA2BZ%?zq3C@-9k)-kQPq7m9Fkb9_hD$Xg zr$>@e8RvP17D#dNuRWr_L^b>6IXnx-PpDC%9a`7hZ^e->GiXEo-STqEmb91|(J zG#NnBdP-J+1D73lqXg=PbStDHXZ`FjlE+Xl$zM$)^j@-z4dR$JqX;H0n<~l{{$(Qj zqcSZG?-iRFSPME3sU2J%Mm(UhAR4HPyC!m(`fTY+v=Y%@evauvdLK0IpfJ83eILam(oII_E=v#oQtb^)y2-7%$raBL(!}^`i^aIL1T%%)2om;3R4z zBq9klwUzi%CXTBKjX0wF3(s>X!>rYk(3jsuYUl-rFfifEdb$hSKD&Z2@M==x#@*v% z(rmN1y7_*d<>jiAdbz~E%$>>n&kKBag<12lJSZc6cCCSOzOMp6Z|BPg7^8bE5P2!_M@dDhAqkB#&rS#()b6p;qAA?T3{3DSO+b13#}Z%B z&ZFng_TY2Ut^(a;wq23fmj81W9+9aiJ?2Ug>I!8#Uh{uuAhZNLbyx}jxrI%sxrV>e zmf14vvCT1!fo?4=jSDtF$X*20xiYLo=!q?Neukz30e+4E$_e09oX+rHdP4)~`%L8} zE|WY>!x+TA(`BsI0c%k*w({X z2i=3D-ZSi+2eRAb3j|n25>h%kv$Uf&Q#Tv*H2_F$WS<_Itxv}vT5oaWXZG9xFGf&C z^z9@TX`vLUo*NNc@{~kIAiz4wy~E%_<0O9X?9{a-_7h5ekFmkTR%(wav1zn>jTFep zStOtyQBB3^ISEvn3uRHa7OHW2LWh#CRc-MnP5PNbjg09%iObxJ$3EoPwbrPNfa3$8 za@+bNo?v2Gw&t6uEtx~zxmWdY=SnpjNQZiKf7d$jFkExITc7Cf1|Y|2^dq&(zZ(>C z(s*mxU<&4`L*QvbQ@21P%g7Fp-jbu(%LnN{4+xd0YrW>2jD$KJny8G%Z|>PL>d{r6 z(5Vnxyc3%_9N^gZd(`yGv)cWU6s1yl4k7B6Gx=C7TW;aqht(`RJ_p!^656uw;qalh z@0I#TqnRi3ikfNx=&n92yXRV55X-z4WKzorVwwB`x=u0zOe`psVq1xgq*MfJ_6J9l z_Th;g=m3=wLh(IP%f7g2REn!L5-RK(MuVOo*|i zQon)quG7TqG?|w5rg18+M-uqGUf{%ub75?ps7gZ`1gj(qBcysAg9T}Flw1~Ahh|Bc z%r=cCYRAsI=uKaZ#Q>In@Fc5RjAag~u!m|+F;$>hiACPd0djjV_bJ4~VJvxmmR78R zLk{dqPnjh}z<8O69T$t^>!HRHh3$bq*Rq}w$9n)FRDTXfJTmPX=R{p-sXgcG^{S4A zI#2(1=E4w1in}mmA1yErdYE>Q7M24$yI@M*YVA>ZTG};M_lUd03bmqF8kb|36PAHp zPjD`oLGc_ip`~d$}1n zWu7x3J*Ai!cx!q#04qK~4j=M5-lgy&HQO}KLF2>xpapM+UIc`1sFN-g-nyG#y&!kC$@NdI$Z4}ChY);CFFn4*aZLl*O<>mgEq~gaRUOsRsZTXsgZKSlSgy5ef@}Xyz3qj(JH18NnuQ5ci zzn32EK-XHhrXsdwZpYDX4El>kFGyzRaIJx6T?)kW7>PzU*(jfg4IVm8V<6c2S>DaN z<5zFxV2XNlZ-n2Dz>beDhy64?=r13@I;cl=?&)X=fM{LFZh+O|MVcU9N?|G^>1pQ) zj%7XmR+J<@rVs%@pL2A0PJD6-$GEqtXLpL7)|;<|%FwJtLx~S4)bq5v{3!G1 z5?oZj zuk`4mr?$%5WFBXyxz)0d%UNa>9Uz}=Byj>59obmPmR72cDirr@4>Ph>Wwd=X=~}q> zs{klA#LPe9V5B@PYz!*2pqcsdP{eaUp8!8bU^TbNuyYS^K;!5TP2!ioF4K%fnzrLw zBLKdkT?}H36A-op-OtT#LVFR=BXin@($6FI{E%%?_18{{!>pf?hN?Pu&M^j~O0gfX^N-0i%!UsJK>k{& ze{wO2tSyh9jL@g?#IgB;h3djF$0+&o_%3S$B>bW0{b#124%sdzK_k%8{U@gHBu1|FI<)wueYjobiv8AuGK() z!Ze@0vi82ACAGx4H zl(lAS3XbX29K$(8mo7H1OB{qraR)(yjJwxrnd&|IapS0kj*#9`?YWC#x~`&;Vhh1p zZHoj!h&Vudp=yUYE;HrZ$a+}n`uQDwAFbkv9m$cVk^@q^L^P1u5URyJv%|>z?POm? zO+|RGNw7W%oo6C~yqbep7SGr2FoPn1c=G4RK{bNRZWhBr~Xs`Q1ftKOI>*L017nhP-|uUb#s1Kqex}xQB!xe45w5boO{b z^O{4)XhMVl^{RhDpnZnE;#R(`vmrO3+&IK86RSG_4ErObo|uqKVww6cWLco@rl7M~ z#!+FurXv{S-WQA|e_LJ#;~+&=bjkENW+Z`teuQ~R>sig!*MB~aUX&`uB+_aw1I~^^ zUN-)4S)x@tEJ7=DtqN(tJzxX?dpgqLBa5JK0hklxDlE+~%)YI8?qHmhw81$L8S{oV zxeU+4FHwbS{WsstGslpUQCh(wrtLtq6!zF@4xwX)njAo?)5K{eM9lOU)2Hi>Qfv1` z_Fu6BT2;IIYGPUoJ{qD9E&2%IZ9 z9KJ~A6?%yHu^Zu`FT>HVaWv&;X!0RFJ=udM<)yxDhn7Nxb@$AcB;yexTTgn7%O>iM z!o^mGdF+3YXP4pi8BAMYMuY4FDERq zytPT9NB6`QuE#2=ybLKiA7j%xg!6tGqJLM|zL<1g#x=>aoLJB>?oh0GKIFM!ab-`- z5X`DrW>&9v$)OncC{B4!(lP>)JL*_u5Rl7)Sg)5JSp?=^pw08vCJx=g0%U*7I0qh- zwsztMU^2FvW^bw+H(SszB?}v{SjvuHP5ggh3dzm;v6SejId`*f=&2 zBJlf*RZiOW&-JzChOl#uoU;TtwVBig%BDW3Rne|stk!+`gD$;YpZ4Z9v#z%fy|CTs zXP6fUtlBUc=lZUBm4G9APHe3}Ht-Mp8DZPW=L)Xcm0i`t-W&Q<&?C`kf{P$@9~g4{ z8i3ieWGjha>PxL0t!FOZ-^TXN$nG|*LCP8fGs7QY8v|Gt6!e<->ZcP9Hk z{FbD0SS6`wt5mC$Rg&UimA6#V-cm`}I-ydQ6vOOE(kiheuaNDPqH|l2O?e`BnyY^hy^ZnlU{kiYYefTampKjPMuGr{WO4Pp0dRdTGs&*KMA3~I7 z@K=mW+jRI(09SwsM`*z&_qrBF0^c*PF|fQH)gc*QKtwU9Co%XhP!{al92l`UVnppz z|8?ks!$diYe7a|cN_`v<`<02bXc}z*P5tu>w=Ls0MY8G7+PnKi zjd7*UFwXXsiVvZ(m{`I=ChDP@a!61<0A+kQ0@AC4c-zK56i#cPk^3OpTlFE`hp-`l zXHEM@X8zc0$YzOkru`vsg(BliVdE9v#_o8i)k&7zw0MA$paRHKRz=N^zV zT-6GFMkqJS8yT1;+mKmqMo_Ft7+vWZcuhDA6 zl$`T}HXQI~FkuPfY2?(X)Fd|J-L9W44S-Ze3Pz`36VK%`4437p-SqufnsY3C^J*kFRL)+ zAS&XNWqoICQjk}v+NXr~t!1T=?WC?PL%*YZSf;a=^Qqu3n)9Xilw(A7)UoY~tYevY z@MXWb{6t2z`hE#^e#?-R#7ze!%tsy;AHqhw;lnqoem|y@g4NJp47WBHQiv1#ID8lC z4{Jogp>3{uu-^CuVim~IuAAvckIb+R;b_F6`PEGLu*-Uh?PJ?oDRBk)N}EMbh&p6E z>%SB_Lt3?jce7e8C?TwoG`4v=lsGR4&2|x}+6ovt;A&9dEk2l8e1{uhJT#KuRzxaw zHq`NL3nWL8(FSfGz>Y=OPf=GXcs__@^PVmUxgnDhodJd&EstuHc50EdA%HL@QfguE zH{IHF^xdZ$=NC^myuY1!?A`ISZ?A8=Z0XpW`R)6Q)q!g|p1gT=_H0)2k)#jt`;x!^ z<9_M9NZnnEEJyOf)0qM(Z!owZBqK1D@4zfA$QiEue(gp&wjN^f?^o(!6uubdO8+$A zREIPgNBo-$&PW8XT~;isrt))*T&XhBvi$DD*_a7B5qWE^c8QwWKq#qezcfL;qbjPL-vQ;Q=hliE zp9aULTwSXfh{yj(Y{VLVcN;rLrTbe=9qh!NuLB2%WSh{U;F!7wSMN2w#1Kw}0J&4F zOsf!_E9Z`w%^v$OEr{0q(a*+&+r@D7aZe-SR|+os@F~RW0j?w1O5Xmf>LlC9wAh8x z7I}E&#)u>4{{~T2M~5gPmpz^iL$4TeTx+i1JjXY=zkVOyi1l7k9nb-z5pxP`(d)I~ zxtpiTAiE2c!4Ei}qU-FdEUHaoUNBuzMmm7VRCl_42zVM?%QL97vR?!GPU|B~Yzd~C zw?-(F99YL+sFT`@EExKZ&lA>52FW(OCD;2LHS&cu?6v_AMxFH=m%EJ)1>j9)pX;Ty zQK5SYPzAr*Bk6^9^*H>~b{b{hP4H}=#@|oaGfvu7gH0~i3|OE+=3a?pM-1fFRb}3G zo+4^sy>_oxwE-VK7gy?KfaN;3! z?Xiw8SSv3IJ|IPcz0=^12*Pf8%xjhjM0*2oD9Wjd6Fw0B5aQeCO@-iZ)UFz>pYZxx z)&Aa)S4V$XRMw|#)NT+(VD1Q<9C0?4nAhqBw3P+2ew&BjVx}_axvP2^%1$EUbhbg5 zj;E!kt>`yC(?Ln-S{^2nmF_SoStRp%MpY3C8*ln?XRo4$owcnUu{k%@*z(mQ5!--$ z?YN4{k_2b=^jabwyq7jBkj;i3BM3uVx7V~D^}9RqOgpR;$N4qTW1UKOZ2g3vh`(iC zBJu~fyP#q_QyDc|=?l<&i57GWq0h6*vVOlrLe=e;vN8PdQS+k-U(8}fajkzl`}A|e zmV-A!f3{x9A6R5?#Jt)t`4q}1CL#-d|NBJvVkdhys8R~HqPzqb2Bj4Ifqh{Yr`gEl z*WlB8op!tSwyknDARlNnD*uPKLWD9@Ug;`>S=S1Fh7%&C;K-ZcBe2n>E03Lks^FEHO^f=(T7w+QbjJ z7T(Vsuwcew6xx4uGHh-;ZtG2gqXoTUF=F6`YV~}d?Nr#V)wqBOQ#sEs7jb2#?E-GU z-`qGR20#zY^Yse;W4sgG^MJs%>gqWN*leM8@pIk$7uu=31b$bBb4Jof*fG*SKrT z8f5>J`sVvl{u>|!cp*Ckt8MJ6h8$cTZQ9z+rji6GY~jFyV_K1m%xa=Rn`DOk!g^@3)(Fh`MWBGTO-AEcDtuLZ2`aW zWJ|jXG>^cXtc+X#f=}=&I(-Q~kEeIOB(?5W=Ke>w2FP|!liChuK-uqTtlwmg{;oBXD8-1lM7Da`PWgdNuJ;z6V#o3+P4oi>ekHlIxN#3 zHEG4J^>EkTkS`$LIpNr`@lv(NuLWHRDOJ}ZUyvSS3`ujBDX~u5ad>-86$4Uf>grYT z8awwD-380k(wS;czf)W0n)KuxhKeml`}`_E-W-k_ z2Zs(z>e-Dy{Ix_CF^)4a@%%W>hvMn6}PyN4|?*I0UKdn0TEBC`=28NMiYn_n^r;MFwTmtPk=GN?x=7a{>$un zNpbxLqSEkr4I)J?Zh^*^wFswBJ?IF*uyt@xv_rl2s7C%+yl$SrYq#MVpQNn@ibzuJ z;WRksnT0#eN;J)umo<}DmB(=fT*4wT8iD(&Yis=(AY-{)G>D}gJVIyBg&{@3Gln;y z-hYt@*z$#;1rJ@pd;S5Q4#N((`QspFqEq~ozgSVTKe_*x>Qht?c9@=q%w?A><7t2A zKB*(WOAG{)TLUzWm$dDU#0Tu!M1Mx6B*~PWm~u+9XY02y;k=Fafg9?c#pHFjMCo3h zJ|?KJefsNMJx?$eB54IgIAKrtG|Kfk=8EEhv)xjtA05n|Js`ukmVVP{*bBRJE2Oyx zn?0@B9Gf0AY=j8m^t$H%610mA0D8Y<^9|O?{4W9Dd&BolKiF5kyKkyXh2IZoq8l;C zv{Q>9_3mgf8iUKeJbG&gYJwn)$t#5C5Off)b!3 z@hZWXu@DazdwYy}S9gZJDQ~srRmU;Bq8?}?wgXiW?9FobxyNe9%jxW|&+EFe^w^w> z29tO(7B>bIdMLAE`YtnYxm5rB;}$cZ-`&&iRbP`{BEH+pLq1{+aaR*C#IVOXCi@*7 zE2%1!HZv3JFF!CD-%vkPsOem+JIH~$zTl;5-X5IdKE=N1qI5XSM|Sl>lg2wQfZ$?@ zH3V7(?OPhKN$R|m*XF*oUFykzBu`cTYQSt99?$lw%a{rN{+LMTIlpd|g6yxM8p~Tt zfCT@FoCtHEN#U-{PVEr?H$kbZL>nRU_7j|^=YLLtLsQJCe;-Nm>>|5Z&xOl_p|$b9 zi>~=B>WL;++uq3wxJAFa7pSO~_~>H|NTNtxn;w-*+NXZ-ReJ$V~_wkIwufPf~@v2|uQMy3D+d zx`z4OaQ!lrwyJEo!uKKkw64VjMcZEfr-i{-&z9Rcqe|?7uKuYPmDmfVh%~UvM%LJR zt%SK)7iM_M3k00uwECUx4szdK@k4sf4>R)TAiR-uP@g0Pe?<7cP&rTEOv%thy{KW= z0>QgSZ`OpU2;JRbmh8j?UDvnd`)l$CT2y4EhhYoyr)w{STwc$8&}z318dc3L3X+dI zNWRdM)Hk_?c@%!<#??hk;HD4%E%QBc4eCjNiB#EpN95vL=)o%ma|bFT{yS+PQC%Yh znIKm{FM)vsWvW6a2hpU#qD6qRxR;8FULkCV&?*lsAoK7(N`(RE$}l0HBj%jxNln92 zi14Rc%re#nH9f6-h^Vq8=iQjQ?}=Uwm_PLtOk7qDyVj|(G z>ZxJAuZ`jN-)p!b;uZ+}%uJ0?VkBT3-H{@GS|Qlibh_ukw~+jKj6Z3}aBvw&`T}-^ z%do=nl_S$%awdkNZ; z_hQV^z|XW1c-^$j$?OjTq&&gD(YrEe7-WdjUS9XTRj`b7|69at?`&K5j+FWLV-<<7 zv{lsN`YJIZRlSbcdEREun(%E2`C7%S*(gn)(e(xT5g$Y4Gckk=oQ-aoNwh-DHPQNo44SAeUt`c}fk{t2E7E@o^9te69CjwyAt0r5EA3 zOtV20%j>0bh_%9Pv&Q*uo(-*~J+w6H{u6|pMnM&XRdY>Op(-uV2s&ysm!$dk_Dq}2 z`+j`zwFS9C#Q%=SCE~xsgLi8(mzK}Rg9dC>Tt3Txp)AMdi1Pz$K3>&pPM-fm$zd5Y zEdAB4{K@Yi7c7M49^hCB7Y3h>vgfVE-A*8R(w8z`rMxStTAdvEcA{ONflibT)U!T^ z`ultV&p9^-3vYN>%g$H^69V#Oj3ih&tG+CT8uRV91Hozy9Hkj$=vmuN8>H~V+p67E2o7azbw3v?T)Gp_H2C%b{BX< zX3c3&)2QE83A@yFQkrDVMCu45b8A&$)+tTIe3sCNUtGvR)r5?mVl1r4F(6sq5jh0- zSUc(k)2Zh$Lm%1?b_Gq`oKlD5Jf~EZtTJFVG;6&X=GJ1w@)X?iNQWv@^=-n%C4#L^ zNq3-sC=UjUg#SFyI`<#%6~{NyL1Q|Mtmx?rUT;QTN|NnX2K+O#7k58jo&yOUglq;s zB2fbi5I^SR7CNln6Comr`agVUE~3*M^vM&qMrW>G{>9FWJ0&ujj}`vGvmnZ+Bd`|a zcHD5_kncIDGf=DH|IIb8H1t%4GO7yscc7gIM#-PsheSMSekPcnmNH@%dYr{6~t%N zfz@$_cv|NP;rv-p{E+5~w*gF_282GTpZ9H(krc-@@WPyDA|&U`aE+@KasjloR(02L zBqN4e<{njkt~1uWO^WQp=yl3aev#VBZrW7La#bEPXC3I9G~MmW=vOARFks zA1+ekJkQ@@IX)6T^rRhb2Uk3k5K|B1I33&ix|6d}1TJ3%zimt+TvO1WV78!ZN<@E% zP2|Sx0I0t1BS~a@Vr4WAO3Scw<6&SXjvb~tkHaN)^S3qmQWc9upJ=Aq&M{utyjmf< zETL<{-)Jiw|AH=+)I6QvX6-2uQjAeAT|bwnU3f(qXT+6NyGQ~uls*QCFO;)*5fqpA z4xA`muD0E*-J*1y$Kw(n2vVE-1DD48Mrf2FLx(6xbwrk$z?il%i z`iI{pU;YefUba}iDcrrUc*uw(q)ArIZ^OL~ zxm#hncPZ4LPE{_nWj}i=rG#({IgN0Y>WdN7p^j_L`Oo-UNV1e?)&S~*40?;)c|?s( zcGHl0HWFoBg8!s0Q7IfFT!OB?)}X)AG)ko?wFf*BR1WjUao;Og#X}I1(e#h%@xsmMs$ z!s^{w>Mh8qHmpyDf*Fp#IF0@B{4nvl3D%7{K_<=Wy%yd{WyJ;yyZX0M1rJ&u^T0jo zvI)4`7J57HQ^5+sIFs1#hvYH6g#odP)Zx#xz8{w|y5J~1!cHIzD#P4InL^#tq4D+m zhbI>PG_-^V_{56JUBr9Q=jxuTOm& zFdr+OHq@T^K$)H2AX2kGEps*r&B9&A>|cN$V2g*~Rkm;Se#9^m@gC_5Rt3C)NB&ei z7z`AGZPYs5+Ep35x3dMJ(6pY$C4`6(oKb2Wq+1Lil>2lD1ag9yPf){=ll=JPGNWutj5Dl zeQ?6_8y(7fqo|sRRX0aIM=~GRr?RrEK#Ql~?NLnw4lpOLX;f}h1nmXPE*4{~<@AG) zM-ZYbF3gvA_1Z5z&D)*oDQ~+1^Qw?eHNI#iITJbV^S~Ogd@4}CyH|>8w?KceC-8aV zgQ&;#guUQo`2-&KIi7)7k^-#;OYkPia@qTMysKht2t;`!+b` zx}(xe6uW>2)Cswf6a6>X>gx=CJA#>?9S|SUUJJK4_wGzP#-cv&|-tx(alLLN_J62gNC4Oko0stz2hrMd?pb zJC{2G!LN(r#&|U0)&D50MX1mXglgcf1<=tr*}qyou_HzLW0(`ix!G#BkHD(d{D=l} zWqyp*t=i36VXR7+)Xle@7YK!ikTWJ_{}OQ7-F&#BCRq5-W%A9f;WWg553U8^-hV>E zr}Y^jDDaAn>KJa;D$q5b;hH;uIHkeW8gHgoa+9$tOJJ~W@t(ab02s4w@Z*Jut)p&Jp$Wqp@UFqF>dE`4&z zV0~3YO`*L)RoTy;SUaZO65;9=;h#!=AmoAUgENNZ&&l?jMztzpFM`(31*1V5=f?VJ z@L#6^?O7i`n5blBv~=!@upw^DVD$X{Ra8F_;tFVhyPb+CwkR*DW9Y@OGY{b(7y&KL zSGVH#0_&bS?s`asr)x5VDZ1yD2JE6&*+#QwslV*sl#4unOI^YLkd{V_^;j!#_H5lz zwdMz+^(&&ssVuvJ7pTCU4#aJHNeN#XQDDr~ZoUo)r>CVTY6@G_c$_0J8zUEAUOldx zv;HcR5Tri1+l$~Az6*YL)Cfjuf5NvZ%hJn-_p@p`#VWzk(FHH~H|wM}VNST=Jz_91 zTyP5aDkQwt)3GuO_D3K(4vrCRgqCtW>_+6@ieA+AppaaNX}~|UwpBQCq~#@eGtt~a zq130=6vE$tuMx7$0|L*FQN=Zeb}bN0+gHs?@UtBEJ5z5qAgUF`ITPHY{VBjh0gAn& z$2{*W?rJ$B_r!D99R;dN8&>7Qh36tsMDu3>GZol{B!rcT3s{OhP7e8#)4O5xyp7VN z#e#AYRi}vQIhuKRo+y1WROGk@I&)hj+W?ErNmrCpR|}iB1)A4l5$oQE+N%|(W!=K+ zL4PgZsDUHoZh~o%e+%yI#_|VWC|{B~DRz)kF|MibB3Sqte31alXRjDCYuC(J^qO7_ zm|6Erw(b%*FSu}SZ8Hw+;+e09FbclS-m@C1SPJOSHUH(@Fnu1+cPe2fqIE$3^|Nl3s*(GC7lb}Ko*waz)p}Vs(&>f9VU`0aR8tymcpdP zov-#I1A3IIkE=UuTP4;EdY0tvl&r9V-3Wrs8YbJm%0*g&jU|5_rdTkYXRqKgi&&u3 zr+fXu(8E!fn1Id;m{Buo4E(9fXCyYp{2;~@@p-@z53NP&ILgDZRF@}hGY66Acfuv| z$4%)D;M2ZZ$+%3m1GnwA8Y2?~J#sbwM%qv?zq|Y?w50}h93m?*6>bqOl#PSQDf2VS zhj<$)t_Hg(x#)m&CsrG}?EK7;nV5g>N;4Z^ZnS;V_jUqBb*en2YdlBZLxA2eM17;S zZ!3}r8;?V z`u!jR{q3mvF!_}=;$281&;SkLMg28chBSgkMVA{+0Slm4HF-q5Ax?p#lSwtUzwSr| zg=pa#HAdOC8Hh|PD(mshVy~F9>%%bFQO|A%Qt0<7Tx9V*DS3M5L_kKK^bmdV+?|qr zDwu0&)O3%*qUeN}DS5jhhQ<@=15rg2y`JH0;X;A&4)mqbV?DV8ypHlS5VBETTw0~A z#AUP!{PBobHy>JRL>?VDEc09ZX}~p4J06)AR+ZJQ1`fI?o_X(p2-i-8x3f|}x3{we z;>1T&^wz$k${D0i`~Es<`D0+WWRd8eZi$5;6)ec~Jsr){6Z3k7$KhgBIN`WMrQv`n z^1NI)9Iw&@mrQL$x{h332vkKK8ntS9lmqJVzwQKlSgQY`#?w2HjZ^IvU6A(_@!r}6 zp~szHQqO9(HcewA3Ycm~TxKj1^`hDXyNa0he&jhb7!&2j420yB5R5N@aDrK_hH}x6_S!bf< zF88F4aF$B=UCP_I$1=(TNw8hM)uedg9*4Cg5( zb{FT2D7T2tUx2tE(@oRLkE&a^4-iTl+#5mIxYOMBZ%B4=4tuG{A6Y|A7On|j(MP%+ zT;+Lt31ZQVa$gMSI#K)+(TR?TkcU$t<;OKS!;qR^EZHpg zOz~&hR&a;30;MSB6^P^H#eF{=st%@zYC<~1kGsQ&wBm(~5bEFZ$La5pceN64T-t1b ztWkE{S?GLhet)0ZRva_5;V5=o4C$%(y;1lpb1OYLdf#H`R)ptB)aNOAA6L3Te05^!uPqlUZKu48 zf(CY~JyW66-eC==TSs1F|CtG$lqSpF`5$69y_M=wQ+6s^Bm1fk^wse)<{lEgs5=C+ z5x9?ZWEjnL^z`1yE^SVYcmR7ARE2IVzgR=!ZxQYjd>tpaqouoeV9pOW?I#*ty-Tg< zj+WKuzJCK-DCX`F3UL(bA0zU0=W~`NaNww=z<-tTO3aOj`;_2Sz;ks(z~!xgCzG3u z6hD%@#AGVFVAX}?x!HodQE>U8in+=W4|jr|>ZPNQ0l6%bz8X zYlLhXsmdyk__Tx)FK zGIk)}?*W=i$)dZhMB+HM$#%lVIhN%&RlbyLQjP@ouO|C}nM!ger?ip)SVu0D$vm3~ zHn$*`FN2%a0&mC3sE07lr*f7o85X0Z*g6rv{NuO?DmXIaxPJH|?tZj({mo@4@*M>x zI_#0T_d4*Be8)A-G?MsuuSXPF{ufuAXZmD2RX|t0Jem2=&qqmgLwOet21~b53bq!+ zfg@v8rqTHHl=CxJ2($=8@@R(Xs8i4*;zDIMB--`+$WDKc_xCXxKU%=S~taASXt&#{M~T zbYvril}2dkR}QJ^Z-%sL$ElzsQqM>36tIHa>Qx%ah-qpISt?2lXr?IClLjcwZ4I^M z@!lUsPMt3yzBkkx4KYRxFk@KBun<=7V?pd|Y$e|60`(HaSj%!sj+5lU^&K89 z#mvpUy|t1X>hdMz&3|RfezG2#8_0u;y+pb0j5{hC-b#LYEC8I&3TtYGs7m?+-p=0k zEA$YbUyoDxWqEVF8S{~$_-4Z_vnu=vjxfxoY}f- z7#$B`prYXn(6%x9Pp=VK(XYyWz>F0R+(=@o!sEGC{`A(UptV~1el;D;+5#p_F!4Cb zRBE8qy$Y71Izf0#+YmXk*J&3g9H-ek;$Yst8QrPM3i(6%pj{D&7?s0-XwBSHL@^X_ zW^(O^i&qOJo5iFd-xoDjMDJ4Rs6B2r5UZUAhm-PsMqRQwr3-oz=+(Nw2rpAo5xk$9 z6(+9vt@^TzJaJupL5xz}vp{4{`U0IO5=-#lZ1>@qJt z8$)+hJ6v(qDNbj3D8e$WMeRR&62M8g zeM2j?1^YZOo=6NxCyY9_oGZ1%YcWO;>F(cV#JpKc&B1n6p&r@Q*{c`$B7=slokOK2 zIN_h3<+Yc!CkaYOotP1{VtQE;vs61P6v8hcYVFgi#k`9Z_d(9L+@|F3yoKDX7_|zt z1Ih-euwy3)rE<Ci!3^A>*&|-EZalz2_W<++Uv5PEM*c+f_~91xSdL zdK*(-%#H}p90c%opRt2|=`^i_5P2@NRWdSq6!$K`EI=D6yb8J%V(5Qw35m? zNBxm~nEzaFCTHMtwyWUf-|WN}#W@=RWSusF0(TOtB1&w5A(n!!2*==N_32O=lzhc0 zkKnj~tQzc_bye`Jb`)o@=)eMqK7skIgWlEDUGXL-bcFXYIaka#bNx!X?3_Yjd6qI$ zDaoGlT_EtIzNuTz#0dX3NUy(-oITVdpGd+x&b`rt{Zre`zsL&r|ZyE zwJ9vk=@P=%1QNDeZOF0G9g*wvt!Eya2c+xP4SH}IuV`dff6O5S>zKfoCD5BwV139p zEg=as(L_)A_=$e96m~$9{*BRS)mG>lS2Ga)j!u>)l?o??I14eob#M~3vjTnVDgM!- zMJ+Y??8GbC7~T>mPG*cs(7rs`yOBzPzdjSRPOjQ7{vvt{q25&6mJR)%Yz1=-^;*Ot z?K0fI>XaU&#V@_-lJKh&@<~^@7;WvTq>3PIAk7we1GZinPl$YRv!@JJ1O>O{(-%a% ziaVuyqi(n-QQwDLW)?7l3Pal?um^y9U!?|v@OAnmM&W8t^!TcY@BolUgmc=xn~_a! z;j7X3>Z#WhOfn3*`&~%IF5Lv6GjDd@4ggCqO!cnFpXo?D%DKqpgcrfm{+~jj7Xfeg zIEN&WIj7awTC0D4H3h)lA&E6=eDOeH-rM z(qM~uwcj5kY7X!hiNuD&a{(hi1;TYed8;ZrN*&Rwjqm0=&4)II70)GWtpOvfU&L!- z$a0{gXJ>oF)PcrA*o!JgbUjKsGQ0`5^UCx``Q$AeEv?12Prx#QoR_Grrl-*1J259U1abO|;nWHN30hmWHIuiGE^u4{ z{n@PgB+kwj{*AS8T}L;sO6t!a$Z#-^AyRb)L|dIou*;pcjjluba;ex7H)bxT&upnM zVzlVcd%D_)9Pz8^yjFEIl;%&^R+$T)KE_BHBNhl1Ldgy)9G%YUWvHEH=eSmSYUf-l zK(cGrV19I%lm;CQG&ZIBMf8m@B010c)wG*W<{1VD=(}Dy1zf7wH#3x|T0=Kcos!<+ z$dXyGW`JSv*p8xoh!U1q z&PY}f-w-Mop*Dco8*OA|A<+B@h>sTf9MXK5`vv#*b~lsdIzS?AWOVw-Io7=~gIWvT zbELnIxI_F+j1cFvQc*oLwe42~ie+ z;&mh6aRuZl{m$qu%3ebM;99?BY5z}?}D4q1jM)SN8l8n?j&g%rx zo|Gp}i2eia9W!Tel4TfHc5*Y4W1P)1;W}=Bjl{sgCSvJI@+fdx1KUPxlO=g`p3$c( z{}Ia%^oG2HF+16r=FLfpL9c!J_d#zWo_j;Upt5U=2rPvuP+nh`($lY8iHgHY=#Ipy zI53s<9lU9TLhM0qBMhx0M`4ixS~KA)r_BrK3&=15v$5C>3=xyY`kx8^SklQ9xNiSm zPeMe>lwGpp(9{`p&+1x;=>^27ShWyExUKQ3{#&(RmV*Ofu#a;~2*1zY(*WzxAGrei z3=@X^?h~WBC3UW$>FP`H`%hdMyVdJlozB_7wvihF}kqYzWA%xYc}!R@P`uWv{`BRj4g*^RL9SkWFA4CRY6V!0g2e z@dXR0;akMpzaYDE$EOY&psx=p7Z07J=R`{@^&8+0iV&_%hd3{I)WYbMDxZcVMY{&z z9AT@m*SAcfoAKSU>jFl~d6uuUvzW$36waLmm7)GO!5^h*ELJ-H?HnS*dzUzPOwa!e zM)jY-di@r{I{`KatQzr-Cv8T2umhZ0_;gD$Y>M}l&(R+iQ+7iI6e;~6N2_T$;@mqh zwqUxRLOJh1?wK}g+CumU^qY-8Tgg0IM)j!ZOU+0_(au*CNW^ncoc}kNz}5d`v0IYS zXwMw~LyvIh>=mijtXUhYb9PB{XBu1+3N`!RR2M`O!PZ$`yVdz1J#85hiUtN5Vn|g| zh$;fR5dhyaym9NvWi<-YP^x9f9<@-9ZnE=6hR>iX8)$~S=OJ{LTKv?(YQEN2>Kin@ z_o!HYTeWtN(+VyrmPp674h9U z97EV}*gL#D{XA8mR?VfWntvXj<){xb8({uEf_n7shavyQ_kj1IXDs9wZAT)&iAA{k z8Ogb_?*3{+dj+og|H=#Cw*;7t>jvG_a+3`D7n}1?cFhji3JfcNQ)-`w)_L{UPay02 ze1l00-s_-xm|s9Zr#MA5w@rM)v@>PaxhK68Sv`^ks_;sP&a07}tK8lVvmRvF+i$gri0*b19PIL=EenVmP+rG52NHS? zN<&WQbiRveR+P8XBSR^bRt9Ue%L&FnefY;Z!5!hn%j?$^+#Wsl*#dmUiVJSYF;I#V zyoB?{1oWjP5T`qYzz?BkN?Y>j+mYc}lSOS@X%tt$?gdZwB>a@=ToPWRO8Ej(P1zb| z_*G+E=Cc-yCcg7xGWn*oTLspQDAs>h>^R-M8hXiZ?nYGPT0s6UOJEdHejm9u0snZu ze5i8`TxW@xYUQ%(dW(0E51Pq`7gA7Vhvtw$5fWNey6`THuO;oFM{Q_z31n=d>yxP? zOe7LaK0}QnUk2uW-0Ozjs zwF<$%QG)+~W82*jEZ6&McV3%z}ju+Az8=w!sW_epJHfu=}n0U>*$w&&R zFqZt-Ky=pxe|B2u;8s_-k+zZkH@c%=Z#5sSWC&ub`sTjM_3Hf zVC~%XwS<4kzfaLcC-w?AL*#sdx==W7OdxxSx%801E16&U>aZT?*WkK7TwYCWPKNOK z5G83wwn`oHGgw;VAiS;*lR2A`x6+RaX3&437R`-#R$J-ASS9-C16^9@)2l#azcwL& z{dFU^v%|)#*HorV^W^mA6~iHrurI;pG2mhZ*^f{L(ZB)Im(*Y3hrbh%hyyEigTVT@ zb=7f2I#4{2HaWn7b!Msi^u;G-l;2yx$7-8#a-XqZ1M)F`-b>6oH1E@UVkmZO+WdE$ z*hVy)a(m#WDkvJhUpWV=jnNyl+!MGD^6$R~d#*v+agWW>_K`z>YjC<@JI1`0-Dn#H zy%~T@P@3GtA#mIX3h|)NoX^MzLuX^p$fpl}Q0>9p{?_frGV|Th>g*ZroO@ln)Hz6; zIKMkdr3~#XVolg%PSIM6zPz*>cFi2s}4_icbt}1CYrA7z* zl+Sms?*J1RIT3514)smvfh)6*Kwhq%OYH3am3Ekl$M}7B6m~NrA@|0}PnqvaJW}Vg zkgH1n`wo6a#zRGk-&>JTXk0q$RUZFRRpFGW9U(H%$?_sYcF1{ELqN%4m0=R8(zPZo zn#Ffz%fU*V&rW$xGvv8revE6WLFR+@{kX}4ijC9#`KEMc8UF1pb5X3RN>wU2QYUrX zZ)HsMjOI~x>i|muw0t>reDcA5zAL9pf&th7(*v}CY9qKCv% zUPoQarOvGg;UpfSdCVHC4pvdT?a;L)H~64{wDZ!%pY;4A;73|F|CFNJA2)VFTr(6_ z$z@z2l%GTY4Jzv-+h)#~lHW`+9N)!hic0-&__1jrry@Ro5yaG+C;y;_t;O$)c*RUZ zN?V&Z<0SX^jGy%>vGohXGpUsx(eu2oBi}K*!z+G&J)=lZQ-hUsVh-b5+9X;S1oo~i z$?0PCS?5G$ht*tkBFpA zSze#ph7CUmocVn#?GR0~@fU0%F9x;=HaIywuz(S2TOjS%1tqB6#m{Gw!~E4c!Sd|r z+9`lV!E`+_|6^{=%3A=4b3hWGtcMC&;lj2&&*AIpF8Qna;)to9oOp84I6m+4Ty&Ujj*0F zJS901^YfH$|IS#2jFW1v`?Xa1xr#N274z6{yl~wW*AzWKc^(3ulMXeq6e@Swej06U+71bO26D-*EOmDviaI>Su zIh`xsJ#5o+=`>M>xS z55YbO_?ZT-3acnIa)Rh`>4Wv&W7QsXMTr{0d&%7Qd&<*i=3uhLkMN7rWl*v)7ZasV zx@YsLqzNLtXaUmX0)qj!p*RpqFWRS@)Jod@8Yl_)OdRFb2O+Dv%Epa$)P5Q zc^XWlrz)*n!!6`yZb#hT3e<*wm~)I{KU=MH;H)p#hX?`)xR>&~8Io1aSo{ZOo~2c;}zr?}LF)@S!R4>2*_67oXsfT$gJtnrjm0vx$Vgl?;g0O9q8I0=dR% z{5)3NJDz&!SgBzmNp(khzI-@&FV{17;1D>p5OI&9-q~U?9L)l$O^A2AO}W$=*?N7H z!5A?K-KD5k6b@|(G-2FL$SeOgBjjGYFf$bPoLy?Grp-fpYYe8PYKfO{7!@6v@r`#| zpzRj6oh|fGPg>w^KM9Ts;Gue1gNl#<-29e&R5KEind1zEnDT9Kzf(>YGwmA89|c2k zKNIAxvaSALm51+(K;N&6$jFANE;ZjySDr2=(X96j|CJ8c-9{`v>LsH^q)hl5)x(I6 zl=Z(vXs#{Tn31GeK%aYOU}%ioMp(Y2cF(69P0 z@(Q!M5Uvb+aICr}wW(mhfb;AQ0rTZAs8b`)53Jbgl#^aQR3kq(x_H=)UhUH9j-K|O z9_>(b$5UoqK=3qkIdo=xWOF`8U*vEd6@cSj84-w-c7KsAFKgNz503mgNMB=&(wr!b z#*;kK69e{sdzVCsCQogt^RA@CnCtQDl7)cGQBv^x0xl@7NV#E(+U!*1Gt@U4R5t-G z6;9=B1(%m^0b21NqI~RePa~buWCdn|D+($4SHAGn2I}Q?K%QCg z5`;92FI~PS%=;zEvcAkXje5?8_a#khok&WF>?@g5>ar0N1ohp8fLCjuTkylx!iFVc z#%Y{6?y2-y-Jsno2sg#VgTOu|04cMtAOoZ~iy;B(0}-pqqn4Op@>?At-hmpqHc?tj z5nxlm5>!qUD+o6h2$Big#Ajbb4yS<$kIfhAQc5`I<(NB5QJ7n!laa%|wXj+7&<5Pc zgqv$lX<^0)@(jrIuN+~>quS0kQujvQADXoRn#!!3I_E9PeWPGN9M}P-CwnhNZ*+BR z-Rty|5 z0_vT{m#EBedq)JY3TvG)3HF<8-Hg0c3?k&7`M$4V=m+|$P@VKE_-u%fNMzeJ9L=?R zj~JALOXYu-gSm;V3$At8_NcPOS*NXcCa6VljZYawbVWBM6jYd!IZV!6BY(rrzbI@?Lu zAa_P`H3y`d5N^DfqJtQ>;MOhlj3o^8grI1!$#F-!hdY|5AFv4qz3L;lgTlA_8IblDDOAY&L9Gh$ z#Sh%m(;0!Yf|68ck(8+&HLXop4x>_e?ZMEFU997x^D0I8E`Zg-gKTE681s&=w_pc5 zPvw0JGUY)l>X;S(~o|;-&Qdv={P+3`7Qdvh+MxBP0Cu!SIXxlhxW-7>d zwMA3186zbr+&q=vQh z&7P#CAL_Zg4f7NJVg3rUyujTFU3EaWG?1dP_RS~h!}8g3;B&TNN#KdK%H!JIHfkNG z`k@apOHtkH@}Q27w|3?k7ydwW1-=gRTIgNFcn7-oyC{BoO~faxG|0ht3~BhR>U;O? z?w`UnUF054P?fkc`ut-YJhnE}_3P?2><^_oPw+%e%WX-bGe6HG&hBPX@e3R*> zVYuOr<15isrkTky0D&HT#XP$79;UB+IEV5LoMxchC?CFW?R`%u?G69|1vXa1eiPyR zmec;Cic$~)X{IAX5Qy+hINa)28y8DN zVYp3isb474Q!3trLR%2`+#&%=KeBNU*KEwyX_e(3>&?pcT;+q0^iBMtuS(^TKVcFa zW(m_u-iy)}z9M~q8Q7O!XDQL7K!Y+R*~FZ|?gog@z|Ny5 za(i?f(EsG{y!=q5y84c2a_(Im}2J`o3aQ)@UW(QNw=1ZSDU1DK=fwT#6{yL@^MrIOFz)S!yh*Ps z8W_XMeaP@sIAI~-vbh%kJALVrkJDJPC%YwhvMY-#8Ez$4Y^p`+;xduXaUYPV!YLTc zdwz06whP+&R9j94ul8^yk8B(jm65q~Hv9!HBWMYC694t5h?cRE>&w!pUi1xDa>7PZFpocX2UL#loWGBC)M zP}HnB^CU5~+8rFdC$DgV+CqgMRQ5(C8-F>s!$dxm7bHplX$lYt*V|hI0n@L$SYozt zU{VA8J?;$R_Y%VttiULP4SNN^i`z z!vvBinbF@SrL#HljrE|pSxA2L>r~*ZR%-!FRV(DuJkSTKA$AqJ0j5;RZ69kwuRfx` zuYOs66ZeQ3OWNB%HTGwzrFf@JwyW$8 z6CJpDV?L2Ajkuqki&AxO!E$_@Q3U{K(tHH_puZHWV$pf$og{Ai7GbDK>*X&3yVoc_ zZnZ@>s{g|&v00X|z5rzO@41*%%imX+vyxKPk~d(*IUFG^MHc#)t2pk3Lg>42o(S*g z`xC5Nh5lyVofD z8S2A6dwS$qf_5>u`w+MAax^LTTxvw`> zE#Cot-GPM}-enf$ey9axNthJsd{EJ5#t&Ono~fp~{e9}#M;6fzPT*?go)2-*OqF~A zu}PMB_8zcTZ@NHvo|`E`VyU|Zb(m8gMyJv4CTX#d3`K?ZFoft|vkhaF$kPJir6kgk z&fW&@&!hKrs0UA2if(R4B|(B@F}fN%t+K_1=g}xw6OftUA=y zXl$T`DQvC74PTm8D4A=bJVLy;C6)IoGm$}?#_j3)2REL}#C(ET;$KRjmW|lzkmW|! zshl4#s#^zZ;Flz4QsBl}5!Q3eA1_Sh(v|wLnq%$-voU4dpS}LZgVNF`@pteo8i5ie z{QP%AF(6t(GH+C?B_OQZP-qF+E!l#T?P|>TL}0#UP^7tf8JeB61BS3PnBNucjVBdl z$8y}k3U|*WqxTl!u6UZbaxy9Ttklb}i^A+@2`Niqn{klG^ukBZOlR>AL>Qfdz9TXZ z=f3C|ovu0dI3m&5DpdFXn92(i6i>v20DC047CT_rW_XTdhW=Y7inEW(FD?YlKk4){ zr7tc-Do*!#MBEbzv7?E0tLaI>!>hTqJ}o8#GiGrV=S58}R^7X(1Bp}nztYi^bCLX7 z*<0!xql?i7`=oY665r@&(N7+-Y>*w%c6al!{5Y(veJ=kf$(K7`^~m*>61XiZZxR@S z4kwXf9!g?$mqH64Bi_HQF3acMdz#Q1Nm_a?PxI*;PgJwKvi!JgyZXQSQ2utBq=)W@ z-ijp@Tp9eyGZj9N?d>3u`|suC>I+)JOhuO_d}pLWz>vK=NP0HA{HX72z>|JB`+{xo zI+f38!#QBR5cB+V&A%x?ccqZr@MNV1wGKW1FMHMAAwB83l-s4X)tONwuJ#C%uW_F>{cVuOtTxw{~Yr~ z;V@u#5E6GhQtp55XxJQj4T7Mg+0-2+{1tsSp~tuf$luP0UIOByY!&0b|^sGfeJI_J1E7MI}G~9M*~}&RqqazsZ+VeJaE2shq$!`Ty6Kv_J}6m&K)P8`=rKMMlC8b{9isSIH>fHh8}_=|Esda7{>wprQ4-o!tb zDXOE*Lj36xOf+vJ{hKR+X!CI2^M;4CGnBv#J?1Xk?qs7ihzh3*o^|?CZEL0xq!eOMZ^3Wf}Rz_m^_@giAxEdvs&Psgh-e>s1fnyU%#4@iYM2F%HokGUW!P@UrZ! zQM)gKqzF0 z5DzK1OFSfv`Yd#9eMZ`%J63?=LMw3>IHww)az+h^-Zw(EIn#8?OWE6 zdJ)!S1U^2snV{Tnlc=~DK`aO(Zp$F(IV5S-us0UMR$Q`x~z#PRcYI` zQNTJC{gu8=09S6oOS=Zo-i2|QyR9K~A_?`kx@CubOmCyaP2kSdT0S_Vp?OgKtJXb@ z>g?Jxwg>i%21sq_0xQr_@UdaP^5lDQ%xGUrDoGWrdEW6Kf=0A@lKM`l*H5%& znwS4z7b;3~?1!1e2ITM1GgzEALVj%Ig(>EJ_h{^Gd6%iKJG>lnC^(tk-jfka;T)+QZSHbMlnKjYP`YuP9WLS_1GKT7) zZ>z)oXd)^?pLUQ&;&LCnwE|Vp3yTC{_==-r$g|MY*M@Bt^J)7YS0s*}xfs)#vzsr^ z0{2DWkk~~bPNpKjxo5w?9oWq(s2?aR;u_Sin85FMkRhpJz91WVz>LoD662e5$SmVeUa9_NQACu{J4e7ta z6e~M)$VW9OgyK!3h`+PHJa}s`yBTDE0pYx`M0c$L@XWe~o9|*sdm6`<&&w*bzS6A@d4LP(sctk(^tgla zFF4-$wXN%(f0PmL_w)_`IX#cv)E-`ctO(h*$F4*(r22bYqlZ5HOc&6xm0h}eJ@(`GcFPiDJdC88XbVZ0gx1=_D)~ue zIn{=Q*4-rfONkOU*WmLH{_MA?g_Ohtv;_YT2*P~WUQ-row`70SXOTU^pJSwdQiivm z`NCv0UzQ!zC+I)pdu&=d3q8fK&!^{(M)We|bDr9C-yfVNNP?AnfZtC6^e#K$)lH3r z4px`-UZSz=IXXvhbjhd;-I8I(_xmnw+g}3Y-L>?^LYDwXyeN=z0i}v=@dL%pR_?B> z@W-rTumr3rdl@RZ9gIK-nnkfI28*lycv##Mr{WFJDx>h|&G(Voj&#r~AVm=ye%V*= ze$9;ArPD0OK)V1*^b6b&blvZ{FNp0}LRxrwMwK+P`*rq%sA9?MNOAE_uXkwj@b%}l za>Bl-QC3CS1zmmBV1@!-vxXkWR%6mfea(?31UHNv~Yo;X!u(#Z2@^pT^(3Ykg^X+8tx5F=m zF|Vu`)c2ndh~s#XPm-=udS$7gdBq8V!r}H^>Lj%+=U>voukn2w&)`;iB3=p>$Jkb( z!#dZRO1-%HYi%6L{f$QaKma?*I9~PhC0*Px7l*dHZ=U2&h2YOpl@B6mGe>voj?X6U z(E{T32~8XtaV(~ou6Lk2qP^9E%;=kHi(|j7y1Q+~pUwUECbnSQbgPZ5KQxdk^;Y@X zv3bVlyo2tdiXTUZWXc)@UzBI&iRk%eh9;S<49-yE{$v=?m)Speojgh3%QEu?yJGzE zLwifyxtj@(6#Ji;DT8Fw(!O5TOn|N}*B!5c{>IMMTbs|tiJ_BQilMLNIhN$3?&ywY z{ohrCJ4s9KM0^QPc6n@7YAlhYGzqay9f;BWskWp9X=I zzmON|NeJ}kug2(jO_D9AK;q)V{?m2!Hn<8cDwQ9A>Qh7OOz4)S=oLWAw-Mo*<|S?M zto?aO>c7f+iJ1sm>oA*}KG6VcwaQT0$1FQ2Z0f|_WyO3_n`v2=Ry)d*^A=jBe2Cd&Hk@!_@meGSQ4^Ue zt3cEDoI#m&Kna{psZPw~D&#c35I>{(=49oV=X!CcI4QC_{pf8up|2Y}BJE1Kn%p`{ zmE(+rV}7IbU;e>K{AmcF%f^SLggO~^AGI#+VmH69NS<=5+Oxj=IDj9sp7t_6^M^rs(5+e~=G0A)9;2c@xW@e7- ze5Bsre9vy}u{^5;8&3LdH=I&_?Y(LD^0-Qml0JTFdmZ11>=V6Q$RQotSd|cbj5kF>m8(e zU}};7dTIYaFZ@Se41{9YIy5g6PRdYz5v)edLb|cXF)c%)1<~dCsme$Gt>{@rjMBX- zD)ApO@nH9BArxfYUHZYjnRe$5_b9Nd^IvqevSu0&Z~fFp_ELq~*@W66Mdhm0&|E#$ zx)*A!c#4}b%wmr5E7QcqwKiAy5_$5 z^4H1sXscAnH=bxTe@uPTI{q&;td%?gy#;Zz-uuKGemvC%*zqi2y;^++JV~=hJ08xP z?#nqpsedo!9-YpX*mOQIk>j{dUp87F4M0jj=+o)B$A-IR`jcKokBWdJ`kx%IN{WFS zagQ~oihFertp50kn87dDwD#hO2E<*CqIcqY=|>N#>%=sgF4+hb9VK5y=Jv?>Zs+RZI#+cn(+7w&2`n8rm(KjvZ6 zej*Vtlf^m$YAjW`!f1O1X8;3U$FOMAe?<1uWyE&TnRL{X9=Z0)@L)`GK^`Jkd2BTA zHD9UoQEgN`BY#<3;E9;TRep?h7H=8HMecJWEP9Ng2>d27Uw%i7tQTE{lbPYY15-)= zUTe#dq|2Y%W;Cf6n@_ZPknk@zTlZnXuFG*XcHoq1-T#T9_O6Tq*jHqZ%4>vuNE{Oy zy&U*F`Zn7)u&k+5)KXjvePU~~#rJGb8QW$&9H^Fc>)*SeO}xP!Xj>m`D|9bD9c7O% zlR$(<+gl_mN!ZIYCg~7%j86TJ5a`9+ZpP5D-{&CRxnYKjntXe4iLdQxlpV2WP9je* z>wn-b`T~y1H?%!hk=DPl$RZ{2^E~dQmatyliOR<0@V~Lid9{B2Kc}(A^#xqG%y3d} zyl~0aNv5TB7k6VNe_YzOAYQ5*s)V~7Fdi>(=On&aLfct0_QGGPwl!F>bprRpBicMu z(Pywmy|-sZU+Wv9Gv7v7i>)wdm+0|J3a^N&0Y3psr_TF>&^v%%H{tNV#Dy0qSr@5& z{zT49bQxv?jg#wv_WVtZbc3nA%bmd;$M1*CGIU-UR?ZZlgf~;U)k$`ZP>P*no9j)I zSe@)Kg2vA%lLKo4HOVAF_Sk|Xt=rM&LnMXs)Ghzn@E76qf*C)J;6L^xqd~j>{f(Ud z!m_+zB0q&xy`H%@9Dnbt6blSG8e~Y)YibABy#Ej?NGFRAYCm7H#-Y(#&;7# z3hQ9LCdx5ExkveJdB|+v_}CSO`)!gdYd7^#80oz1Lx9 z)iBTQy=rx@Vbr{h94ByR5kx>KXO%4qY@UCHSUEShE_~>1l8nXhWx01A%%*vy>Y^4< zE((~Rq94mPlHT34xi?!MG~;M=>xv#~;5wO|2Ooug(6bJHzU)g>S?tYf-)f>{9k{_M zlcOoc?Nyz9*SXEk3Vtgt?%5%F)%je4T%=DMl>nXX`N zK+OT1=#lo>|MS(VY>3ubMkM`T9$m-5I>KKRV`M1|IDI>((PSOj5{jvsdu4~;_CWv zv@4YZThxW~Tgg6FXpc@b{Jo8bnq4HA(V`3k4n1MHGMS+1n*U?Ywcb|o< z|5*N@a=xHlS!%mu-Sv*o8GMqVWE~?h!{Yu+-V;_B;nR0CHEH63uT9>L@^j*4w*cOe zk%TGz;^nvE3d+r$4)jNw<;c@kukBYcNpsl4-Mveg!kldu4CH$Zs3#rmlC?m@BH+Er zEwkH@OB1(p?57(dZ^>wR!+SeBksVrgG_|Ow&Glhk1a~5913oQ&Y=2m%D-#$pbwrX5 ze-f3_omj!YZ1pjheZQE(neXS^`-F>^P$y3Y7JZ;GL&`i0QejK3#rNLtp(@D zUH1k9D&a=c2U!>(#fJHku;&2X64Lw+IPWni_fPa!RBpQK1D);Y5@@=3jXfH+TDj6v z5@<}*uUH76%m*KYGzpT7e(3h^=Je@a33qIVZ>91649$zigB;&D01n9@d01 zHS}xtXtBo&l5w^Jr1YdU7qD0_!ZmyBMCmcv+!F$NU;wzG{@Whzz$_9S$qs#d&szHj znFY76gxgEm$~N-t`Ya1Zqr8J>*#j<>{GKxXvLVsoGhg#lt&*7pQVZMmWHnQCOj&53oZt1YmEj}h6EOK}{NwF+eluWYL z3#reP514AIr|QvMEXsm!TW|fMIt6>TshEl@aULP<{@kdwV{TMFjuc!@wWk@+}9nkGm~uH}tHU&@3Uv3ZzHS zZ127$FTQY3E5cn*@^%)vn5kd-@O@EpNS>r1kROM)xBtM4#O( zV2WumoR@mP-~TE1vFIixJUOp0c`zh}Q^yMYhpCzyQSPyfX0`eDRAgvEw3E=Yi(HLx z^!_eDmUnv6@M5JpFg%6PV+FWRKkJph2*IK9y*U>Iv*%cLnJq6fyVI>!>S-_ZHm`sB zv19S~12Er?M$VxG4g`fgnYFhvJlFKH zDS-F0@ZLWzl_{PRwoaSwTsGiQiCI+SHihNqKU$2A6rwk7oP4_{4R1>rqUOE{@A5R8 zOtsGid3gs5ALg@n8PxGB+fm%DvZM5MLzgx}$GKxiD3a>l`$ZRd7jgGnq3EDcjst&Y z%UOymxS-Q#4mpc47Z98<`~=I7AnB7wWInu8hp#|J_jVDV1?5&Ctq8r!P+}djUgIFJ zgpMef3)bUjAy#@NPnY?`kve14Gra!3HBe491cPPO>UcXwl7y|L7rE;@ z9|Utwuj{EQln2#vz6Ehwb$$4pn32xvS#ZGU>wguHAQPU=M_9vWMc;>M4@$#CQpnqZ zKys`Kcy4L7xpPq^C{>#fPIxLCIVt5GG?=X+x{fcteM*LZyJ*Aty6W!0C%jZBS6}J> zFpl+l*OavW>j@^#cg?#GoRF$hBkaxPXmhw5bUs2RQIv#U4KrK{S{$T z$x5CpXAbPCW%-aF)>T!Nkpfw_)`cZGAeXAK=BXf!b&Xt38+gV=L?hS`r64QbeI~&V{%Y0FR!k%YOy=Yr1VIs2swL zoO==L>#u9Bu-2xyCz4DFuv~3#`)0AfR2$al(!w&bFbI-lxvpFj?ZJK^+Vo?I&-I=X2Y=1lDeLbLknmE;omk z%}#1ZrbHY^6M=>}EXM^KnAdCZ7vE6Rud`&XVwkDQ&~Bg4Tg;nfH);FCZi%Epo12g! zlE!VdR4JX5SF-l^Ojkaz3SRWz5IC`~05W=mh~-;bG7vnTfmsaLI2%nY_&M8M4lNig zUZjwZR|*X!Q^*zOgu{_6&lYXg7{1xecstyj#`k>8e9gygKN}F3Mv-72VDQ`zrK$$nyQBO$`rMe?8UxMO_iOM+xK-aU3 zEv8qB0az;ZzLkDQ;-IX=gxtlc#x?gN(iFX%tcCTLqTzpAuXv`2&>IEH zvnyfvK15y_+NP=fg!^o^0TI&p9lW$q?F6Ef>_HovB@ETI#s&F0q6)~DpD|({=%D5P z$$Opj(qu*Gkcb=33i&p&F{b!UlCxpLNc1z3ihmE}qZ*9*q~lL)Qs}O>#7z%|&MWcN ze#`6DPPd+yb{l%v44-?a4EWq-Ef!MZV5)8*BL(JT+c-S81At{{8>#2|&ZSd!gu>+= zj)Z-cMV$=N6tI}4K}XW`SRMaC2NTy!e`s!Ez5@yD3~S*)Q5k0pksDg=Yx@VpsrYxz z(AQlJq7JfkBWuk#lH^Cbq|1%^*C(6TvJuWD@nvh$7$oRwI1caN42@|*|RR@2+ab4G#+R)PQDkk-IG~gg07>grX zSD5C3EagcIZA&{a+qzl`ImP-YHr98QPhoI1`=W9OzT|&Ur1KQp3)nYRLB$GZ$<`h?7DiIKk+C5&ZSoY+2Iw%)Lk|+@s9G6~ zt+A~kNQjQM`JnS}^#X*IqT;6`l3`#a{RhXkR6QB!zlWU$Z5L64RTNg5411tSeTiKr zvy}cM3w8|qMyU1d%j5yt)rJK$RL5-Tl>z?Ovlj*Tc@1fJGMUOW3(ceOA&j=liE zf^cDIUX%Q9c+PL#4hwsI3S=jEjT68YA)K8zC|Z26m;V7@Mu>30PBcC5lSGZ-LIKHL zc8l8FqS&wjS;q@nL0aHAcN@R2L%c*ey|S2wubS0g?(d{r=bft@161TUSgGPvf7En+ z|Arg{UDyrSX1CQ)OOnDfcR|t4a66Sza2zXK|2aJ3^eAa zKx^IMG<%mj5-8VpjiWB^35j+jQkiKt!=JNp1L)D+EK?+XS8Xd0LTtDF*BUik5bK0J z_=~(q>54tSgmbfRO6Stv>$>u1nt0FNov~_worT9M9_SdO=xYKkN(i?;S0}lznX0~} zA3Iu(aHblPH&rMK-Sv&GpNTn+)IXEZu$~NRTe=}G6P|6EXAZraalsk#1!yH(^S#RYaJd1c1jyoAC$oEcugzCH9r$)xl= zEL0nBu=@{5<6*rt6Ga1{L7kzKpQh_zenZ+Lw>rLrpu>L#dT0Xl6Iq3_6nCnA-#ew8 z#7mSG!)ttArFx*+6xZ4-@k$r}0@=({896GclV=&uh%>$2O!KY8e-r+>KC31#WH zdE_mW--5wCkb|eP_>l>@o{*JMOxNegdeYXo9WVs|14jw-)>TGhfH( z*63>2y;X?@kDe2V9IJd(jsE)UCt@09AK@d>^DqNJ#qgCke7p$@RNRNis=e2rR2Atf zUp{B&7^AiS^B^xvnn{3k?4hj;?`tJq z*8v&OMe$s@SRL7&iN@W{RRdnqy8HvI{chAhr+?sy z3mn6yT+Yj}9xfxk>s2#NK|Ov$w{CW+>?|4LPn>m@{+YBc2z6*VZmbvzK*)d`i)AHF z(s<#J0DDU&w6w%?{wB2idtcOYQx_&XkNad}kLS|T)2hXDMs@&65kmv~=O{MzpGfE8 z;|Dq%7XHMGOgo}y>R$+>;WL5h;F2VLZoBI>H_or2Tbt43fv>`2CMcdBjzK|-4&D%>j* z$^3rumE+z648q)?p^9&G>mu+GY)JnwGX;j*B#R6o*+i*MO$~uCPdd{pp@84Xa*3pUR@l2aEATmiT8C6mDkg4#jHm z`3u%~(K=IEtD3sCv%YV_2=S)QEo5~U<(}q}am-44o+07dul^IWY~AM0Gsm$nke$00 zUZCu6&k5($s9n7-sT1yed5hNmXCCFOH+A1PO|gtll=7mN`;QL!2m$!K(h7tW0}WAz zB#TC5B-~9&H!N_je@|kS(t*CL9mT&R3+-{mI#Ux}1sTm}jP9Tzz)*Y_Z#**#X0BH$ zOlz5*hDpk`uTja1z!#o7n6pVpP~232iT4Ki`17Wut)0Ce4JupxQMC;BpyXV-gnP>> zQ^?}Jkp*M)fGVJ5sb>;YUVa|8XO=P~pST8b!)GB7w#Km*3>=b5|UV{AmS;w%^U!d*yY)=6NP z>Z4}(P;$`pPG-J&s)DG=@oAuAZ}=qpgT+(c3)n8yDcWOLH}gMIpTbdWMi6@?*k<}{ zJMKbqNPf`?C0{83ra&n2`c@~l;r2_~mw(4u#-<@j9Wbq>>r4YZ$bKpe0E^2>bUIT_UkK{nT-t5hR>o;c*hpAN zx({iR%Q{Sp&0Rv7;N{2=ax9iKwJ;-o^tjY5_Lot~JZ{EIbw>)#<>L*eb2eEjVv{{W zYywwyA*=erQZQZnI6TG$3j}bqo$<~bIr?UX18TU1oWUWpYG9pe;zxeGFk0|kp0Maw zzsoEcN`t0)>mw@wz=4YW=3y>H2YyAWslx|rYMeRSK&ABloU2b>|_GxNqNHlD1W<|HRDVwjGuthb~4A) zmoXb!0MQ2Pu(?A+Hry>>4h$x>xlBN#Dtj)a<_=CfHZa!%Y~C#UOtrDsxg$p>c7s#*=jKd~GBBl0C!Rn`GM4 zDF7i99VQEG={4l^-QGmLRvN=V8YVpk>bd)Rpc^$A71&dbO3SySP_FHmdoTL;X^y-r)5E}Mr~J3L<&hI4ux!yP*IGjtW32AFCMYH&+I ztmKC!4AGesUN0%ctu-ys=T}(ckzl2*Teg*U-Qp65h*M_wJwVUUe_i$%={=tMhw+rX zyy(ds3zZ?tYG7;=GIscG5JL<5@(YROz0>$q|91GHh$)nCC;e2->en5KSdb5?f;RGL z7*Gt8Lp0GLD;n4Wvs0Guo(-l8?AtB@cUNW&6lL~BJ*Ei81S{kY*@2Xzxq#T-xDO)BY_(@ik)Km?NXpz1J`a5f`qZu6*rtX zPDpN8YbI}|e)!3sO!j^KjT$7hw}3c%BPPC<;f%dR(ag`&#;ZDaeeTkllP1=d=_M7JLkHF+6yk{Ri2^^)F{t@O7- zNm5ph&bP>Bf0%3IT}kL?4Avwnc%-V|Yb4!r)i`q}eo&<~nEEg$iA8_cZEUTJ-ys{> zDJ^s)mfVmL_4;SGd`m)28A91J!1xfD;g#^blBwQYG3svH(jjq4f%8Rpvj=$A^D3P#(i z`4Oo6W`C0I(XlUjE39LwGoZVYG3M;`ehsp0vlSV5nKrX>d}m`7V7;zT2Rn{1d;|t{ ziU{$(_vv2_Nb>E667e<4GPe)0Vf3=F27cjF_4-mFd@^j|Xdj2rO_TWdwpGae5*}hF zP!$WSOdt4#plbc0K35arqz@|H}-In?LtfI@HRxGi$Q7KL?$ z`3d3YP}lpW;GKxn$7#r--R*+E>wJ~zvaj?-Mx`uO#EzC;kTHGgYm2U^aKUbd<%IO;%zp0#LloSRp8T&HzZD2kIIea z14H4R?+0x@=OjtQV>aNOvr<$DttZgqxEHc^h&m)aL(DYi| zfw9=B)u}b6dG+g9rp?WBiB}2vW6X#_q*lE^a!vy8YpNyYU;)v&-G$N9-a33n_^aOn;F2U>P0->wGE(LoEC6lOY zz9nV4iml@d0cU+(hP~uRRGTbJjYp-YdA9z@hHBl$uJ*)fxcE8XS6mUVA``Q}9hH-Y z0Ue~5aIIAGO^uq4sgIN9qx$LMYvk}$6tFSQ4Ruc!+ijJg)Qfu!`FXoE{?hWI+)bKl z<{0EUda}33(mta*my35#H{p+?fAU%Y`2P)vC!4eOnHg#2z-&;ro{a86lChv6X`tx- zh>#J7fA)I~(UBT+JB@Pc-{~bkdNW9OBOHl0dXCylxJw*%rPc7>V62}6G+H+-3#3mc zDevS-NUk7Dpw@4Mm4sG#w5%atYv%B`bgZ#?>&GefaFP0KAsp63-t;!LkoaQc#=#ft z>cL>d^#Z|$j>8L|+YV1_^YD?+iR#LTPTB?;#Ad+u}o{` zV_TsAT*RC=_@cu>?3mW=_(omV@3IMLqh7ha zorKj(O`+9uBNvkx(DmOV%KH>vj`@nSMsPVe;E2pT44(_&d&Gq7qsaT@n~Jk$?k#|! zySdDf_y#Nq6F1NrVMC1XTOuWHYMEhu>^Df@buq}+@9?9QHJ(bkmxhXRiFnun^zg>qFD+N?##f9#U8nk9=7T3`Mq01CIs zRMrF-il+vuC}p_p-m!=qrV7~;4YRE#$`JklnJtu^xIi^6yw0ftXp>i3osy)yKM4rUt`sKs?&y^4w?fx+$$TC7 zLzr=gy}(GHqF*|^c`EGJ?~lxox^CNvzG6@?4nw`9LAETQ1cF~_=PBNs)y0kQEMC=p@hIcAtI&&El+GAzx?d_Dxi)|il z6u9usNiis$2$;ZUe_`V$7zS@<$m6gxNW_ZPv@!g#xA&QeA}8#n;Mlu?CHsxV>+0Bh zq?l_FaFbmT6xR@pfXgYH`&ouyNJBNo=il;3oO?Z5-xPJ;{((8MTUpkR?aIUuaDT;= zs7dCGm9eIiwy)kFVo@8kFk70gJXCH08fNXw2t5_DPdUq=Owi2w1WUm7CQH=~ISUZl zD~;BTT>p6)f2BZ}e`LqGv-QKX4)A$fjbv~3xYxa-r=&oD>q($<1i3LQxO0~w#@>&& zqc$18b_wCEO7%jG8RhrAyj*l&+fO4+>1*`0pXl#BJc=KK6@;0x!=1(PPt)XBILU-X z*qnp{%YmA(=ppUMW?bk{Z~$j4mcshtNnAWa%z?V;f=f@XmZVP=jLt1k%3Cy`TE*w| zseyS0lwBQPvtJ^&cuIMJD$<77VAWo31T)6&OwU_tyf)&UlKAfC6b9rx5wzh4*~(*&)?JF;m-Vn&98k~Y6580>tTic)e~ zEgtqSl_MI=IF3*>DidV;4JI`fD2Oc&Utk%&WE$(n07-qUGDfzdI?_(cc%-1v{|H*+ zQz5VHUh*$DgyA6Gm5>q%?UcUHS62h$+fjM;{r}8!_L&6B6LOiPwrC(*VwZrHy+?J9 zr@CnWvBLGpROTG~_8w0d+SL-O6IDAX&)84#{GlBeLm{^(_s?#Yh9vdGY`u9N(&m z-cfbQ#6K>k&q?_ES@N8uZ&n;~MDQV`5Oyb2K83S%+`wUA*^$4X)9% z7mwrw)vl8Q&Yd1h49y2qAoQ)cpK!uNF6xGD4IZo^0)9OhBfmzy)S4FY)Y5ryvcLg* z{z^qWD_h$J8>6IM#xmW6(c%5jUGp`Yi#Tn#5Bf%lD)-zz^ai7;+?SCAnr>u`ESKgt znK#{Ks=5AsHx?<3WK=z|deT6ytMXBHn?HHEdE0-L&T< zZsn^HCwU6ozuDN;v}py4Qh+gB@zdCjXqvFoFSsZ>(yddNOOh*`S6VqLlD~uXJW#Pq z8~M$$nRlfy%ocH4AUs~f7`i?nJX=E?pz$7NVCi`^0qCh8eW~lK)>K&PFv+;-URLK? zHjfC#g7NGz$)zZT{iTdFJY^zS{5VZSb^-gtKI5RteGbdaSslzVIEN9pbn}NC>z7T}Mpk*cbIm|FML%omak>uNG2rsI_(xB=k&)Wpx>l6P%h6$w05GQC|`& z?^rqgG!=RH9HDr zN6dZ+;%^eS->`J-`8Q~2eXvNL>Rzu6)9}#IPib=-@pZybLZxfOP%JmH$~IMu`lZ-bD`w_0f|6%zejb^zY2U|yY6T96NoE|>bL(0?R&n#_`UG+ z{s#E`xjKI75haXsqmDa06!;?OkJw@QfsaJ~*^_}UfDVX0b!I7l|L;codE`wtfOa1SCE-6QXHi?&}q0K5P@)xE$UA$;~sZGWD5J@n-vomX`@ z+Rxvo>!q&&K75k4^PB>FX_Josc_HvZbid4tfG@yqd7I?P0$)5t+jHIkyf>=n{0@1q z_iOw1hopbhf8~%mcwYtHhxmCp?>_=Qhx-TX!2d4&tkUsd1IVvgj_R5|5%&}?NB1!u z4}AU$+P>G7`=g=1KT+Zh(7rdS>ryOpe&`(XLxrBVr2kvA-{CdD+tIzrUwZ}U?a%qS zQortMv|so-pX+g)_m3gIdhjRO-|<;_-)prT`xW3ze;4xm3V-~8;P>nK`C~c%Ts#VT z&_Yx{uU;CRTKpzVK!Q;GL>N8hF&H;Tx`#XUz zeNe}Vf88hZ5Y_YCH^KgSx2D4f18;wTap8l*&A2c2Klk|i9?#}@~a18Sh z*|iP^zW7NU-?a*O&q>c=IysUKa!Vp z81O|Tkcl7ma_A%T(S4)OMf(NRX&(W;S?~e9pGSfB-lO;14Dh+AzVv0l=U>C~Df07s zf25xeX@A_b-23)^9WQ!|w8wo7l238F>xcW7`#qOs{J2+T74ZK9K6{(atLh!kU&lV= zPYv#?>vOh|w>bO}9Y?(Z?F)$e5`X%+z@8=&Qe`?{oy#E(~x6pnW>nnWiLV4~tH2->|;9L2<-VFRI8PCffq2}R6f4MK< z4DMgzE3TJ$o6vr}n}84hocE{Ho&G-XrTcjNvJZa>e0~odZ~d{r7jYk@_`8n+UO;@8oX5?; z=bx(Mh0X=Ofcp-F4vYaGK1J7&m;yd~0gwM{GN00awEy2M{anN2e7(fmOZyJDe<#{6 z$apqt`uRfGALcL9c9oCf-p`)P^n89-p8F6T_p&Vbh1|c$3H#P@UT)xdf0H_XPX#^< zf4$rT)nCuww;RxYFuF(VZ0YAB9bd5<`0`F&Pi8Ohc9h3`3GjuMjt{>Ec+XQ97dya> zGM*o3IsePR`%tG>;?@5k_*)ND<2e9%--D;{{QMjE;}O7TuSPsD+8+gc=~H@LPL}q6 z)^WBYjr{pMU+zyo4fPhVe=e5;??s(1i5nS0p2Ez>xV_wi^L51a4Wka2Lm_hJ$AHfq!tFl~{L42Ka{K>=^z&t{ z2R-Ui#Pf7@eC*xQfBtyA-yQ%y_%|)LJQ8`YZNxu_9DDbH`EjSK(S8wi01ktr=rrIX z$V8BH{Sx4P(fzzF;B#AaU4jdM&+gKG%r^obj_~WG{dqbb;0rQN)PEB>_M7rtR|NSm)4}1Xam;a&bh`vSclZx(pI_Ny?f9KWQUi?;12flO^^Y@EI z&H+9%rt9~fBmJDI{SIwukNaq(4#vxYFCMP#a&H3O6Wu?14e$lj7nS|?Vc_jo>vgDfkH{f!IsogAd(}n%{TkZ0qdH?tGH+WoJ^!<`kNhJCrFiZ+ zS{`^J@R7*_)%-tG@V371b$yyoKhKcSK@yTmTwf4%4Md+o(~y$pC8dE64;dlm4) z*BGC~Il2k>9QdSb)$^CjiLEP!=2A&_W z)BamGe;#@f&oKKIt*0Lgd?eaG!@%dGIJye(HtK7M{+LSpr*c2P0DgtEkLu_StzdV$ z4((^6fB1(RWSo!UbriYxR^UCjZ$b-oQ`^3`aDH5#`z|dHEC3(A z^+1JxZz6x)8=w!fpl^o)|0VjFi{#Pe${E|0%-rL}Ji|W=M3wzyi zs_POw9sRU%ua?B+9wYsKo7-Okx^dd1&{f_4xxjm#fO>rxPh0Tcaz9d!?n2-*S7`g& ze_Mbrd`8d12jsaoYd`x4%#UM`x--&dET{Y+c0@4JBa zeOk-Cp9H>$`lw=m{)*tw&~nb#mmnu^f7N=&9n$_R%^&XvzVLL$Tg@ty;5NY_6)Mozkj4fc2?ztI?)E9ndIGbS4x3J$-7o>eB`80G-k^x=n`6e;B&8 zQhjWqSx(L40H?`$#qvaBqHeyNOp5iSS?!L8U#9IOsbm1|x;`~Z)5?CwkP;o8Wc;FN^x|wwP#hk)ajbJ08I0k zc50OehxyUPBE4?0xN3D@Vf~IXe|N4wb=B&DW927R)4W(~7TfhwIg#$%PmcC~9`FA= z&i{F=|MM6(iiy!mZL(HLik-x)NowXa7=-_G!2jvqV5(DU?=jOtt6i@r&$QS`I@RoY_6MDebB3m2)G#kG z(P&K5(EKO!^0lsNT4_y;n)7Iev}I`9j^fbv?ZvIz3iaAp*DMa5VEbaDr8KesDVS*| zfDY+ILNjDhZq=>Vnn|fc=hyzg%wl=0DPPi3(pRQqn%u7ID)UABe*^i$^k>LRd0ZM$ z{}1{@G!R_IOs6>hjr#7veuvJpqn97WGo*UV{3`A)_gVSV+nwk%+g-ERX0N4PI!tx5 zqYCBmq`bRWG1M{bPS+D&*Nr(KVKJ2!3HTHL;MBV%hf zZrnb!(SyYeYj+Oqf7p5U=Aq(_o!d8U-ME9HZQC~tZTHZotviRdpRsncZrMm$DepG3 zlkA6bsavYIs*+4!@V)D5F*r3FXfESIw!#`5k$YclE7OYQIr^Z$bR zf2-|38J;hKK&e_4zH2`lF(BC^A6jj}>8JduQ7hW-fEK!=tyUf1CCzlAlh9BM`!Zkb zvHvM_Y0#Zgf1OBJsXNgq+Mje=L{)(hn=rswy;Ty({w=LM=}41m!_cKp$ugmunKZN0 zsi~C!%xk6q@zC%M{R!%r!5g;JpyM)O`|s|xua*7A_0ufXr@J-o$UTwdrqnEsY3SsT z0Q1AH8G>9Jn=V$`hOQej((bg{W|f(wbUM_aRxfpGf8FWTd0??oGN;wgrJ2J$Jn4?2 z*%k5cXh%>?O6Bn)Rtpp3$CPOi{@VXQ_ozE-PBcc74hU`8uD4-I0ZcyzocW3UPI~>< zZ7|Xm8s@a|vt^}Jo-TnJtx9by1k97n=`jx@&S%6WI_v)BE$aps)Emsu1+z3|I;dUR zoe4>~f531o-7wAGbzjjm`d+#`x~`duq8qDOazk&-Uv!4I zB=q2Q(_77kD71-*78_%`QbTr#QFe)_tFx?{7zyq{zGYgm^7nSz=Rx?SZnZi_BO@6j`x`r8g_44$5vYs7!0N3jvm++j?W7aJ;j7v4Q|ESm zJF>_V=DgXH1y-_6ygcG*ra-)}+(%-Na$<`OyY{>~;oo$|6_EQ2Vqw8&>N)xt zv~cX#0Wsgpe8HR}1A|0n@c6TlKk}M6f3lYO0?J;MW@wL5^eo-8tLvnd)XE7KbD~Xv znS)*;X~rY&mpMPo{4VEbehmJ34wAd9) z8l!T!SGFVY6JS3=ShCYoRI6Y_8>3!{p@loN;)MOvjMZ={MH(zlBE4oOZYjL7f7B4J zA9GI-TuXQGw2-%UllDsASq81X^JDOjBjzK=N`@8jj~I7M#C_pTVGIOkBp~PxVyZ45 ztuSwvL5MzdjC$SD?EZpLakg0{gVcnAT`W3#R-WbmS^_ES!w|E{VtZG?h@h=v*qYR5 zEgG8Y2rM?l-@L#kLVKc8;UW)?lOZ`pN|5TR1Hd+anq2+vU-#-uy=}+1OMfw6C zZ5#WM{s?6q=0+hZ+I4-(Lt~wiwU_AwTdEcPg5m5@Pj*7=x4~lA)91dmf8z*c&cMjl z@ArX`G#zszx@Ax3YINZqoo(Xg#&0(-vGP8ZQLOl7y=El6b%x*Wo?c(CwS(uCq#X^A zUnREwO2?(KF#`PRHR*CvuWMD#o2~7Jf42ssI-MbXG~+Kwnk-eVIjx&(5EnbD7e@k8U|*z>lyI2j zL(s(HS~c&Kb|vL*t1}(7_q!3+dNM=@b3q))mXWT!!9 zYPeSc$qBN*ac78@)}1%9q~}k2C$WsWle7~fWLENoY;@9?#3SO7e~7;7W_9Inu!ZAO zY#k|<=A9x6s{7(vf+sq$mvv^q(TVOR?Qa#>}^*1WlG| z^^%cHTr+)U4TmvfG6P+;x=^c_WhFCOI&HXO!*^V78M;rOXc1_8(cguJQ5@NEm|7{2 z5>k)N2=X;}j;{neSM<1x`s3)M!q-Ru;OVaqim#_geWD96$xH~{v3rKF-&Lh6bKTf`VO;Knw7!^^G_w& zYK7%fYDt|Cb4nZL%#y+R9Mk*S(a}ya$wp>tU^c(zf8I9j*mm48eXIG`g`p;OwNoZ@ zZKW~{i?{jJFfmDR%C$z-ZdP~zdX>V_;KNS)CPACEm0c5Q*S^RGv+1SN%&?;Y+bJq` z$+(U`WxovoFwM)RBYfL18wG#vUDeN%y1P4CFO=+b_!;NFc(5DDo>EEb-4ed1Klx|Y z*h>e-e^9Ja7d|d?K8i+B>5j|JVfziY(KECDRF>`SU%Qj(DH18{ht!-t`v+blAxD+@ zyq>IeBncMjgB_2x@|4HT?zB>l-57Zr*tg>W5jC>Dx?n_=7V$AB`>F4y(}{-p$G{CZ zh*EQ+4U2@AdZ6EYSs5+sFT>{QYctP=x~1c!e;S+9Xik;UyXy4<(SH7DZ8&b{)4=TL zM_ZL?O$OXAti7jTCZCKrOcaZTLbOW7rfjKU>NMRpw$r@%>cWOi8#nDN?p(WW^ANXP zxp5ygFr2j239UmgqcO20M~C^hOkoM+Z{~ObVkU<2)Cd_MU2CeDw>)N>k0+(Jc?Wys ze??IV9qTR}q1|P3Gw}}hMD~+cSt*qkKDME1Z5rmilGF&{#es_3p8uk$Oh(nn8iu3R z_EIQC_-S?Y(Tx+X?nHkZII@eSrVE|0uxbbnl>M>!6MZX?h|AUUM z|NnP%{W+uSUwL%>YIHSt^kDz0aacn#e`R9<@R1@(tbAY>2Ox_OMijFWqYorN4@RWs zXab6=skU514oeLKR$(aBtF4Za=NcTfF*|( zEJjEnhg6eDFReoqf1~@8FQr=!PRTqC5~S(P2=n8Kkzo>geCFjW3iZqgCoBKneZ#^9 zqb(mSBwstFM;Zi^R3yE_sByHAc6XU+q?2r)zoz2*bTjXMiA_k0joss9V~25k3`E>y ziod9V3kSaneqqg(=H)!%+e;5Yf9MMXIngrmt7z#;?V8;f9mDBK0PGho)W6#O)nBl3 zYsdepVhD9rc2~n%>xiW|i(S{+?_8{vm&94pwAzhTV@yxxWVEIWlZNW|9}`6E1R+@c zYl6Rn=qWQW|922z)gMIutPbM0RtEuGtAhxx)xmRD2hUv{Ja={Q+||Kze^;*#-?CUX z3)~D&8Xfz#5yzWi=8%vx`BkH|o3(F4^J+%$t4~M$O;9uvX&DnqXS!G_BVdojCp&ZW z2wGqYNE)?PI#Qm^V-q78j9T%ZIic0A4GAgON6N1znnYR9(6CNcrHcBkXn*1NSzNtz|m zXL{P&=ZqRTS!+$C7{oN~IMbf~DANKNK5YK9@n!^#@1}n$M)frRn2lJXe-qoA*}O^H z{;;{n{!=fJ71E-_hus4ryiBG+1CLRZ5{r)ZEvBbobK`A7zc1UTKiFq;;`U^)Zp*&J zc+2cLJHs?a`&Wu5e{qN&_9H&ZS2PK-Sulfk((N4DV>(gR3d{6#I&GG0kI2F5tG40s z<{!&c&A(kz=ILKLIdz^PGrim>?b@m7l5%hU?ex>{tF3N}KCI@J_M;h@p(CZPmAbLl z1u-(xq_wU%rncL#K`YFFbl8vbp@TDFJ7W7)C*f!VC~nM|f74>O+%6Tsz>0hVJd-vG zyXmY%Qik7v_N;|p<+gVgRFP-uWM4OWjkv#!#L}#4%~-;w?Wh}W{0$#U+i)UN!|bZD zQW-5Kt+CLZ$y%LsX~+8P$6}*ct2W6F(=@7&e;va&^XOJ^V9lW82Kb$)Yo%0Z8aYpc zk7>tg_}=voe*>!ht!O6nytVQ?d>Qm(X&5so>Cb-&eljh?YSej1je36(lfoYd;*X@O zHLGUL@!8A44w2Ay`Rqd3@c=s?@-S->lt+ahbSwXBwzT1cXD+^vx*KcIbRcZXFTJ}F zZUHlgyQ#-?)N!>Cp&z7^Ras}AcLNyVryfJ4PFd~Je^N>)?@0u+XV=jFa5P0@ygdKT zsw?;uOs@SH%q@MkZ;Xu|LP3A_GbbAa08c%?XT(&==7Eq9B_TH+(G8)^oDcFh{y*2cNuaYPD&FT1p)>RA?X{Ihu8gkhm$ zwWN~1$h5G0~NiR1{k1Ul~Vhc zVaLHIcK*7Lc5?)u+t^$I6bN{34wxTxgbG7YGS99wNOEh3wAhgKicKFW%HKw=No*8u z1ewN8SMzUVlNTbr&~G@Br*|ij=4Vc*UK{2;f4sfi+9=Sijc)4Id;@`Kmaw-g{npRL*4MN+VbEjN7_?H@u?S+s-_?xMO(prkx7ewDk<2 z?zdyLJ&ChHm_}@QwV5cVY+t)&s5rEBe?zfYFw(++r5j`~Q<{tjJ~GiTne@Aitrd(U z6kLl08TN-xw7WL4XOu+k`V{XPY3uAoA}L!f6Cyy{lDUdigS1f&T!wj>lkrr_k(hkK z_2LagK31Xrc9RFL682*uB`vn@ILcVIN6zlsqFFqQ-RMM4=9}nr$H`6?Zq*##f5hJM zVRQ~5Ym!)neW0CeJJJ0{_@lEM>|K6K`vAL-HlI1XZS&b~1lFWhHgC6ks+PJjkh(U? zOWk1gH>oG2n3X%NG)+=F+qTa@F?2MH)3$h+l=)fvE%Qb7qlsE={O}x?0?VHwaf8DrwDBp}|E$}u}yl@7^RG6V}U>yt8%PtP@BIibs z;TozPC#lJn4=vM<&NNGHw=q&CJJHLyLDpL-tvz>2Ar75Vdwe>(pHew+hy?d*9Z-EQ zlm*Ph3WTIHx}-_R*fDmyhLbkHq{t$+oH(oEuaGf^olLvLFnjq4ZAe-ofBv%FY6q%u zH;G@HccknIv#;uPZ_^6)g|h#L!WcUMpn@p2NEB8ti#upM+2N)&Q%HgCm`2*V%1ba# zVaX-BckEI6KYDzHv=XcNs+XPS*?w9Egc+12edq^i!r}$7Im~J43%c={fr?++JcJPQw)B46!3~ zh<|tPn4{Zin^jk{Ay^R%`vp62!WEU1P{mfTOhQRs^g~Qlur%hoP_y)3(2BD3mhX8| zqMD^^%77U8%g7`pPBC}r?MqwNtJ$S?)-=m0CL5Vg1CHs9Guy71g+QBoX0LFRDb^ivR0Sf?0t^ER-b7i*Q2 zgA9%eO& z!!Wp8iCXO&wiuY5qX<#koM3axI*uy_gghjWiXEm{HH}(kVqvv`6hpS`m_p7dpd%0< zXnqQ!8<-Jyf1JI{yS4ZL+ub60X;ZaI*NIY=C|HG(JWnErFa%B5+x7C8b6mEGCH@R~!tYrPN6wPt$wh#`smkwdo%xEA)9&(Q!)E+v zWO!OZ5+LifZnvKF2jBa+12e%+6cF<6zujdh_H=w)e`)h~`)v$fD5hAl6>>u-^xD&6 zSXRkdqo9mve($STSh;2;4sBjlL?@A&-SLvq@IwL#w}HoM@zxn<_<)HKS%|O|S7F|brAh@;?b9h0=8t#C0HIbrCoCqFi_#>$ofFEg_ri2Eh4 zX%N-7Wgome;H_(Bt3e8Osx7qWNy~KA4#DQ|tG!3lOG_4u8#ixTw{~-J+bO5)7(%33 z(VnX!r(cpeWuV{9Dr`$m4{2bJvxAB02|iKwf0z%~XYzyK%}od}vJ{XAV8{v^r9H)Q zGiRhK(JFC>=Z?0~c}sOykU;%JZ$&EvS!0K_PCIeHoK<=)R^*lS+!{A(6#6YEy%h;V%5OwCCY(30uz?zSI~piyE&hrQSbLt;D%yYPQBF@>fSV*NW8uF4Xd1pMzTu> z%8%tnlqcb9pERQwP){{=ja-&>>r@Wl=*%SSxF!(~?fA;9I z>%*`OtA+(rAWmGXp_AzW;>LrNDC7)ILKk8%Rcbr2eka9lX#6rAV5-sGxe?FL6E$9@Hc2o4D+uPI45W-V4DtfehV zGlAGF>X9-qvXqc#n`p#*BB)$fEbX0W)PmsB&^{5c_F#ap8L+dI{^pZ|e^cYP(|EGS zuy{Ii6r0x)amJYdf&<7+9YOJDrCgrUOM(U9hleB;f+8ny+0-Dro=WgCf7^gP3JItd zr^ahO9FA+DP%#&C=F^Z=*6cnY{daGzy0=s{FQMad3mmPJ2Cr1E*K)#l0x2P)g}iTx z#T22da8OufqA`kE6%A|9e-}-Q{^`_4Df4TzWBzNU7H@K}+FL%ufT@&rZQ!@vxNh57 z{Tqk2?QlFN4Yd?c8*5@$4?Iy~tZ+M<)bLSJ!^zWRX$BjEd{sQ9N%-9dVH+jQdMErGMJieCa7iPI8B~Z95aB%jC-%tYOv8n%V}OIk;AKN1*2TwIwku9(#U* z9T(_G>3L+Grz2V@hFs42SFs%4BFOK*f(Z|f-AaF&>=9p%VKB|mcw^?Z+0rk`o+Gtz z5}S=}nfVcuj1XXBe@<=8o^B)Iqz%##{T}tH2Hwm}(wnR`Q)p3TT!Mz-5A4cjzRRUP z;9?YWK;RVcu75(fANl~{tvwBa&D$(k)Q3?Aeuuyg78n~s5!H+N;T&WPbO=?o6e_c? ztmfwkxGg*)svMo&;k8gJ9nsLH#CpO$P|-6axhr56P<}k4f60kAj7+zV@P!T@egOsi8+ zE~|odX{l80RKTv=IkWwB{Y8zd9L9MUN{NMn+<#TSit(+LW{Al>rb}yS@>N5KC5Mr1n*-C63ESBbhO= z;oY(DKy-Z&8I?rBB-%LXm|s-Y>58&UaL71+#6c zRa%>{f2cf!S{~zW;}C~&in6mNR7Ado+{u>Ii^WA=CMnXjQox22-j6Fd!-2ILg)CAH zCbosz$8=jR)=Mm7TB}uEgbp2qwscz7>{Tr8+_D}aZNX8LS)naX_O*>kcl|`i$QfO4 ze6>NWd%e~o)8JyNHf`Nm(1CFa>!dDvZrH6p-7z7eR7PE%Avb=#a!cT%pKLgPK{PtG77Zyfr=g29|!-E zWXBGuZV;;-1UV(~3j|Z`V{S!{;l6Bn!%mb&hLqVLiY;~~$KIzb3tuUcN$6H!3Q#U# ze}4D9@FLmJBS+7yCxy+%E?N$RM54MQex$YcaD0IwI0ztFDI%%hT!N0OfOnFX66$$Y zRZ10Aa%?PA+()NbhKJxsd}ef7955n5da8ihe|x6)HpB`$#-ufL*P{+qw6)1h41IgN zHr93G=|F!dp4td5E@8l4A*Pkx2D?jFe<+6GStSvZf34Lx8nWZ`?We3=Ka>$pu|IQT zhy$s9TeGf2EtW9@{u>yI`$I#q7}>mfl4FGQwfN(-=nO{&Gqx|ae$)2#TrS*66s$L6 z??@^-)VMX3@cb$>>v*z<9dz~>**~*~IN*fkcB#m9k|1Ugvr=V^uW+0_UPTx#pf-j&{a*JuwiRaiTBr}kwp@~c&Hj&%wev#+(^ekD!Z%HwyhyGJ}=z1 z=ncibz?F-|@Z^tjO|tQzd-Ithe_8(vaYRHWw8q;Cytqmdt05|)dy`?a)+ur79xOsp z5d}l>>1l@LS?( zt;eYn#L7#Er#Jo?#ivGwP?zNh`CC@Wa2KP&l{z{Tg`eV_rh9?|lcnK}V!;109zY#x zs|`C{9ilg$)T-lI%L;9hIPw|9Ieb$Wr%MKCo2C?+pmEv|^OvM)f2nGinP{8GtZ{)H zoVf!IB#9oVK$Rf^f%M?45qX7*!oRd43hb5ih`RyAElki z8wvP9j=P8C5cc$-U$|l25sc5c){0M0lXAw2C&4wL9_-!Vo}K%4I9^nXTHB-J9IO@Z zcLGVO>agpO-Aed(f4rsfUbz=K$#KItq_mVOOx_OA~nIEe`3d@9A6-HG`IvIv(rPV zfCIF>SHf1|G-A4!>O+FyC?GUJof#MC6$M~tEU~LIGH^EHMeVPMMIoLIDI~iJ99vpcN-n4Xm2ZIv zrJ_TWxnF(Pf21d;E2P^tTb35O7vp*55+%7&kbWlx9Xe}~k2Bqy7tYmh3sW_$ISB+u zriY_NV|pDZCH8ZxDMb~WKH#YYX{!=toLQXFC_;aAHY&)>YEo&JsC24qOqQv%!?I2^ z#oe$IrorI?C=qlJ(Hn-Vc(ufS&JB@4N>GwD?MVfre}Rewz62h7s6RgAl2a#faZOY?u7m?c7-1W;xp2V7>h&t-@st|(re z)Vv^+f0`3klS&wibj%w4TGcqB-pnf-fI&f(y1_OU#Z%2W+YziMo9mrP%T6X|xx#*^ zJj2^3BDu1TV_aH3j_q#45Y}MD#xny zoG`y5;w%*16J#jLuf(z|a<$cswer-hIYA?e*<^2-E>yW<&NpolDqb$8U*2RZSomD$ zNm5Bw^t~B^Sz_~$>5!pBuD}(1DLFB)lKUuq`h#eFBgITWFPHcwnz~nIAg){iQ>P4? ze`7qRg;K*rCd!FV&v!)3Z4VVlpi>)c7QP>4Rl<&a>MKmzJ~1al8^d&RW}xmEv*Xg& z5Z3I8sbVZ6%f5y8hPF23u6`G`Z)Q9QWJ~2_tO*U_X+kVC3FC*fLmGls5Q?RJRX!)z zng{_7rv%SG-=B$KBf23t=D*Q{isqF|G(DA>)Bf=yCm42zMX7)C} zX^HO03dM!cIv!3*Ckdvr5xKW~3`;0xc1upN_0}f|XDOy`Gv|b82gZO>5Ea3phAS0u z?ytC^g;I^-4W)@DlV8MRNKsz#dYXn#Dbp-7HaYfstBpf>@O7`oTDrwYlZSMwUiQE zRlosvV9yw((lp7Wo2Ko!7)am!oehZ#<2)^I?~mVYAYy??$nr{B7<|Zvw#ni!!`h*+aBy*zQ_gkyu7Q@o=@h$!C|5&UyYw$iq4W?h7i{tQ?y@ zvelf7R7N(sSi05Z~ocAWL^YheV3-DK#>fj>qS(-y0+NiL?{3Vf=l5>r^U6@3NnrDy9Xvud39Me9nO(cz=i}$Yv&7dx1mir_ST-(dz@LI z7-u{+MmCMk0+fqo)P}8Agl#BT2O&!P>tuqd{A)zgVagBIOi|6Hn8VQ6mJ zxT3uzevwXBq|4gmejThr!)`5R=dc1~|f zE`m`C+6%5Ql|RC3>a5gFlu3uE$W@=&i=jEZhHuTaSHRnW^WA}#E!(?dYW3jCd$}Fg zwzNi}*c(wz>y*4z9IZ854H75qR8i!XeR=(oB$i>G3ZXyFf5+nNuC?t6+nr3OxUo5V zADp`%5t67Gf!S3_bCN{miFP>A`X04z-F)IjW2pi_qY9qX`9zH*Magy+GRPQ2wq}M8sK&>o3c-YIU~&yRR=XWe%jimDLDK zbgca#gSjqMe|DA1314{Vmd;_ zzsIh_zk0y7AUMSf`n&D8>O_3k9l3Toa30#k7`N}6l9V3IvYUS|^|-fpDx>x?DCfHEl7T$@soHNr0*$-Xy*+Jj z7(@^_?|yb->s7V4GKL*=y)Xp(W^_fStXGvH(Ov0j+#;(sC`1U7Q~b(!YRkc!@g2$f z=3=tlf3Q%hzJT>NUYf359Y^Q+JlO+fw|Fwf4=zH&Yc=&{!`L%4TXxOjy@8*20z=eq zo#jNsHX+_oz~C0>911Sm+TRdMgxQyF%}}r=U9#P(7ww(q0VU0z0=_8SN?Grw1a>S0fh4%&-u#~{3-uSemKFF#@_U7Lj?l4SQ1&^tQh#gI>Toat zf0JpYvS;wL9ox39FZR)8HY}xt1Ggtfie|VikdQi4BI$D%>;uB|nj)a4HR6$JAvidG zf^c-L$I%(-`QfrAyhuqm+*)osgQG}422I6G(DfDz$19VHJNWJdBZC8SA+M{Eb@v(? zStc48>0d_3_8OQGV9d+u*g8a++RJ%qe*ja&bse$har14#Oud4udc9p>pu(rB9^BO4 z^+tGgGQxSuV~jomw1PVy=*>y$k9jZIxXH*yYwV^&Gq`c{rgiI! z{j2&{9StD@8_!?lt}pDi0%;?m?VIysM|c}!)>7+5Z)-pc1aQv<(xe+xd*;)018>OK zczs-$3$GBhH%bhJk2U*)QPA#?e@k@FlcYc!jVR~5!y#@>VI=i#%oIlxiqQ|*AT7F6 zY-*CTA=*zhsGMv&D2ohfZ&#m=mU#Kk&L4z#@Rs|bSIR( zgEV03QqG20#p#xI_-&@N9|*tJ5@KF}2&WaJ*_lY@09z<9sT(Gl5*4woe^_Gffrye;jd^eOY~4U#r$9v$j2STIZ2l#t#C z9`30Q9VXcW)mRF4y5?w_E5K$RV!5HUhIQjLYp`92xkcKYHm5+?LCaTKu|&o489!DL zU|3R5!hI^c!wIAT6>7N(e=PJZO$wiFcM4PAI!9{s+FT?{neT)-N>d^WPV_R1$PeO! z>J@-sp1ca71@r{|6KYJ-1!-0`&yS8Dljf!?Pa?cCPmUCBl&7l{Y5uip?0O6bNyYqY zsX3(Ga4U-j&zZL_=8g}MryH@TXK9D%JWikm!Rop{lo5rVj-%une`ah3C`2C%E`iMG zf2?E^Yg92L1LTW0E6*`Q(wo{!it<>CXp{GW*AK1Ol(cy=>}6zG*5q<;(XXeM*~WqR zEJC8F&7@>$i--L_vy^TdnD-;9BeO%KE_F7ZWKX-*r1%3GA&$P%z#OegGxHG~eXpeJ zJ>V=ya#%ywlQD#8e`(zAF5L9a)Yu9RIB!h5?F*3-AdJN6Drsx1ChpjSn`VuY0+EG^1)^#f9cQ!R=u55P!}>J`UsIg zD;QdzInE=Nm1UU8q*$5gu=}2dgwRNp(B91y6enVZ^WI$9{2G`dg=A57tJeWgJ`&s8 zvIdchf@@Y}j_qG;cd0owHJ2IWP9(iV@UB6|Ev5yMv{Uu$n?P2RpaE@%Hi~?}d+CNd z(Scd(kY(t~e>QMj%uazd(@_MkWy0QAE&NCp%QYpj*-7_%!$y)2KF|u zo02C9!iEr9C}ZAQ$dMY|cDX&R1@eFx<8DFpm+6cJ)TG>D<4A#v#%TGTSKg|Kw8&nC zS27226ET1D0bXNQTaHgPRAR^w;a3^_$BJ$NlVVy0f6-K|VlL~#PnFOTrq=Di)`L7m zCH=u{AiIqu%N^5=4WSvztt3KW_yw$Y-8s|)m00Locz{5reOE%YLL)ZYXB=CMk6&O| z5jTL@i1j^{)e&K_T%VW>S>i1t9Sbdp$^vPVz75UcO3+oNuNhLHXohEV-O#^5@ylj5 zI<;13f4jW|(K9sRac+{T&in$*oK72*@7a4`mPtaznE#}m6u1QBi1NQ7_wmjGZ@#zF z>@CxwvBU0_KoBCSYeh3R`-p<8k^Ib*oQ_H!MA1WH#n-KH+HJMbG_Z+wr%IDmYuV^8 zJ1P#T$1+BqcG_}QdE9LF$qtk+p*hB`^A4^+e|^Pu5j2lDz#=Y&Ms7tY>Gn1IY`ybC zTS4kczGC9?Cy15L!U$Ajz597k5V#WAChcx92+7MhwA9$$T4#aT} zw#(Dx3~_iXjsU__y<-<=!kPE<%HchTe{+*NpGBd-ZsILIV?|;^<7vQV$tuv{f5=)$ zu0>}|@!WzdY zmPEFT$P2HM-$LS94d+RIDhDq(vtiLi+L+$I!QlaWy#1l*RL&&yb7_$wBT>XLB{XKw zCt&$W_SCfKsg$;mE{lptabGOqe~R8K)Fkk-+PX9yYo`YXHVmR$K}>yjqSI{0x(oJx zmg8v2B4d*XxjF3UZWG{8lKhkjWC+*7dp83yNE$+La%;)41dx(^G)}0eQq>7?TNcvG z1zYgI^Bp0z-h|ra(U$GInq%d}Rd6}`IKTKzNfGU?#b-7gcRJ0My;rDPe{g<*$Re3_ z8=KZUC_g3HQL}VoN%l);8D|LipiHe)e>y6gD;q0w|0o4uRf z)AogC1t1kKmlS?N^SSD*xy7IaxY-pnX21P(>)CBZonE)Ea^dIt?YSMACUP6N_H~8& z`2`nLEE?jAhIs%}!=6^o&906!om*Z+Xvt#Od8hM{iql$iwog?{>47Fnzd?EqM;WJE zS;8fy){VQTy9C+;N0zpK8}-dmguX&ct%FW2gvEf!6dhzsfh@+bHl=65ah0kl_iv)t zpqY6FD@zvIv9xU2>~umf*iPXfa`S9+U!Y&?%``~gyG#I4wdPZNH>{8>W_l!1W_!=N z6@L%E`7_j3^Qu^?2p#L=TM_)K{6ZucXBHn$Olz-MlRgjN4PAjb;n+-1dZxgW&a%K4 z@jhMU0CN#D!&=|GW(eVb7TYiz?r440bYlyV!I)plI!P&a-u&`o&z=O$X8(#n0&-tB z`T!(&W>J8l%EfpTbS2*2Ez8?xDXg{Li7f$67Ve4a?T%)b(q^O#Ix+rAhJM1BQ>89S1fB(X0s4el8Ils zQsW?FqJxZ3w-(T|@L#Gy1|wfv6ttvG8`A^vFWLZ@Q=E09O43-vP?eDIo5`_v&?@=7 zl3^b9e;pAu915=T(Z82{$K5jO5_D4=6NO`(GgP=?XCpsNq+5i)Y(eH;h1a;*9LYzp z@lCYMsR@NAKyQ!YgS8Psyf+iF-2y&vz{1r@2En^A8xpUyxl9Ej9qRfk^1w-l2}Tws zC%FJJ3&YkHTBw*?YAno&M097+E=No|HYrfBFh*cmh+#%J!ET(=sjc&CpOp4!N4UJQ z_eI&5Dgwn|auiQwEIt(ow205ugY$QNe!-|iluVYOz}h1_&|F(9*F}~`5#l zJmof*c2@J1f1bjWCsPvpVv4Y{O-+5k1Yrs?QOgS~Mj0X@>e=`vf!_Jggay4qBZS