From 116bed1a858a012c19c6b003bd6ec3af7d1083e2 Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Wed, 20 May 2026 21:16:27 +0200 Subject: [PATCH 01/13] 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 02/13] 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 z^GP}Nki630`e7V0cV^Wjp;ro3B4&ja78_n~fza^luqeg@feU?(*fHWKh0@MhYUEBq zF<+h7hhQ$kzU9fy z-{msV^3KZ&`zF!ym&=MqmWi_J|9xqNeWI*Ow7hco?-A=nnSOSBRZ^v<*dME|N4~$Q zn6#bq+AH>l3r~fHHX09nhKCC$)11iy^c_FSijNWsvhv#t-2A_}@(A=sxL)M}wC{ve z50~!09v*%_IM_>|o<0<~jGsTl`chVCSxO3FX-ZiF|e6iTo9lA{A7oWXr)M3}}6LsdaER;F_D2inF zXE(-Mzxu^rx7alJ5w6*>zPMM@0)k$S%k2uBSz+INRQ4|2^(F?DMb4ut`IS`_a~@5B zmA!zU)n+TV3AQ$rLJ^yW;_k~%mbML>FN+)gZQI{g=+zHrEBQxMPiALss(2cgt$-7U z{57XCzj$WGn?+?Y<-)W2!SQD6{k09Owry+SbLB@`b&I1p*Yzy^H=~tPp#5=0*W+yz z|C*Jl*|36`^4!R`w&6kLjH9T^+fS+|-iHoyWRsT@RuX0_*AsRE&X1vY)yeNe9+}ev z6B~>2jWjysn;6c!sIXNQ zE59Zon=^ff)1M-<{2F7eW`V=VBFF!fUk!x9sPA5w3HiRO}7#=;dt8qN2ojUwB zQDIZQNmJ*y7$wnJH~K~u&tJ_M89aaGO81uMwXjvBN`Ni@Q!2j?FLiOm)&y^1Q3UkM z*Hjj@@Y#^q*T#fQ$W46exT$|x9kZRz*PrIpMQr$m>_P?7)VVmFuW?-1Ta zGnd==%$U9xxh1Ou{B&#omXY>GkZtv(!$arbjg-)Q-)Y}ZBoKt7q~TI$K8`~HlKDH0 z+GMQ)u7BrBzkyNrfB0_Db!+4iXe$eyua6tme9FfYF(K((1x%e7waQUxiYHufbo_ z)232{U86kf#2xfae^W&E!csJ(`yt=3_`zb6;g_XY3Egh{XPId@igLDM8*!9C-Oc%xsQ(Iy_uP zGuD2jRX;XtTSt_=E-cQsFTn@);}qW-ApRAxx2MJM>#uW~A&Gj5NftMECvK*Ig|s{( zE+-1Hb2wlVeTVYTd9ByJ@|QwW%WNuXidd*u1!#6+ic)&6^{}t)W(zGVV&VKiFlPOq zwqd%1@*L^Rj4a#pxGr5`)u1-rsis*Fdd{3%YUmnTd~~`mm>uWe#S(>k#Sa&=`=y_vOUyGD8VybdNxz^A$sHpkmq0_B9!$!J?J}#_AU{b|ICrml+?uXpcp5<>K^NnP-anZdk?%x0NTbAa*$%Nk>wS0#d ze1+U|%4E;-13L>9av~!hD)IZR)(X$3b92`@3nTqx@vrrpQJr=I+^sRD_cZKz0R)!6 zhu}6=|A>zM`e?QdVs70zYWiB!Ta~^n3p4{>uFx6?QE~>SliuE-4pe0w-z&;hmEE zFBH`7;}6$0zomZ4R3U=>wq8Jt{M&}!3Co46pM!6h-rt^Q+a$P6wOY{$GmWG=*@nlY z{*-}PN0^SCi3s2CHov}-TZHo(y(MK&tYAaZebmfi%&fIM>Ajtq8do@e)+fi@*{`tx z=~j|4{{3%8ZRYapj+mcASYpyI@_dQ=wl}hBKj4!^#kJB{BR{pLh=>C4^CAhX&Pk=3 zBMBE!4CVK?XlkPJ!@*{U)W6hkSt8><*Zfk%MI;Q(m%yt3^h@a*mH6zCK#x$dyeU4S zRBR5qkBLEr*mF}B@hxMilLm%n>52+&uvy z@g%Y+q!K5fet~I^n}ep)cv({cb@|nKstT75!h5;guLq<|$5@gApZ%_S=+ftN)INHo zzVN`Jj$zN-^M)7GVi}9kC_7HDgyLi+ zV&}KQ`fGvG29R#zLXo!{ko^EpbngPE@Mks;AU zGnD1iIAA$khx7jGWM%xjqV2)5!e5h5Z_YNFL-9}}=>{>7Lt1i!f~G|^U9W47IF2ys zea>h(qrMa^VU_yTFtBc09%AX%bN^1ihT@1lq8K47B9E&;Ky$?6*x9c~H|5yM*TJb} zy*j_shkAtPeAQA3_vNvDj+yAz)ZmI!Rvi#Z0lk6)+hpsSDD)Q7dbXS0FUO zY-K4coOFyvG8GlEL+c?+j^Q} zfS^cfc3RKC9hetxJ*oKg&{pqholQKprpD-DXBMb3KEV*!FXGgIpAcqUHVszRFBnNo zwYRP9uWW2q8m#8Mk0#LXHC14sHs#$Pz7|L{zvovVji)=dAdeCtB~?${P`k{uxkk%T zAOLQ7=iAI>>+0YjqcU13Vhzkk3VDpYU-YL_XCUf-fb-#B$y4+)OD}~L9Pg(0V!zXm z4Yvlk#b`}Y;-f5uS+Us=Okti;0IT>6^(qYR|B-_MOwMJVdD@UqO zjo4mR|F4iDX;Zh5oed@?^l+5!i3OCK1?n@&DFSZ4XIN)LchDCw`kuc=`R_& zW3iul4_BSAw$(MAm>4egch*IAm=m|X0Wc@_8RpRJ-=QB%>_B`!(le8JSJ`mIU)LYD zC_2G-E0(k9iNpS5yH=?F+CUtW(y|romAE%$)|QA7A3SYr)Uu{MXk}s(8?S=T%Cn}B zSS}=El>3!cBMPFgVCL3!kF<;;0KO!XJoOziuM&SeDjU73IN;85sV^mlcRl#02k;R+ zq+2aE2(pfOYf8S|iu`y{I9smHJ-yg_HMr3}b&>taQbeb+LI=!kCrQs`#P~-gQU9_c z#R~l~mFlNDt<1zlx24^hw$E1o6x`Lej+uDd97lY|(d)MLoesqZf*2*u{R|UjpMKjk z2|~+wb^I~;TISQor{kkgzYbui9w^?(4&SENRJ)A(b$*V(R&mH7Y+c7v6-btV>dZJ_ z+-EVnT<|IsJU*VIm5wuJ^RMORe!%SB%-Uvc=8A9m%I1u5+?42X;X{(^FVhCy7AKR2S=(vj=$Vn5z2)Ig`Lm1f&4UV-5G3O;e+K97yaHwl>7VWB zh=WWneFP7P->s#8*-P%Oqx$S9p^X4FfI zAw3*>)-4D0>@S}5mv^E=6UYXk5H0CWq+M6`Ctpd3RL^n1LhpDa4siYx+#ezk1fW7Q zs5UU}iH0~spSXuO!=BKFszaVwhN`jb>3uPW4;#RS$S*f>8!-3LaSp**0*DR_zUa`E z?k>Vh^0*D6Re9(wn4`zzBOq|;fqi`^1yEj}hrIY7Y#=_j&EbrG-lXvxCHI;;Pllz1*N{KRfcio7X;?kVM#NhlwEoyo z(Ha;wIG;ejH2)shMREkJ?)48R(E)~N-;us!t->~&S}^uxQJ=>zB{>QVwZY%PbXi&? zIwCp(oCQq+J*UBrk5XNf&?J;5iG}S^*f?y2Dk*3%6(xo!!o4uTrSa1fcNlzZz{}@@ zSU3vIXD*QGg>Ou-uP6io>Or$J7Y^W^WMjM}V%&74ae?21tw`Qia~H!;z+|I}SW>V3 zrOtsD6>y>0bfL+;yoU4=g6Jt4<7K8Fyi5^6mXr$&<~If&>bwL+=}=eb zlgLn4Sce46E6Ni-WCGL$^BVC05dd!lzJ7doMR-AnIuu;J8@_WYcm*gEXMjKzs?`LP zJAxiD%;(p4D{xo~$(xRLc4SrT=zdu5;An62E6JNtn%`X{gA9;&l!x@=+NkdwUsf(b za5X4C9UyTdi7jlZ7pfiVq24$-D$dXjbI>k`JU|4_1MX~ecfAqaQ44JU8Sns8fW&@} zGY#7zPH&*^)(bdN0wF8Jo43-K0{3%gI z(L8yd#F0GNAc6%xqSIoqhuPt-n(!)8%?Y??1R)}X4{x*!5y9M?r&&Fm%z+if_au4} zC-uaFe24l`K!iY7n|FvH^gv?jHMh@qCIvpI(=7y^Bt6jp?dmRyR**lO;4epY6fN0i zs{_k`Z_iU2%$M5MPff9vukwY~@+TbtN zk?xg401*gB2!OoP_WRW*;12E_-ehgXU1GXU{`<`CtH+^z>f)(<{#jP7f_x%%& zkTy7vZNL1Jvv!BXH6ZxTug<5ZT6Kuk6JTxAa(C$QYbH0p8=DrlcBgO3Ie8h{fDMmz zb8shw277MM`+PVrHp332I9@+72K5HY!PK6OQS?7DEaiKNWr+Pembuk7(6Wq$rg@h^Mqc=|+WGH2v? z>cmTDxoa#t7D^0S4+TXA90w4?b9Gw0ffGIko)g)`ckB(yaK+8~79(;0-SReP1!00% zAy4HXoptQd`L7N~I=Xij0(mdII90#)DW$WK?WM$)F}%K)yvrWJlHLWGVepg5(`Y9a)Ei6+ULXx@g55yy<$Y(( z-pSORe{63Hyo2~F-x|~>JbuOA_yu_0<$vEmd_0$JM-ITIS(gUg!BCEOra=5^u24=o zDKC+6UV}l{-Lcq~l=M$1)6Y!Tl+x|7w1znW5;;45pp)W&93+1vs1A7lD@Tr;Z&bn( zXU_&FY!}888l*h@j<4@gc*_soy$kh;2t+S1@&c zO<(!-IJP%YT22%!0agH*tJZMX*+bQ|{^p-%+&$r>yl?!mp4 z1^4o;k5syy5Bx?}nf4jna}0=OUgo&e(_h?Ivc#Dd6py!{TH_*q@*U_NTS7KjZR53aewfxdBd&+l>7C-59z9InqZ>k;N57aL9j z;pqcJmFl+EWpQxa4+H81W(>$d@J9>xJ0W{pnS<#6KZ-KI5W$2J5DD`;S=9=7D``ym zpXL9Q_|MiCE7YwKim@}XY;ROw919k}LLVUr3 z`hY0|{zp|>f(--SL?tHF11u5n-?koX3K|UjZv}S<5P7ir#}m{2npkoq5JnAv`F2z| zkBii|wY?~dSl^lkYKY ze#MI2^-G2bLI&Yg!2aTW&6Fmq*eXF;34wxl1lbX;gH+Y9*+}2fMYHz1Hc8%g)BD#m zn>ah#aUW&^F+0q00yZ1F9mc!e5{oma9qS>I+7Pb&t@(E(^8~!KX)xOFWJs}LmJ}7bwXX@1TOuR7h(8&Qys-uKQ#-jN;MO1Hc_v- z{=ivn2x4X7m(hSJY3!bkf8p3m?6d7g+in|jZ2Ovo^~Vt&4p z>!l2lpnJl_*|rS7;CZt8d_0b`Z4rLs0R57k67ru;(BUf*R1bVUIbpPl@fz@OB?ks_ zzN)-nJfROCS2Lw_!Ms&_fXp0v zFK5^OW*F+V!8Tm`syg)ioj}rl-}h4_$W)(<-5AJ^DM`RN-bC52$fGc#2*2R&@g%vq z6t|v5ZlM%}A=`PN#O!`GUI#3rWt*QreF+>17zq@iT95hek2~M{Urbf4#?VxR(N=`z ziv{?=$px|o_&AA0-^vOZwMX5Cwo?v!(ck@@dTF1)C5L(WxMNAU6ATfBtPAw`Y#e+A z|5qQxB2XZTzW2m{XoHUi8k{e41_xQVpJRblkk5jm}`Lu6aY&-$_o@SED z-CLZ^4u_DtPTciJSxeXnq-=Om;+tbpuuH)I^vqG(QJS$lxsG<}L0cvrvTgh-r3vX;#C2F-QUIb1UI~1oENnZeCpN?Y?Dz3RPwo!BmLjHx zB8CD+{GHe*X!e1zR0Tj=0p!blJv&D>c_uaf{|mtXWk;(qAMEAcHNDmKzYw*7J8+J2 zyzw7wdxqRN{6D}+wC6$K{|kZ?#$>S+(qi6ZP)hJycMB#bDx1dlJyc>3Sb;Y}T0|O! za{=MJgIx)X42TT;5IMX_3vCmQjh9|l+7YyNiN82VB=zn>gwy{mC@weJOhJL z9@Ox!>kE^SVH`G6knQ8)7T&i^Xm|&>=eG32O-f-6!_{$(@riMaQ2Y00ZN( z^#49u5C(<>CdKa&krZg}Kujf5^an|SP zp}$H_q(>Ii*4D<>So7ZrQteXK+E&))@D6%k6Tl}|EbtocA&wn8?sa_40 z6_eGJ+Khc(d~rti{N$8Gd+xsBdRF%wlsJC)Joj=>&AQC~LRgoadP$miY>BW>R?)73 zqLcLE4OGrgFB_K6+puSe-2`@8s|>Nk>iG|kX1{2xtcYl>b!v%L-Bjl^DrgEBYZ&qU zexcRp>H~ZuUtZQF=4DT3{ zl8=_d95o5N4cl*C5<0sr3I6`Anq-LjEbD|V=Q)l%ZTR{0dEJ<(K;4EeH`$@(VNTO&hc7n^Lcg?;=UeIW9SJ3ETM=djpm#VV9!=HT<>wb7jA!*6o?E*?Rh7IYK!G}%VEKq4pV?!glPA^Hp%e>C%(RZr! zkCq;Gk`A#YlSNL^*XywJG4smQHc?F~JhQRq~;0tWtBK}+IDpi1+c~5hnryaY3$i|SAh$1elP`s<0VI_A# z5lBdt^)2ePZdkU}|An3JQl=lF)fo1cvQaY?uI&>?li7F`_)rKg^+FgMJ z?^gk-CidLU4>{(k!BVMD=1ol)qm)0a$Wx_5{Aw%`5-ziKX>DONvuY|fKT7R^(rth- ze6jN7`2m&$Bx+WM^ak5dbfZ(tQ%>tJ6x-8GN@|-i>g%gNOg?|yzV-;eo2Q=7%}cBE zC{e9w)%R)p;G8#UW_h8K>)hcH*||PXA~L7zslR73LP=R=}j-t@VR z^P_sD)v8$+OTx_j)I1mJv9|W0&R`^fau|_4OY0eTv$XCmZE@B7uMEzu^+tXE*StLH zv6*(Uc5#HRJ9E*mB6dt%wDY>Fy`cU?Dpx!*?f7uTNqcxW>T3m$gS4x*AMzi_$Nmxpo3q9 zK${`l$H=t_=sK(owb*D$SO@vGR{p*R(A~PyDi?+PGm~;QwE0|Sx zd#`y1Bau<2-DZef?-)I=2i-K@#FX@%NeT!y)Zbt!7em{kB;HbcUx{g->rsZY939tS zT2201%%JRf7<$m2jZ><6P|bh;OfbJuF%d$F*pW}a@HHUfWwD?873&!N_{*k!7IG;G z@3ayc{}rpYq2BBDL3b-Ma4-c*b})V(c~HJ|wEjhiO2N<)`ARyEJs+FrH1CsT(7uHe zl(p8vZ193`Z26wo*`$58hxhOry~0pBITfEoxKtsH%=R-=)YlLU=A+Q&P`vljOv-Fu zD87B57yR`#LKHP39RHgq9aS(+Nm&9yNhirLbs{$5kgxyZ3L_Ek7XaCN)zB&zPs$vv z2bF`Z!A7bi?VXg^aYd7+&a`8QEKZ!opK=fT=wzl`Rg`E3w?fU~pS39Ld(&9AH}cE$ zIJ)t&FEnEImD5qa*-zNHUuf$w+)ne(5(7!HPNO)&CYvWOg%y4$wW1)ZkVHzc($wSO zCPiay*dQlQvY=EB=L0diQggQDgS5PX6+^87+~$}e^BBK$e5dr?RQsybz!*Q4yQk>t zv80aU!4(5C3I>$9n4g`Mr4tXLah6lj2)_@_d8&u-=R3>bf0JRPsYfJKy2_klt|yez zQ_qch*8Z&``-7BbV$nuQMuITcu7zEALL=}LcR3Jk#}<@Siw{VNxX?{fYuIXqxSI+& zdmSY%!RK1#iiMKx3*FTO5E=#xzFQ{E^<(-@oEchOMh|x;;vO7^3#I){NQq}(fjX-k0z}pbIo!c`F3vTONh|rzfp6$n~J>QMcJ(8UEsvPqB z5V~KItH+A`L4+RS0Az1%Df&kcdQ=X&_H$L>afF`WKxYH4jHeKKngg8hJNOh%_o3vMf~AoMCRgdMqUe|E1U^hW4SQGZT|wwX5W;bzSBX%Dm^bxVkcr5({p-)LQ=w=e|8A6}a z^dL#pG-siQUm)})&t#a?e)<(cU-NXtcCZb6gV49^5F4L(BxIjQ&2UMXF!e#Ph$!bhmqd6eLJ9_= z#4LmGvTTjhhy^ZNAi?7hUY@OSTe89x^A!dxE_) zaa)@m5#EXL<^Wu=*ahKT*u>@TO++PD(2C&GKNzx4R5(I`IqAlwq( zS7_>n>RL}*i&(!7Hh4)vyM^KD2)9zPCbyU{f1|%H3lc>Q;r4KcJ43H2tfeP-W*fYR z9PUJTCYe$2u%V6Wa2LYeq=mLbaF%A_UWEI+puH9g_ai*u1?P6Q)n^bmi0~ZUC(3ya z=XnUv55OJf`ysr4_y8Zy{N?V4$JA-ksRto^aQG0lsW*h0phaK!FoX}MLS?&rT7gLo(*l`FS&wa(f*yAT6d=f!LCrY*r_E+hR1)--P zd@AYUtczTqordt~Cgiy5OoY!ORZ4nb40@Ug`d>O)*6G4+sf6z17?dozR!dDSRvrZwa!)9_d!q77!uNYHr&B$M@I#vA-ahpR!jJl4hx6kIKM{V?3ooiivE!abfA|@y zk%Bk05%?U!&l6Y*4qz`L{1SODXGSlAUP1U(@?F*!kzPmm4dR*gg`>9+e%nAC+ulX^ zJp*xk_5s3wb=3EI>?4Ff_JR)2PZ9oG_%jn+l(#sP{2k#hh$Bx-XH*ARhkqdaRrqUK z2dRf*m0lNqthEKQnk+-vHwb^rf8E{gB(96TL->1w;^l9-b7)R9B*PYC}U z{;$36V;_i_N^5YR;eq242_eB!dV@WYMTATWSuGJV$pucJOaPi-?qrnZB)01(7CROX&bN!^kj1e}+2~7aOYf zQv-;ML}V0CAIvypa~*@oSVL9AL5m}@1czLE5ux{+$Wn+bO=#Ih&5jdU7Lnz6Xt8nC zbJCIJBP%2#Dx* zA-kVOwnStr9=`Nhn$C6-B9p1?D4l?;HQ%a5rXVua^@t}{M7Bd@dun^eWRTjQ!-Xx} z5s{sU$rznXI?p3+7esh=+HA}&4Q9I|vIlv2L?DTn@3MV+BC?lHe{aV<`ykR1@k}#m zOT1;EwMs9d#svhRMw4>xvvu171r*R{a8Y1mPGQym>d8lR}(ixelPq}_Wr-pkG zkuF5KiIuzR^vLQ(q>l)O8FLDgrXP_39*&%$ytURzF9IWjh|Hnp<<0=wY90MG*`DVi zGM}5e1BxGf@+z_)e1^Hu4+xH{3jl9E!+cnhw18p>#h2 zkt0d>q6=xtAC1T{+Vq8Y?`-XlLxktAT1id)6A?Ly0;*P$-vkqO3L>YHX-zKX@%3ql zoNn^g{e31PXKAZ)dxOtb>>NbS<=$?k$Vxjk2{EsIf3y3L>@E{ zC-gjw$Rm+Qf4xiezW!Qk=KwD)ngdS5$k|WiaYUYoJgE;rdI#BZ2(PAxwuc^h8j)ur z&+3~5nt}m)^Fw@L7kM6$7svp2cfnJ`FCp?W2`;h zFvk#s&D)5)Loa<3+{yTzZ{$5h-j93`vf?}v&K}~ce}0-1Mm|L3Bd2HwEAa^;pSq8@ zC4Gj-=guRk>KBN7={{nruMqj#dBg|rBHtkLEx)3caZIZF9U|WoT|)MQ+4SrOM1FLi zNkx7_iWin2TVtt}%L^DL2b|w>~ zQZ$Qbf6jQ!T15+p7R|>ju#9NMcr0~mMs%3@n5jn~I?{M7H5`rT7`f%Grmhs>qKhHA zcytNTD&*6yPN8A7bw*2%BnfQR0h>ob%{saiqDvF+qRYF-mAovX%W*8wr_+oqkLU_i zZlsHN^&+yB5M7zbnoKf{VpT*}i;frls@gWQf7)8>QL}kD+i0+!qLv$79nm$SYl@C; z7L*470*c8~l+m>jT_?J(=%!{d9vuS9O_b%(TRv|L2ejfQkZkh=vIhsO;p1SD)OuJ7tu^cbQ@B%$w#AhT%uDE-IiR? zf9#`RFA&N0i0(j4Dn1e=WhX>;CQU~B2s|q9is){B)3xPXbPq(Q5ykL83gw@@5Zybv zk5H(!x2In1?5VXWljXaFz;l>fZ~G!zrGicVf=YfXqHRPmJdi@kZ%4EvN{4SAZ5)mez1O;jTrP$`YhMf5x(8`GFfF}wiL3#k{{9+IcG-B@rjqL*;cGH^Q%T!!f7 z6bDKM>coI65xt5E7YtZ&z8cYM$R8%C)VdDQ>-B1tpqiFOZ$R`$QhKn{)UDZCL`Mi(le+TS+7u3D~ zA)-8GZSup4!6%4*>Zj1H`3zB>&<+ozP;9>dWfx0VA%_*!W$yC5zRz$j61U% zf;K^HQ-bn3q}Xnb*hIog9!wS860xnQ4S-=y*GY&?CLrqqisKZ-rgEDy5LIkD#I~n8 zk*XL`I<_NXJ5dbIe>s>Pdt88 zKE!78?83kujRp{_a~CpTRdxvJYzXA!3{ei9F}a}Yb1BeqK!5N^&#>;euY4XBhO zFGB2Mp5itpe^U%EMeH)CN&<#~D-gSq@QM#tqW+B7)kH8Xh(Iy97P0Fbe+LW+e?ja9 z$KQ>Ig_{t&nWtGgnO<+VB6b_`8RaGLFuDV=g~Vu>hfde&F2wF8USk7jJnZg8>^`Sb z8V?l@Aod`UjcP=uJo+$Vj}YD1MbIghk0JIrM}D4XfBA=vClPy!m-Rke$$AE{XL2zd#ymw5s0g_Vd`5qpjB<^Wu=cmuIFd0cQvG#lPV>>XYso1o(U z9%Ao1?K5at`72@{avXIC%sBcnVxMpvHE<`6{tdCuIF1^yD*JcDzHq16o?+%6h<(LD z)&T9Hf99WveZvbd7d3~Qe>^Iyb%acA%W z!%y5oJjAmsgTioKJc4+XS4KV>Tg!MH@r2W51BRk_3h}gG6Kyz(1M#f8mIxk_;(5di zrn9wSDPBUn>~w?v&W;(LeiCm&yqV|RegdV%e{jS{@Ge#$g<>-b@zG9KkVJY{iH}8m zG2S!s;Y!L9h%d=|MnMFM$X;^UkVSVNV76%b#M_l*3oVz4set2hl) zQkb>A8sg)fhUpSGRlYjnYd8(l#Z~FG5MSG=C>K@2*F}6ir`fuw>NN2U5Z{m&a2jm% zf13Elh;Ks5RXh}qcAFu-xif#z2vqqk5Z{vb#5}O=zpW9U#2a1#xUyjz#HaB7i%DWS zaa+WOMo_d@7WFU-Ff>hm_+G34e>oae%JfY-iYtR ztB;_*voGSj16&O3H?4^C?r)`0pJ_+De}h*b0sW;D@tK4bg8E7q;@#ZY8uXK1#QS&| z;_D;*h!60_gTH?aB0h&ZS76_mhxmM69|ZM_{Se=u*9QT8;y}a?;`M>AKOBPip*)xN z^@YO`KY~{d{(f*2;zyGn#lSvrEaJzJB88y#e*)qs^7e?o?VpVJDI_o-(C+_)fB0$K zK!V%+8Hk_BL8DQ7KO6CLIA}Cz>*pbUJ_n7!c77q^7kQ-XZTu3%FXb_$Vf(%u@hdc6 z>TUZf#Qz+>TJ%KT+#jfMG8E(G$1*`LKZ4%&#ji#Dy7=`%5rdceB4e4L7a4(^Zb1CT z_)YT2gUd;KF|kb0i-|y1w;+Bie<@WlSZUqicEstUt`%=)_%@w?~@MU#(4&6nf% zAbu}h2yOOJIF)=q;tvp$ijPD|c?j```N)NjK&kpD;*W7E6CZ)yHJ(8HNit@%pTd~5 z$Dc<086q5R5}IAMw%sox{u0?e%unJN{tDu+26#{Fd#@w@e+C&AAjodz zZz29Rk&Fl?Q6731@%PBAF@7qK13p0fuS7Y@M`>35M~Ht+%KPQ&)&D8tedHM${{a>=)d|BDP=Jdn`imG2S%x4(ty0pmx+ z|3d-8lpMCQS(R8f5_P85+S5mqoT#kYb)6MVJA5J%TM$qMaz311OZ9 zGmz*ck`ciqiqR}2x;VNF_LvhE0(+3?<#uI)O2BL+`Z>Dze^6Dtj>I5$N=cwcm$^vH z<2I>7ithp>_T%W{!Bo)$kT{T|i-e8naxfByaC0^=#rH5I4(I6N1y$iAkvNK@i^MfQ z9D~HMnjyLqjz{7IjxHvo3Z8_-$sAoIYBu6ik@ypLFBh~M@aagL!O_KqoW^?=5@&OC zaWTd4TqMrpf9T>ON{JxOaLmW$A55+|JQOgFW^vMB+}4E-r~# zF?SB<|!h?ztxghD$KPrdGK7P$bU-=rE)wq%!?9k5Zlkm{`~Zo+66q2Fq?&w1{Sgu$6ZO)+ zNv%x#e-sJM;5FPSU|*_mFFPkbN8;~9G}0up`-m<4OC{X>C*KJ6V>10d%BaD_%{+i5WCSHc22LhmHZD9KM~<#enMBaqWv!tzYy(` zzd8s#Ojc`3RSl4+tFy9hcZ z7f5F5nqAo;HKIx~k7OZPr0c*szKDacbhR;AMzWG@qC3WVsYRWGrMgNELvlC?D;UL; zCL@s?l^m^m$P+*s9Oz}vW072p%&fSDjR7IK1d>aV=#ojGqGxhxB$pwB$|h__&*XAQ ze~$CG$sHMzDh$6*GQSskk(IiBP+`DkoSS4VOU(zMw};V8Qn zl4}!_ijPD|Sr^ImNZ-*u0*}fYAh{v+1Gi3`n-NZ`kL1QkZen(5_ZEYj@FTeylA9CR z7$2F#Pf>1xO z&?r-E`WftiV@GVUwBGm^W|$Xl^9aC*z{hUD%%G)n>>gK0?a$^3)$-y6w&c;pUL zeqSW3JaUt7{DoVQY~u@71gj|~<=2&HJCYroL(fIEvYklIB$QJx1@P`dvRjHKf81BR z7s)=}_OWZu&!HblzG~+j@%L#sh~yled6*O$k9kPWXDwuUKrg%>lKWHbkJKjveoYQU z@*tkS=wv=-hah=q@-R0ePX~A2o{$wEH+izWt&}_h$s?0TnJJkB%|Kwfu*pN*eN7&N zhL-KTz zQP8IYw#sKBc~DNM1uM^8pom9g^46y*VTGe~r?M@Eef4 zF?o}oZffY&IMlXx3zD~zjDjA9Z3S;f@(xZRN9p;EtZvCWk-Upj$k~v3eh-rOatb+q zZsv1K-jC!1oI=h874i_056c9jgh=xrMe;Gqo|xokGGAKq2_&CPJ|+6H%JgI=1tLnm z`w)CtFZm3T&+^*|Ra#33f26)ZkbEA=7m_c^ZSh9zCpBRIGLo;@Z!7|tzlP-N6wikD z40aoXs7~}Il5g?;wnOCCg6Q5s@?DwHmHea9oh9E#@&ghfpQ`+1$q$kI$V{DObNK|x zPxbs%_Vdq>{9MltWk3G{$uFJk3p(%>l3yDs7BuV|B)^q6PDv>vf4x@nJ0!oCxdIfX z&(@PaAo(L-ueMQrGVv3VKL_QGvc>*_A%YSL4mf=^9gvjP% z3t0}SaXv`$TLGyR`Oqps)RgQpD5O%NbPFgxiH|}k>az;xq)hT&4l(uicc%6D+va+4^l0B{>(llsDo9c zrn@JP4X6#Nf0}d3C4g@SQhaDxKWJ$X%tUIIdA!VkyOHYgoT4%CKBQ)ACk+g20I9mn zy3OI3uMnr^AjJok<+#T8hg0*BTHrq8%fqStkvc$o#v$h*qz-nU$wqc4Qio~JnC=Lq zj&z^#h2hlENF77tDFxNuE;-b8x6d5lyW*+ikUE~we`H;Kt$`k%h}21xr8HHyKg&Q* zPeJNbngW#U&(RpufYfP7ot`?w14}_6YrTNQx3Qk(}jrC{lxE0Ma2<|AqKRC(xXq^^-O z9*S-re@@pSb-kR|5GeWFfYgmL5js6nTy93{7Fl7u)bX&n4XN8@g}DjXQwx#0Q&yOk zQ9X4xQun0pCC|7uKfO9oGAA_AoXVIt&lakAzfdU z6FT}AGr<{OQ|}=4E^%Da;kZZ#ypPleH2W;O4bd?2L!>^UnQfME!^BUJ`jkqJsPm>~ ze**(QL+W#)8rgtK)!G+GeMw}CE3!rE{1sAPr~b+Lo@%oPYqTFE8`<&!Yp!Y2CN&r) zzeVa_sqZ*7l43(rC8wYanhn_e8>t^sKXRH451W<_G4zG3b%wMO3{GF0`U$C@WnLDy ziyIa63sS#Q%*ru=UPI{+(qSq)vM#f)e*{-iI*N3R$VN3HlXa9%Ae|(-C2YDyRZ=>Q zbVl|p4k`Sd8s2P7XOYgy)T(x$GiT`O0@6j9Bg|cRsIq0GD-yC-9`+_@x*6$Va=9Ru zK+|cEck;oeM<6}Yi>VBW#>7kY1UyI62PLvYVw>MS3;U z)ns0${5S~_Oh9^d-fuGq?1oGfYa+cCB@i2KP?+1o>2;7^ms2b{L~7lXULWZVcq`LE zlyqs=Mo4e0zS&{IY}}?uZzgk~f4ivg7Pb5IM5MQ%s&N_X*#Og9A-%O}xm?{imQO}{ z8xH|5XB>j5NN>yeNF4%7=%%Z;J<>aHK2n3ii2_8j6Vf{q$uNV&NaU8@73tm5yX$NQ zY8~BLlGT8%B>x;KI69@LA-$*RU}9cV7VM2Q?KvGRh~~w1q&tXYn1@7fVx36Oq$W1fL*r>=T}XGQdpKXAL)P0DoUvwzdw=OZq-RqL zE4Vxdr`PBAv0ej6*Uia+S}>;PAU&5i!VSc&()ma)ppM+^$5mp!^!`X6V76a9MP&LQ zqz|Tit!hcyQk~P`2A)Hae?CkHjhJ-=(nsnbHERbv8tG#UP;?3hJPzsOIY+DlJ>l*| zq)(!7r{*+)@s8+DLHblq>}t@l(WfDOIv@SeA@024{m~tu7myszvcWG$I6-Zx6hCriYGyaV9)nrD-e+AfxYmvT=99Xo6 z8Kc(zg7gj2_X?$E*dagGnZ60>n+eQ1Bh*|`n2=kMzD*`7SBR8HBQ3#qAiYoyZ9G9R zJa-q;cWap8x_gnnPseoMJ%IFsa(7K0$S|GvFw&36VUN*9-g^w`$K_zAk+J)pMEWT? zn7Ihs@(j|?rk`^*e;iffKK_K9OgNl=0qGahFR3nB?eDigG8Z&o3!WgSUqSj+xm#m* zJbR}o{W{WbnBCggCrZDC^xNKWS=Yv-caeUNcA7@GxPP}P{Q=T{^+;hV8~+IDkNxu_ zEv9~o^xyb^wK;*(BI@Tz%Y(;(6l#X{CDQ+px%Z{JRg%T@f7eL=lcp4Q|8?^xroTn{ zU-I)^YEh&zFQ&go`rrDL%}uG8{t@Z_(B_&GRoEF$Yx)`K|E7N-RTZpxOy%tksN9Lc z)8&kXOvn(%+-zZ)2r^OfiwX*cCYd-g32Ix-67=dpBq?OlT6vQ>kjZ9py3?y7qVr_Q z{&d`=p}b4;e~(?kV|%86Op!JZNB9J4Z6Q-erjlu*uc;%t&NL5zX*G8aXS^j6r5B5&1PUmJ*r8ky(N_N%cu$t)H=_kXf1!kh#;i zT0d`(WtK%|Ilh2lLMQqH$e)=S6OrMg(ZhlW6qBux+1i{M>f?E4GBVqktoI2upA5gv`$JUA_r>gzSn8AC+$QlDR(F1DR>2$r_1r%U;OrE!We* zG>TOVGJImX$wTHkXF4*id~VjB+-a?=hD^I2!92}t1~Q#|td=8?UT_vNU2bgh6zf5z zS7wa0XC}^B&dh9N`ejX;m@=o1%%HcZT03Xve|S)STR2UnF9kD z*!&Mh<`CJtd8VM7dl)i@%Y}_Sf6?td5}BiDUmfng9&eXqjzNagyk*?wEbXsnjz{JM z^SKNnCn0mP=Q%5WDl&gEpYvXO=5%Dv@H}VwvyeI4e9n9BnRAgjFLOTSM(m=`g9~k1 zf8>4%{g<~*gTG6Xxe%F)G8a=?B&VR-EpblW1uTNN=%vV9mbsi>{y0VDd+VM?=?A&k zmB?I0-#pM%l@XBsLj+eNa}A$X)CipUhx=jr%yr0IZ+RGTI%0L$J97gvH)d`!Y;z|Z z4NnxZlD8mpD+=J z$ULBXp`#Y;g@=%NSXYJVbT2%L%wxJ2h(PlKkvxISle)D;qFMViGS7HL7}h?A%=3n| zb)U5_BJ+}AZQZc;6=YsDtgQ!I`#Lgj7^>7g*1mp_ETj3rd!)(*6ruW{9U)Ut3lme*gkkNE$o$8!)?c?jBlBOwTC;9{1uVnb;JQT^h#0DP>J~8|ZdmK9 zTO@&$VXaZO5R+?oMd;Qd2julQf7(;i;wTXmfs*cy9$)370yOFF=rJlE!+_y>{OhTi z@ed<`QM$i+f?Eg10Ano=Bg0>d154=s>hZM>ECnpB`>V%j9at7v&MU(3*Ydy$@~QHS7_fR)Kx6&v>YYE@u0@>Rhm&^umSnV(a`Imjew2$Y`H_A`DasLGn2XDor%B}uKE5k09yfDyXKoC044+5xb`)O z|CkDF>#E?5{@5Pa!L`pH`>_+SvumFj`LQdoo5|d;Zx3LaW}h!IU@u^A%|0V8pas}h zv#&u^m=3gRDtKc;4QSWwfAdF#89=9IpBWEk0bM3@!@eG%*R{_d=P?`TckMHyJnF!p zYhQyHkGa4+R|Ri`#{ytK*FJxI#{s~Bu6<^7$HBlMCUe8S!+^sz`~3BHByf~wpILv$ z0LNeqWERN<*s)c#qcYEt1N?w;hn32Yh3RH#P92X>s{}7qW2BJ zjV5!$J2wNj&=H4R-50lS18(Pg>-B(`y%4yQUb3U^iPv`n_sGo-U#z|lxL+-18^q}c zfrr!%j5kI<0z4|uf7J!V=f{C3)R%P4*!&dmw9C-2{8`{RX5Zq^D6%nWgFlvL6UZi|4Q3q8rjgCK40Ri_S!8p{246j73&<9g z4Msg=%g9!g4Z-!0ZANyO66vXj>DjR(DkR6Te7-fS|581_#UEF18*svtBOUX#! zjgi@9kX=@qf9H>n*>T7&FU>P!V|GPkSCWyy8yB;yAiJvC%xO@2p74^o$>>9|f zDJ}QM!tC0}t|Kis<6w3@WY>2Y8kTQ}>_+Ckul+_Wy9u(J(q}?OX;8rDM6#PBJCVPH z;-S+>wnTO-$x3Zc8JuXBiZ}GKlaQS(Ss8RX$rNO#e=1wl3qA+h4%zL^Z&o;m_$4h7 z?TGA7=BF>@K~k4u7i9U=?MRm*sFrp|c8^A6?q+9pPh|Hpm9iCA$`R2%$hLTt(ySwj zDzejq*=U-#AzSmP@3e$8oZwBMwUbPlrTnx6si`ssXRFJNgdMUVq7e?s=+Mr4{hFGcn;Q>g$yU4iVC9;G~f z`ZKau2eZ*MzZTi+JSqkG=`YCMzz5~|+_aVK~_A2?6ZM1nwaO2eL)xFvE(IWUzV}ggk42mMfNpaNRTaWAp0g?UN9~`xIErQ z_8o3NHXdZnd&s^YOr%NrE3zLNl05c&jO-`ucrWfM^EYHaGvowW^mk;xaMQhe?fD0? zU%Bbt1KRLEk^ROc2xwpbLiRh2zsHJyetOS^A(TMNCMoR zvycllq;oxziy#;EiZs>E#gR)miBlUjs9XxUv{zt2736>%Covx8yHVrv$|J{j+eYg& zK~|QKD>o+8q&6Yf?33!Tb2xG%oJiNOq2)#)H`*sN$kMUMEoP=`_BW~A638uSe`bC5 zI%8?%mND7*8(wZXf}c&u9ixfO%iXtGvDZWT|C+yI?dLvFk$*{)aV)sb7n!ze)O zwUAre%gCely2!29fRQF{1LQW;@}36hyfJc{Xo*w3`fi5Y<{E|eu?=!lXg!v%)4fDvL6+MVf4S{wX(cgZZI#;rxgF)TMi+Am?u^_n_B~kfeC~`I zr6Az<+_~M5+numtBGY*=Y0l5>9JCV=sNW`zu$;h3;&KVe- z?$hT_$eqT{Ay8N64CKyaf9DY3)#hyE&SB>;s3~(Ea_7r@AO!ezxe&RF)R*j?177`| zbE@^uIox_LLGDu7deu4Rd2~i2cR6xb$UExtaTj;atC0J%e)h1dw`2Tj1YCpMwelRJ zeL!V8Evs|aBlj11eB0KnzsBc0b2lP)Q|@N_GtMp5o{qt;YJW>xe`kApt)I@#@sU%R zb0T*ua(w=Fq{H4vPGol=w@})u$l7XM^{R6sC3hEccRN{0+%GVz{fykb$lYhc`gTX| z0puQ3N4gBy#vexR5oxQs>t}zPIrkWHk4x{!bSUck%eg0!drEt5f3Z3D406wMX5+e> zY{%0co=5Hld8flAf6-dSOUS*<32iml-!@)F?lsEkGpwg77wD?3+P{eA4dmXWeekkP z)2X&Sl%%(jdxugV6&Uwu`5toblYpWIx;^2q$bCp?UPo1&{}{PXXm1{jX_oyBxz9+S ztOM9Z{*K%i9z>P-2XbG@ij@JC1H6+!CihR|zLCe6)HSJoe;xf7a^IP!(tL?(a{or| z2lEO~z1q>CrOe6w2f3e2F7?*lL6ggWk^4n9Fy#w6EbiiY3;B?Vcj}37@)6{t20lRd zTwFYkd_sP*TjFy){8PxMP2A)UvZ^3HfFnHB}gn z{0I&8C@>27f6=6%M7`#XMSd|IH90SV{E`~#;k-2R%gED$rZs|55a24kC$553BP>KT^;!~WIJ=F%08O4kY8J# zq0}>Y`N-Bqem&W1WSsN3a|7fzG+@)88za9-epCH`f9pVJcVAa$`}~%+zTorZ!DpTG zn5!sf=Z^ik*1IUDGHrXWPIWfcNV6r+78ALb*`Kj{r?@o`^zuTVQ z4*Bi#JLuPz>I0(5ch!b=S!{Cf)rkB~$nVS<+1&AZeh+o1xz+x@7CV{~<*vx@X5Mtr zDf_B*f4cma-vjw+#LuN_7go%mG_-qW`A+0#l4eCaJhEQu1wg(F z`EJfYW!#vu)$T>UkI<5d+J*a(AIR6eurg}ve<9_?8ln+%ke{2MNBvuug)+< zA{Qcm5!H~B63Ej)EMTAn;z~@3X$t`P-5oK>k6x zZ=4`RCSS=vjQk@us}7Y=LCoCx>5fwVG2|cT6fZ8QTtn!S$UjAb5{&YlnEW%ye?M!N z==PO(9{CsS65XoAOUS>Re?=_AMQdBVO=Z9sNm&=g{~Fl;8uG7`Yg4j}GUZL=-^#x& zo_5%I+RRT$=_Sa}iS%{(#qkX?DKc$!K{k@%JOd)|nlISyxe{|J)I(XJq zNTZOU=Q)1fSL+uMsLqS`LKcNwA#Yn)UC`M*Sf4SpoMpkOFA7BzN_77@!yH{DDkwD3 z^Bg}nlo*D>aK8NA)!D?bfCslj zVS87W-ZyqcVJFTcDUsfuIkkB$GX}e8PrR@T3cK=#0E6y!AjgQp?kMcRJ0dF5x~cdi zz9$NMaazv+oU4(DfA&G4#U-LeB6~uZ!dI*Z*^gBern`~`X7u*gYXfzvW+|x+g<3Ga zI^!KE%;3#m#s_KWaqD3w3bSYh+|12})$Hr-qNKuHkwnssLJ#k>F-cc%tAX~RFqV-i&9=6Txtk0n2x&bM3f)?x?H|C-+f3GlK%!SnmsJu83IG6`q ztY#+rp|C&awX|!Q4~r0TAPNWZwLOJUz@X=cpuit8%&V#&m`NO^yAMaQ;m!b9 zO}h(sqre|~AvfCj#pwBcDBSOa)_Sk{G)mz?6dtnU7H3-5(t;EoLE%xpRINZWzenM5 z6rSMxEeduscNCsN;b}WiIuJYPSrne*cITc+Q-daG!3h!!PGt-K`kHQC@@0_VJAENM)_KhN~%qJ*( z>iK$+D)Si%pYuSg)u29U_yUD5X*A92xWc|d;cL!Spkc-o;u{pcr76UiAOdG5L6qO2 z@I58p%yU06GH(`sK;cKqjtK`-z)vXr%!>vIf0%hO3%{TsbIfU|go+^)!<=MNLfq7g zQ50jmIFJwJq`sIyG0ESc3C=TZre0mLN_(&8-aS9ZvfPi>uM9>%% ze|grKb)XJaXmJ#mkcqJ!gd0nU9^cukg6j!Hpf%3FkU=-IxaV=`z>aj`yS6m0hb@_WU?qfZ3 zc5!_aH=q@cTZ|jaMksD%4hmK=*1{r!i=X^TW5K}%TT?0^X>ab9s{Wd8cNAU^vWFYz!iceFbBl}Z-Ci*Oj{0%3QvnwV4zeg#n(`LU3uNdcDqkd{FLS%&2@Kg&&+{c{0zmTC3 z=6ef&h2qz4VM!tje}m$;gwTz`UNM;T`^tWY;`c-WmqHf(0mUC3f4SX(O8Q^5Q5hK`M=INGGRprKM0>y0na=4iR$R z=+@re{6&IFip23YcrHKcWDf*9a&qTv}K9Hu4--cm4i7<5wi9i zN{gT5PyRH-{q)i#lqQ$9A%`j5)VTxs&Oubd5Yq}bU_TY5ZPgM&g%iEPw?}CQdOc8{ zUaQg`k=lWGf1I}yN;}hdRI%~8hhSHfIAL3phrn$$d!RH;9(d$kZ+FYKv=>Ty%cYOp z57)PBOD!nvEAv$H{*JaQQksrZt6R?86DieDYNxj+GD?bBAip_ivll<587OtigtCM; zNQqjSg;JMHDC<&jAm~Au!g)?nIt!(F@r-AG$}l&(bSDq4Ju^27T2qjWV& z*T{srY)svLuUNVcrR%AqWo^LeqBo#)qs+vte-Njs-;B~N@)iKUFtYc|nBQ$E-A?=p z8s@NEh|-<%5`zmmT<=Ed9`dWxMqMTEL+O4g(1Dy{52EytJQ=C{Zm9DJN{ez7xm)wQcZ(jM(Gs~taE=2 zf2G%T?lx=}e-ov*2zRm<>EJsky=#Cv=l4w+C@J^=_9wON9Rva`qTh*zMrA= zxy#q9?-wY2DVv~2*RN3e+5vQa-=OrZ1Uy=Nhtl^BpqKaor61j9?!E>n{e;rbrT;pi zn>HWpqej~V9e@kSusg&L+?0Mr*(!(Bf6QNr(vLRnJv4a%$##dRK{>=_C9FFn`-|hDRiK9^FJAA`DJ1RQOSd>CmP2`*N#hr{0?I3T?_vjtTN!1(#aGsLdvts?l*hZcU(D(#uc2Ra4iK>x%4^GA zEp2;6Cs-Hd^)v#%kPT4YP_`eFKxeWs%9}_g+7^vYuo=pmYXp8NTcEt9am_hE%GM}P zl9!L&Z5|!p2IVO(?w7GG%G=4yf5`@}v)BRU9eI<+*eKE|c1C#@ox(3>H=1psNhjDF<$W{)znFbduCm8G1Ui#el-rnzzGbBow4>ai5%{HaqCAtOcnEYR zT_|_6-?eQo9q&cC&&B;R`cWR>dNFaG#URRaoJ+Bdn({o9=X;3!!uCUXe}DJ-bK@p` zAj${1%o;T7Lr^}{L*$ouILb%(E?fslJPPHb-K)>RP5fAtk27if@=iecME81h!=`>R z%BMINb{jVLKcRe@m&z~l43y9GU$qVpdN#`EI1X#n^v^^2d=HUdIRpie1(U|FYzjrfB)=ATts)c2IXtr0V23dT#xc!Od7wu8&ST=9Yh*-jayK@ z)zMwwIo648NBIs9kze4QDBtB6=poXX-GlPI95fn9yC3BTGy=b*hfsc)&0mC+M^S!E z&b^&6Tbp2(pFsIZ53Efy%TJ^HjGUUAuwDE)l%JQy?Q=gy@fT5ke@PZMVY~P%D8E{M zjb65>V?9pkp)_3uSd&rrrx_)qM|amKX^i=diBU3Aus|9?8kDXva41Sj zDLEz*l8S?#Wd zE$s7wBkdKJ%ED^6J%%8B;zPM?Hp*SS3??pK)>dKl;gu}s9o9l?wU&t(1uKkkW3qT` zxYc}ZgJIjgSo<`YcYIt8M{?)BxL;*k_Io>9KXt2l;Wt*a_YK)A+UR_pU-{AK2``cq zn#PgzB#gtK8IYK25EZ?BTzg-zKcJJD^95oIxXUotZLZ~67Z&ZRvwWj)f3qnkX3$Bz zpI=P%J&S|TeU>%SLgzmpd7S4uT;Q^8s$wxp5$N&L(n59k=S*mnuoFWkt(YXqR}Pfu zZ9UH({`XVmG)x+K;$7iv%PJPnhL%EZxUxLU7?W6~Uzj{(^X!H1VA*@(DT@rb#a{o~ z2iAM~1?yIrnyAYxw@!yN_)hKac-{~TopW|kAh-w+wEb4uR@TPNc~6cu^+@3*>IU?y zheIK;g>p+s?o+4psE8#ZqTlgCwEl8JcHekwIUJNfDv#;PD)@fL{^`Q&huQ{NWjAna z7S{y7kOj91(FPCSOOIC}EA$W_?e_LH;RYz8V*X-j>Ur-45s3-gn1y5$?6eU}ab5*0 z*OZ0a+cf_sRMtbNq{~j+v7Rb&5oR?}Tg=)bUdyPo4Rnd0>4&Sa7lv-XE9euNQBb;7 z|K5H@;o0t+5H7JTTd5oGqGEnmR5jN zz0(0*pbH2Td7Jg9P=4@4chhLvafv+U%zqwLH_@ESw9?mU8usOqk&eG}6G^UWTXS1c z%5=xS@xi{s{$UkRp9U{a6PcA4OjtPQ6`!7QVTbHhEU0O4YTGmnuDURo@KyXtYY6go zd`D@@SE6v<5#42bDSR`gWnRY+gts&0Ew%F{*^t1#o3%t;@t*}wiS_@w)L~?l0pEErZ(G9cRYKJROoachU zMK1NfsaQsO-!6xd#pQ+sG~Ud-n%L$P;Q6xhKFdhn=U908X35phqAOp-8GDB zklY<^X-;snxrOGJ`jh!bB_Dyq?+5;sp_7CQqs*J7g`)~2#0T>a-6H7vZ2n4OHAAn zh2ooMXSUZoHN#W<=UL$$JQxTZ9CCjGhC)s!;FQK|nKgm3TwC1aID+TIgu z0#_mNHMxZ$8mW@;s@%-XN~N25ibnu2Ozn`R)Yc^`X5W_lAo|N3_<59p?gdCyC?IWi z&+ON|?+vf!G?+4P#}b>BurqKr2|bT-co(XDG!~yD)pq>$ELP^%&csd1sQ0XMgul|` z>uO$cQ4Too{n|auh#vgh1|+u|^^{(lr4Oup*21~M{^nn;1iV{lPvy8vCi0Hjq-^z; z=3C(Hp;Kf1y!x%JZ;n+9pJKgl(OB2Z_w=xdgng+{jY0WV=C)5C=7U}5VS}LsKV;70 zZq5+!F_(mo@hR&6{xrhTOL_WN)A~#9o2;d_nP@+I&*hP|t#)gS={XQbTG1Ac7>N}U zd#QrkpD>NeQvbrm?4wi z{^M&CZp#Pd*B*iDmw@EgoM)vEK7mNtxN=LkfWXLG4kg!#=EXtx*pkN|rWtdGCHz%p7=S`DzPT@RpBMPzp4<%) zy>;L@!^2bY+g0x_nl9<~9)0ekLuTwfTIk zeIsye%#qYOlEGRj;!&ZUkEhQ3%?P`^Q3iukoke{A?M#7t;_tz3(T0Q_F#cRd29L{K%~bZq{|_t%Q1axWL$&J&%sZW zPQBvv?Z_Hs2BdvvjH+?YV?G+r>!~~Y{hJ2@>Cx!^Tj}xZREe#3udD*-Otde*+Z;=L z91LI>DaBLuou1&G!CUwyMJGi(cV@R@7%*&vC zd+n3YseoS~3%bhh(8B#^VM?Lu=k_AIBC?K^EbaMoZPYtIb@~aG@qMD{WvP=lD@9%1 zrf)hdmOJQ{hdaD~_wVZTGfi~5s3D}3N9?0xF&AR|QQsOaA3NsL(l zVHPMc3xCOQ{%nhyuM+<%Qd|Tw|6Zf_x$c;MFa*R!7`d)Fi#%NseY)a#veK(J2Y$`j z_#)|D$NEn*Ui}&oSDhV7XH3 z{R)w>hM%={(ZO8V*Egtq>GXW*hxyVO`I7Skbzhr^Ds7zBpSDeXQFZqhq0IR` z|G}>U`1-wKbFjSqQhQV5f#Bbs(qyC5@4JKne;REZbCGbW#(Tu9hm@>`6s(7e1;LN> zVQC8dE#Y%)NNVm(l}p`OY)#3$Ap1xI*|G{do^~bZ!ZPSWpQp0~=HD*f5)~)@^sh1W zV#4PRt(ezqcB}9}SLV z+$-)bk8RS!NHwa^9_2q;Y!XAhexCd?sHIcP-TIP}RXnP=Bsn*aNj4-Esc-dF+KOwA zZR3{&E`7|y2G9jAXFQ~ z`{`{M=rL3j4DuAi;*<4s!lM&H6u_%Kumn~`CkZ}oiTG3Ha9~3iS zQ*TY!KPV5^8F?-sfV{{|JBB44W0H=AQbW1w`nHv}^a5UWD!9iQ6Js1f7)MGB;E3Ou zDOr%U)r4clp~yPdzWqSxz*5iX&LG^&`uUN90*gVU6##F+c9?*HEy=P_o9*XkjuXaM;w=gCVlkCb7FF zEV2$XtkSBj2TU#vF(0Fy-Y+@><6*|yn8mj&4ml$Y?II)!di|DOcJIO+{w$lA8W|cy zJ+Cf6Fg{dRSKc?}@WUsWw6Qc}x;Dxfe_toZYn7BbJ|C}@UL)T{KS9xon}5EzF#!{?b(7O8W;?&ulTlX zSUwp_qyE=~*nE<%q(odzee&pJDZ6IvIO_aus%%LhkB-EL5O@2>sy^@d7sNBUtnZxf z!#9Iu>Nt2|h5RWCIp@TcW8VuS3dzW+9wN?EA1m0wFTM9gcBVO;efq`bErRRzyTk{d z-4l-J%LS5JE_D4O4+Q+I4uHGdZ^j*GhC$$e62jlvZH~Fvr(x^v;IxZ6 z8zYGLhA2NszFEBwrZ8h^n*?iUemeT|Xu{yC+(-4mz^wly?tAh&d}oCWw;jcYd?Afq zB&E@>zSdu|CpWPE6?eI3wm0&7;=c4!uS9#Myrm^yHII>z!9#i@Q9-~HY$RH4U?{pG zL6l^N;49-1dsquHs4?hY>y|?@oT{F7(H?Ri4)@X0u1!i$st?9YE(e>54rXf3Hdl_m z-#mx|Nhcg>m;O3lJ06YVR2MbN`#VlynZeB`W=vP;Nq@oaEm%V5{T_B9|5>Mz%!3Bv z*AH>&R{Sy;W7Qi<8xCkWS>;?R)0dfoEO?3Dd=|eo@im%k`{Dkbuc}>5CKOUQ>75ZB z3$sf0q#W$q2a&DA!~PAyVWcJ36_ip~Du>scbjc8lftKQ{HR z9c7wQ0Ny>UONHZuC@{lxBd}pEzPwawe6eywnP!9sO9vlca5+#i6Hl ziA*|sThC*5!K`Z`^8G0f)y~s3x>`+eEyJC;%O|}a6K4-hEOafZdXC*j&IVmCSs}n< zwq`tUiTk?_Wf9;Z$R+8>6XZhC=YQj&C-YMJ5e?{?7+b`~EDXgeg=0aNKht^WnCTjL zi$78dk2KBbUMjjreD`kw`o}Vt; zOXy84GZ}Z*(QSk3R;AabyQ7)&&etMnwBGuAx6h->IDi+mgyNQu|Fpbb5A0~s|C)Z5 z?v$Yrl+|Wc(Ds6=MWT?W!Sd+!oAh)M{tEsdf{z7-#Y+`jeJwdQ;T%jB983yqM}#&L zq`GHXAlu}iaB1w%_)RC?+KMj&6nUaG1Az}~vm|D<=H`CY^-vwu_15aX^;l!HO3|yP zm${;YtbqZH;!L`c0&`)V?wJfoF*zty8cP)qfAwCX$qeC$XC**5`q?=Z**j%|I@5y4 zK@lhP17E#^)xCl_`Iec`D?H22!y9BDH_mm>ltHISL4jEiMR#URZN!CEmnMST$8Nd6 ze)%Z~A3OkqXy;nGSYMyP`PAsql{{(=!yC*WfsJpvXW^inlq03AI-mCv@ktd2)WY$XDPSQU()v8r(?jKP7VDi4n5fgX;35S+6Bz;#HArggDJ<=zz4}%T?VoDiA<{b!K}q7O(Z! z(5gfjK19uw$SStM?vSIA95BVhTu3-_cIbM^3jyr-#ggrL$(!Fo*+upYw`s5K4J^o-N9Jd?jxe~nE z^`+r{`dY_IZi|;#`!{a8P=@*CB!y15@fUm!l^l2i+V^eB&g$EFDsCCGnJs`pvhCFM z@rQ2`J(IEeaWXk?Kz>!$2>sM(g-O$hpUXd%yeIOE_F^Oo^5ELstTgwK={avQsthi! z3l{%aX1p+NG(;#Ewg|D#SD~J}U*C3TX&V_Zr!UGF@#1a$%$DJ-&Cr`J&_PlxmND`; z-)ztF)kyp;9ed{TSc2IQkY^NtXiKsck^Vb6(v)koCwtG-+U_S$!z(hsy5Z++dT%h# z7Uv{d#SPuR^R$NNEk@%7>NE7F3Uu%m-$RVtd~CJ{^SX?7kClV0abPr?f{zzJN^upX z2Z@6^Q-j#EOi?yo$NIWm#0XV9xmW7jrDt!K(t{L15otlRG?@{ynGpaOdk1_#gVkVT z1|}q~3P7i6M+6|+*+t7ecV<8fk#;Lm1d--z*Z0J}uLzWrbmRldnZ`F(Iu19_cBbZe zOpD{D#Bu%6n;pHjH_!ZOXh}H3WX>OgH=`UIeq7EUJGDc%i@?`g_swPm=vbBQM|7i0 ztdZ?2!Ro_V?JL&6!8G=f^Wp=MI4(b0v~Y6z<>?=XDc)Ud=g9ERQ4pD0vFJWFuZ-Jj z!d<0=lZA}a%UgzD=16aX4xSgk@>X+G;^ju^g8j#`%Gp8g41fx| z#@E7Pd=VkBZCgnFjWNRO$ou(_=ezZgyFn@DWVBs!k+=AO$ z0NJ~BZuw*g2fwB^S?8rWtJ-+L$5Mgue&X@J6whOXowJMUG4?{2EOb}&=w6;aN1Zbw z1|f3={!^_pcFG_ep#KSn{e$&pOgXBXEn4M$xg&bXa|54Nx9G4JH~ zn+fp2x19ItiVNkQH&j}44#++drih9zyG;f zYYBj*Xt1)0Px{ust}_;ry%(i6vkJ_u4FOBhVkuA3%U^5FJPnfJb7Df%YIi+P4H9B7 z6Gqc&b=^dK_W^CSK)mxHiU~*j;DFk^J~g3YV+41~kq0>7C9l&%iYGj1Jg1!?!qL}C zPvg7V54D@SqW{t2S$f-qLMA1nu<%46$QBgw3EYH2e4xX6^ImcwVthfiUNTJv2$zH) zP0;Cr!D_Ne7bRUh1v;5mO;@LjjG+mJ(7zQafYA4~daGm7B}5lbgKpM|Y)E|@{w&C! z?@|aMtR0!3dNgd(#YGp-j{d}>=B(4j%Mfr2;jMM14vOLSJy9K}UmoE?n*+`yik6zx z%)bVpx{_czIF(-5EMLZLmNDn5^--d>=k)WIEsqo1IU1N|8b*oRp3}`cw9F^Ab2ZS+ zGzi;=IOKkfMSQ)l71D9dogjT$x0OM( zdG~;I>$3j8t(ta3c&`=s;rVcV!la9VPJv5-YftL89GFuo-D>t0S9f-pEe45Is$Ii=6ZP!1n_h^WQ!Deo%gh$=7q<=|Ne zu!I$n&;=-p52xI@E2fwo4iU}YV;(KI-?;&>iY6VV@0I12!Fhq6K8G_+$kL0NK2E7BG zm;!Ts57_(MgqeV|sgCqEyL{UIzP+K%{UR;05PXd1eYOk}%^8>oJ`K;VZ^o&gs|?RA z*jx`x{5bed(a=2l>NGseo&-xsQeF&mF~5rr1Y^g*Kob$Rjtza=?u$^~n>j>~BuKL= zucPzXkrf}FAc|I}D>3zmx;y&mOKVzFIBiY^7oPY;9{)J4OEW&L=34diEi#;$r`PgH z;dwLPr7?MIW&uE3UB-_xj|Lsh%BO z;4usEAJ9UB6*P&YqdOqSUV*vFc>CldpPlDlYqj_gV4X^v1z`VyFF*OS$r-VQCXvc? zTohP1n5&Vu&n!gs4XoZ2Q(=n9nA$$(YkW)YePSrXI!$q@ezw(L+ zR#k?GpLO&cUxRT!-C_xm(#Bb~t92C&CTBP3nm|}1a8m=o+ra;!G+XU^)~g#>HgFSb zL=y==PD{3|+SM8=Y7dwBBse#}5CY;3x-S`@eD;ho!#sJvDxv{Pe4 zd+=Nut?#ExWm0&9vB6+2S}X+{y8D3W^TGL5(7+eQnh%%&X|2H3GVwceL4gb2N2|XC zRj#5wGM48&6VvusrKgYy%shGO%O{Tc^RX@!xV_p>vehfxV|O~yToqICA?)B%SLJsK z_Ux|3?*v1>vnCNq13FU_{?#wf!a0iadMd*aR}H+k;Q$wmD8xH*g`x>QXHF0yifnKIrLu(<7F|hkscH zQJEfh?l}GUSwX=sKf`xPh^7Ev&GM)Ln43hV?@7N>BPO-aiZQVDV6SL7$xqVBL8OR! zwwJHdIxR{mFQ)5zbFCDk-n=Z}c0O)>( zV!zzyVi{LDtz+}fu_DMehmXZC9E&CY!_PHdTDsh;&rQZ&ooV2oR47xcR1agWu3tbs6!^U!z^1}+mskye*7f_niRZ?CA`$PI-4EdHy6 z{Ouur;^BAV!QKPq2s*_PX2f%ht8o~r?GezbqKD1cxCV@VYNUScXaBLv8Fk3};ePpvu-xbWM#WT8e|ZRkxn|!oXfI()kvD?=cm!w z=vmviS=-1I#(lhY&o3DD{hN05iW61mJhrF%O2c_jliFvL{@$q9B5+K%w-{2oXU8>_ zT|Jx4*@9zOZ2hUR&u`Oudaz@Yi%$lx*F~k*RU{EKak>`8jCF9>uBY(ehO8yDxHXYU_BdhaK>O%Vf| zZClQ>BOAU;7R2N&;H)9_NZ2G&m2Q9p`vE*q!F%~^<$ylkIO=^X_$_DJxZjhIScPc< zSoC{4o$`PhxK&7lTPv?vXl^O~exRGt!2Yz_+m+@3iGZATWuUmGOZ~>R zGxW;;We9ZTI86O5SB^Q^$Ek@0WfkUj=bjjRCgkor^mNsXfbJ{p6_(w=j27}ti(WI` z#TRQoLkHAl$DHZl+b%T}@P{(loteGnBi{$wgu8->3)gng(EW5h|CDEUYL`5YToelM zOxmxZi;{e7`~xdoyTO?}tESlzs@#VUG+@E@E)_(RGr=CMFTo`Q(?=&R)hroOS-FQ4I&>6z8YEMi5N~m>yIt5pJJU zeyN*v5HY4?2ALbGC4`y!VoD2+$=zm2E4d)Qs#$A90i1xFJW-_##I%alTNEda_PK$< zxxUHuawJ}k>nmp^1~zdYy$<5?_Es@J?dEaKaU$6H#+whp1TPlSzSMp;5aE#Kjj3CfdrAt zt{+J~O62(;%JP9c=pdOxc6{S4aG1QC1i1$(M7)|cxWG*q8SdIZ?vX6dpC`LPf#ZjE zB(z#T&(r=!5SM?>;d-rWx2LN2)EVd2ssWgmHg#MZiCNc5!+yK;wp@S7`n$l@wkh%L zd46TVTJ^~nVCS`xRPy=&VSpw+{v@S9AoV0gvIwycMgLYufBVa1GPq=XPQRS9F_Ke? z9hE-9K|XhoQ9Al&iyH<31QA4CniNtNiJyl#zEX1+*x`j)jPO3S*tvw*Il$5F z?0=%fj=z(mV8Pa6Ft8j*2pji=HYEfXe!NhP19ago_AYwkIm_B{dK=_q_7|qm062z_ zTeA+XSyy*KmkDsQOQ1c%AxbOy3)^-p-5z+u!VbCD;M`qXU zL8xp=xcajk@tyOmbb8;EbCqb|nw#o&YV)F{7x8fi>hZJns@qELF)JOS%VEj9OQMb>3i=|jlFC=$Vfw_n)Ss~;75ZFR5 z+lzRT7$$AuvF%$B$sr$7n4d3uV~rE;yS zVs1p6@^fc3R7&*OYu938T;GXBSMEXinsB@mAx;dkP?d%joXyc2$tiMOCc<^#TMIfC z$aj%SP6HcZd}?OW{mYGINKXWQgA%0{j_ew10+?OYYm|}ARB#>|%pzE^QIR4kg{d#w zOht#kDO;#z(RNZRHckl5m?7=YV@5~QqpYAaD1#?b+v9J_6zMcWQ13`9yTY^rtK(yJ zFGXlztk56TRMD!E9sUS77n0J|sz7S{ML}yal#8U24Ki2VyjDsswQcUJwE)vv(9!}H z^t2YlwY3f_NdJ#=VoZoRdg( z4wBry64@pc*-jMM*3#>8{3#cHAPj6QTPP_~PrTP$xh#~8=S5DtA_;Y_c7)VL%Y}sn zH!z7ZTu6$U`Wyc%3nj~tB45qCg_#>|zcJUr50A+|c%FYmSr922@k@;5va6-NhE%NmDcF}eHY5w%> z8Z2TE6(B?^-c#_cY*aV*`f^UtLCy8ReRdN$DW z(afV<m zvdLMp_=-s0hGQ*0H4VGxbo#7ci(#=Kh!FH+TYWWe-fs@&8anP9FcL^!8`VQz!JtXO zR_*joDxKJd^oKbN9cO2J5+c5{-R>jZj7qlDz(lo?>J!$*?yy}a=Hd^jp~^v0ouG+L zi>~3>nfE z6>0r^8X?O@hlzv=B^;;jJ-US_p%MZL%SGRhGD2S_9Y5Z4wjIXpk>!`Oy8Sb`(AC0z z{(F)6cOE(9+KrQXa6x{09;UN7ypCF$%7-#1w~`=f?;e^$zQAGZXgflT5!5En?!|A9 zurg)f;a3lJ2s>&~;|t0a$Nz*1aIYl?lOVb82Ey1&YLta*tTzBc90W2r zwkmS-q(&J?9N8s-07=35=h&j3TJqe)Ae;nb3#DX!dE~N0ejAgC2qs0=yGE-2rVcxt zfFfm6!5F+9O~n2M7UfV3z%VE}i>+zG0M)LdC5&b`(O3wL=j1SD<);{?P9>$Tm&aL; zL3AK_uDXeIlIq9V)$JE-ZX=0ww6LTT3nkv8W%+FXZwwD9bhPWzjSLt%5GQ=pDGaYd z1HoG%>rPU|xE%Gk7e(}o-G;N>GeJ$%#UIi_N%evb{C9z6s|_boC0n`)>->^PZ;}TA zY~f98#q~F~?xDJ$>phKJqfxsauUhXRSRn4wK+&?e9Tjsz)H0LUiI+*%UlM3KkR0`) z)|DBTiPnV);_25P<3GbPW$mT$s`5c?WsQaYezk4e+k)0ys7mrQDY9t>Nh|6>;dVlT zvxk;Ex&uf)`BdU)1er`eCW8E}Vkxjrj0qr>M6kd?(&b>XN^mNpo0h%t3rEvpcET+f zx*I+-;SbtdR@q(l3pxl_Qe>XU5>ECOlWpf4_x=ywR9*jx76U6xl;16yc{P2R$e^TxKF+c+3{DjmykGfLp<+q+t@G~Lhp=X9pYsJ^5q48NGl>EMY zuo+$1{JO7~LgS+}=>HkG(D*dj06JI{R4f6WH!{{dnWZJa6=A6HUmG`fdjCpUao2t# zYX|{nN2<8C1jd|iEO?RdC>vZeHYDIpODq5}MI1vQ<0v1q%Ol67EVlwT zLF8lCH$=l1OC^K{v~2vM{Kfx)Q`Cp0Kd6I%Dai0|4U9ZG3!lq3XCy;!V>>eBJ->Q=rG@1 zk)%53OC^~5_|9JWU*000rL)Sx|J7_15)|dnfvysJ+=R@m{g!|1 z=GWWG_*f@=e5a_rJ=Pyc4! zg%L^w9E9+R%4Z|cAp79FlNDZ zj~K_kQ@l{F45W|jszPrh2HUA@{qoh=rN@}Na**P@@oGz(m6ib$==$$3rJ0y6jQkdj zp@v!VF$=`I>NF^4rdW{|nd$08gljwDYEmBm;~`)JBnJ~C0RZ1@J{7BG28l>fpeTKm zgfBOW;0(iI`E*Dy)C4cAqhR_u6paFr^J_=bE|eU^eR;K|_MR-26KS{emnp6{Bd>2o zK$HS`7iw9>da^GB`|;pW6*W|L=w1HmaCl8jX%ixk97X{(GCFLIwuI55MF=V-AhZT@ z(QwRb00E~!j=5Uptq%XHjwxNOdf=A;XFxj4T-3)G9ILs_5?5+KXpQB_@JogEp@uO) zpBo)w?^O6*@Z{%=4*3vb7-klJmWTOsn?U|+!FIm?`G7CN+~@Gl;?TB4oI1DO!U)~} zTd+8FAVn6&0ON+9Cmr{l09*&*&wtt)YLF$#fRHTJp&BLMVkO-0E+gK68E;*hKL1G} zVB>*`Bt_cd8=rmi;B&)!j6{$?gRM)+v8URQ+o-3MWXj_8Gh3g0C)R}iJf*;>y7r0p zr^TdwizRczdy9C(Rec(CI9)tw?A{JR3cAMf^rsaW|CA|$+5icy^hj&`DxZpaaJk`~ zMq&s%zH_FC2cg@2!hd=O|AlZvGzDTx-|hxVn0}$a)VRh9wGKLze~s-9ChfiQv#jsQX~_*=tFbN;sGJiX=sISvHTG}vP; zj=xV?X8@eX5+CDOpm;S@Kl0_^1jql|Q68hcF-ifwB1!J!d-t6K@A>*~h}au`Qzx^`$Lun@jx3acg@L;GJ){;yd!p2BHLAMn-EOiyY`O=`+c zYJww@G|Z^ZA)*MCpeCu}df`@vP-Zmu8*n^7;eEU#`0q-sD9;5Xw;4uqyjHDA6tmOr6ywv!&Pi64A zz^Mm6m>ZB3DQcq)H2y31j-YBFLiaXIz|HkPBlp3dyVW2eXcY1pl2tB>9q(3JtBvbR zyeI#!!~r>>$tZeHf&U*NrkeGw2>-MHO-jQ60$ha`PCQ`YeI>w+A5z9c=$fb3`Nn&9 z+s$0+jsFR`i#b_yMtp5s(KEPtOf2Umi}o7(>1xH^Ih{grGTod7bN;Y3MD!OpmQr2;G)rP#xj?u`ymE; z4pWuQ=tt@F>DZM^2etasrcT^8(*;bM|7oH`u%8|->QI^WY zQS}J@s#N(mwST>2J?a?4{2lJMgZ^7lurWjGoFlvYZw>y5_^R+mjLI_^Me1D290o)& zhLJLc=`n^?^D&0;J51%|YS)r&)eU#Ewf%H4xa|PSG9-}kc!^(bUb&a}7)K@PUy=VG z3BL%;VN|>Nq5oFupXj?7E79%8Zx%~<@CzXNROa@gpU>asOMj6{rhh9ignYK4;6e8M zTDyeOY0BSMD?$g*iqO|Oy``o3b8TxdH+#1G_el3@P!nzO&-1+TTlg7lCE%Zgcb5s2 z6u}cTNuknLr+=iY99@H0D7navf)ZTFB6aCdlO$vjHS4wn@l5Lr1o1Bt<_0;pNHq0@ z-Wgq%`qZ8RCNP+&mrIr~RXq1=)-`bBJc+)MssGz-U1S zNO1t(<6$q5DS^fl;Pj#KcnmB&-Tu`yKgVTA=>{fn#_zq=m*hto+`>ajq!`~Fu40(q zspQ5e9+V{n!+RchTWY>!&}>Q!=0pxwlOycIRF7`BEtBDHKqBx(<$~i9mCC1g>@rz( zBV{U2MpQMA;_pfI60js2v|7+vOPDMI4^vp&ZrK@7oyYys7GWmdx*s$l*2IcZ{gci8u6BAgr!;jaW`7cSmJ6^n;;4P$Im}Q}w>BjRMG6C?!fn+5}++ux#YVMI7zs0xGT zW%FgP2#yN9O^A_mjVvvskv~45ahmG&)jHMEI@QzC%t?wb2QeIK>@M4mbZZ42=qa7% zpNz!t99^CQG~oeC#WAcCSqY*1nb6317D#Mvk_+jXLV^o<r;^_WIse0Q#!RmWg_3OW!=IX$a;k6Ws}u4}Zm5&#ihDR2tVJLDb>C-XaW55&h#TFxblXBCH@f-nNou$zNSp7%^xX(;|F zy+j%3=f@(wrg!gE#FO)dGeZu6L>b2ySfKaAY_TjCKk{_QjsTvzMgjI zpFc5n)Lrd$Pmk4{{-5$oXtjAh{TNfHkTE9&r5su`2|Zx1|6MSh4b>p?P=%;gvA$S* zA$gk|ea3;5MxEu4j2%uqer0S?l{pQ%2B25SASk7&Ie8}LR>6rL5GyG0$|bX9Hja{S z{*Sp6DAQO8gkE`d?3{7DhW^iiPG4NiKh%Ckhb%=YiH&dTu};!sf}!!mxCmdE%h@G6|0_=LwZZ~Gqp~^04Egt;>#z*$!YK)2ntJ}PrzYM zawPJ}hovhML??9V8_F?em^sJt9EM0Yf?0TEX%yk)kxzYF%P>)3|BlS2WaXPN+34Wd zvA4qNSB3D;LhM?xb0>I~C-M>SrLS!hW``nG8~F4T44+Fhfu0Mi1TWHG9tP&#y^$(zcbu@pSAV}2D!@JezETQ|<>T~y=~O2-NGYISd?#uUsg5iZ^q?Uh}$ zMm6oe9XR3sEN3ETZKP5Ysb&=IkY2lC5ZpKI{r$NO!=8hy=GWUZn*1c8)im2av%*AI)BYYW5Z zjiR|kcbG+Xgb9F|`YP!jV-@|+#L60*=Y=QkpXl4$j6w?Lv>j~x^S(SV*uPy>bx7wg zRS|73NrSpdXe%Y_m0NT+F#OPJyLg!OH&7X!t(mD>GBPKXa$S2jfptgFBX1w@guz8e zT3vCPcO3aw7kOS@`I$E)zxYkv#G;;}uy3E2`@7h{EOcT@p@6Qh>*ClcIHI0OzkWZ- znJn*>lX_U!otKNa=4>e=V)nKyQZxA`sVUsIklwJG()6n-k8kCaSmm^sN1uad;Rl4s64R2kcl~03 zC_BWv{=SXFCjSx*O8~-8AO63C&2H}&@%Ik#idcQNQ=;;0n5xMFbjp$XAffcCH;QVM zT~C)%-KE%1_@*C>KX6u7VD-3gq|oWpCk$lxITumlI2%#odmAC>Uk5Ud`4GD0dqF-C zb*L6G_4&$!e)d_=E@xQvsjX9BPee-RrPqb|v*S`QZVP=D1&tqga_sVl^;*xuQTA5; zDWXa;_1M_8@AT9Gupx0$@tzcV!V9`&io!oEWCMg*NeD#3AEK0KPxzO?EWb} zMzq7=nFR4^1YAET*VUcY39dfErb`XX|E8Cm zQ>cf}*4Nnl$*LHfsr{>6k!r6_^E&$ZLc_r^q!Q^e8&7K%%zk)R2{|b$&ncXK8+s*= zy#DYZ(%aJ!P(xf(&)4e;woaXpXHb%z$Ww3ot`hgWu2ZWF`9G%4I~uO_YrsSsEeyek z-fI}WM2R+t7A1%}qKD{&C`TDJgXo>8k?0{Ix{-`TON<(V$SBc?-oJ70{jK%=!SbFt zhP9lty?gKH*(W#pj2ql}bD@hPq<7#qdDw!|0OE=h^^85l3{g%_xj?RaoZsrzs$z~w zq`tX}69f1{a!75tuffA8uNK&nwLQu#&Wi%^l=_1kXdaH5jQ8S1q_O8$bA$}A{-*KR zZtVd)ecgrJR9G0k1Ad(YO_GfsjU51}(jIl1CxqNd6 zb=Ev-f24`5Bg6{z9t(~gvn1^D^15@Qq}Tx~TGV?Hx6 zyu`eSR{E0SI@=Z8y??4&bP0_dzxSy^nUe;?^jvs9N5rKX)R;$CX;apE6uukqf@?dV zit82Uagr7l8R>1hl7Xt|tEiw9k3HUxg98r+M}y57YVBt2>uVWNBUV$RYz(`rcND6D z0k22SNABJ z{#D*jD5}xhZV2_1jFchn2`1_ZKIkL@MAbM0U2jk5h5LK52YPY_(t_KykM0Ei5bqfn zgL>W`%uD(;bZ^IrGjRK7^DnwAF;UIl_K#3c*1$Zr+SP@f6{ox0UDb_~X0XuvrlZ)65w=1Jsk8 zn1@n5p4q(Xmp#zSIFW3#kTBb$sLl=`IadjMD z^7T()pc-83PHxw2ZlLeiMxEE8?2p%{1@zF#kpn+5;;5~9*@>WJ`OmeYlFAPIU6WYu z3jxkigM{pTW7bY|t9HZAcu zRAVX7WU=0<<_hj?OCtN}Z(%iE1wYj^65{<(%{%(2f*{6?~6r>c>PEd4!zCpDlSYIQZ{wsh>Vzv8SR3L_M^(Zjc zkc%GU9a1hmu>Dy zhPXWKza?+O+>t2pRxmmWZbDGnDv5p69~c9D5@kq&Y{ekw(s!Bd6#gl4YfBWqMk@VR z-xeAA^R08hE-V6S5jjGJoS>mtDyt6ys1NM%?3zeQ2_P)x7Z6=WQ5u*Tv^8SHI#=wU zHqn20fIXoj1s^gDzE5HwE@?06h~!50z$x(UEB|W^arHom&@QfM^S=+io#&qFjUy+c zdF-n}0}zJe;=-UCw5*!fR5}fU&kba7i(x!^p8c9jX8}+W?TE?eKZSl)gA5w1C&EnJ z3qP^aIk)reGd8A#%W*2%*J|}=uN+hc*61A??mG3QaqP`3yE;(ig)45De25(~=jN24 zf02#ku?e0E-ZwuZ=r>t8HW}`Sy;GMj8zFPsav!=g!be-^5JwFNk?QR4{ux1IpGFBx+}{JhbR9%$Th!0nKp=G^lW!HQWsr z_q6FpUWG#dLi80L78rwu5z*Sf5XmaXW*|0TlGq(Eu_KU3=fct$NC{RV zS=giQd}X%_<83bl*+%b3fovzK=LS_9;z9F~J5NFLBcRWwd(sDKL{5L_(sc*JbF%Rz zI-Ks!Oqy>Y+K4-xf3O?|E7k?Lqt3;G*NRBhBx*PXB}}Hod)tQ*KYNKn);uqf^36b+ zECc1r<6rrSvMbNZdd_(qL-Zk}aPG(y?xCscRudN`(hn*Q>fLT{J8}CvHra00ffDzP z=4osJ4GfmjEep?HY`~L(icS-X9ucEgdXI1TK%HxbR^Uk|GvT=B%#cjIDIFxMtWT({ zzh7D3e|0gIasu_=y8GM8U)GFZ7#L4i^mn-IIWK)N^247-5@uI+E4Ry;L`7nqQ{q6~ z!6}sL_2Zw}5C-C+jf`|X?QG4N^T7yZLpT>66TuV$Pm~DnvOh^C=PO6<;Bwq=Y}{jV zpZ2c+_*C)Nk2`zbt)Ta?_$HP3CXM)}vu)?*LBMF`l6}}e($}E(oe zk`=B%05fn!Kk7ezagA~@AXi9x0dOn4^I1;txIb>}f2i6I4}Qra`;`F+l7v5lDyYKM zkUmd>m9F<@0h_VEpE6lBr(-u&bG|SaMP7fIkvb++^s6Hq zuvkvr^I@(nyict;4GE3IL1k}Iej(2voTRFh#m+SU(c1#FTKl+WXNNa_(0hwT_6QKk&(p}?TW5F?A?}9| zqe7m*+eL?r#1G*HMIYn-uJ~6wyU^F}@zDImdh;l)lm)QV8 zb?=xR(KSvD=yULW71mzk`zkJ`=kz#t@H~Y~2zSI)w*>-5OXkG8itn|=cvW=dZp%pC zZ|y1uR~d*{|B?OvXr!TaI`K+1pL`hi%;zAQtSnlzojBjXaYVh=31n2LnHDNxpLhT>Dlt-zGfNCOuWv`7jqmIW z`SWm?(ZPoLbnu1Cx=#J(JFWiq-`*>HeNSzZX3MPbe`~b({APy?QY^8)#NL(G?vE$9 z=;FKiu3ewm{Qmdom~#{TWlHmXD*D{KMdHuIUC|YOJIn`p?DT()P!u}a(?`=>V2g??9Kl43GBLAN($bKZ}>QtL-}i9KocF_|z*WKpR% z;UOJTS8aUx-97a|+BTR_N6#XAkX zjgo8p{k0Z_)LO_8RZpt@Db1xO_~I}|Ux)}Nv?6`U2xV%6qEUZHYizpLc-;BAzWE#R)1fSm;NtnT6HH} zfeKCT@M!05jzjUbSi{SsYzN94SPiI6>S0tz-zU{M`&21rq8)KEI07c>=ZvzB-w~n? zqeIoXf{q*}Q&}x0Q%Tv|@lkoVCsP5N%sIj4r2C7HeGi21%)X%x(@}Q{()SVD`rgOi z>-zHVo0xY6e_Q+=f(mPfLba;rBKWp%$m-ZX-TIcga|3)Wk5Gr%a*;;4xZY$hkI%V7 zE@3$liz%0zntkkRWjSEw==MfIcYn&Vv$COi(1K_GQI&?v#O;)q?@hU#Yxc|mYoA%( z#a59)Qr6%B-N`xeF~Botv!j_AT^p(PMb#os%M(_njA2d^OT$(>3gGE^K+_eo?Hj#Ic2^C`y#Z3Z$$EI zXp;owglArHDCCiT<3!PeEIF9pawsH|e&awHQYXcDA!BxKYyu+L-&)!4+CUm<5sG&W zKRNTwz7{dp#nD26GCit^ykGPgPB$p*hK3POA8`uI>^;;xTCeyV+eDgKDWf9o)ayPN z^W$&hg3pJ`I}dHI-ia|e*-H;DHx~O|Sbj#BQQP5O&ZcZUasPA6W&mME`~TK+-2uAm zW56@r>l1L_=Qb1*tsBS%M!RPx{($Cvi_u@WqZ=sk|JVOu+sGeKrbavIBFX|(5p-cw z{n!=sEXIq0a^YJOLvDdzaS$=No`JCBx00NqHUsjZtgUFLHm}ZiGPVakXL6>wgdIUq zwJm?+Y#(`3%n9iOCD9N zhx}^gIa%C{WR)1x5BRhR=jqC$!9oTv-ROLTRZ;J6Z5Hc*<$6*SZ|RIcg*AH1vr6jj zoGA=*{ycMfuJ2RqSa&**+o&0JjY73Uj%-xvSD(wT?!E(@2Ji<|{zAw8CZ6_w-|&t* z2?VDo_UzeJ&VZ9+i~Dn=>SBvC)%Hz$nz`N67BIJ3Bp?2^%9n80ba`@<7EJ+lirl^V zkp;Y-m0MKFrc8}yhAu~nB|`;IPIk#J#0!@AwTC#%oWzV8)fJ^8I(41p^m_x4EltcK zHQ_o!@j5_CnB7@aO+Z)5xCe`A+kyF}v`cjWpR1BSHC8!t*Ajkix*Bq>!T1`4rG*AW z?!J-4GLwI2qmOA4aIL;alhjKn7cQBzOLnlik^+0m{qo_*bXYs~a3uAP${u$Eml8sFj*NNPq z0Xs0XYanIT?%%6XHluc>!0PLi^{d9 z2NvY$Z%f-|p{f_Qun&esY5VRL5iat`cIvsmf9FZNq8|4rU(4=W{9lEeOHQ9>+*(Z! z1CLx^1ujWf`52hXF*rO>8aE2CAGr#vo4T#h<>r>iZkMEyjip`=q*;#rnU!PF*;iaG z9sHERKu!Sl(ioty)6#%o6e@I*p)E4yyNB{*Kf-IhS^pvr z|GW&`@)7oyV-i{EUb1?(`teu5$E2bGZRV_dUghCJlvX*MzY@Hy#CtLbY8AZbKwCz5 zR`Px2G*%CPu@ctiPI|YtZk@hiz{~plL12OcQ$ba%=T@q>9#~*ez3wskymRK3n}{_) z_Kvg^ACeqC^8JP3yuI&s+pY9pc0&57Lw?jD1T|3&vMY5Kt6mg_4X1g%;jwz6Aw6e% zW^+|Tlx`RUExb{x2w^E>T$0R8e&=`cCvvG&C^Ol^T&dMfgw2san2qjhz$Xiv(7UO7 z`SpwYG!Z#S%*hT()yNOvyJW{X z^6OVjpXc`8*Y{mSs%j%)+DHzbg=bC}i#+isV6-_Dho{=)8eTV7(cDlRn;H#0A9l20 zdH@SWW#7EMJ7~~B$}q0P!yv?mZ|){2=B95}P2bwD-h}496ZF)58v=mehKRiliHBv# z*rSqZ7M7@O@E0<0|2Jqmk@CLKiPCeE4hUaE{)F2NjmPg;DcV*4wf_eT{}&zftB!eq)>x3`zUU z14TL*CuEzNxZzeN{Vs2LG3o5n7Cu6U^su2gs1q0J zlC#GZhP2MJ4bB7Ukt^MQmgs~Iwo&pI<}}sQD=iZuoJfZ5KO`{VU1p&EoIcv9H8bQM zL^MJSg5&^j9bU42a~OoH8$ud$RG0b|&>Z<{{`BElOtU@kK6UZ@-`>ur%l@3bgAG2f z8n<{h&qy&aQky22?KNATOSLpLdIqjbVBh-bp!e%>+@U5%{J8KnC-%V)a4)@Rh(6v` zf{=Hc^Ut!~b*Wb3MgH5=S)IN}7gqu}kmGP1W?$pC8K&ZPB$1k|2fr2B@TfK5+355| z>hZ1^WTt0|!@A9O#C($j`K{;p22vEKz%W^~*`}F?5?$kAX|=OaO#w%=%D8?u4iD3w z+~T-h$VksEQQ^ta65ut+=9V%v(W6D=B_$4wOcE*c2=kG^`k zW!xH2H)?LpgZvG^7b6T+aqm<7{!AwRp%R1$o}N)VJJS^4Nuw+nc@2lXd(R~3QoThD z^M^hOH#GhbpyrPR-&TkC_f(R=LVrwCO1+z=98U}RS0i$8lNlR)A|r`79$`k}05J~B zw&G$*Q+kvOC5#C=-9O>sLYOC~)(a}-f)sQI0u}+w6p2n3;M>}NM_8`YP_7xa;(!UZ zVzE!jbMSrq(mFrjQ)7;VWG0k2T#Op2@=n6pg=Q$|h8+cwJp|HQ9$XJ`O9>TR#lQrPN#P;!iRP^6jh1Jf@Z=%VdruUEFa???cr1t*;^RrQO zuEPVgXiYed607o~GA%~lN9>Y9?)Ds;w31YfuvXvq=_E(uu&|V^p4=vqD%{n9Z?6p5 zNUs5?CMp`niScBC|7j;|@ z#V#NJnrJR_YZh>nsAHJETZwkn(I!lQKiWr1Z zdw!VrGpXn`(tnhosQd=p3DQjgmT&q5MgP%)%G{0s0gJY$@oWun9L+3h-NxctJxvQE zgM9AR!d(T!=_B#bcimrzxinh?+D4`~RsUY+Oz?Ev)#U858Ne5&fCrO<_UlY;`AV89 zl9rM|9`*!2Xbm{~KE0{&_#rtmw!895U@HO znj%h2gQkTmkiv9Ur&(~f15ax5zpZ23Qs3J7V4fQ|2_!(`dd2+KZN{#fse2Sbo)Np!kkK-?XSWmS!2O8i| z6HHE8zVnwnD)bp#_+_D-^T=gj?BaiTj2|#qe6h>AYflHM>M`edcm zRabL-IfhQo{zu2mM(OZJ<>!1k!$HeEz_Ds8Nfw6nJbW=k6k;2(``(YL_LZX6u)6iY0-D5n}mPS*`lQXgT~6PlH<8|7B!o6f5&%$!EXJZLzi5T)01- z(}wCtcw3Z^WHi1n&immuu7>kuhNHakkuPWz|LoffomJ@ZpQI$WyTPqU0IX*`tDpFX z#=ZFB8PGM%+}$EH5~YvU@1H6j<}YTLpdkj^p!ly3t!yax|9QP8Cu&E;bqfjou{T!S zHuY%byJ#HS2pku6(*CHtW(#($4xokIfW*VOwfA48H6$PQnQ@!C!povkIA+;MT!0X@ zbDXjx3kkwp?6M>R<0>eA0vImt;QoG!j?A3b$_`;^DlYVCxgCMNYDz)hMj5K%!e+($ zGuqwKo7Z87&$_J(W1cckATUCWgux|om*c$aCM#dV6JnSzlr^i?`gD}7c=5IJ{ePgq zr?~4}GLi0NHJOG5HxL@ew>qte(+qGg`w;-wP$2I08#S{y&EP*@XSzez?TB;t8e;B- z;I52Gm+D$-G&M9PQcSls!1McbhyG(JvTIc*rFPb`Dd6iikPab7%RDyH< zs409jAABRdc2>5(o)(=2-?(Al?6=8_nNH+8nIb{Uz&CJL{4I+%?N7;SaAsm`@anW) zX@ejPfN1s{Ga_xv++@;*^6gd;yLTZ#xVI`UDi0K2q-gxTMwq*0g=X1;nv{Lw*|NG@ zDA07Pm;9fdhU;k%*9dbrybJPM#y4hZG(XGKIsF#OLR<@xMUlDHL&9Gge$Br`*x?pr zO(X+vR@xn8Az-*VE}A+{N72Qz0Rhm*J#n~;oW!;IE%i0w0>6b@-A*@5ye61$M4ea0 zUFF^CWyQR1gUr>Xs?ttylL~OC>SW#m^Ava{9RPhJy&r--<$l8Vf--E(t&^(syc{Ef z@mhQcvu@)ZLHowJTKc;m;@3U_x4V7urUcdUdc6-1j{9|+uv@D502qlI(+nN!>#a;C z#vJTI&XnxUjStT9c=EzWZXq>0APgpxgiB{gyJTaS1nL@hhAXUoHm3{U<#udhM}B}e z5nu)44@STK)6%%+v7$zz7qO9Sr7Vt39M{ecDe>7j4FDtQ4@|g5o)sXAW;*Sinp+ME zdWUaR4 zs6aB1+VeoFy3OwtB-^EnA)wMY{uzwa!-djF@fcdPDfC0cZo_~5jsLWYvwz)};O;4M zv>C=U%FZ_N>FU2#dVS*4` ztkGGqmva>6x!y+i@Z+{ZRs8lucIm{W6p#}P@_l+kF0?<&5FeR#3%mON%B)7 z6Tl%;W5m~CrrhlrxuZMpe-5fEx-Y#U1NyIfT7HJ5?Vr;BPdQx;34t-*CB4qXy8qy! zg{={K1#!JQhWp{}ImPsb7tlh2QU*vzx$osazRJH{BtNA?W3&>0f>2yXmiv?A&FS9Z z*H{xSuwcTNE0Eiuf5lS$*4nUF$Zb-4PDomJwy?FCrT|tGl}(KHgF0zVj*Iml=lp9$ z_?GSMGC7{#zuxSE(44ES@+yp7v}hw}W<-P4bh2^!F5mx*()Be8$9!I-Din~8+D-AZ zE_jV>L^QAPd@n|(a}E%*NONpYc3(9wz)S=VzNMKJycGLBYU$n9=fLbTm#YpXV+ z3<%42E&Dh64R1d{-$5NyBIkRK)uh=LRMNe(t~a^30ODXzSL=-2fumYLXdbA@z_Nk@ zLYxAzD+2*!x{o!dsmL9(LD<^*O!Nvy<((pg6~<`l4|C;$aKN)2)&&((#ZjbO6gY5- zvus^3M!W>n`>*~G^2sPB@p^kp%%#y0b_?aHa1;?R4?&1tFf=EA3);C+X)NTnwtO=D^zt&~5KlrcrE;D?O+@ zYP1z}IYP|#P{BOVH{g)#TnuGSaUB6(DpJv35}u5|-02$!q{{Zm>;yWD5E(Y*0Q;Z1 z7)0}9lmX4c0rec-LgH=IQ`Z2?v`TjslMkGNGi8l4g-*>Zb{mAaw)j+C>Y!B<(#ysN*3!y@Tq3vOG zi}RydWW6)Vg&XR2fmFZyMBxB4LGQYm$}Pu*!!PT&gQ5W?(DO(C>JQj5`Q9tsG27g| zIfOSo(ia|hAsE+DoHz1C)bzq-xQMTz_1b@^)m{l<9|{6~_gy=E-j?z!q9gfKMn|O- z?!u+C3y%93Ikx-0O6If4;!aRuxH;}V6dyW)qT&d-$N;3vYJPHw9Gl8xIue)ygcKtO zL@$R(?v_FzZ{TIxE9cjGN<7;S_+og9P{H1=m zRZ98vRuDoJX^2xDJxB5lIKmVNVNaoJS}P&)Lnkwzl5sm=Tx%Nlooc>HQOCRd03?J<8cp;QUF1vgY`yrxpmN zwYi5Vir(?1-YVxf$EUT?{olYeY8x~{nHwdl5(q`ax`65&Py_KhAW$-5ho5pmYQfDK zRb!>>2H7+xO<;%t>cry&ljfISOxEp>gy|tNgRIrlch4Uty9C=$T2Mdrj5J6}`;%mg zz5DA}s&j{O@ZA5?xs2VVdbYB5@3|^(dkUzFa>13lu$H4eI$+TWlhXJ-WxJTG1L)%F zerAnQu0Ylx{>{I&c!|2U;}C!<;|wWQ4JW#D?47Xy`eK$+~v5P zGYsEdvU<&J{L$8rKxF*$84NDe8(=>YYhi z2(3$yXG zmB_HP+dveghzd&%4|%kTH(QLfL>Pjv<6fqtI-w!j8dZ4{MhOL;+?Uu#g2B4~rSq<^ zIFIHR3kP)lspVu`6l-Qv=P*vmu7uR~e#OvbKjc9ux(DoYA ziZT@Q8p(-7|3c#(k$Kh8<7f4FyAsNzVUvPu=2n7o=G}0Hr8+`14lF zex%n}eCal#YxQET=l!4A?#Yt4)UjiQ$LCfMWhwyuEvxo}xB^?bmJ&S|o6gH*s)U!x z@5ahQeq+d5nrK97I7O^?eBUTID%`s^-7x36 zIxhez(th0~@2H^lpU~_ItBH%XLJqem$kxh>^|z-RK@59;0iV4eAC@ZLjQes9M6qhn zW9Lfxrt$>2(y*hYA6SkV>{!k6TA9uBZgi3CfWnn;;U7cW$f;H41XHfaO9Ckj&ogx8 zl27J{;#{;O#={-{bDyEPCysC96?;BI{3$nAQX)^u}XbHH)*-QP~uQnCg7nCSD zZ~%o2`bO+o-sNgRPIb=Gmlt>>JE1$cF(K)a-7?Gi~I_{b0T;SAf6M^{n2oVP*J}H z=`dXge#y_EexShtep;zhGiEJVPv)jl2@(aR1*{5e8Cm`|lC(;Q(D}gGGM3UhR@jn` zmqoK+l-i_Iu=$xF(`gkIr(Z2ejzKiATThXTtB0smgt!XUzQb%d0Y4qTt7qGziUbl= zh+nJ3U`S6e4bMk z`?}jT^GY}zHi*9q9cKS+g^uoSDV!czQz?CjH`>o>LB(#dBw0%Lnx-bO%jH0PHrPLu zEgK8{Qd^A)B8@@CIjf!Pc~59NnmEvbtsjirKWc0ns-N)%tQd&f6wN*ct>6&n{>StS z_}fgNxjdBH4IA>E*h{{^uDIZ5FJoWbXZELgMpXzGMh4C;+H&ZJgn}RL)YsEV?r5px zGqE|hEus2~;RVOCXS8H z6!md$>0>nj`gxQKrz%-)i47Z_0MW4RJ=a><^yLqNLoDf%zmI{-|%p7_oTx`kbwdwCY1i>OlxkN zwDpJDhSjgiwM4y?K5i2GyL_w}^0CZY`XD{<^l9b{FfAM`^x2}1PxC707F{ff(|NN% z0tvn0;F1czLg1setC*3?U^3iDo{LHRi^-9yD^t3US1_U{5#T1G))J!DVxrdI_uX%= zrf$?}na;Ub1bySk>Ua>;VHgzJF6cQPTGKxHe(z9l$P!q5iuYHVI*7@yXkuu$f=49k zdE19kX<&&pOk9|8;Bb^k&D)hFX34%qbK2cQ$Q_iir{N?`=#uz2ddN|urEmCj2ycTl zUGesY7`*GRas!{Hu6F|o*Ucn;bn8^oz?ypLmCckk8y_b*`bBmmDeG>s|ET@!zPXH| z=_5)1{;T02?Zo{laMx4M&39Pq^aMtrg7* 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 zpJDvT`{)1TpR+3S<|dR<1>;)&sB=fdIj}_>*@itq5&^qUgMowpI<-e{!&t|zvHHXC zM+I!2l{Zk&mvzG(w%AtrUVY%KkGL?I92wWIe$J*i%6q+PHUB$yhy(3*{p0FX`gc}d z3jKTi8h`R-`w8$KhOgo~u3{d9_=Q|tZeaf-BPr-su627ka{{{}fuRE@e&BK!@kw3<9ZKI2Wf ztBw~(jRUa2BC6NLWt~LwfyWH~W9H4zr4p9WY)4#+B2nFhYe$vkv-iMY||pjxkQH}$!NAAe?CuzpRAoBVU*Q2&p&)_+MpoHXor?&5yuC4XTa zw?-vQJW}dr{VKLMgk3bwZsCE$wo1OIiabgnnj7~=dsL(gk|QK0%Ah22KwTl@ujg`@ z@-m`z^n%IhDD&I57<^q`n*Vh+y#D=cw|`=VBG#d2Qad<*w9nM^c7(s~YsJeJ*!aRL zn~6{V;qJFi2z_D;*bjLV``~^2hQ?h-k1Qx`*VF3xMmWWlWdrIOB9i5n zz1=EkKEQrEA9-XCDdm}h-LCv7^XFptAR7ZRdHSu*)E~qv`P_&LJ$xN?Jg9aBa)07V zxRJVQF7aWgMG>q=)az!lzAuFf4Xod0)-6d>&KU}po|l^vx&e&2%TQA3 zx3z=$%xzcFRomQ@NL1%_@5BO3?qiq!Rg*a%_<2xsTz=Nx;NP6XzcFPVTWY0O8U`5Z z(~wJ_u$JWOyY0Y!3T5e`0V(Wn(fCejBZrYl9hW6VYL}sgNF_h?RBFk3{eRXKskY?! z%I(_IRB}>L8V)oo-W? zmetwU9)NG6j+=9qglM{vlYfN$b>wRb!P>Y1>Au|fIPUAQ3MjM%lLDv}mHBVesJpfA zMs4eBOh4S>A0o!_5W^flSR1##KjZr$m8rJ2zW?f`ls3N~y{7H+UtiYt^eBnOT#8~J?*c-#G7qw72&r_dx=;^qDw1YL#c1w#E00? zUpC05l>g3-KCy+rupuclQD}rFD9Ik}T?N|y`z}aN9yj6=U)z2vE-}h((P!9))X#B= zf!n*F%s(7d8;e`$v44-v3tIVD`Fi6rR`dsg(f(CkFi>H}DeeQI znb&>z1joDr`w=f1M{|?xhmT2kWmByGZBiU3aB@P~ZSy@Ezx$kimq`?R)Qp{fSF$4c zcY4)9)`O;=eOl_-CoFpQUicf|xBmP=;ipSJ#bkcB+hkpxnkc+;^G~u5& zVm@RY=2Q5W!xPDT-a=oL5l>z-W1?m#)f0F9u_lJCmU;$1_;;FCjiWi85JOwg9g0-1}XxCayfMge74Lf1I)|+(n zqL&QSUXR3F2!HIEn45UBQEA1P@il;igjXG8UPn}3ZarK2aV>dLM~cWuAZMcz-bBjs zbWq(0kD_Z9zA!Py&^cZtI99?v;+7l(^JA`{h)e(*I_v0 zM`HVZ3)T7M94=|OYs~lwfeUu~BM+i12yF>QL(4%9^x5FXwiqWWjQC`f_x{KiZ9)41 z-29gKWPj-Qf_XFaJFvbsz;55@##M-|_bl}=be+42K8~rqHbou;2cwb_}cTCWRp9w-X_lpAie#-Cv%zmHj@fTn>Y1;1_+t}~i zoWi=_u@z#oQeHzZc@Xhe!^+!Fi9>y4vysnivEL`tey@SmxmgKcL5#D_1?mRe?{z=1 z-+%kZW%DSljs3pM-0zckzt^92zt6Pp_XO_u_PE_&j{Ujq?H&~5_M(duZuc22w|ide z{f>?|x!R*(TR(m-8B%78rix^LJFDe3tuUONZK<+P$6EMHZ3YvP;&}@PclAfQl&x?S ztMC`PaktqyZB#xjMR@t|E)qc|ZN_W7;eTJws+am5<9GhZ^)iGvK%$D;*0aK|9+|N8 zqZ^Wt{ph;wNNdHbe5c8)+`5lYgUw<$?8W!39wCZlF9G?%AX%M;_S_cJKOAM7`>4d< zfDjm(%&+W=3}rsx+sPuihevn|@d0=JxMNEzVd*c*sI>UcN){=x1#nh_P2bx$@)c$k&(c@s(vS8_jzUvaSF zd7SL?@Glh~6gz!Z>F1g}@TT3eLiW%5%F;jYA4uE%&t^-0V5YD?kPjSxR+=!S*Inr1 z6(hdO7r7Ib{!s20gv`3<1|ps5;eXKsWWL@2rg>%%Iq30#dZvJq;QEzx9Lz0EyF5-a z0P~~I7W@gm$iob?=t7pK=!4gea2vg`58iRiijD8o&L)yC6Pc2oTi}>`%*wBP;wSsz z&9#|$j?g2?z3`UhJvG~Nt&nGeV7YJXeAJ)BtK6;IIf7UD0KF41VyJsihHa|fjKQ}a#C{_)kV6&uk(ZEg z-$IdZE1&Vh>3+i1G=^5A#;*293T))3?>r5T|H6Fg-okXkD>+X=uxB{LXRwLCLh6z1n#Vex#ja82-)71=wr#9(Zm-q8+0ur6Gk>vTl6}MdD_Yq& z)_fx633mx~2sWM)M*P3NBX0JupsB}I@RT%J=8(y99&Kps#i>7J*yBIlzrrd%TKF&V zw((%5T{AXe?XP)u`zC1EH>bhAd9DM#xs!f%Gmp=Z`y3a1)MD1)^A4prZKYL&eoXVc zSzU#jKO5fQW&wyK@KT)b5|SojSZhKd~-9~ zH^H2ymiEmSi+v*o3-1$UeYjJz#k_G*q^Sw_qpJX`cy`79;S-Jw%I80$W%G)#Z05(F zrF}3I4nK-{-bHBDd>n{ihli5C#NHKF4L&+dDASy|DW#qDuNTK@z3Ek- zalT{qz9bt8eWL*!)U$_%M!oUew9;Y8vAs_E{z@Yb^sWQrd!6-uBEBd4K4AQ=i~iad zsUnZ5-~J)p&wq&j-AK`*FMAmAzZ=?0sZ?O8LDssgMq)3!tF^ty$C)@SPtXB<#vq=< zm068??-ubVI>x6XzY6E$B17CineW4wP*!K>xYJpVuRV!pRGjtrl9Nt6p{?T=;ql~( zVB>wZJYRr+5Og#I4A1jXrDK^`*$P*&3g5s|?w~A8p?{AlB9NG>l)nI{lwJ>i+e01U z|0zniiWdLvwD`MWXL)r=S>1`Ul}NRpzob~bnbP1@(IIDYQg#3xJUL#A zsm5`jCmS6t1FEJxkQe}c$uWnm0{qmhdYGdB6i=be>L-)?1M@DT#XUBwa-81pdIzmn zcwoXy)EIi#df8i#iTu61Y(;Y5Q93iq{J4W6!+%p8!l8kOY@zopeO?gjhALZGP}!=V zeNx^E1fWCI)xrP*IU7obm^|BO_eVmzgONF?TSHsG52-0o&jh2+^I&LRwLYjeuwIpV zdL>CIO7cAwv@b!g!AE@?KxV2!BZcM$RgWj2uA>B>j{=w}4xG)M#=Ob6C|{5Ady9ki z6MwP}fb(l%Ygdw)6c=3?h~}OFjo*-pro^dMcEo$!HwNQ$z26JicX$c+Z}#N{<-z?> zwvq*25AP#QDW8bEnDenu34HFLgb_j4I!N@|*GAsdxSmb+SJ?`GAyoKi?0sv$5P|=| zz8%;j3@phwV<|1y-S>fcU2#78Iowsl8-JJBOY2bH=tp^O3tsO68HaJ3ahP%kUIsn? z@}}lixBcCxW}d)kdDIO>npjEsuZpO{&dmpU-4``sLP$cy}^oXM0@3qP}K$>zf&%er*cI><{qzoMPiXNPifN zf%kte*f*ZH3+!jSi66+Xy_c~*@6p3fVY`W7f#})X8lAWoF16;Vk)HF>kdaXvqAjwv zkx4gj>eN4`-iA2!y-Io9Cj6XPn@m6Fd^B>>3)I8<%PsAkA?(kF2B{kZ2r)mZheUlO z4K36jo+n&ivfD^vUPQ4PIJt>v9DfSb?H0dhzY;!;8BZh?Ua5~rvX8j0O9%94_n%Jk zXK{Mb9{n8SwF?5Gi%9q$1k1f`_D^?3rlcDl5KiGFD$50D4E=G8WaxL$;B@STaXwl? zGVnuPL~;7i6$(mMC|$oof+6+d(};yqwE$9pe9M)x<-^T!G6rqNIt1H`vwz;Dvr6{r znbcSp^)F#>OS_o3+vl)_Q(OAJ3^YiWMd$9P^G+t6$2=c!sj|A}+%)9{KE#(!|4jVE zymZ_8oz6cO&Ug9#qw`6nT`1#AazN%8t;T=YPDO9OnMbVVMq%CSoXNS!oZB9IPQ<&0 zqul~pVoribq#js2lYjSDFzTtLR=}0?ONR#sx}Ekk+AnCKw{BI36pk4Lw7&;SBua9K zMQ?>N|7z+%^mwF-0(ti!*!W_!<4h$@PGGh-0;23Hg1@yEEt9k zlu~{P5(JSGWdTS$iOj3p?813c!bpff_*U${gwD~8S2XPt-`c^7ot189rfu&R z`2W&g`oa{O&0>%H)CQ!V397woWtS(VjQVF7?Vy5@-hWH6sCgV+`!QQ;X*GU4cdf$~ zTW!e~a-`lUn#20m{H#QNRwI$!^sdcEL&H1wjId+jg%4_SBIIrvNSAqj`w@v#Xiy5* zz$Dhe?5^Q?zhk=~f)MYijpM_ub(4=_8C!>NKH{e-LM$I~ z1wCTg_ES#V&p7KkpDqvRdC)x`q(P5qe65XfHN^iB8VLl4d@wea< zeT~1b5p}L#aT@MVNQUx0^)H)|PL-w7ALBS&IK>i&n@LsGA!K*zx+;J+U<~}9O((H> zyno5?e6*j_^pilYfiD?{*I)u^_%UF_C5v1Zvi&t@p1V^ zhKTM_jV7ACU1VQVv`4`jyfsze6P{kp_=KQ(94$OI*}Oh1Yt(;l&F6}Td5<`M&ZAy^ zSYJ%=h@<)xBaSKtht=qW1Bcpho!+`2! zd)>`ud)@Fd?9*6n@|i~Nf%`t-!hb#31s$DpF)~dzzJlU;aKAv#67Vxmqn~*O2JTZg z2i2Y4vV$%dKM10B%KSePrAN2hVHQC={Q$z~ucE%q7YV@ie}l;zynX_&uTW&YNttrgXB1%8hGNVk(Se%GFwt~< zP=X1~s9$^r3RFCc3FwstlwgNN>5Jfk!!@Me+6qsDQ!=(?P>LY;%KQa{V@tc>xU&W9 z-Wr#fEA>Qpx2=^H$NC3r-+$mb18Enq8%VoT$8aOYThsy0w*3^|uGwbEb}&~Q>@uHJQef1@6E1GG_igTL6f%h zQjEy=k2%QT?AjiqZQvPck6uE3A%7+6+izoyLwGxo$^Sg+q2}HnpXy0qCWd(c=zp-lMgR*5GD?L#K%vDF znFXIrCklZ*2G6`x0NXjxBM?4C9O%i^bCU%S$49c(<=R8%=ca_N%5{XgQ${D(S<1w?YaM=6UR)|ZQ#XJ?7%W;>b}~hI842lKaEyc)?%{Ln3}%O^o_nf&>6PUx zISzs!?gU*?_J5-jQ|nK+z+XqbC&Bffk4>JWgV(rhLrLM6_@QyxIiYK~;$6ne>HD#& z#$UlW>x~a|eD0~Vk_oU`z9iXcS{5$*V`Hrnx*rOF-u)P)Y)mw#CCE{2v|uZ0@m*DYZPlg!LS zFVX_tW*l)QL#>LF`Bn6jCSG%o65m8lA-6H9Mo!DKGYGg2xuP!YBb0per1l+=_ z9t=eLZL;vW$UOBEHp4OCVj`APyzhGw3g!XU2kDHzUPGL=U?dN`@d&ybI`t~r=~KCH zyu9vhoPQs<8Rgad0{cmpSB4NlNO0sTyzCO(F6!R0`gWKSD7^+$<0U*P_5KN6!HHUx z*aIJ$HUEW_3tefKxzP3(h+OETv90qpqg^m3IDtEm_J+X(p|!Z(sd!QGE!E$*+RcWZ zc_~@X%#U;b_D6*smq2@ECE6=&$K7b)jeM}6C2cdEq zfq%+{ar;47EtH3m0+eKWQ*$f%%%B#w!;ww^(GW-V zwN`yFisblcTuY(b)HT$V{iuMHCHH}Mcu-?(XVn0v>B+b-2GN`&M}Xt$1UZoY9@()6 zmGFac(GPw(;hnZx`rG?+nk6sLQLp;7pMQO*HA1IJeSmnio5>GYjd+OaK*UY!2bsoV zi?ZrLJYjvYMl8R%)!Jtugnjlpm|(DAl`y7jnggE{9ud_OCFcM^(LD z%9`!UylLonWAFHR#ce4Cx{je22sp3}(>j=UURR*TK@Zdfv7mGZY|t-aPMf8!RGI&z z%}6_o+EO#`EbDQEmFc&0og_HgomK~sFK*yJVmPcC|IE-SIp} zQa(4&s%J!{EbAFZH7FPG0!ADl9}d(^0D;OZ-y)YV&E8d{W(I?r@r7-EyC(cmrYRPB zMzENT5G-ccFc2KgKG}3#?9&FiCW9(xD=d6wwKkK_EcA)3fGT87K7X?vN&4km(l14* zUx?4ls~!^sW>hI##9AgB?(P#fSmH4|uA!dUsg(a(@R$`X;yPL6x#t=fc=sT_d`5p= zvF_fW$?Ho)dD&Qb>KeE){KCKm%Xs-{#C(Qs;#lJJuw0#h=G;JD0_hQ+t~HKbxjG7+2~ zHhPeW%!*Jmz?*^V`1B5~;vq!3REnfa-Hhz2mh-Ya~-Jg$9#DZGnOLTa$*7(tp8W?of(S zq}L*pB2&_*|9{)3mZa-nr{MVPoZm-v^c#iTieDXbqE>q2gj2W`S?4-zdQiv(ldt79 zn=Ld39t(FMz65%_1Xy{e_Bn0vc##5(v%?^l&_)`TB04C!Ft_s$SXCXWuBNAva7q7V{Ck zu~#W-SFBtM&ro`w!FNpG;{R@SVZTAM&)~JSO4%oNrlj@ed_ALIzPf*CB)16_XN=-% zkvump{ePYL<@F`6!Nv0EVz;>X9*_J9)+r3)Nvwv%XXwi;m^A);bst=-0k3s~#EeN! zsh&Iu^yanoPo~m?8?!OA#(~u%G%WQSZ_cslABP)5y@JtB4SuyY%ZR5@S$zlf1kRJ% zsR;wL!JHK(`(W+B(% z;a(@=CnH%*2RoSL{4L!Lp4tHAzO9hp43h8rwe($<_;Xnem^_cAD^EU80of_E4*y00 z=*MhaDdMO?zvmvm zAbo$y6m&C4nhe4B`DBopQEm~)dqly7ZzpEEC16~vR>F;lPWlCzMMJFcd=l!Qf&ADg zrsR#-H<8EF{mdRq1OSW03wuBIZ!^&P4IWu3jx3CQC3r9OVW^K#Y%|feOS63?x_{cZ z{8+PBrCr)Y_L7@936lFOoAqb{huQ;d=6ok({sPeR(@MUd=f`D&E*m zu}4GOc-^7$!aS++B=+XTTq(MEr|DG-LZJIQBv<|GyDafgTq<3+0)JF5~s~xto z$80Ie{7>L}v7=)FWBotqQu}#mkt4TnWQt9j3BT}xL+Qhwa_FCw&tp#|rGKOY*`^T` zsNhVOPk<}32pcc-oaj(66pO#ZmCVzwyy(NXgYHqRhuA5F!=B ze@!LYFF$%3_4ybot_iO!>3fm_A{@2LomS^=q%X39BZL^7A%v(%e(4UznUPv>xqe z;xC@u$Y@)54hk8|^UEG{fWJ70r&kHz3-^*j`T?x}6M2aj?UvNdQ-1;t>JCO7wFRmU zc9K8ZqhlQgtCp#UThvc_Nf1qHQI8mzL<_ORn(vrIQrcI~(XT$Ic3~88H(V3!7qgzW z#O7s<^&R^Uk6Q`AD-2%rGNMC%g#DdI>>|@XJenJ))bvD8UV(ZnfYka$o=nxp{6JJ9 zoDP142Zg(z_;!||AAeE56ULHrMk&9`F7m})-k15}qdw|&kFg?{V9aTH^wDu6Z=5Im z1FU-o|KMwkLS@HIzd#HTONjC#H;}(UZJyK`y-5Q$TsHvL zTq6dz)WZ~Ri_lAH49fE5^a#Ee%&?;V_ETOq_BwWz+WbCP#+{oPFK6jTS11CXE*9Z1 zwmejh0rd<9nrn`5=HZNCssG|z2HQ_4>`sBUN7r?_IU#}&3p&wpQAzAlsvpH>;4uFAD5;p^b- zly7724K>E}g|b7PTCMebE}qcclubXpj;{3dP&5$3$SaOi$)SUUXLA-^hIlsjY|kXo z=eV+1DclVI)xgoED6S{rX#?SOWam8&Kew>+?t_oH4y7Emme7bw`5(v~hJh#xwt)gB z;Rzx}^nZpqsp<$u;O=HV^?=q9W!C_(1*dP+$D6nmwgP>0tvOt`cw?OEyld1SVMkxI z-DyLRRfEKBh`Pn0@t@*hWu6BSMX5uxP^}egV;#4n+TLTtPek18uMUcD`9Vr`ikNsH zF|VtXr}yFwsSpz9_2L-!kaqln=5?}XrrAHbaDOBGw+4=`Li+2Oc-r0rPMiLQMPFO$ zs{OLAdXS~Ax(`}<*I47^ZPy*-G|Tvtpg7ouaspPf{^J>|zG0k~*cD)C{dpO-5VAzO zw#6x*&h61rc`w*T?A?8}CEq6!VDdimE?lsz`8tD!8&8`5Kr^jMqcIEqpmHa}(`RC+ zBY$Uk(htgVnz@^~S9z&Mnb*TX%XA{HzQT#PamMt_>FMOuM(R=J@jjQw9X6$W6qNz} zTXbwZfemonMCILATi4K>z(drC41~;5_)M4V3(oFjYy^{ejQaDuAbQ-p%RP(uk3Uhn z8rrM~*+a_0@ZeP1wVUAEfmdFNFLxxo&VOq+EAyUZU@3Nw+hl$_i_Y)-Z;#7Phd0rO zN(zIJT>;V>qY1MfC$@1iLW$|TM%!|mDAA*)>}pK_HuS%bQ9DPiXe|YBLTC(W!{6cw zZRZrj&ajIs(_^{q;vq!)!*Uvn)}i$si`%&4&Ek#+YDLIsNfR{-(zd?I(b12%i+>Va zCqmJP6KF{sP3t2^Mg*O`3{f@a+tvMjg)%-8r4^M5s-P{OC1 z&>q*-PUXJaswAqHGdNB3^a~^j?E@d;u0{j^v)S@EdH; z1gpOx07LB53?0`k9vdtr`Tj&Zj~ut!!c z{P&~3tkUk!sV=E(A#5|K0hScGchx70+~M^kazpr(*Ytn3z0+n9z!}QZb8ztC-$+To ze%Wb1*N9I>=w~D4Cx3;#=wr^uz8q?Y?WO+~lm@$ z4aW?7lUoWDiqJ;Sf6CAXa{Lk5;&q1;2~4S!_7@ykV>Tq&oXPlmwmUoe)m>TJw6|Bw z3dB}%YR=*1DsS)ZG{64xhwmM<%yo+e6(pbBrc=auX6rJmw=qQR4O zVH-SI7X0+j@PB1x|1@7#Yks^Id|BtbYUPu-tYVqAx4BSWW+A zR;tZ74xjJ+D4wu>&aW58|4YaJVvF&=_3z~I_xvv(e}0Sck7_ag@WHmnpMv9e$?AD`A@{$CQGTaCXM#vghZ#vYoD*M+wcx|ttffSKU!%Y*NgRo~XQ-}w*6 z4dZBTOn)BdlosQB><{r|{HxU0++d1^o-I-e=a$|BS~>L_XDez8ALDPduc{>CMkz;l zq;^e1YAX&*Wxi??kcnuwAJ?>qD>35d8qkPl&2ibKRFm@{B8)(Qy=wNQ2%6n82OGS0 zJb*A2k|sC9Aw9_U!(ProhIZg7$@mlXB@6xpOMmO|w(vxk8I`G)+hQpr-BwRcFy3(n zoe!pCL!9{GTKwRZrCeIEPhUszW5$V4wux;NrTi9*II*2F(7nc))JI5}Kg{HzveXS| z6ON!mH}Hoo5~Ow6;Z&QTeF8nl1gBFrr7-tS6lpWElELY;-6HHy8qhG`mD&z@xEcT??2;ArL z_1X9Lpd~H#_pOJ1W`7r~{_or0?>_gxbAMk{`M(H~Ozw;RGAWKcVYlzu|`} zi&rX(YkkXghb+AN2VL-$*7X1_x8v*Na$B#ZTKgv`i`OcPkNDIY{lFV>OT63s z{^niCM`3<`asu`vG(X?7#h!Hhxqpet=l^SLs!ia758K~Coze)9JmU=j@2a!M97(lM6el@Vj;x&i|GWWwPrhorz5Nj>0`>Llk zZ<{XhzLNR2K&^wVUtfcByG7<#jJgsA{N4%f>cy`Y*iU;C-xFRlsSi&7FMkaFf+RkD z@+FB+pQ2`}4imDGNFn|PqvgKEtpK-AJsxi>Ke9~?G4!DK#31l=d|NfK2qCTa8uMt&-*vWjX~p4m_9@U2?84u|anu{R)Y*6ZHM&%DiA zVf~Gr_<*+;s7nLtYAi&J_J3Gh?X>x@Bhr`{fzs{IEpxWw*-ZkTy=9|P1<8wh>@595us9$X&8_lB z)8;Hg_{kYjS5W%6Xe0V8m5Ev8AIq;+{jk7Z*@$$l*xMclr|v3HPXw{RL)tBC?IMvo zd_pj4E3oTc?60MdU6hnhxr_2C{}+329^X{CwGAho=n-%SEq_=Qv}n|#AoKu2rIiL! zNF)W6Q9(q(ih_cW0wOY{6}K^1XB>{lc|Oj9B0@`P3nE%TCYe!Shse}QDMOogUF*L0 z&Q4oAdfxMV&-eX)-yce|hkM`Sn%A{%fom)}uekG9_3L%C4omuTemEkc(VzWSack&IZ!UoiaYc@LTFM!EeT`${6k~kN z7UWou2|V&_y}jT05J*W%dOa*J7qFH97m++-UZ->yZT~^${i@p^6SMs(*#*Dm?Gyp_B_fZQ&TEdkOUL75 zBlI?ez`%rh8a}k!B5^;W{&}L)9}8;noKcv3FH;Nl4q?JTA44yi>L2KSwST~`w$Lr} zL2_`qAAid&%qHn6hn`^uHJVT9YLV!b@C zRlI{(MDftk4rHz^26x-A=G5^8Y@T=uH{Kl-&e8h4<-1lyzZ5;!ILZHocG%RyHx-NF%mcCq!XH={H zV}Dw|SjG3nE3qD9N<#rMi62hzW61_uSL%PMx6f&{ro#* zzK;KX`o<{uIsO6ePxPTP;HU~RnLgCx;y3GD+->IKa61LNNhlKup$!t?kq2J@FMqTW z`&PO+Gm(VegCtPxqn~3fp=S)bq~v>e z3ycwanscIv;4$~l&Z(N+Kk_; zyv9cvz`IxqWj^qAgI~yaW)mGu(e{Bg|_%n>F4mneIAk0rl@jElg6N zGc&)1WVPGCfwBnsN8;g*seg}$J4WE)E-_0$|FVcU<*fbz`!9?cb{;4wJYl z0~`Qth%Dxt2=hH~#1tgS!D7`Ue9C7j-+4Ju*kgMPm~EBambHIH>V_$d@d}cy+Y~2Sj*oF-UKd}=7p5op(-f-_M3$>9<5a|Buk>YUge; z8HsdxNYY1jqhqi`{eOOlESrfHq62PEasqilv%g_Q)lA1d<%42r)PYaxXbZ)Md2hIn zI_@dOWk+#cqBHQW`IhFmXC-cV0%Pqdj^f(HK%sG4ajht>NkoF}J@g4Y)!5C}!53ix z(B(^YKPcj}uUSPFU`nn_nYF^DR=A3_E?0z!ay#bY^*N3}et$v?A~P$(zM9UnFE1$K zD#uFy;;*~VzwL@$w1yLZP=6i!=-YHO&qqAGY@FJS_Gkn< z927yKLtbSvWy9ZJ&k#|mhw$cLdecj9X4HT4^Y$?ohktgmtN1{ImitpI|8T1-F&)>? zbd)=Jzgg0@A)wxdj374`l*w43EoPal)WDA?h8L$4K>hSj;&daxHK!d4Il%7*5-*vQ z?Cw0&=6~)yHQDvI%Dl;ehr)1&kTg_$Al_p=P^C<4qO`EkKLcz^3zyB&ASQNNHVk@P+D9-S4WcE*?;18{`6$kRBwuwWZYY{Luve0OoF3F z-(+PTV%43rEQ`9kVie~_LZmL*%$i8qFF3`e|jw^ zy)JJn!gJehAmQjLz25QX>p1}Tw?!O)yMyGZ?6gB726x;#l!jkPhrlf8@dlxdvb?F> zfq%z_(!TN!OGdxedw)pVChQ94UAXKKY#;8*6cRV-N#2M*hhBC2XD4bM3*szt=cH9L z{I9WnyhT>?=F)z>9NTFC@1WJ*bbL(8L+0=8%;yG?u(Co+qb5WMv{r_<@#P9kMB;JI z!NUmO3;65K7pwt?i6FLFAyk9jy)xh{VaX zYBZb6$f3vd`%U^7E3!25sJ}^IQdsMOER@68X?R@Qo^3q(Bt07R*4qdp+wn#SUL)l# zsp~UKOVwsEy((c+yq-z%eMt`Ww{?dczF)1reO9-+FM=Dcjed!#8rN6x2u1(Cmw&7x zb{xqIMLRf%HGbg_`1jgXlW!8zJFeyH*D|58C5d2d+!(Llu#>Rx0$)cK@D)>JWBtVa z-HMOT4Sh5CPbQ|Rx<^FdnbD03d4pXE@*abM1-pbJ@=^TXb~NQ=ojA731>#R`YicQr zKSlqyxR#`hNlPDdSJ&%YYW$w<^naY%@@Kjcsb`X_bc|0;jkiqegAvdAMxbU-Nfr4Y zM^;xVw^mdsw|D@{liN{`zyNX?eAU^-TwEc-;jS?Y7KLl8kX0Z&_+rxR(!AXDt~Vx?T-`a z9csn8gATBry;etHdQ7&mxX5MQ>^q>il#fr622;~35Z4RXaiZQ%O{}+{ug2=VgsA4< zkT#&S=tIQwTmft#BrGR_q$jphT3qY$J4of}gK+&mHdlEcn~>dF^hpl=pg-3_Y0--Q zxrJI8WeY9V{VYo!6Pnz2i+`CC#S-Jw_J3brj-wabDlM+$@09mR7F)QFEqI^QAC}~c zR`NwFJJHIk+)C&xGu{#F$m$7o6HQ!-iw+#(J!$h?N+deYPX9yZxw=JZ5v#Q5XQLjZ z098P$zl`8{UNTX%Zx`(s&_7xhwI3?4SHE58;3+O0m&EB$P}k9dOu0{4+$Vq0l(IJ? z#$~PX?Z)&MyZrqD%2J$Lus*K?g3N7l%!x|7W_C!-HtwHG?JavJdWQWm(T3$!+9lbc zh}c5wcwU$MD*Edc^!;CppeAdFzoQ<1!sFQ??hh9CKU&Q9?_Wdr3+vT0H}+SdX@5-_ zW!hWn=5+^s2e7l8fxa;w>k5D0UJPp;4XGlxAe=}0dZI<&6-tYQ$Q~->F}66DAs%Qw zL%$mJc=Qo`_9gc)ME_{lepi2A=;L@?Jhh*OqrJ;dg|^f`9}CU>&;1Y1hSfWr`fH^T z;CLkIBZ>?M@`xju2XfHZ-;5U?=z8!A?&0MaM?%AKoG+eQDW19npC$ z=PPLwkvDG}tep#sc}t(5GeX+_zP#D3AHl_9AMSuBCfH|Sv#74(X{l}$8`SZx5F^LJx? z{!VH{yMZq>AMv#6g0#vm#rLmUm9^Iylcd0+~ z(_w9OO*qWGiO!#IG2U}rV^;Z!tYvZMQshp0!=4vXj(SuBQXyCYPJz?&M;VxxvC&`=LBXpv3k@x?bJ#X)hU5-u?6y=ey00N&cR_*lVXJ(gkiDH8(zhE=s(l* z43G7)Ywk*hmaXR$WV$Fyzi>V_CMY}bp&ftMX`*t*9MW3Vv0jKY)PB?)CID&+uzCF5 zwPdqXTwUdW2n$mNK~o1sw(Ul?zkm5H7cHGIrf@XU4lk)S}n7P z(5!Z!#9Ks~7rps4y(wL$S&en>!CIqpAC(xL)8>^J3q+k;b}yENx386k+O?@K$i1%g#G35)biTH*?CzB{ARX#Gvj_F zA`@`hQ=r*HwTJzwlYAgq+c&BzoQdaWH7SeV^dnTqxhv7p`uKJn-a_q+7M%~sN+33o zloUM{4gkgXpsqkey$oF27mmqG!qpVMy4u^!@3y5E=Uo8@dkJ;*#ecCZzIS=7jehUaavB7FJzs3DRM7;H65pJ5R&3_()(LNKY2WP6^2>Qz=!G-LEv+1wptv1I`4oiRL>(p8>Dk!PD z5tQ_ug@ckdkOb5JlXy$LIt%Yx{;19Zsx%vMNt`Du>MV41ei9u=J?*Zj+{@^A2U%EA z_f{d`EhjK?BSfu?PxQP?*-jf7DD@o2&KmK+-TbLUu+vyrHiw{_;~qua8N3V8c$A*> z(@FvK1fHqTx90d^9UFh|Z4rySR^X4I=&kM#8ZO)4=G~4p+bkm?%0p`n+{2Ov{!Kpf zdVKa8iyoidGVt-);0${oovS7dYyQUU? zDy?XUcu+kq8lZpXx+?Es%}zrWxZeetfCQFbl@%fDehpz9BW#_kl(RiCGZpO(ruITBWqz7k4S(WsQzb>s+nuE<>efYBB$%ixv-1xr z1wXJvR_&`LrDZSuJ-a*3JMg&z*-1BdwTW(DxfMQ-js7Hf7Kj4Syc`&jRvj79w9e-Gn%bjNc0d|p(LK4qBDdLt$rr!|K5vuh!Y zqi+8I(yqD`S2{=+1@bHDo3!onzQCVDZKf8Fq=6g(3z?gp{2tc_&GApP;RUziEajY{ z-hsF)9qDD0FA5@iSK?Uun=llkbvNCaG7U{<1IX3}bY3ii_7t5u{_amMfp~?h0Hc4k zY2AiYg~3LVC*>a>he#}mU9FZ%Eqi}UnK&6khei2>J5J+)PBjZ-IRmSE~JBt%Qn93Qjai{5T9q`atbb^ zY3*KlInlVx5dVYBm$?z_C@teojQ)t0G{u;O)~NN0ZT@O1_se^+tQN1we`!fo;k2Sq zQ1=rJ&*0x%&G^#}Q+{Dqezo^1;w8IT35HwQn=I1uw1zlwpa*$emBx;!Xpw*6;}cH# zOW&zq^QBNPf~!3}oq>yfmuMow|Go>;r_Lv4|AfKUWn9rO475B*NJPWqIsSXETirxD zTg}@t`Hky|NSv~RF$TW>6CUeH9pB$61GqSz@JC%jE@KH<#2zf+??yx)aOXg=U;ZMND~uAcR34cfhY2es zh1Mb1==p^JwgkqIv&TcEIF7;t{wV;scKI{P@Y#ptXD_GEy43^-Eo&TszF~J@WGO<9 zlXZFgVU8))9=e{om%by9>urwu0_egs?KW*JT~0g1x~q{N%EJvIDxrS~#<3>`ZY-;k zpBxJeL(M9`d`}w;xKw_J;4igOev|c0{V|cerr9xKgOtw{QsnKi z;=|PVo2NwMOLMt#qdvG^7owZf-vqK;N9+-8s(kvANzBIhL%{OoD#!0#!A%73pbLeX zKSTUN1}A4Eo%$?RukU}{(;08ko%Wx98fyt&X~f$}Ia$MFy)y;AnY~gn0`>@cK!6(sHmqh8GpfDTc(zwfa({GfhQjf>Xr4 z<1%HgM3Q#?0o#ATLOs56Po2mw(EKUl`QGAr?Iox9-C4drQ0N6j4V)a;PK(!r2O;7u zA*uzhj>u~QTWXq(j976(Fj3EMhO@(fk=IU55(Dmq7|BABr~#~7^{_VaGQI_+y5JHh zRF}{*yaM^N>WscD5*OpVea$`Kysu>m;&+0QKS)RY73(P9ogv@NTPa4v1W5il9P*cA zD04w3hq-@lWmXxBSOPyoyZwqP37ml~)`eI_S~Wd%e;MOXjbJHMn{lV$dd(Rk!!fGF z;7doF3x$XD1G=o^Z;S86$nR}-4CT)bK}g&V^T+qv%^x2S{qZkv<&VSNw-y)61&e=0 zT-L5j7JX_VYpqA~%i)oJ$y*WqGZ^Yr6@|w&#HD|pBHaaQ=A=dOmLVQ>KT9K4T^f1u zw{SQUb}uFWZK2S0|ByqKibJFiD2vA@5l{W{D(;x*Wnzty;c`0$Q$t6}R}=R37BMa9 zbV7uX=-Y4AdQ=)h0O}8E7k8-&YgZ~ffD0ZnLlQ^bG0deNb0OX1gkxx0kz1|frGZF7BOdjo81c74mlk+rB;3DELsLr} z)qRqzd5I({PD~;xaqej`3q25d3Om}gb`EJo8~V@sar$nVpC|LC80v7^Jq}b1pyzWN zJkNn!0uR0!6NcD$i@*V`UvTr(=%{>Ifl`03*u{D(EEyAD%T!g-va_e8RIb` ziWbF~PiP~1K>@^HcOHe={+LHS#Ww7c<*~xx0mgkDwXW?!&oabbt(VDU#^V~s20DKf z*>dYOT@S!o6lh=J2{a%1O1wqg>S4bl4XQAbkF>|~2l?1tttM8N%KGRx0>X6u)f@mo3k*#~Aq8s2>#^Wym*TnfYwd5ljg3(Y$oAel!c7 zb?yL2?S1)G}fYQu#rhd5gUDR`)?^lj@Gh}%gL_;vq4<;8y^}{I3^+w5bt>0Ga*I6b z+LuuG8ab~qvfS!7n#i9*o|bhZ3TF2G1M(QB}y^>eTt!@q;I~{#~Wit5& ze*QKKPX_b_r@ArpU7-xH-DrO?$&I3{ecUm(`UB0)tuKpRWs`J=^^4=#{8rMW>2X+2Lp^xUUpCIpJq`kX$Fw!B`9^laiL#^u7jqMBB(CeUC zu!~ZE*wLsF6`Xszk$f_luT-InX*Q+cX2wqu$zc;9w^`YWg1XUnoAG~^MRLQJ0IfW7 zs=@WYoknt2bpDCQKU~z8M8?;-ZhtI4Ik7HMPg_$8t~n#?*=}YK@8IS2ss;xc11ehD>lR$}v6E zN+C&L3P}P6T4(HwX1`KYy#+oW05lN!P+tnEV(%Nwug3pETp@q=Qpv9%5qy0FE45Ov zB_`G7w7Pk>X}d3wHVQg1Gp&sEN{|2C1L8%s6fd@e5+UPg|8h}cqZBNN&fDcABWk05 z)$?ezdU>?kpzFDDJ)hLb%kut>*To}{GloYaXNmT;ZkaZHsxGn*_v`!cZ@)0{zwCcgHhXRRKpMs76~kBR}`!9BXYWu!eN_~V%d_@4r=Bb$ANO8ygIjp`;*)|YoI?!8L*;TIJ19aj=C~O{kc9~$M`y-p(lSLgU;qaU53q!S0n4Yj$k@yw>w1d zJ~ZkA3VI#{J%1z84+rg!9HQq$$(MqhFV6ADa@szU1VZl>I%$D1CdP!Fre}`dZ^|48 z@I&x69mhi?`y!ck?Xk-uE~tXYKGK4MVY z3D=pGx%+=T3$=|0wLOYY_p??tLUK+1ta5+N{lr?u;WXF$b+F7*V!nSu3e zlG{VpNP*Tza;!)7dficR0z`BjBnRAOqPvq=5HQnSHpWKL-93Lqcc0wBboc!aAasA% z(TdyrEOfW~2h&`={;<-ex&6IN^6p+i7FQ|-OPMT!g(3ek2fB=qV|BXt4d?r= z%~5}Hapgg35eB!0ba;V5hl`jF(|YZ2t2H<+&WK!Wg%NbanJ7IA0UC%C@dJObztdZyS`bgbLcI^cc=262Y z5_b83Xk7L+ak~Az7=KN$r_iLd_Xy~1;7|lIKUv5WJ$(z2)h~-x<k!oJx4u3hqOH%(oTOkpWTCyWKH-Vy-oI@ zZqgpK8H-!oxIM_n&kwP%KtGl3L8TFU(7(*~pjQoh(2pdXJhmX(9wh5@EdgGG5Oo%L ztktYy>i$HpN4E#{KD#|A751QSHwt@DaQx}0`in+f-Dy#^z>_``HlA6LywHf9=j0ht zuPixOeX3Er&BcEZ^jqn6oASD7d`M}(>32q!Ut^;R3~LVfdm{e20My(^b-N9UCk3ZP z>^9l{+mhLKL!Y`BT6HVKZu5va{@SqLyu{^tOBt|;>y8Ies-n{lfKX%_+n!gq)tR@KzwhmH9=4!_hm zKU}o_ulYN2AOCCqj;RfvKfAxh~Q6WZzAaPsDVepReuNSk>2e8Z~Hs4{3d@# zCuWNO4S#>fiAMP0zLS-I*548SAMkgys$l-s@fDrFJ^L{8w~wCqH~tP;@yG1%*hMtF z&tnmPN5@9|9UpnD$N#OrW2V8^HlN+!;f?lpG*|2UJJ$TD^S8Qam&b)?qWD{5{*Fyp ztpBFJ1N`k?wGsYi_&X$T`%nEHJAU}{{*F$9iT!^Ye}};f&*JZx`Tw-PW7GezzXJoV z`S1BVzWM%a{*KqaH~bx^&hGD+DLALu-!bmhdj1aNc|U^#YXa_zI6GcggE)sp4<$K# z2dvT{cho8ja%$5tY<(L+UypF;h1Z+vsj~g8RJXq^mH2*LACbnl`uKjZznQT8 z3MH;zL%d;itUb{c@T`TmgQ$T05m137yVHNb_0##tR;wO3C&B%q>^2f_7*3DrbsRrs z*w1eIj*0la3)ye+`BTzw@!hm|i?&Z?8``qEi2me?=ufMmKXE1k%w(elC@CeS{8mlRD342J#*<*jx zBoWNa2dQEBhIrm{O!l^uf}>2ZM^vRkP&j5N-$a?){$&*ms*^j={x^rZmiS2$gPgmB zt!<`}!ZuR)Hj)j!3H896cg+W1*(V~>xgPkG)rKEE32u$#Z1qTRUwu29NG1~J2EfRS zv=>}v#@Cb2l`t_(Wm6&Y(H-iM&^mwE<0ja}E;@*Y?z7;}UEC5Q_f-WSsOKLMboM6L z&rX}a(>Pw@9R^+^==xfvU<%vu7%!1F1wcTmf(Po;>v1~0J_LF#@%wHFGyRnKf2X;f zBQABVM=cJ$8sVQNdz<${P~aqk0=F^IX&q<~vWGA$iUM%2IMtvZs|ScbmjQpf4!YUh zBS_{*K{As=OORhfJ81qBf5u<&K$+pM*k^6rUvaJPtp19{#ybB?(8u)!Odm&-66G3d zHPOfS)sKZA93frzu=E3HPgedEcJi<5yR&F$Nq?k?2oud`XdS&^DCs6GF`m+Y2B~z)npcK z*X1)!+z_RopVg1?d_6w~@*RUKO#Tn)mw3obA@6VKm-t}r+58eQf8>{lHTxy1Esgjk zo|=n#9{)@Jh?aBNAJKn~G%ta0|6l2k z_;Wspi%ocRy1Y2}v9rpH_Z0srdGXHKe@$LoF^B14zak<~ea=)y=-~_BHDigizQ`ean+s&S8X}Qr2>#7=)7sqw_xAJ1atpBpS=$-XnmlxX> zFari}!z#y!hqp|8aS7@5BE?^5W`;|M%s^f|*iYT%gN~y_f(0^5XxB zyeQ^Z>-;TZV%P}&r{%}@AwT|+fA(;Gz9@gC4H{CGUA;LmPOm64MTNB*yN2f@8^mPw5^tX0w#NXP`EZX4`wns~UYgv7N>mS&oZ=L=>XpheM>fhR<>&1oqf5{$g_TO#_wvF=N z{z-eZ*^m2&_UL~9)_?ow?9taOI-5PZ#UjHVU02_KJ5xm6H}1dPqMGf|(ZyqiGo!mr z^0{lLo~;g?Sl_M!FZ9uFRg>1A{M@-ts#YK7%8BS)j(MK3VF_{4%iMW<3`ORX4RubMs%tlU_8wv+g zg&_UZe)@tzAb$t(OkKj&DTGFa$FxOXU}@;t6;`MWHZ|L(#cXa&JCR{Jzw;7K6h~XI zE3U8Gp?!ZI!pBeKHl+8}b&b}u75s`-3SACIsI@!L>?b<>ZSvwdMGrQYC_P1)|Ax_? z#GEqoza176wXNXkIOz@~ZFZ?gAcqIq#O3L@Q!;)7fG}*v=|3jU=eBNf==Dsa;xE$b zMAcd@wT7aE!GpE+>*#IKqj!EZMelrz=$&QebN_$G^|c!3Q%b>WwUN3r?)2|PnPE3( zsEQ%^w9sc@P0i!xHnqrulXi%9_R1Ly_;lN7Ql65h#9D%Fg&t(sg?5`YybZiF2BUD% z=^J6i@qiRxp?I;lC-Hq#9>hf`*9Z-7z?h7sIo1OXbG;vjT#&CUrdaw9c!85DV9-g; zQOkcBxr(d2FlgIMVaVwYg(k}-kmbB~Tgb+KRM4ARCBK|ELr=~B8B=f$-M0mwtjDKN zhnD$of%lAvoN=dbRtgfhu0<_L;WV(|C#L!@dcD1-4!;d(Vwq>eg0lgp2^W?5krA`p zLVW*FuBU$-n_GxLzKGYK71ox#xgo#K&!>Nrn!t1I{g`&8_x&7ylN{LXLa#FBmdLs% z>X|BCY?uH)Ccy6z^1dxNC7QSi{1540n|@Y%N%|*$%3d;g@*mnu8srl_HBschevJIr zkcnd5^G!p0$?=-XD0>NAQx9uTG!g06n=hk zpSPdrc4RcK9*KeqQbREjyeDBV*{It~zL)lrXCF9A{j5K=^cT z{6pF!^eJsmMP)cRQ{w$dd&(iRJ!OBl*`Cs2{Ui)|s}qGj&GwYu5qnCcu9wN)E$u2B z%yyNs#_TGePJ*h`h+V}dw$(`3Ra*bkV?7=IC6X@!QwJ95^C+S!6edVr+ zkgI?&_dyUMl?Xh8eU{6)J;gnu>U94?_MGQy+`LJxUVvT<&b}|C~OeM+hPT=Ol-wuQCX&G_f=Mg(~4+~pDps$#wht$ zNHW%t-bHXgcS*s_yNQbklTdcS{VbH3@j8|Hx#9mn9&3L8S>-Wo+_TDK@m7;OR?~<) z_WONN^4PS|4P>!seM`z?uho~wFgd3BDMr4j{@!evmp6?Crik8Q;I4mqzr|x;nebMX z0)USB-*Gvw&f4xvFy4(Cy&u#vrYvg z%zStVn`V4>$6CHZ?X!R2(le&`V?%BeNsT-mcY&@*dWbs5!NHMrHOX;G{uF+LcJ#gM z{c6IAlK`#?f;^hVx|tB`CP=Z4OPd<$jJ9BVv;PYf2R7fY#{&!|abZX_Ud+93@5(|mD;>LCNi_}Qv))l7m*kMlbu&r34njC<6Q6fL)_jO(Foa& zt^M=ua6OoqLe2j+OBru^n=*EGAoHBTJinLcGAc|(Bl77nJ+>jxb>DrQ@6PsUQMB2k zR`d8`#Q2h>4xBGWQQbSqn)f#+*L9)+JLaAdL;hY2`P{pB$j`q?Wc8`trt$9kBtljn zwMZKC3J?id8@bwHlotxeg@lR7QbJf)Qiko@nf@5O=V;)+{=a|2s+ZivR zS3+wzU;cdjSyWhWJ|CX&Z{{;myZ+5ToXHhpCRdK(naqEAgJ#mT%QTZOeH@v|S>~CX z_pvdPx5_zOe$1G|X>txfJZ;S3r|+G04)4&qyeYO?y*Vs2&0mW*dH$}Rtj}NJO+0_^ zjS=%#)NuZGzG2MYhBxH==~|LoJu?L553oH{0F4H^D&t9l9Bdy)^UEJ)XNfS+XjQMv z=o{|xXe0!x{*Td6g^-L)CS?jy$YrW!UR5?kpOb zq?Y;i>Qv!0reHOrUMh>$Yn`>)u*2V<$a*;x6b^rQQ6Yu`P_KlTNo8(48;?_9zA?#< z!%$a2*q(sL%F#fmu|V`|oc6D}NU+bkSc`!0z6`9}Jti*SW8EFzt;@F}FTN}5FCDQT zZt5aX1)qx%8!F8vAtcMRp;fg;F7*2}0-&8{_n4Th%$p!^CSmbQVKLe_JK0L|1spDx z7Q%n^86a|KA@g)JE3Lnnq} zihqBVPm!`XJ1Lh9_2T?^7t(S*I+_=^1wEoQ+m0h35kqhPFfu#e#<9Z*v&cKF+?Y(w z6;ow6tm5Kf8Rw((0O`yO`=TB}T-D^arCEPzOdJNY)1`(yz@aWR?f1j4f+1DYq;XA$ z6IyL&Vn+Wk`9CCH!w0g$0lRTtVNqlgJUPf8zAIjwqM(q+t`p_jf98EOs{uawEY|z( zVtL|lVp@Yvz<8r;tY}KcyerfM1RlmC$JbaZK4Ca&=jhq%a2@No%B6S z#I@jgz#ue2EgoS-y=1Yy? zMcW+QBlNdynlHEi7Cql;o41w6-xM7!7#3A8LJZ$fbRY3QehzL5%_ zM=O?E%Mx?ak0}L(wE~KRL}q`@qwWa4%JEy=MQ`(L+Thq61;5nl5^Jea&^#=n_Pcw8 z42apFMHm=*-_WPB3_Ia-`0$hZPI(A`96tDCa{PI`&hOEo@V=Sjzm`6j_eAJLq2~bK zQdar+ad$0uFgdvIlpgP;EShO=m3Byb<2EK*t;aG)`nI3Wkw%P+wFH01p9J|h=#m~! z?YWnk^?rP>&U#zk$gKBTJp7aye*-mmu~m4}XtO#(D>{Xpx)T_dqfbZd9X#2zS|mmK zv0yYSlhE1eY^8EV{5}`H41^FykljTczq%v(k~yLu_u#`3)Ptopd?|%5(Id~};yX1s zF9N@QQxtyv+}~gU(bj)m5f0Nd4Q4LWC5{cEu}T5#i)>Y~&>#MXgc*@Y+%c%$*y>uW z;hxLijzY(sus_%HRd&VY&rjfDhAB$BvGz&y$7maBxnO!WbCqjLDwUCA?bGSfB$9ODhy7U%4UyFN~^i!q0r9sM4ieT~w*u*0MQmgGw%Db!0tVY+t1E zy$X8!XJ!6qZYOm`rE*hIl`^Z%v|HlPrObE6p|)u%H8nUy|5nk{wNtzE`_#~(T&I#+ zROwV~&2#U;gF}CgqD_sitSC*$%~l2j;(R#0J@hcWU243iuApTZjb{&1UpL~*^o0%7 z`l+d%@l=JVCYpK_oj6Cdy#>#&uT)l4CeXttDwW}zsNoIVZShLSJr4CJ<&p205s%tO za@|oA%W5B3s=~CvM>|nzx74M4 zjH1hNn)lXNK6Jd9YT~eQv(v&HBiR}rK_XV;oJ98~IMgzyT8YUg$qQG;qT@8Rw>V)F zJk0t}R_IzCpT}2g%}ZiDX^-6nv}qUWoV7@@a{0CN-EJjF`ON&-n z2Fz8GDp-HvnVze(%I6J}s|=@UxnM9V+@3$!ZbS8N_dA+VJQH6UBp0dn$K~9{iCXOwl^VONdrcq#Z2^@bp&t zjYNi;)f=#BwQ<5@u(4%TScgr&XHBIn{f%Ds5Kn(NVLj_eiVRI)41JPDrWAb4gyo3V z1WBU2n$4l=1X^yoi*4o~kCHa?1${{#ylEK8=Br6I=XeBlRip7c^wxu;n1o)P%>?OU zdMmUlH)7AB6(*`S8q4KKFH;KY*eZ(cK({7jt7m|U-1TG(E%h1e)Di5DrY(FS^4Cw)7KZTip%^ekYJg1jVpf;?;O)q5=n1NxPmV9pbNr;bAaQlBKhAo zclu5xe>^e`9E$CJu6S?>?T`tm6WC&;JyAPR6JrrunKl%A!r4Z!n=jiYVE=X$CC#RM ztUm`yyOPWGb=2u3^tdStB6!8x^6%wVw+T}K7qiBedM*Zq6^>{-|5hcp7K&x;w(@^f z+FCW*PusDz!ZG4?CI2m$uYF6s%)5USHqPl0Jb^&h*G7na?c{ykdob}-NUL;Q-no;H z%N+4Q8a<%dar*~0v!BrJu8y$;pQS#Q%RXdYcp*13YEUezdXF5{NB8))%5d;GmMFnr zFajpbHja%*)Rr!mON1rm%S7Q4gHuoH@{GCW6-=Z_5SnkAGrLs+vHCohdYpfRv0)sw z;2r4kPh{b&Z%)7ixis^JTl9KZk@&Zpt@R2I==1TwtvuZKd-G5_4~pdq^1hWWPhmNwjj=u%wZvO7MLJQi)`jw-;-t2dNg5t8Nh=#lmYKu9yVc z+TkKNs#8S2Nf#x^{1#DyjM{&j=aDX5v?t;>MsmOU3iIy(E92W2i6E(t!tMZwIS)&6 zftJtXE3{QoAho7)nJC(~-Ie^7R-^J%D)wy(&p4`0-U@+8P(4t*Ql@`+$|!tmYAhVc zvsR$Mgjzaf!fVcj(U{|3jot z2n}GTQg8z_rPX?j&^as#7PMeD1mN>MINSH)nYB*;Xb!xB7i%Fru21U`SCH$2^AMfx zzbP4?%Pv?CF#IBb;d6fwL4IffKH;B@(6+a5=T&)ULFhT%f5ETaFRE z0_So0yR6bW(Qc$E$nN2_Cr{q#MsS#R=B8K+DqD@UP%mcJHHa_3Y3hf4lo9Lgk&)o- zs4S{sv*MVWSZc}`#)sm|bX|YAc%Z4Iah4@GLg=T#DZlf-wA6n^=J+h5zLZm0bl6;A z>ii!nWr3-$H&%)QQ#7}T6QmvEt4&ZAsPwn5wuw@ZFGc3Ula&zYn_*9{#9mU%X+Df{ zL+b{{T6Am78Xlfgmc8Ajm408zwx9dH7XRLLj!bDQ*RFmh97gE^68BbUf$UhzjjHpw zMK43NJajv^Q*eLiK|7nnPiHcDNE*;+Z7T~uv$!WebF@E+3O`5A$DF^3I#cX=zfjcU zN;^bHt{GZ#qq^ySRJ&TPU~mS0$A(%cKRra7FQd&z%>GL@76T){oGr%Vhe*WPh^g3c zEhq~l;yiqfA{{|pDb0y{1tEVqhnM||013+}t4(&|DKCFS?8K<{hbmxJhSsM^%u=2y z)8?L6r5lVNkS4AL``9|{QNzCdR{E&7yXJp7Vl!LLb_BCQxA}s49tnM3wa;q}ocj^7 z^-ed?$y?sQ4!=6UOl3%?aicS++xQy=lN~{7ROv|8$iSVq#-zk687@kaA90~40YCOW5rorqw`#B=` zJQ&!F*|dv_yjzx4>a~Ib8!EZTZUOzvrlU2yb=be~WLU^vCEDE^DrGIOUD}8Y-T~d~ z1=Jh%P5pC1H@GkIsmrL5&`W4yOUrP0If|2{txj7{Qd#o4T5d8ri|Vseb@2BFGM~)g zEzp0fpP-bteo)D>;bpC@i1nT%&MDoY>AgYTOQ3tfp<%Yw&$xx%kXNP4s#d3Nqz!UC z>_GfVQ+g$Mjj>a#14IfRYNur-)lIU}O6^80k z%~u);$wF+Yw*FaZetefNvP$>Ss>(2mdf$KJt4Z*VMKz34S#Zv~PP%dqc_&E!&7M7# zVNvnvh_>$uEY3lFYtyOuX@0F4H^X;>0Pd}rJ^_B8{>^iUN=hD>f+rI*XlP5WE@*{R2-YP zzvfWGk$R5x>mTY42-v^4k1hW`j6JTB);x0^O~c33ZMY2)=Th}3=AqCrRE!@(PZ`i) z=vwzC=L-P=p%fA0bn z->>I?2O1x6wlKWmWsIgP=KyB+yRjZ}Y9N`iiYCYmGB~wbzT{JoHY{j1ZUT!Rxt7Qt^!K z)I?0)ho&aVyrt9xi9Dw74NRsN*3bAjFxg7aZT48#yV6&9&r@2EGTGurXgFEep1qRk zi)y9#X5Qlt^?dNTwDtJI#NU4hi!$zNNINF28z)broSS!ukoTMVPR35_p)5vOA(Z{v zeVNC{7U}s7CF`)ePS)kQ^Y~huB9JU z4rO9CD5}ze|IV=~EnI&#hd(>nK>|Q)wlA|398TL7B9>?+=IrQkTk;eq>9904J6T)$ z!ot>S?_Q#{Y&AsPX19Mx;*IHXm3ga~{=?4j^6zzQc}NU>DfEW&I6G!08!23HLUnYj z$k=QU-k|#{Cj#9cEx z%)=XXh@jBg3fX@`bB7}mD^znyIm@-t3q&AvdPpgl%W~1LO8yiiZ0Yqz-RkZovjw$h zyaZvy(heN241YaGOr}dc>{g4?ipre!*_JBT2lSlw{N7lLwjMy=fv(T-2#oF3B_?9o*wZ+E(O z_l_{#V16IL-_I$?Gtgi0Co4$s?prJ@vxXxgQEDpglKdEyL@`N5c&#NOQG*+ zOuVxAI2!TKXDS9cagxw4wA3WFB+T^pwmGPsdh~s!?aM=N;?Mg6R9gbvFfV zTvR`y0C@T*&Hi1q1KW%5e<1IR@A1caYT@HB6F$rZCEIi4f;S~? zo3wx5WbASg<LX)IX%(^3^yx2COU zWrcPYJDWYRDQ>^TKgp)qN@!21h{hRdPk})qt;ii1W_73UQhZzajm^FNo^Q`^y+BuB zI5B~wQqlb%T>fT1QqM|duLFI(6wD+|157>|MRw}rRvkD)!XeUXUBx0-{=3xL%K(W7|p(YqPKubkhNt|%K! z{rE)U%^QVy;!=+fQrC#e?eY0HHl@AVOt1=n=A`Eel_6XqwSYkUxEpns#wJJvTS?Mb zYnd~ z^WNhE?$A!;=WyoZ0qx!+f-2s;lCxiuO#?@~9Q*&dexywbr>T4CzpZFI@}ZHd_(LCm zEzm!d_dFZzlJ$o4IWjEx!>q!-)B|iZ^pk#H7@Nn%3S%=cI{TW_hzg_P;k)_IODm%J zdZx(0CpY4*m3-viGZS6N#%?42I&Za!Kbzv*gHg8s?k@lBBGKVHP{2UO22bFMy?u21 zzL8(^zQqVrf5v0o8{TW+Cc+~9t;H07b^Qr9&h;6>?f+P+TzxMakZOMFP$dx$SI z$M=*ZdeTn|{3o6%6zYz|zmu|r8a8=vb6^Z?-6)P4S{3nE4wvn3^KQqQZI+RL>*b-f zXos6Dsh4l91k0%RHy3crwu*PrV+V4#*LA zAg+d;W=5P0dmWPDaIkS`JXeiJh!$Qcs}mLDMWRQbiZ6U}K93ex?Dy0suOD3}#YVTk4aO)+q^1!b#(O9}7()*5>TALrADgCFgUDj29=6Y$uGdRj6N)C958~lVgNLQfE{@${R!7;ab#H4?Av5SDn zK>{bEPgIhMkuPrei;$WqZn_B ztoTQRjLJ`SN`jd!c196)2D^fu5cV+r`;Uur?#+)bCYHAEWjv~PqSJpJF#YcK=<^;_8DAlP;(uhUje@aEk$^I{S1IVj z2{1c_Tu=FLWZ34fnN|I}pa(MF`- zRJi?}I0|(LDBFtY`NlMZANgSceguet*ii)^!HMeSTpCAWw%?u1Cb=vfWUiYDWDeEA zf>$CRFxxMG><$86Dw2>1ceY3U!j8@l2xOdbL#uS!M?<VrHwlMs93l~?2b+q#egluMc{Ys;r=wu+8Q}qj z;9Jm|8I4|^4Ci$q$B_nyW3}Nw&jA$$^;!eJNLh}5|0-%O@6*syD8`5kf&@MeXP!PU z2I%t3q4+VBryKZ7g*}N#73nWkMCTc>vOJ&PwaC98m4CA&YJtdm*jS z!aWp!FM@MB(YDJ$T$=Pp?~nl&TciX=M0s9M5apyNUG?#c{%OW9dWy{q%_`i${yF7V zcOmag)L~WTf5#+#61CRG%dK_!+-2Pv-mm+`1-?vtj7hGm;r6`8iO#H{*BPPa>-Gpb?;?8B%)i>PlonU5y=#& z67tE-h%L>xKW-6`7Rh=R9wR4#xsk{eI-kBnT%yN^{G8$wTjLpSQq^dyCcS?OFQeNH6mi5vM1$WQXjS+wU#4Xw&D$!h9W{@>rZ@MuL)W)BS&c zHm*qbI9hgs^BthCYfGpp*@ek-3ndT^lG@-DOfOLi+SZAUAi9U(G1}+x+Usc|*5~S@ z;V{rzi0^;Z2;Y}-)ZLsHa)(Df4KnnlVYgs8XdvXEC%~T{)8#3Z1uoeG6yym$DDZat zlOp-b)yP+7bkx_P>x~=}_?zNuMl&dXXdnE$^ye8v#DKBC@isq}hR2#pKIfzkGF?00 z9O;u_1(j;{gGAlB;?_*Ix#b|sASlnnwIb^MBa0}jSwHSaj=-=s0&4r!=5##oB$`pLCR^~~_ zd;-;C$|sm$uzesW6-Y*Z=*jBcrucq_={TB!j1LxK($&Eh^Lm!^~5L$OM4(-c^u5N@N1S zN1?C9>7z5Z=(liK-?PElj0AT&eq4-|o zl^tyF#L?GrEBwih^c~)vyxpAYVJ+>-SYaDecfzQ3*_9xlJd1W~5Q0R6uz8F66Gkp(#J<~eSM@0AL-68SC z#Q46b6L4QP%%yf^xiG0E^QL;=q(AVoGQy0Y(r2y_gGklp9b|X(xF~OQA$NE&2LsU5 z2EUGu5JP^2w5M)jsYE^D80=7g7p^{SwmlZfY#w+qR=`a93ajVd3$oKz=cqNLS~=Cd z9uZwI<{;bk)DrD~Ydc%?5*x2)r|(bFaY^!Fy8}ofqj3nUo9`rT%$d9ijyqJQ!8S-l zuS$ss-JzfF%AeZTSI4ru;-Il_7YATkn`uW{J>uf?%MvhYfY3w6luPa8Og}y);~SpK zxhv6$dY#oTd(>i+tE*?Vp$B=?O~Q|O5ER|!2`uHz4>)Fj+8xDGicApxKAjg%El~1* zPT=nID+t}LYZu-1PTHBrVOl-mDn1aS?WVg0heQ)9$7}ZBQ~@u2k98Aub74P!+yNoy ztc!?c*K{+9Wl{Dq&0>vz-+92P1?2`^*}ap zRJ9EB^cfzSQ{Bxp3qj^KqK4@ulaX)0Pz1@^)VAW(Cqt+&)$VQ!(pBo6!R9i0y4ReH zR15K6=#}E{+vUFPN3^(~Kch}eq}E}Y5G6Ox7NTUfE=ne{DA^7aDgCtK6Zno^d-uQ~ zt1A$Hhv~Jb?O#dX?7ddqz;<|=Y-f)*#q`g+j`i9zV0{B~)Dyu6Ot?j;%?ZAU^<-Tw z74h%A%HnRYdIA%yac=c{ms-`U%$aGiLK>O`Y)8wSjPor@!2+?YaXIO~kvasAUBKIt z7?c0FQ!aN{&v=BmWu2# zCgvTljAaV4_*W9C#<09$`aEdBXf1SUEcbDAnZ+7>BqC=^`?u9>|Ax<+2zOvGqsVN3 z>|RsY}`tHg^PFlOXGEIHPYBm9dQze(bs_BPAM*GWlMuQ$1*b3A9G4+JeA z4M}XAVduRBIAzNGl}t{?N1(A~zsEBS>PnvZ5rU2^wg_7R%#5x;`w&Yd9$_I6>X=ZE zJ*vnIf!A+(=sa030C+|rB|pG3(L=j`_<+DO@d%-b6mp!xH&55cLuL6GG~i*DjL!(1 zP{W?zSHzindy2b2wM8;yq3pCb!GC_ideje)Ik<6QAqaBf?Ldejqp{b=33_l)QWmyFV zc^PH|fC%71cysCh@k+tV77=CFC_~((zoAQanQHds@?dYReIeq zoR>w=n`q(4y+-WF@AMRZ8x9|e6~P;WR_H+<{DGJ0vZlNv#AHNuDT^m1A$+mvU9ycb z?daQ;0!`ubSg}aAzivbm|Ma$uU6~RqVxG=ljZj+a?4e5joEX6d%*}o=)`(_)fnTLl zQy6(}7yS8i6qdkK8-zAH#U}1w2I07>4qjl?PpLm)7fh^QLY>3RNe(D$H6CXthc7eQJ3E zO{+HxuUvYx4z&1xA^d&$u{sX5Uc=ujLF}8$-(71)m&M=H6SXis?_R|^JK*hqS>v&WUDh95)*rQ-msE<# zJJ*;)E`LVQ6UaEk`iT1|hAHi0h#30AFK{{wFTB1xuD;XQiOQQ|cNFY3;hdkKmdcLQAuRgR4(#)Hq1`c} zT?F&-j8uw$-^f3>n&XOo)VpyZ9`7P?YLOo+?tjepwbK{JGEv&5J^2Q5Z!_-|*MFhw z!8!vEQJcbdyJm=&=ZS}w(LTOpO+Nd&kV3FxJqPckFM zdqu8)GVx_@8Rh}{@g_4*rQJyTXof3rq?hGAMXe<1l@ThG`4=%a_u88|e05DYaS+>ODyRCDT)S0Y|dF-jodQ<4cDD6nD zb&~MI^}CVwRIoa)Cv~2L)fwILy3$`B`?wi@9rCW>R|fK(Ni*8yUCh6S^Y7_1nhP)z z$$yo_55W!HEIaLxS{E1?<2zu@syK{uu>PA^js}tX2v(A-~ZywQ9@!;g`P*6}W!$Gn(Br74a9?+(*5TQ?#=wFV<2tH(-Uz!9V z9x0CjPem#Cf<^pmB}BwyZ}G){iX7#^Jc-YU9q`y=d@EnSHJooP5*_>;gTWABp7G$$2l?KAt4*Y+QKogJ%U>ZKAXsrG%7SE$k7hB+_gi<7 zZm8tr1!ex#G{TG+rC=Td&BLQ8 zw*K+ySzw3>JwO6cwg`g+0U?k`B8gc8;0=_=q=Xd|O&-?N`WM;anPF0;cRdwpr zsn5|S;w5kKWqL&;rfGEASg(aD5iuXRo|nrHg2wD98`!cjx&^`B{~A3ZF!aj8TBEph zxS%>&9%x0*^hD}uGm^@Qca@vTIXmefEa-T8@t(n;-baSDQ#v!qpMFGt9!t6vs{|Tq z9xTFeKTC81Myo&Z|3#{m>?+zp%N-EadH)6}n`;$%9CB>Gxe8qw* ztzxR|3OF$Mz<2aQbe6aRqfLT5sTFNt(efgXgYW3|?oQhvE=IG7v>&;UBb~#xbEin1 zan1M-Sdp>yg1Dp>SD&JP8hLF?^v}&$&{_2YpBD!U!Eju+glN0VZ?>Z*8AxUhCr4U_ zIW-o8;GnOCRG}p3)?1`Hfl*zgQSBUucfmu-qhbFZl2oJDnhrYtId)y|{4j#xe=rsW z^Z0YBVBRq{ESN8G1lU_%;s#fG`cI=Ou1&`>P?C6hKHS81JMqkac>L}xmMM{;gpsZd zJ1C|a?|K_wn(fR>oie7we7v?QgiMtVBy9p!kUMCWq51~v98Q|@mDlS+?%ZnBr_ikz z`d(fWhkQaGl|rX*4isN=j6xrhEy@bgW?8 ziFmmW|7MfB^KXfANBRbBzG($17RPR;^48}oPL6G%!Ae>4h|)$PB_8kiDtNHaj<&$;}`=Lbp2=hI53{!_b` z58cuC$#`*p@oe0)&!n3Zhvj+CYdfO#q-zGrdwx?b^Hu%wb>j7m1md-|Bk}rjGvLA& zrk}mQ9-Y8P-*X4oS+A@8IQez8A0K&L?Z;8C^M1Ssz9<)YLD^cKzFM9nEl+1PPrKLY z5`x^4)$4G3s@K&H?EWuSB86At&(~Bkr(UD9->|fQ%FUEE1=BX+X)9h+3ty|{`j+LI z$8wEhC4_9)|5sS97qnc*M{`7>Dlo-F@5%>UvQ_4a|Gxrr8r@0j}r%*(~f z5zdh0*VyXQjp$@#GXnFGz&*SI&ES>Nfn8GF-R=g4e6s-BCy%hPtFC8XWkgQGr_%Zg zrTnaa9o1+d<3o2OD6lurvp2)on-=)yWNpOV9MIdZ@fUug!+(*#aJvrwDSzSE4*wZ{ z;ph(kr~HK+oy9bynN z%9)6BjMoM3=XFP{+eH!^>b#32~bBhdY$_AGu|LXNaGTdE;{ zx?P!n&*OsX-=jK{^7(}t?|sPM82xWt46fw@p>kRHr3;itq0}WEkQ-$%F}>4-*o45c z6lOIT70);6rQ*`1CiJ$2?`?}eHXFoOiycB)9^rFk_k9G`?R&^W0Q%1<^(NB34KuH` zS98Ck5A}XWuhD7EXmq_`en*$uSqR{NH5Iv=$=mZF1(caF4|q6D=WcYpxE0J_4t4)* z=}(8WN2$}D@9}gywRD?EDc$3ce#W2@JJj*S{gTknm#{et&a-scQaMlhF(lQ-1-z&D zW57I_IMJ8^IAR*S!&88S6>q(Eu5&#|-XU!zkEn|pNh`bxex}Cl{wsf|#@zp-)Qb3Ng?^$3A_?v1&TG7+ z8;ybN8>u@#BRsc%T?Tf3c0&z2KSTSG$4QP+(pfxA9gZhzBNZdJBl4o6 zo&FohEvlE^E$S`KEb@b*(9u1$hQEORV@B0Ji-%4g|1@%sDn|FHf4lwd@P5yqHLw|Gg9!c%vw`X|xecOV+6G(YdmEeB4(S&weBt*tm5o<_X~*tI4giaX z`jG<&7>mPq0&c}dDlYUMzqXKJHX;m#%!Webi;Xz_xj;Yo)?dXNVXnP2(gI%l1Ymu- zD?sSBbL~CLp-jvIpBQF|dHN>GH`Q_n>tZvxXJFN!18%4NBb0_HeC`?_DpLwD!(*}R6u(MCd6Pvqg z@J2ule9JtNM*v+TPvwatkKm1gbBHjC_s=|OHTh*#;+S6%_7lyjQ{2)Yd15Rmpy}u- z09407j%LhINoGm81@=hzk~syYD8>7+xc<0(8_-$PDhHl05lC2nl|vlku|r*&4X%Oj z_dD_XNCF0IhIcU2uI3|SQqlYYtg1Gu{$GTtNW%w>SbDc1#2gj76p*njI8%q`V1$Jn zN-wrTi?F=~D%_y@#nxYjSD7{R?ltw@Yy920@Vj@^ckGMJa$76{t+LnKJ!!RGw3(u7 zMa(bnnhi4+W68{ad7CiVYV(oL8O84sEbDsYD5R|wm$sz#C4Qh*=nX1?ae2%EgrMbB zW-rju{~OY%CgOFQGtl%+uD~12PN?CN5GrT0XuI22mLSJIZesCtQTu_Swqp<6hrDlg zFZI9xY(oV?W^EvIEe;SbT7O5Ept)LHI#r-LGKX?pwjcq2;{+Oprx0JTXgtJ8W&Q*l z@zAC7Z$r#kIwYo8O^9319Fy}LVxp3lEha)~afD2}n+bN}MHE6kK1UStckVl8!}Mgj zMd=VnZwEG2LjBjXYn02^+xRC9BCiUbL|4f^FJl|-4xYolP1xFc&UNCcPS`OyG&a%qg zrW*~xG6oMTmBI8lINriG4RWPGS4}^maY>ugldWLt{GL62fgpnsM|LDm5SauOI@Bq4 ziMGp2AE{yhv?C!Ay|ckP>~xIxoG2@PP2V6}v*1l-9s%iQ@9k*0Sz=^(KrIQ}Zk1x@ z;C6R^3Sm??cD}9*o{2N1LAogIXm+lj@T;C57axlfu|~r%4lkIYW5VA0YHe{!>XIP)Ov?3pFG4+zAXS z##u$>vbobXAQ;j~dEEzC*1TSEdre? z!!Ub=ka4{C`1?ZhJlWX66EUE9X80Uf?$8~GaoqDaks62oyS{RPuk-7F#V&}0 zei8PQct%|8#%mY_cz;1$4b=&QpanceBaU2G?k3RJ@u*-t>i9{;Sk1=`Inueu4UZe{ zgBsp5)N$Y4ERJ@-Wkr1P3wjCsRHq8ME+>|R;r3c1u7fihpqo0m(L(wO z)k9ygE%*ZdMwcF@^w==)cp<}on?#s+fI5oZYs-2x>5nZ<&>U5GFL45rQ3eIGKr(H6Lc>$ztuYs|Up!M+Nf>+Ck$rQhEKE ztK{vb%{|l~*Tmc84wJ9~&ZVRMxKBlkAyX_W$2nTln{?;RbI7jd^|yjWVv?MGl@_>{ ziz#ZRSXA6VUj5TpfRAc#f1E@zT>ezdp5hnjWIVrl@K!F@!>r_gQ=h&bLjwJNg{_pVgzbW*QBu=t!j-Y3TA z%#li2+}^geP0?b1TH%qD9O>fnaQ#}4KgI;m#kzgw5`GQ+{#X9cInpIW(rUu}+UF1- zv1aMza!ftrW0676NAli{ywAb!hvuN;=T7K)q_~>&3Rl=pw+ZcZboa0@eBTq}%kEq4f-lP6bvZS`L4+=OhqLzFp#zK*yZR9ryEMD%>#VyABHQ8d(L<9`z_GON6 z(GmJR8@A*O-~i|4@cnqZz%9~u1-kv=k$#8uieI>+XzIh!R!bgPPK@3ON*9k;%;F=( zyc~^zk$~!dRT@L{4DzrG?0!7ZqARe3!USAb5c6C=-gy5od;;%7Ie2!!dq`=n@msq` zKR?^w#*W%@z8eD&t0`sGUl3TO_2+5qPl^_t|4syM!AY@j8V2J+Y`iTVsU%0*r}U@j zOA~d`f?2#_j0BB0?w4xqrP!e_)-(Tjs112x;?;eBTkstoft@tv6Fd?-GLJ2Px8C?!0tWwlIzcIcKPjvi)4rMc1P_6*Uz(Zdps!h_XT~g(+YO7I`2;-yX&R~ z*ksyV(W9EuGX#@W|AP?V;LRK1H^W&xqyzup+SU0RNV}Q=G9|xU)qt*AUmzioDtQ9; z)6uklnooel1i|a1_m4fS!p)Vl_bz<@0>2-rLS>0XRl{%^A6(6vd7Iiy(D!Q9X5RS^ z*34Hf7!9l{8ZH;LW^10-np;?FqSe-zSZh9kD#+#Mwd{~-(^$2Bcd`1dgx3VI>bwpf zl|TBwXn%cY^nYr9ogDq2*-$~V%kgj?j{9KN3xxsmGsadBn6`2vg$o#W^ z8{tVX<_73Z&4GM2%#*5osJKyG8xh?xEr;Z`S>YBAIw;lK=0Zkx?2sqk z_7mQ&`~rRlvahC_#HEs%If_O%HmG-vBjM{Wtf&v^>9#N07!DY*AJCGTn*3aOYT zXLm4jY@XPoQe1kgNiC+wPt)z>>O2L$ub+;=r7CIvfJZ+Re`t#QOb6!Z7P|s}3*M+y z8F*Y2wf;A1^%on|KV-lVfAia3UPZS29jqb}A!(%Z$!i)HW&*?~QNt_F?T_Or6r>CvnLdD#kX_ zMvenMiM^;4mwZBdH+Z)AWdjp`uhVZ+v$=#dM5-q}cLB#E3wfInP?dTIy#N2fPM#T0;V*h+#Lg zi(?VuecP+`A$=<9!E&+SBO~JBu?%QcyyXWfNp4CdmdgW%gj6@o6;ta%ibvDCoiGu4 zDDKb>)Q2~Do2niOXRk1S{^GK$h=ryrX#Ti}$Si1t+Nmrid|_>TY!{dQf+y`IbVVmT zwr_-FFqhZK_b9YG>fOkK5v^%|B+5pEQXGNLjdF**wr^S-6UJjSYIBD9Tf2XiWfG2+|m_LlD3&~d$l)5 z3hP7q{Z;AzxW8&1vA;53v%lK4jBec_9FK&Ttl37(gBvY1&}}eIjXzsx;`^(5ZGUx< z?XR$WAahJJBQvac^8{ zXT(C>qC2FGInpljU2-E{)M3~^1u`z1NGqTEJ9PdU^`11%H_F@ivk3V{7&p>U7rUQM zdoJ2*A^)_{xWVULftWk~j52&bhE%weJ54-5V?KP5S78Z%4_|3;pTsSNbZU4!EVVOQ z!X(8l{3Rz%bZ9M?o-i`)zKOs*{gV#T`85b!;imjlWhYJa28XY{v9~pak`Ba)%c4Nl zFdLm|=hieP^&tBkW<|&A&7$ueTIUB^9n!DrAcm5L1je5>4DzST@{wv6MxUMWzWSK)deNuIPke?=izammqe*G=a>)b=Bo(@7MiRrItl+o&QgNyYO7;J5>8qo3q zge*hn%pB2q z%U_3(P&)ba4~mC6|K{>PK<;|`=uS}}b~C7kIcSqf>21IP0CaC)XsX?qTdf0Oa+kP; za|Dxri@13Xh6CG|CWFV=h`f#a7{fYF0Xn;P!VV?WU}>8Np%>0;apSXL9VbbfZKSZ~ zBcWxZ-!yoHpdNn&Z%&iYcBMP4y=Z^Zp5SH9AaKs_!7keU`c;8?io*a3RUz~w#Z?&- zFZwQ%WpR>K+UNF9+{o?-Hl4BMyQTw?quX77;`=4j*13Ii_aZ7wSB?kp%}c17m67YO ze{OlEJZ^Gb2!Ao#QQiP7W(U16cQK|2x+RCIjmF-8*w?wpi_jIFwoG60o7o5W;E$@PC!gu!0a7(-0(pE@vsE+Ax ztC}2S!$RgJ92W$qf(m`<@tbgeHZDY@ z7BmZ}>xJfjEEYVfV)u^GVfPZ=OHLTKXqweODjqv2fzV-~>sk>yOglmvuwd#&A*~(` zarJ$%4*zr;-96L+QurRm;WDo!Zlzkm=GFn~c1skv9BF)crt&%+Bq}Ug2KuUbn1voY zo?#t=bdXM|yjC9(Z&7!@KVHy(8>d2aV=`{)RWmbANms6WzR2*k8{xW;e>ZMdq%UYQ z1`o64A3v<;0UKY0Z(`A$mi}qBOmXcNaqV__)z~`R5o4*5wwi%Y*M~H__+d3k`2C~H z>%;5H0t(Btgirlq0RlHV5it7?*k@e4Vm3&paspl$Y|{B`slK6|Yzhp2*yL3np)AC3 zZuz~5fc}(fA&pn{%0$L*S8&K4W%#%*>Ckm>-u?$W*%SJc#W8gL6>GmM5dE_&(6;;v zn_H|o(iSIzk0{IC{%&?Q!R$1#2?jdB=Mwg5_a=1Ub54IM$>lZ_o!!~eCFsb;>^u~{ zHJTm;f1|`DE9=$R+;8E3V8Y#3+;bTAsxP`nXW67|8!fXp;V!%Dma7DTtVA0bJ|!;? zl@ve8_3LVBZk%{71fQn$d<4^T5hJgTkCMZ6;Zd>$$KTd44*Fl+FX+PW39x1vjis zZAG4VcmuqHyuqWcw2k>NolP#u6Q}KiO@Dob`oqkA%&$=If#7}Gf>n5;yn0wH3>lgY zTvE`zXhU)2yzs<-gBbK?WAK(RE{=66;ke*!*}6wDlqXJ|zla4x>B>%5JVy-r=EV#7 zJ8&k$l>VObPDsh2VUWgnm~Mg_(U6gJT3))3Hd8AvoB2WSfW7418ZR`ofi2h9S69o8 zqw82a;U#203$EAJbGANa>(|Fre!s@%Vk+Eb7;Ug6QEG61+$kJyL1(w1i!%-E7GXSg z)qa6nov{7lE5kMC!^?)-Tf^XMLjj5iJ(9x+<2?&Ru@AP)Q|%XTUc!a)v>J#UM$obI zVf#gEyw}mjBON1$ab^0|Yw&~7osQ36|3F8&Id5dxuI4*SS zA`KpX)TWnkgNIm%ZaV~FAGRNXth`phY{92!R8HQIw1W%yWRU5+pJ6C~kROK6APRgX zygUE`KY2a8EMep1Fnk8#_xxgCO-OXEcfIEF|F8jnN1<;)yx?sir?4W}q_uXGbLmu7a z?0=%I^w!O=?7||pRjLYok2^xNuI7n}Fsx&bqr0_DesMYldPE)aS&S5ohFQX`84nwz z#GkZ(^)@hFK*vc}ZZ)$%h(*qnP+(|@wB2{4{mvu45=)bEymAid7S^_3a9FCXto5A~ zSitE^JJ8g4LA-VS1#x7Bub7c~4ch@tw-7`|AXD(2>L=~-ooK)F1d_YN=+so!5S^!y z&UQ`*{*T;_s4N(*^a2^+VUZLQfqt{$_GmGGwnTiOI1hu$+tAS~0kh$kp7MnmCWAAr z?gH7^FQ8R4T70e@1*1BURK4zm4Laqk^#(Pv?r_lCF!odfEU)EiJ(Ot-$5U;e(whCI zg=n&VzZV9Nn;=hm5<$i+V&Ti|Y()O`Y4U$WaYj11>&P2M%7M|>$Jyz z@-8K4E7*8r7+c!J%WJ)e?9d43k7qkzB?8$9MnoHP1*eeZgm>^X^J$g%#Qp4Efd%|K zODedWn8Jdn8y530vK}&XgMKE*@K?Vtsv=D4RC@06)f&AW$iocj%gHQJF(fL_HfVR7 z2*4UIbJ{bh1@c4FO?2{dj3yD ztYQ2UToT@73%R_LJYmTzGM?y*$!oX?;@lsH9L>GDZ(J(tbaw zxRm4igk%}op?t04du3!YJ_NcaUN9TvzT4sDS?zqm2lNF7V}?-Ku7E>urB!;Dku_dP z3la7|)}S*<9^%Xgx|Qqo>ArM-aqELwFrB3Rntv86@MtBizYD9#61i!ckwrU%Dtri! z2o3f+`n>Otku-W9wqW01g>fU_iH@wuwoXRIrS9a}I@4-ku6rmSfs{+ICzV^^8@3P5 zZ>8XgCD%7c#nYCP$yi?s+VO-<-f$e|)qF zJs!dzw_uM8yRv4>9iQW@ITghoG=ENG&AKSgn(otq-*U~fVb-)!zK@EqN2>gJKZ^6` zjK`mAlRwB%`2)(w(kP05wO&nH5*xZ7469Qy3SXZwYMI?5cu*Vw)~zVIuNM$YNJ=&cm_6C+jlc5!AOmh#Mqpf=@VeaSuzD76p}gCjR=r|273pLn@e#hzVZ1RqP8)I>hWW!k z88tfjYsidF&aIIhw)s0c7lTaqpQdqfD`ZpNysF-t4`kTR(DUZ_e0(VUd=^Vzy9u5@ zsiwzne(h<0>UVE%{NaCE>+{@3YM<{u2Yvq3)8RhvqQ}4dgXq2obaBS$qo23EhjlVw zOCuRLjyirh_5XO@|0^v9E}v&2gHu0Q9j<>DR?Zz*{~mR^`tOst+@9ofYq=DjO4U`S zQ!{MC7m{9XR}0t5?fXJlZs*wK(W$E3!pgQ(U<>qrqq)4^AHhmU6RTO1+`&U|V#TRa zE?&sw)(Bf8pDb`i&Z?A??5g`2;6F=8F54u)eYie%k}$~RkzJW2_ME9r5GT15XYf~X zGnqce92rve`rJu5o+mmt<1Z%(?2YFqQr!AEDtutc9Yz&CaQe-N!BvXtohQwUm|(XN zymeWBQZ;3#kt-V>C-gX2qVY=Ad$*GK?_eGtVwd44{=-51yNu)FZy-G{${65h8PpUAchs`PkJdSJgG2Or|n(~C(@3z>S` zzL7~!n|6YMp?d9@1oBgODJ&N?EM@Hmkc(Zq^L=|fiTl)V4XU^|ju#AkCr{@ZrChBR z3;JAQ0DuX~1NA%(#7TK%A)kL9tz*c4UIPoY`KKRy1akI#5ag_Tp??19qqj%$`KKe< z8nij{m)^Q{vvC~*ygNCD_xLTfT*4Y@61Lf0$Bc2Ma^_qn2a916bq2=bPBIv!p6}x3 zjMR_XTQv18bdLFwH|2bIuDv$waZTE+q*fEpdz>Urt}2C**QAyntzeJd#78fGT%t$c zouEfg!z0~z0)37por+0+zeq`+Wl0~xN1tBS`zz`1|50f2MSobKopN$2)%yEThyjQ~ z?QeEgh5U2Kfg~grPBXG)d~XL{}lAv z3}3j{#Nc>#?#$+e5xPA|&tBnw^{pSWwjV3P+Y5j63X|__WMO0i8COBKmE(2fCurvo z(1j;>z2#S`G^o-ioE)n3AUZyp?Id^H8u8HVdOYB;($5IH$2IfW+f?s*kAIp?o|&Z9 zyV|=HtGaYCXU+5w6S(P%wYonc@VciwqX270FAmo|UKtPypL=n6?j7QP^2~S?ourfJ zR-Ak*wY*0BL8EYaR}5--ow2+>7U|2|Q-4i)bZ;nJ-Wxr2w26?4pCrtc)l4n`pTqmIl$&MPuHv7er@TLIjGDJ$4`4A!7Uw^y|4(Z zHPEgzZpTT2^K(fh*^-QZ_a!>9TNypG2v1&qt-pF9B&8U!732}cXzx&xXwRMT)G@aI zDaP><;mpVEiP9yEuTZb;!d?D>9&zmqySR2iM+u>qadG;Yq7K)hgVT6>YSL->*f3~}@RJp`kixE;}Kq5kaia61S`>5RGBNGMc zOLhC_+c0i}Q0`8fZxt7RNr&3ghY}T_<{<20mw$j22x15tX@K=wl8%M*I~v5oX6O*M zaK7D;KO2FaeH#U#6fxloaG3(CRxAyRU-hA`cznUC;7Y3(eaWE^M{o_KEIV$-c_)qd zNUx^S1I@Ec(v(A z&Z{t=5;Q*1U7^m$%q$8R5ZL*f*?{L5iSqN55AkqujU~3ZO#^JoF8z5h=g$p_v@;l%KFowH}KC`&Iv+x@0l|Op0 z{jRun1PqXW86A^CN?K22*xxUF^A)tc86X-9Y>4<|l}q18#*asfAV%&0#vgH|Wm%_= zaY~Bn!HEHIF3ERa32{tqZ#SG-E2oh5H_uT$0QeN;@bxo^OODfYUr%_# zu>ZjK=m(Vce=9S0tHTm2n)DtU3N|3B8w%5&A)dW>gvk*?e)T&Hj5Ge5iIbHiX}pRD zhnpSL+B=@ES0Ug-@)8gxO0pbs7ej6|JC}TKG+;#vXM`wDNUBFVa?QO{D!bJY>aU7J zP^=$vaW*Pz>vet?Mf2NW2)PyiroOv+NbS1^AVb*yf1_c4&4k(AM$ys(E!gXe{X{CsNh&Oq=Qsaa@p)ycHhnL2!3~3X%!38@f6=tKAxT)HDa9%9i()tFx@ns&h5XC#u4x3e*IN(bsUhqOy9f7oTg z2tua|cPzM7$t6cqqU8}nEXTIS3}_rPWT*Wh7JO!5Q?8uyCLT=U+?~G#8q$(AWcLBm zOjrI3W~`!cT%wsZOr;+C2pyu+b5PgQ5vwE8eFNHyEfWiyT3Ob4JZl`w3LBN5)N=vE zNgMM9a}ElAtIdxr|H;NIf7{C}fB(P6Grx~z5&T3eo&4z?dVY>JHst4l6@S6c2O8=4 zDaG2wf;$;MVIOA!P5@iGk=GLQKS#duoM-u*!7%l^LC$EEvA?XKC@9F-pV9Xa5j@!O2lmhWM13&Hm3fA}}JY^UVxqk+(Lg^E!3#y??d5W{vIw{)7~13k=KRxXC^ z^eN}}Qr`FWP=DwC(`blXAz%_#eh=F_>%_BBr@$ja1Ot^TykrLxV{0k%fqqL%X7U#~%Ue|oAdWw1{R;FOtVvhb zp4VS5UHZDFtHiXmlGT;3V>3;5e-A~zwG5hB*`OpNuG z%&tOh%-`-JSfr0w8GFA1A!XXV3&bzE7e1awXoF(kkAfdS? zZ1;Asl#5x)e=A=Y)kR;i)r9TOfs7kjx(8Ugom#q+wA~MC&x=NVkcl zi(=_~x^(As4BF>e0=gBLknXj)bf<(j6nH>eRA zIZ(E2`+`kr>X4F^hbihw$_$n$v66~ZK93wxe_Y|Te}=MT0@B*>c_ghP%400*Mpu^T zm+j2{-GJ7gwGHC6yB7U{fxyVGZS4-a9)Y3S==y4cOSpuep#GOL#Gs=H^F@efm;r&N z8PA5>r{Hvwj(t;24Z&HPSV7eKcFshWD zW1rtoM$d7d84YDw?S!P_QMv}`vB<14q7^Qjf71>WzC-X%+L!^qVN1A|3@LM3i)*K~ zar}U$#>|Bw!QuNQl)12;KJjvZL)u6PVuKSr;#V@A=b23IlHW~(0ZS9Fuw;DV=hPU;Qoza&UPV3j3JS!GUf^ zf1$sn!*1VttBk<*xTWY{<4N0{uS8O1d{FigA0GIW@gY0uU~utr{6@IESGJLWrNi6c z@#~$BTvg+@CHhVXVqp*krSde|mq&hPWVf@Kzma+n@-=Bop`;z2K=+Fv#lg;~r!A}( zXFNrA5{K`ESaQtlY;s{)8=E6A0=5Nve_d&(rp?U?B=>Vk=iK7j^kgS&T`*XKSTs5V z3aN*OLbh1swHOv&5vP9*72mOqx$)73V+6OG^@))kyP-MNh6PT44#sm5u0L8@n|u#X zW>Y3Li1%#`!`5kde+-bQek(Dl6=YRHwEslE0U#=y@sTAG?2^_S)q4%biC(Ple-=O@ z#Kmy}LK>mKwWYf%Fo;GZqzmFwCuoembHcKL@v?H22_;B;;Uyf~XjMqE3rwSSrwiOVl^LkG8wblI&J%`-Q}_Z?D6Xt^9px&^$MbG#FW?Pt;k+`6p>J$mjTvKt8_< zub*XEZ3N|(@NeFKCb956ez1v3y4Iitm~!nfXwbCQ{yDH;?|?&|H3qiQe^k@o=pgI4}Pb zOq>K|D%IRx!t2{qEUe;(lj|?5bN3E@iFl=n{13b~n&1}yOx-@}Lw1mFs%7^nG2sFd z0IGPDZ=M0_y#niP^qaOj_Zr&WUsU~e zf!cP^)3q@*0>VEu%pl&s-nGLcE72M|p7V&Q0+6$Ko=KJ39oZy{%Y$8WDk@z8>j-PC^dE z>HQNZUWkI*e*iw8pv^`3GW;8D7s^}V-y;5gHvGE@{+=KHjW#@GQuuc?{vH$l9fQAz zXulUe(Oyu#3Gctjg=Kt@P2%C8-JDVrAXW4~dD2A?!84%D?J7Cbp1I`+XDaJm zxz%!RNP|eSVpBMtBsA&aa^!8&X?g71pxd5^)X!W}t#nB`?>i|}DuIDU-*1Arx>%^l zE3D2GUn+AI?r?}N6+5kE`2%47^E$-UQ>_l^oI^VAsFWRe4h0(5z<@_EW+xRp(n|6> ze@W+jC+d9_LSA7=%sz*|>Uybj4u_ zX|VXsEL+M_glsr|2lI z?r)XKk=8awt6VBWT3d-$S)SD2I*RH>e+Rl6k2r3+)<1IJr!Y#0_ap;6{u$x6{aIG0 zbQJof~7J-laCRWE2h+eP5zqtduy9;8jJEUT$pM#iJ?GUqz z=|P=?_=mrt!B!S}<){2Ix|6=#KP(=BoOg%?canQU!>YVduU18Ai|J7thYaB@f8W15 zRE0c&Zl+)i*SCHa@Dh+GEeKm#acx&g_8mE#{($#HdQN^6yfp?1-$HKD86AZT)y@e* zLjD%qZ#mWDTK#$WHTXK6aUA});OiVHGyjM1b+!Yg{{+5H1*h|W1YhUIGV^~0zRvR- z$(A+v%ijKzI4dEqJxbe~?ry59~?t4`4o2+Po2YKQ2#Oaw`)#AYMn;k~PTU;?ctkfpT2{{MRuPY?fhLLNrWiaE)yfI~9@Lp$^& zOPGtMe{$eoJ;ExLRLU?UZ;1=*Km*@1eK+%tTaa{r5ymL%SiNNc$S(o5k{V z2y%ZqmjZQ_-ag<;@f3O80Z?ll*^~nOa>MlL@LJ~ zRX$h!%>ovImHX)(TDf1{p)VKeOVdY0pV7L2yRsFe%v_Q;qc*ns9Qw3ALH@p%*a-4t zb@~eV?eNZ12!yJtiIHGGluZM4_?MVvWhU|OsgJ2X&BOI+&+5}ee^;MTTra4sPXc8d zmS|wW2|>Q75}!Drp4x|zK9om8Iy?7aIg^#sgq5>6O)F=0n!cZcujtyVErh6{-GdE2 zP@^??Fj75GjScpKe$oA_kD?6K**yhs6KJ`(WI2_~TK`fZ`OH}f_(Unn*6!s&J<*r; zUkw`cZAAJdT6)5Vf9!|t=+RHbt|e>)`p)`azlIx$6!^PJpb4pyaIjREB zKa}UMe;HpN((JqNJe5B`GM=jQuu4SGRp*0bs*cj(I`OFnQ+%pn;_4Yz3cn*&L4RyN z1yUhr#2ERpt@mDJ>=(e}OmXdQig{BmH-*(_lt(&=ZniJLD?A^t%zBrtf63wXFZr5v zNW&2bSlldqRc|f*rQX-1SNlO5e?C6`T3?{?e}@V~RlsGetOX?jYA#gbWcHNrveDZ? zT%8q*AXX9UYg$Eq3waWOzM%N*8^!b?c?CM@1T5daLzU_tuGF~R4Hkbk{t83+B`~OV z1aDyR7uW6(*PcrX$);#Nm}d8@4@J&5sjP^*SrN6pv?4;iBJ_k6IG)t~44bemWNfXY ze^GUrX-zn)pm`Uh%F0vBcQi1(nGsbfrbh*wf-!BqSQsUc^dEdXJgPcnC!Jn6zoilQ z2;2UR4&O$T{O?KiA!nK_E`ES;WHF)H8!r}RwM@5)1$cgw-b5@w|NL~LH;L@8>GdHl z4?_mmF&qGf-C=cI6R(5r7pF6n=i(O(e>kN6jnC}Nmq>0ij%4_Yr0Wc+BS~yXb-{aL zflkfdjvU8dCxr*nzgSWl#Yw06iX*F4aWc_a^)M@Q<-;@{OWvaKc!!S6q@>9482pm( zEBdnfPw7$@Qu?an@UZ+2e_j&}&pU>nyLdU7@Tm+6Kkvz(Cq7JV{-o!1#_b@etVPT?dhJHygk?R+Hu)HpTB0jeRlT$ z$9Sthea(35I+g~5lU44=9$Mw9di+0)xAzCug{aM^`ZgSI6%SDnzrDfQA1>m#9@mUF z#$RYOMFxXdMHj1(4TvEJSe=7ctwh`lPytq+)SzLmEWf7x)YnXnI9)HVUw*L{X z6DSNVDKnC|73JpDIx9*9UO(F4Rou7>1|HEs{?{{qQSZ;00yZ)duK5Yhu(4Gt8#K>Zjt;d7IEa+RKlLjz36!T=x&^gJ-*IeehX#>Vw7x z-JWga_2T@o{d=_2pMYRCh2Qdc?QXnEMEm#G7|!byzE7|A9>IP3LCqdg$@gKiSRFcq z>(IITU#@?gKlkeK3SHzze|6av7`_{LU5i)U0&Nff%gk_SRh&XXZ$KdLA-QIsTi8cH zv}8vh9NOc0j-x{dnn$dI1Lh5$K*o-LA=@W1O9{o)O3-l2%yy1Li>@yYjELsW?e>*N zs6$XTSP@u-cNsM7P_}<}2hz7==r5NC@!LHJGx-Hg@=Jg*)^&pn(V#`x|EYv53XJSQ$fArg-px|lsrsM8 zKQrD90)oSQB*B(~pxlMmJ3$}_=M)zrC4-E@p2#R)<1xw?@Ly?vt-pp&w|HKsu@^?@ z78n0#-6H=c`H|kZ@Ox*mMStHYE&icA_yM-aWj#Oxbo8qiq`(FRAZ|3Xik^5Ou`|hWr&cDL!0^xjbchS!U!56QmPi~g~f2?oqPHO90 zSysy?uwKc7S!Kqv%KVzBRi=5D|F`w+cD~@;l+tj0lSfh!0xROva1mc6UT1x)_IAZZ z?iOhI1v$`Lf79Jwh~ouF$$EQE!1Bqnv7SKNe~w?9382&yh}#EWozg`odQLf{ zN{>|Q3YfP#r4kJ{pq;pSPOL);Rfe*q8i!QxJ4uILj=97=^xoAvg1-{r<)!E>Y@m%+SMmj5hFFHl^CTiQ!^<%m0b zjx+Ayf1Hp8&Cgyou%$<;;r@tvyiWg|c<9VeJpL@2#@@+uGW^*MFdx@=0+tD@u)SV8 zXaI-uu+_8OQV9k4khZdOhc(TsVpmOOy~oGWvLjRe5S+w%m2-~51>!||$LHL#P< z#36z7pma%+5ndtCz3(bi4*q2GH{oi}xJ4|=e*q?W0-zQsq2HGCc&4DM!2Ig(hu;*M zxcA~c!FKnNB=>odByLqFP2zscw6V(Zy>s52;9HSAfDp_pVyi6eF2Y?DXeyIfUhZIU)F> zA%?&(`r#zAS(%ONsXvDXjZ2T;N)YxKe|#0?q$g-;9VxKTXnQJK$}2q5Z!W2uouHZO zP_J+~q|55L8XmIrWTC;x->PT;VyZ9k2Ibl zsF94twoSnSF*n$W@W)FL7dGt+#8Gcs^|{&LPWuJsiX9w0&aXIvQC& zV`O3Ja`0VNZaJCGCmTxy*kc2QqOqpRv72UKqYlb1i2IsyXEJAF_J88 z)82F&pG;4ssvn?4Gpwe?>XFOjqCC zQaK11ikwUO^*VC4_DVxJ3!g_ad80F6|0H()N{71AHVQD|k`(fnZ`*ggcNc(-uafn#1}4fb1K>bL$^*omMA_Xz{=l7w_#XA?UNa!D+BLWTYwr-S|;gb6XH z(?1v{zg!lBuLc4CQGm`8CV3k>&4LIhqWnse-Xm83lkv!Y90HVbe|R0HgighFr6bk; zL{(SQ?e)B-<@Mp3;=oXf>LY5Z)bpAisSno_8LVuJjPHv9+rPlu4X`l|T9;>vYpcbz zm9WpLkvJ-L=#S>^7IvT-iRFU zr8P|a+z2e)kM=lQ+!$2)va+X+;b(0cLW}BAKP{^McG{x4yq#W+Q$DJ}Zkors$@?jW z_5RT9?*XOdzYtu3)7MbkT8zZ2O@5p~VNRNWf;+_tkLN0de^)U7MBH{z>rY{7+IbAc z^dm9VSmmzBJ&0y+0ll>2qWXUQMZ<#DijhKq2K>3^kocT91*}%rP3^DfxGe ziZs~Zd94d%e`b#hT^z7t?0wOHr~9l9R8L(I7fbtI^BLxAZExn_@M2; zB28}qK{gh^F!+|{)|4mlO;K_qm}XqLmAL;}Z8qfjf6|9C#|<%Cc8KfDLvzIJqfRmV zlyJ`Vnz$}{U|OZO7x&i^*Tvo~Rpu?KU1gYWb>&vWl$hMxmAeB9s;0b{C$Dex!2DfM zUIu6iZr^$VUJQ^*u=WH??vP3|3r>5RI;HO4EQ^9UzS9TrG0G|JYl!ziC?gK~OQurV zo%$_pe@`|+*EJ~N*bF?ZOHC@4A5N(Xt;5qjx$(*KVcf5br+_s1)a63PiSWY}7#eb= z#XSaJr#0qwM^|8^)fGtomG-EsXQ2a~B^A@cTnmyNmki$-*ks!-M8dqCLny%i1o+=` z6!|kSbK3w$;L=h?puMY{I(L+-+;S40(UD@gf8{vh#=<{z(whq-UcSzL9OYB)L%Vp( zN>1(xsL$t1StVS4n=9>r_dYZ(B)I%B-lZ7AEp8TkENg}@r9n1-OdkA{2DNcX@&2qf zE`JNjG92^c6&)$A8Ge;4cd(D(5+q<)X1N`Hk1EBr4OSydI=(GAVhaAdf&2qshr#>k zf2C1;?_BI{1@((o>(@6mzcFvVKPv&|t{9A#sf?d#4g{9ZQlUwD7;>j7)-_tD>%i~z5v>;Ml z%d?W1I~o-m7emFi+3vjol8hzmT2{C6EISQJsV5yk(7hzOS+p(_9^;Xl95aKW_IZ<~ z3Gsn>Ms)Ga4at|LBY(1J;lHUoD}iAKq7REan%qA3slJ|1egtB)PZysce7^6ue@rN3 z@-qr5I1#@Gx@||38}~OoB#YFfdky~nZ6r%COyTcubNQPCYuXf&bZjXg#vLl)LedN$ zv&OJ~ll`c0LjS{ywT4VOh&hLu{28AVup(tE6_c@_Xk}vxq=%c3X7C2u&CS6b ze|lq>C(paZ>|NPn_BL^yGshs*xL$LL>)K>F)AoD2Y5CVhyQHmoi!Q^we`x_~>36tt zH)-kf`X*=P9|YpjpW=kM0Vm9XQh5gYx#jz^3pO!D+$p8_eAEM8`0)7C?b#U5bdN`> za_4SvLiIgeYCTfME$|jfbY>f*xI5^3QA>}MG6KFXi+d0slr=K=YTAlRKNjh>&&wa` z&J)Tl9eiw(@~6bZx5DcDf2eXx6o2OOWgJ=z6BoPS2EQuUuk|$BT1-ABWH4ys8sm3A zOakyb1)c2uLt*y8>Ar9=iPI~KqZntUxYEV64txtA%Pil+Uj-w>$mz8tPCqUVi_^P{ zNt_Bm zU&TV^L2GgU)`UMkyNFHzdoGSLXu)d~219zz)zwnG2>YPz&G6bM3!u~4LG(iK(6Ou$ zWV;OC1_fgGG2|_ObN`@J)LdsEZh3CXPNF><#$^nn6Y~^)1nhkTZ-|*2P|*W_7b_hu)VUzSKL-< zK{$7ouVbSO{+Ou{`dlJaJ+PEOBe1+1YJs z1hBYeJP|vzkP#cgi4D*ZtA+pPflxX8->MSBAbr8FA-|pSf4{}^H|6;o>GGd~|FBsc zw-NsTtmelswRB$*&+l3wiBX)y<`#@ZX^X#U51xA~T^WhDh(tUmv5b>g*y3+mfd&di zW?UUbBz7-gB(gb)j23^>5IhlAK4c`~iNp(>gpre|ZT>e6!N9J{I7VVOCXTs_lUUcB zkyzdQZyJI|e-foVBk=-}h~^~bauVL=f71{I!&H8$BNBHJiB0nvi8M|k>F*j6gCt&O zB%+DL5>BGJ86$C~8Igcd?}0ae*&ey+ZX^;{4v8e=8pKUe9E|R_NFnYvc#(sqDUg3o z`bB)<0@7`zxh6v(xfwiEe5VBXIMJZ3K<3H$ILXAre>iV7pN;d}^&X)D2HrRGXh!=J zKBTy^dAJPOmc^ZiFQBrlX^B-SqTBJ7E?8pB`|t*l(bDZ$n;2dji`LNGdAy<5W10M6 z5~68Z4$Z@vgK#up3K%+%#y+lp^VG^IW5`fxnJ^DG6`iu#3y(jgH+)kz5d5>{RU0y= z**wPde?>M{msvLAjPMh3#1)8X#-1Nlx#IG>hlV-x;yi8h=#pFs%p|*k?(kdsAf=eE z=Q8>?bNV;h{zf`6;JmVkk@!#A!awX)YH3MqCj;Q#nPjyp{)v#NIiKf5bpeqM!ITEi)pCj~R)Zh{Q{rgqf4L z+VpS6T`ZCq&q(aW#4&es5+zL;iSL^JO+#8BiJKXTmxx4DPGUYMF}>;EGz9&BltWC4 z?j{nOXEPFgIf>qX*ANquSiwj%B@)YK<5K3uTXd6RF2pc8!5E_B1fAzETLf~x5cB#w ze?18wN&=xNTfW1bF}-=c-skjI#QaUu&?K#xSiPnbiF30UiLso-$e6!rnhi-5*AR)` zMB)ohqAe#87xOoLgdUCxp>_r0&P79F%j2_j+}Rz?=xo7PgK*yHItvGSx;>DLQy6UB zV!E(0tFeJD#7;UtnW#2J!)Dg9dL|Cqn0IDkpC)f-#2qH2f3ski z+dtpx@J~;0b-C=8eg+-&EqD0wa3I$w^MR!HXWs^`5T@L144$c}m&in=G)W4B^>Ew4S^ zA??bMwg&t9YNE)pDi-_`FLwLee>R&*T4U{uD8jrNY&OHOk8$^>WHc)Lw3 z$fYBMjF)CaaX8oax>Gm!-=%IS_`nPbdPpkEe;ZOw!c=rxC1Gr`lV{F{koAy!G)sOj zBrgQUZV(Hv8mSik8B`1J3|x=$W*|?Kp&m`8yW8NcAcQ1So-}HB18%8gf3V-Y-;p; zK)(1V7eOWPpdk1_*e>%rP?Xz1Q-JKtjO?@To5@di0LJF>rQ6M7VR!th;*0w;#$%?v z?Xax4mD8z-&(lZjc7~yAf11sZX}N61^u`R;X5wuRR!Sn3B3XuFMyXs{FBUvWo)c~F zV-)+rM|RS2m1DEo1iO}7+D&KHn)3c+h`^Vy&xeN$5d{*KJ5uo*MdyPK7xwm@6)!%A zu&PqV@qD118*-GH(;#U}4BK4hyaSCGEj|80!0ec*`6w?}1+k#Vf1hZ;KkAXTIsJA! z^o*|-hS!61nb?Z~-A;IN$HNQZDr}g1kWDTNhC=M#Qou6kZE9rJdw5A18gmntESc>} z=kuXZWi48v;|16xZgb^U5fI3xJOl!Pr(C3(AOU~dLHXF>aaZ0&v za8xXY*7;5uvCXE8e~=f1?e2Ib2DnLcLLp)Ogrtn$@y+ZuSVfe+b+i%7c-4#Cqe*D^ zS?Yk@Uh06gUJ|wiZ<#?a`GkJNO@)f^(v{a4a`#s+!ze!$r0+Mp0^bj@?-yQz?>mBc z9tSiRF`AFV#~^>~KHh%{#y)iA4!7Hh$wDP`K_4thinhzse@|ikV(n0eD{m4z|9l5G z$Q69w5Bo50j1+Te8tuhp_@JG#R_^lIuW;xR~<)4K2 z?f-$C&X`I0lLs!U$L+q?40Bm~(9oWrMk?D2@S(ImM-96V8+`c`Z9qW`+!*{c-H!GG z1n`qOO~C^@|^w2cokPANCxx3&+V75R> zF}IYFNUxiEOl~X4Z?h;I6SXiZl;(BU*emH+`D1Qam**27BySiLZP`og(=>RDX43;B=1kB}jM z92pknHRA}Z1j~KE7c_dLvB0@<_^^Rmu$dcY^Ta77M_lEZ2{gxLvTHBpnaS+kp3Hdp zDFx?xc~r!GXbqJHt&eA40P%c4j)*TY+!@F-f8GmAJF}xwe3Ws_$k`uik+j2=yRq=} z{8lOsLQ!;!Wzk&4*q(nbuiQ+~qbKC%EI79}9_omdQ%#)Vk$q-$sUCcL{%O z$-l}a$4DxqGI<1W3ula0lcE|7FvMePYnX&w#Or{5i+vI^Z{it8;w1HqBfh~IM-w{D zSon~Uoo~!|h@WpvdPqIrP|q)Yp?(Wm`$9byMEOG97qs++TFSK8X%;1^X?X(!!AqjAQqmahHMmaFwcUYf7v=@_kcCAs zg6uo8bQ9LFlVyJOse5~-1HSY7{myxRyz{=EgX!t6zJ2elx>a@S)>7O@&ZLs(|duc~f zz21609q%M@++2Nnr%etVHBCCb`zl-}9p6u)yA}3HMjd=re(EgHvYqrC<3YZ2t+VRrHk6(pQ;vrlVT4k8aI$%sO*LVQ0UxxWaBTs^NBb zCcp3+g0cIga_ZRah+tHGV`yRE9jMwo#mp!8YX5JYF8SL9ZB1ipJMeUKQ4 zd7em!JyVDCf~=g%gs%f{*csw=e5YiBtW3C` zARE{;UE~x|k3TtgV3p8vm^zDFc00ZP@Hfs8Dx_jPeoqh{_4G;(*AC(YmrJl!NR1ZU zO<8K=H6_kR>B2Ej5v?Vv9X=J`5H3fw2PklB*O7kJroo%JM1A}g2HfiHaKfh@@cmxL z+U9K9YN^){e*r)9LKB~6|46>OU#R}A7F(trrw^rpIk z^*L(MzuMYt*&|mH!FY+2-iGr)m-cJ$%=>{mLkYb`U0`E|P5XH4fS-PzX1y2A+h{!` z&?Riyf9f+&15Ym#&%Ek`c$>N?-tG=N71!)KHWi*9QRve1bOUxfXlM$}PJ-Fu!lGauy(e;?&AoI_qxH$9=NJ)v=gkAy00hk^&w ze8EGG+vszNdIMaH)L$-yee7L1DVUKTNcW$82BVttxp(9;*Q}nZQur=G9i(rmzr+(g zJ@x{Y&DH|!*lK**Ay~uKpJ`?*aH-?g;(ulEy9%}5T!16Sq;Y8l>V1oe$va$HIo|xb ze*j^91HHarMH&_c0t*2Low(DpXh^+prLdEEY{q0o=3T2yc)H*M$%)O0pF0=6ZXYey)a`wZE+uM?o}5xzh0J; z4LC=1Snk9Ad^OSTv%YZhI&WxV>M?cvfA#clx;T*k##sVwqmY*GH_m@TSLyJR6Whn) zWrcUTw0f6zoF_p{hdOQ*{o9Typnof9{3K?_?nI^goL=y4Q|C@%;%QO#G6~}n62`N= z%F@V=c^oC??{LOjx-;IZ81B&J?$GG?>UW~~V8Zv>x%d>jUl+_n=_G2twflh!e`v1m zdqD6rO!#dNfCLqqV-(I9-};Kv&1}J{24`wJ zx5H9;=~nuk4^P4z5(g8~yd75fO83R9Npz_hG_d=zP?Dy0hy9y`9$}E!e?_`CJldfq z4R+9y3+flcR*`(0vV8VgUTJNZ;JV#0pIyY-knUGBl!>DCdZKFDmUpysp*F??oEKrY z%+Vj*7Ky-<4@S@&En(8g3v9;CgfEEah(A2mIRPcnrfNSqpO6xb1z9-Z@{^>!afxfc zb~c!B^u7yh3R*<7-M!jte*#V`a$+B@w>lx>ue#$iq<{|$o~G^ii6nMG=r)pF5Jvxv zv8)#F=Izf|WU}pb5uOn_Y@+tnqPPAA+vHYhv(u`XDP91-&|SiRJJ?IV4~-T7Qyd&# za>A7EYwwFn_lo-<-N&AQbjP(Z$*h-46X>HG(Q)XP9JlnlG9l+af3YHr5^?U*Za${= zmyS6`D{7)LAsw^8=Q8XJJNXG;=&=p@oHDL@6-pRDkGbBu`8`rlehDUgdoR5On})AL z1>Lz7wBYT4bNVfB0QvP`vdmo#FS3e;Zqb)4kxklVlM|`Q>Mw~TjZysRHpU3~H?LmQ z_|hZhJFD&$@7w|>f8A*uq;?~9^hvg(+g{R13?TiDD37U0FB_436h@c&D#FAn6-_x)0T2(PzLt*^r+1+V{$v3(1| zgL9pu^htm4f2elfa{-&uNAZ}DN7K**per=_O9ATr1A|#;LSiIW0Z`Bnp?$Tev~y$` z`u^-aj4O0ILbPby%uoZL0HlCh3b+;zN;vA@dcgfnz-=(=_Po7JQj+T)K}lZ$>Oh@v ztY03w^TyZ4i^w(0P%jESR@T5e>rcJPqXp#iMr^xkZn{?F~9Pi zgt`V$_tja(#c)TKVoKZpW4I*N&1zBo8G`I?>Cf1un4@vSqjR(w5N%|C#+71ba)w7| z=4U)TU27qBlhDTznU1xR>D%9O=E-y*xKdAEAp0CA`#cFPeJ)!Xx53)fKwVAB<)%)H zrUo@?e`?vcvZ?QfiKf!f)W}-7L_ankzak$u!(%rWf_RLuscR;{R0*JyR%l#VYvF$d zCddE@QVtMXZIrEezU8UCaae3>-v-Fmvr$wbk*xkurEI9VY-k3czB_9{6~lQB)$f0iHXSt6i%$9jg%slJBcS_krDoNUJ_ zg1f}pH-`L(AzR#GLL$ZykVnr%d&h9I87|=p6OQ`#G~kwj)ouOIC|SAzHS>(6Zw%K0a4o(V8YR$nfEyI+8AI(Wm-9AfsF=5t zf22B`fw_Z9Pf zn}om-uf) zv%GK!kau zQ~E6ckDL^(G0+X%T7q+MY*Oa|XvIl68;>8C7t@YMrv>~z)ayuIbfSmhm6uOi@VOZv z-B#vB=lEuT6rPM?b0PESPxGQvdl3L~Pf8rkH$}>md4lTB9;3(IPR8hRT8V@hB_TEd zqLl?=kO^_SgjfKGqp?}nyO|J9e+ltCAbvX`X#1rf<0~_pNggDH0Xg%S#7~02k6Hr!d^I47pGyHX_?W~Gw^jWM@Dm;o z#n0Izp#NjBnHvp=7GnlP@v{LCt>oy&d@twbjsaqB7UJoNn&=w7_6rHnK?1x2fIn(1 zYq+Ti(nNwx2FO=6(KWpHa|y5~R{#tEz`Po{hAYj-74q?oc>Hjze-H0}#whwAH-@5C z0O@P(#cT#@{djH+PlpZ@P={DQhBHWudvaqaS^0!CK*BA#G0c1nfIUZ}eYyBE zAf;Vy6e$`2%8tqwYCi=&>ib9W@gN?*cQl5N09in$zl}cwADjC}@!b+| z*k8=WwRrk~`2Lsl{Y~a%y?-JBngPJg01LWD1f2ej2{lPV{doxKPL4*W;yDxGZV9j$ z0QE=YFaqY|8|346@OayiXgB(Q&L~OlA4AD3fc$tQx+;)OK)>^6#>#=aV_3-p+;c}P ztAZgfXUGSCo1>0^;w71#SHD4JhZWyP}lS5>I{d>094Ol+C(J zpzO#2dU~CF8Z@8YCx4%=#?uyuO*;$6l!lNoII}X)R`WZvq`js5D9lkD70;2UQ)9N6 znO`4`$n--vHbJY4V3R^lCD@_#&v#jjHO4y!r4`AiZS{^!cqNCu!n|6wQE`wRG9$ZS z8@fBEGU10D(>B!l;~Y3s=lt2sCaw)Q(1{iX<-l59E6kC`Y=2Ah;uf0zJG(HoemC0m z@L1FRxakwS&@`@%>$wR`LaH!N2ILMf6AQkkE(P&~Muj ziRdl%L?T+bzJGwO5uN-#Y}T#k5mfQ&K)#pgy`OMUaOgMu4WYLQBl-#JIyK)S3#}zx z2xGB_FZ(;_y1kFDhr&U$FJ9Mrr|WCCMIy0O{ce8$DjNe{3FC7DUyi~1-J0?BB)s3! zeE$W!A5H&H;|?Y4@5^*oJWzy+wAzUSy5IZC>7vP_DSunk7gKisPD~lD4Ns%PR@6~B zH~;-7PyZL?zaReee=7fd?$iI7{P+H+|4-$=e?9!)k^jDRnDgJSdg^~I|2@`#Piu%S zgHfSAj$nzR^>KJZGdaG$7nWcT`=r)HNu!3I8-MN%U8aBE!)|j`-tORe)i_B_;p*r- zU+NF{YJc+-5*?l3c<9Z61?=>5ck>3G>O0~^?go78HGgPIBAR@Fn)HMUQheGln=5!g znObR%Tic7GtO+G`5zv8GTcXZw%bp@xNM|zFPrH8P_2YUXYSC593dV@_m?HA@Ac@H; zueMS4-^>rFDPmz06aN4upGGFXk2H)UZB*SdR0P`FR`5QU2NN>A^Bi(2h`4Js=hTSLV{aPM;CGokA)LoypA(l@t znjgl;^E-^N)b0(xaxC(vHIJlPG*U5(d<|xYiWNo{*KZk?!YPk z1JeCBpV}eyAkA20sV8gp6G?bPKMht3R*?MnX(xc!1Dkhn6=A0vGyIOn+jv2HQF1S{&^lR&? zKa0`{$OCykFF|InHjq%<#K{JWzo`%#SMv00+kdP7iLYkUGQ_;zi7+-|g04yr^CoB*JzGxkdc!Ts zpTHq*RkTQ@Tifp!9x@;zB!mR#?+!A^f|Be-e#jhf{XCHxGQi^Jw4Q$>*NQu#ai)TN{Tv1?+{0O?nXrNTzU=@)!Y4vI@o!MygK#HXiX#bBAg|we}Bue~J@6bDa7Jn) z(Y!Y2wAb(7v^VRKWLw~3(O}7g4O}=fG1k~TPBk-#s6oH)22M4zv~l}U9nq`R|AM?X z5R!R%aaTL1JE_cah*?-tk(I2_By$qK>(m7v=(6+YSan%b-f(|Y-G8BUtd$gjfNouZ zfKes_5T{Qaz2`KaBjtI`O1-iCyCDzO>L#R#$}Zj=_&qz^wagz*7(FLm_~Dp&fv3DF z^~`yGWijc8jq(diZvGzc@$QEU7nD`)BuVTMbHK-GdG0Te?U{1tEgQ=nFUg(e&txlS zT#=oe=gFJG8|e!bOMf2S1{Ypa(eaXUk$AI(BiOIc~p8N#JIcRcH6mBpkMxt;z#P_@ew|_d&Dx1`;mcEd}aGc9< zp5Rx8TKpq>V;)0xS=!K^MDIGG3|eS-im-pNrZP@QIQYKa5e{s{&S79Nbf*>B+Wu^9 z=R88V%{6O=)5L^FT`<-O72xx1=k*pl8TVvk6QiBCdFp&8Wx+|Aufsa?lEqV`TZty zshB?Q(2bz)TfyLItgU4pKeI=HW}cAK=_%e_xJ`(pLuzp<()wz@W@~G+p`8i+k<(L_ zsl_Xp->)KF)%egN@BE?RBBfbiZ8ph^DqrXZ`h4N+>VFD>_iXI*J@ipz>kB*&$@EM% z%^@bG7@ir`v%uB47Bp!OyO_JfIFJre&>d`Fno*GG(#VONU+*wcUr&OD*1zrCVnIa5 z;2R=kaOg4!v`b?3T1d3%kEUbYa|+DD15(xp+KT+Vcs@)#PZZBN&F|r%!;IV0O+R^P z?2UTu@EKMS)?DJEcyuXJ|;R=BqR&hU(@Z1W0K z#~qGP6WV*EdV>}5^z%02RDZkeH2v?69p2I%2{o$YZu&L2)T zoh8|=Ehi;3aZnVwa@b4Vg+-8p=Yis{4P@sBxtH9V>O1@lD4sg zgf1zQ<7s|U2xEk`%6MPqQMDKq4~Dw6Dt~jPq#RpT{j(VG&|&n@d}i7Id5CIgQdgN( z+_km+Y4d$hY~~JnXCHW($+fG~ugNG?FINdmcLmST@Ow2St)reU-s9@ueNshUps`Me zCu1{z*pso02;iVgtEahWeP>o2k#5?q>Ks{DVu??yq8mG0+A*SwmA~M_S?c@>)qis; ztLUU!yot9hoy+N7rRr(ODxz&Q*Qr4W6w}9AVYBgQ%jpAoi8XH3K|eP5wcqLYRANp` zv~}Lnoe5YEer2a$`IGKv&_5Tj;{$e3rZ=C+IsZ38%SnkMpr?W$ZjcZ2O6kX)^iKW? zx)|yJC?SJLBY(Rj4I+`eRrGJglz$88$*=014y;LaDOKlke3n+~(^k`Hce=Er9C?6I zpoX(Kl47`exiy^>Qa2K*2Tv=au@-wqyB)S_lgKM5D2Y!!>-fIU)0H|!`XMS?x>uGEdfy;dCJ%I}U2c3aVA_4&nW z(Xa8mR6bTJxCI3AqFpIKE{6+EjgyhD1|5xT)0_%)`g& z!+~q4qsO#$u29#nP`eOW2#_YOB%XSWj_r_qm%5#V7!5fONdCfep(YL7LC@}@Nw4yP z9qdR5R0Q{C@;HPl~U?%oe}T{@f&U zv$bvN0z#YqWtu>Gs{X#bO4DDHS1J0lbcJ{bS7v3PAUM|9QwiMT(khL`ob{$#@7cVA zJpKrhbYhjIdWC(`%@l_e0;yNqZJ0C%N27xXQfZ#(iLssLmR3ShIb)mkQV&Ek=iMAf%)G>d`j?eN zOnICPcn9)K65SAIg*>HMYC;Ur#tbdEI1x97gJ|+UT>pdbltdyvEO9XRGy6v<# zv$XKXn%mT*W!<8 zc9paMs;Bg&ONIX3h0fUN-`!E}e~07W3FXPnfbdG8q;%O*qu#Sc?Q?{F{>gD^(3&#! z!dJB;-f(gyuTNzMy@5akhl?RfQ`Mv-`Z<-RcACSJd0KrOhAllv$TS9?jYP!s17r$; zJnS%BbboUp*eOv(=1iuF+oyB+?_ZpD1S#>BQ>3K|Nh6nqPEvLKDoH0GkrXD8R1_-6 z=2)^yJ@IOjP8+T=>Gb$jCY|o5E8}O=fBL-hnM)q|FFK!DHT^$zK2tXRKXX3w)AavS z=QAy)|970v6i?&xnOmm)FP_i1w3DWC&LNS|uYYr$qgV^~X0B5ok2C?pKZY$IO;-*r zj@KC%wB_OYE|+t7wa`pf@Q+Q{CH)yk+`y-m>y<@EIrH@w{EV>47XR57@X`OG2y2Cv zqy*}36k#WMI9og55BIujYP?OK!LRIRPiKy%)TcAdcKyEShw!9azmM({mM?`BB8&7b z4u7uXMBpAyQg5CYT*`|aIh?u9#zQEj7d_dTC(m`hwOP(}K4f}yquy4Fx+%!@Oq%XS zlP?t7gq=xa9`+ar@&~{28?w{$b8%kscRnw<7aiYd)XQq5#j9vF=$X&KY`6qaveMHB ziQ>SC*x|2J8WkF|MeX~rU!(3YtFnb}#eeE6RU{%p)Snq}CaT5Q0uTw0@@UmiC9^mm zxC>#W{Yf2W!xt(<3(lOADtL6demhwVeVrc{%TsNXDYca&sctD$xddRfXFbQ8?+e*CD6(a~yKKW<7tdLc0D#p z#jlEn`P{UK^cJRH7asyio@^d;zGyQye&P5fv@7w^?k$|~4{Dh9dpEeSzNYk}rpBT4 z*@u3m99=Z!!Q{kfecRBbXbtvR7jpiuFv4}FeKtFEHwlB)fqtIQ-(XAa9MYvE|4l8aM ztF#Mpt-gVhJ;YpZ?vv+Sv4g+`cJrQUDD1}?2_7 zJsOcn;@W+>K%z(6Xn3srhU5WMCXv!xvfx_GRye-Otr=WPtbd&3R?)=9`lmW~wh~oj z|KZ0OrB#nDw_A>+zZZT8RoSqm?S~ON+&(Z7tG=8TLiF58w);pNpSO%?(|4rv9iOsA z)JJj=9Rrj9gf2^KHak|6S_GQH|6k#K5U1PCyC*Xi&su4IHrGs&e>UZps1!0g- zpm-)KXyCM98(Tz-Loqrf+$K$A+`jq{=z+IJdHSPm?Na3MwkXed?M$QkiE7c9s2{?; zNHwCZ^lHa4BKjXsoG&CDnpH?XyT2YQx%Kp`Vc0~^A zJd^?MI|C{8hX@L94Xu)3)B?8%>oO1nKTf19(eNztK6zr zi?8IOSrxPlxXlg5$0%<^yGR_uLMpArX!=l_D0y(4D4IT(ULGG|jOf@c& z{v7Ao7bcDSFS0LOJ?=kcUuZY(KVx4=9`}FBzVN_9{~h*)tz+4~@Z#A2Ir~DcORHnY zmH}Rz{AtJZkCN=RimWzv^}Fmuw>H9|Eq@R0tc7z*aCtl}5TtkaEHBW!$s*I?Ir$a` zxTK>DT0TBNTkBC5?e3qYE;`6Z<$h{hJLJ~(Wvs?Guno&>1x;;?gKrmTy^}@S~>Nr-=OEANe-4Il?0%NTgnu6-}FKGtzIRyIGGx1 z6rv$nA1CHFl&EJr>^P$E;M^05*Fzp6zTOUR=+Q*|ttEDLtq_%LB7sExO?zDgu0YZ9 zz6JBnX|G=WckS6k6Zx_U`T%Y;(|7S^Las+qP!nLeG%Skr9o6PDyZgGw3;xRkL zWNz9B{>1o-@o2)5IE#h~GouM|@{z>zWRzqa^oE-+_G(qtsRi>2NPhNkYk!M>7EGQN z9kOcCLZuB+pc6?2^}D;1we`V$c0z37@7n$XEYrQvi7#JVy=tC|85F;*)o6#^@U!&e zWDe%^aIe;*iArAn!j1#(WK{U%gk3(ZB4)qp=~NetZ<95vo|x2O1!vg{$}RRQQ7`^} zMYzf_zZ=B6_I1Sa7UMvr#(!tAhxtQII zhX@fl$1e1vl)mBQKeM%!Br1O#B{{X}PkNzi)-*KRTQuvkni;ZUwSUlS@i@dzzDL+i zb{*VGt7-n?)#5L}2wvHO1G2Hs2|lg7+RTG0b3q-#5pv#_c5!)Fe|xsc=dlZ7i3GjJD2+1?TIc(hTx9cY|bU`qM;@G zWS;Hn-j@8P!vF9^;eYEJc-n^wuctg2yY=6{v18zmw$X2D4kyuG6Gmf-Du|Dqynt?q zgE@brj7RgN9YmB86}Awy2oCO~<3V#=t zKXD(S+@t(^C>?8QLxY@OnnV4kN0df$TlYDs$_uRTPZ9Qm zihWV_7iftXGm*`Z^o{J07X{vv;U1@EhZHWqo+#xYmvufu+XnUrUPq`m`dIwCguP)1 z>l3Zu9M#evYQ<)T?c)5^R6~S6@o~=5=Yvc5;%L*~lSW$oj`Ww}^=<5`jn;{G@q*mP zYj?C*Hk)k1-hY+GR%M^IIU5GA7AXag{$`zF_zRjfpg+o1Rto?7X#HnSVP@8aT_*Pv zBl?CrR(nAqw2OJd@4OZ2hbVXH6`pqiah^BI-1mw7bBos>fdAcAwaBN4jdR&?CiES& zKf-1&9b1oE!Hh)xdgG@$=`S5}Nj)PCs{I04Z`YT(Nq;TQs}m-%lx)oq)?;%r_rmP; zd4r{1^abpDUObuKmnO3#Nb82F-i+NzTJ`%hexd+TW_-<8cDb+yHzT1La5^$pYlr0m z(>)i`+Q0(igZ#r{c?r3H^T&3ZxzKz#BQRETb{7|IV10te-E2~NhK15E0i~yMp87F~ zp`pxC?tg+uA+X_%h`S9tyfgzNVxqY0N~tkTvR zyJa4Zj7Y{o{i%=aI1?ucV0>JQ{eGi81?>}?W3fzEAg)}&W+y>X}urjsy2>)Sq{-X8?Au95ps!k0#La4L#5?HH*U*stop|HkJ)M1t}99=gV|N7-ks zV#+ieO3`NZ_WK&0{#eeFXrF{SzlHsH>VMQlW1aDCb@&Uh5zb!)ryH$PyU!miNMt?eP9gM4x$OuMTeHj_I- z@jI{+&==p>5aH;l{lM@yJsKb!6<_9o!Zl)@ewEO8=Fumbc_09NGW#Nm{houzsDFOQ zy25$ZPB$EmD^Q2yUU-3TB~?fFf;@NlLM?@w0G_KZn0DTNZW{0B9$>aNSa8!kj^k=x zOInAA+S5+)k;GD#Sca5SG5rHM=Sd8YhGFJYzp@8xn(!VP&1N|_L~H0_Veh<&1B*zZ z%MLd`l&vlC;0yv~GQyqO-3!^hX@8zCbg5wfPCJ`Xd$;L3(p_xxDLO}X*-*)Z3ow5T z;oJ;YAE5&%{a)P&dAr_Y7fX=mC+Kyk*OL=6^c1cqBHQ zD3I)-nSx}5c5@L7Malk9whetO7Bwe@UclU9iCP?FCzBJ|+BToIk~;gj>3`o_*z$WT z7P)vMYreVABT>t~hBWMB_XtZ{YPPn*L+Y?RUsC685&G{q$lEWnm3o&v2OB5k?G1{> zaD6qmoA1o)C#=>kQl2>NZ+|Yr;E^I2au*e*J9}htJ2JYheA$LrNxWgW1|fG?iNYBHV*m7`nA1 zkd|I4DDy>y>W*F!ErkjE7wmO?V(}QnP!Sj(Jdo8ReInvVv#`~J(I94T(rVT3W(v`- zH3au5SyhLEdlkLw+ke;$Pogd8K5aiVh8u2ZfU8uz(;E)JQ-2@*@H++5R6D>z)Pee; z``;yH;}Hk^z)tEjCo0%rW(|$Sz5hjh2sV4525dSG@-j{$9VZ&l=Vj2Io;LUFtE%5k zJqn&y3a|18d)NXFAsL$MV}7iUuwV+7rCYwk>EBAuwU89d6Mr(MmUquKQ$-@F;(+yHg@>3^NB{PT6`IA^SC`&MTk6I!QBei`FIz{BwYxwxl=#AOj=yRxz3!7ll*p~ z{;%sHZwPx_ZhuHW_D`_8G9vq@p$*lj4wU7~NAyXUlW@xtMx2d5ERveCsx(6+@J>M@ zd*Mr(Ry{Mi|6-?K9K7!+P}9n4)ZuX5<6UUl3}LBGadYkp0({B|Rs}BtYNp8fp-p53 zp2y83JtZetqjR=^Zm?Jzw(tq_VwXCnm0DM}$IGH87IZ40n zcTT`t=|~`)rKb(zLnj34sfTHL^5UHZYL|8JEOe@Kq0G`#E?9OrvXIF{?R+Zgzs%?5 z@UVY+mQDEEhCS?!QR7mtEvJ#YG5%|p(%4JI*o}zAP6$hzz`(hQQwD4IIPO7U%{rZA@Mf-iaG`HbH6sGFJpd9Bl{8f z!^u9$idU;FywK?Tl^MrkEcr^FCFuzt*Am!*>i2A3$V%q@Y=Fnz&Gg?|(uZ5z{1qP{L2p@oIZp^=JJ>WbN; zx{KIAag#=O`4B!(e*3Iqt6mlEAJMk48!A1y2IGDb_ZLL%snKY`{$>DulTcIoR)JXQ z>Z1M71KpuQhn|HQgDy=-GL`9$4GQ6GlEZzDHPrcfBW(}?hEI?R8q>ne`qCGEA7v^J zIe)-7H`OW@wayJ&))=AJjkNNV>Q5WRQ#K9RIDWFRwHW-}I;dtK2Zl3R{mS_Jx6jv< zTkUxy>m(x-T!(o^n*PQ|?3|+yEMwK17>*v2w?^U??d(XD^B(<5RMQ)PEmKj7aMRC) zAJO5GALI(E;uTbi2!OWi_usko_QW`wI)A@Zb@N@tE{+#7%kAR(UQZD<{Df$&^~cTF zi7DaZMEo7@W-ldp1hxONDNcBEms67))w!bp?^QdNpuSwC`U1@|6uh(ar%tb*57sz< z%e-|Dd2Hbc5kzzp?IxtcVS9@receenSr2*+5FbH30t^B*J_L_TVyb3+nC^uqD1Q(S z@K@JLf7gRM*+T7B?AlT9%U<=1Qdknbuw1%{`+R&iZ7(uwc?dFcM}4-0IYkPs6ye?u zc0UK^s3KX{NhYR#m$_qgizvS>DhULLsV1BDw(AV<1jBtI9t2n zgghMQwr^bDzz!ze5rt4gD^%~;rGFt}0#c9CxTlU8)SYMH4R%@xlPOP-${Btb=edr| zqiXPT+0*xh1Ry;HlT4aiGDjHHAOmrVQ3X|0a4_Hm2+3F-<7GzGEB2`W*i#KQ@t zOQ%mOoFWgE59?2LXo#3Ei8c7)p1o)6OiG6D!O^? zQlia`HR|FGO^7hJAVR4?9Y_S4R?1n1&+#X774O%xnqK>Gbymth>dkoA2(VyW!y&C@JCX z^i7p=`8jAu@N`FxU^u*tr9FiIh>XqEZ7k=7Zf85%W)z{&H4_mvLv$qh`nGF8e`n!T zb6EeKf3Q7c@=%HCL?%QBP0a7`?;{Fp?wtGyDd1&=f957=I$BP~S&HD&y5$ z5c29G)VEX@t(BW$3r&q3rLbN}O?GvfWJTIY=Ofd57Tz2st8UacZi+KbXd4lQ_4|X0 z?YsufbCKX75}BLu>e;KQGqLk;kBz?|$cEU9z6sCYiQyZ*mB6`AtCwot1{3F|%cYn- zb?$n`7lPGLdJY?gmVZ7OlbR6hp-j2R8}9bp-RxEKT7MRbosKIufbb$rl44kD6Y8;%zz@O@CkFgX%Jo=Qo@oD?>a(@yk^!3k4$^mD_G&JF7hvYz+ zY`&E2cbRf zh*zt^@9XJzhXR+HzXqYFgWwQ+uLHji;dfsL{{J9&&L)CRTU_HI-cq2p-c0xN%Mn|; zho05azkjW`Ti{XCb`txkr54gQ0A@GA4BkM`D@oh0MBp(VmEmp~|KerWdBgMz2&O_f zj{sr`nySSID(I?p1phmUw@UD!68)&aPZF|um3ZMSVC!+Kj&G@h67rK-`yuVJOTs@R zcH88>-cak8=mO_F#5nR-(TjO&sI9!;;r^^9wST29Ck>+EA^O2!WZi!9m-IS zfqw(odC*DJxhsTVTdF>JDU9;PDQr081GAyG)WHQlzjYi>(eF5#s8l4ur?U_uEhB9| zbIk6%@gsdDA0sEM58g$yw1Z*uI4qe)OLwXndW48aAH0TOx6ll2#U674Jzhs$9(Srh zZIg>~RU(oSG56HP8uiInK)S`xF-PC67Jt?7-X-9ifI7|l^h;_6%>1ja|}j8Hp_a z>VURD9X}TPdeV;hG7IIwFcOh#WFE;|BA?3GaRLlWDN;T82lvovs9^H%!x8i zVKccMC+8%*?{h<{Y}0SO-6jHo%Jr@g!@;r?S+F#E9%FjWbV0kETB7f1Jo_r}O zNIlv))nI}mb|dLB?sLCj=EvGgf=m;h*CxqD338n}_XA!BxN{Hg)Tnb`kPCNu6Sb(+ z+&q}XNecAv4I->s1WhunIhgKJz_tj6Sl-|zB0`iP(&_GUzUq!V5gdqu*8WhFkUe7X z3anOwUP=G{KnRPPl#OZ634iyFL^tkcKF%3vZv6euESeFu1Juk8_d8R05*|fh{9ViQq(szHP@ z9(uk$;uCW92I`kzbTLs}Qopx-!JYjBJ5GX$+(JElgnJqhnafD5C5io9xzb}yiW)p= z6KDD^?Z6$Oo;&nk2XV||>*EQW#%5{M$W>aP<|Yi^4SRN%s(*+IIhsY zq|a5qFW1Qc;xmEA%ye*t{&2@Cf4F`7+Y!FHlQ%4fX(aPvdDlL&M;YI9er1!42QnMz z%JHk6MOwIPJQ)Y0{#rOk!jV5mPlmcy=^dyW?j8@NO#HLb!*)jKMrF6)WTZ@S_ZXR? zKHis?L)j?5c7LSNHag3ukD-Z2o@=k^%XaNrP7U|7dSsX3yiI2mPdI7dRgpI0Q zjE$x0WL!z_8!1u!Q1bniiY2b9MCKVyL4U9oDThAoj5pkVp&JL(HBmk$ z^6aT|ZxDIxa@zDI1o@OrE?|iB!?6$F*NR1=ysscHo*T*bDzlL~Rwohl7BxIC+mhcc zNqA0LV@hK2MDHlpc%m0%SMy{r5h7H&wKpVTk?ha5GV6>9sIY@D$$IMr{8u?1aoA)%@Pl}X-JJjMBN1xiB@$}+E19@PwL}XBJ83`eXRY% z?-Xl)#rN;w?;ESOE2jPz?zOWB-!&HEo>hLTi%NakdN5;|91iJeb3NLx(g)A)Yz~*i z6#CbWg=$Iyy*KO3VA_X~-aE4=U1zIBn}6c?Zk}2^I)UeqX*Ijgsm--Ou=d4=l{42Qm%nAt2TIzL8yr^Xu?_?J9uYUyb za{&5VMf;FsC$=rwn1Gw?{4A*{`_C%g%>99T)CI$+ogsyDi29n7+OpS0m{W`Vc4;=a zM7Bq)n%fVU?K{qIe?9v!mMi!M(Ou^L!ne*jSB=UO8h^7OEOduCMw69;q-3Z5$5th# z#3V~gHI6v21IyoJd?WYiNZQNwg@53lN#rMdExE@Z+07oOaF4%|6Eq;@{2n7uIQKTi z*x%S63r~^1nHtYiiypDx9|#G&Go;-t$%yFv0+ME zZ2d^!P9m4Ut24VYO+mEo|Jf&@KEOB(c%xVzHC<8a!L9 zfAPle^uDnm%D3^o&6XKSFvPjML28$G9Sw8Q!ry;`-Izwr>haX04| zjlFu4kyX!@ra{6X{a@S%%YUlFY%exK>d#fjuMa5S>|m#y~M%cnA5}j{736^ zg}*Dlxpq?w=k&d?{JpUJo^fNWj_ZD z*2q%oqYG&Tu`PFNdX=tK(4XKACAe47DltFw#HoKY9Uj)X&h!j%I)%t#QlKYZ&=4VM zT@KIvtXcI$18J}#J+m4yPqXTY4ie+|Do^Cmi5kGWI$gg=>--T;lSzEirM`qLZSl^D z4%4#S<+K`X34fU!?CDg*;S|j9Qzjd*)5q|E*VUIwv{HBC8MU}4HgT(^RqWOoaLz|{ zns0ZbVEuSL;U9lLy!&l22d!AH$rlL>Uh!)29}4dQT|GKF)!<8tFg)@J+H^uAulTR% z^D}Q{rn-PRWnN)V9%PQ-H;`Igs?<4ySu{l=g+0W$jeoHge_MWG1aXAGN}@Xi9(r$K z*0*MzP`#?Z73a>ueTrJ#Mr`flo$$QmSSIL>PQUQcoB`z&rJD4;sHV7D9)4#&Vz*Tn z#q!d+oq5JEQ$H2fd?P!W&$|2R!rq>uNZ=OEO&I0-43|aNq$S+FftM{hJHHoq_G;N# zqrK?|i+=%YrRwvGXB}14qF>?evRWwo+<)#d4}!WI9fvst{c3Cfr%kuVP&$@=7-=y( zj4ODHU7gGJbk1YfaXq_yPHnt%jV+OA4$--zDfxFw;vs1{pe>??SDC;e9|i7F(8|1rwx01 zG=KFOyAg}bXSAj^ax#y^DT!jEpSF=5=5M=@cgxdY5~9uXNDdNc{ZzMjL||50qBJDk zOiNJ^m8=#mb6|Dk!vA(Z76LxSlP2y`Eil956`Cmp9kYO)fhDn}oV(sY@$& zg&uZr5A=$>x`?M}H$P`1MT%EjB3u;J?|-tA)#CSB5PR9tpe+vWsP}{hrv#VV;e6&< z439j{KhxxI?Ejjrt>P|;qmh((zRNq^zk z&c>nbVm2OsS`OG)YK!q-edrpt2lc!u9#$Y>5^B4eJy|~F?RukiIM1VgH#!*;#nqp= zWg&z;aCqF$V@-8c9SZJJJlZM98gM?hc1E8#s4fzl&{UX#gv>??>CiL~!wS9rv?x$V z8?h3fMl0CYgeJOsoI1CaiqBPwv47n72r^{S)jU3Na5gcQIjl$*)!0SHU_*MU%CsRp z*o2F?7*{s35Bw$J?3*QMO6$b0kW%V|^>t>M~+pdFeI{n>$a0vN6cvv}s0 z=$&p;AVLRQC`po0(cLPfZBe2rZSh-3+h8ION4PsndKY78Da7tZ_3?NF%71CUiT=** zqp;6I7w+SBn8&^uA!nP*ELis2>UV<)f72ZNCKiwwzDwI0{8JH=;Ho;PZF2?pDDY~! z&aa56c58;ViECFAg%V}+pkE(gMXDSd4crrYn4=bkoL;J(69iv&%#)9)E z@uWdpuI?@JwZasDREPAw=?Eas7rW#-9jsji*zdDO4dx^Wo3E!wL4S%GoR|Qs8^XT! za2>0jy8gwjiZC^_OaQH=vgIMWa6Y%qNuEBWd4UobTgY-DkXGo{e|uC6eD2G!$@o#; zd+ud98PF-jsENJGQLEp%k_!{zAe(O&^j+AD_^DcyO+Q(YJ@12h4Jn!Y2pKK+m_J0m zpmnPx5z@>Pzy6g=?SB$;AvL)Y7=Tq&PwF2-JHky_5iBY*c>{70ug+M_6)y9gX^7uk z<0oZ5&nLKwm!(p7iH#{SeQPYw_kQ(pj$ndi;#3o;1yN($%cYqb}GD{IQQU!@^gHuGAnrE#RH67TwG` zd!1b^sv_XxgMpsHaf2Z5cXprLoZm=M=higk0S27i=?>B4@gRJ~4ildBk{W%oBza zwP;QqYszUf?<5v&D}=4a7+)9DUtwh{zA?@;rWv2e^M6TgyPiH>E)hOxeoPdnYjL(C z7pD_-tIT>nBhNtYO%Ty<1J4L%k>U$?T;~sWO6(-KQySvNLQTYR#p(p}I4So9n_t-< zJx`K$`lK^3lG`|DFX0RV`5$&Ys>=hw+PXlpMr4Ci1TZBlf}yZ>YsRsc}*+FG}RK zT*>Zv@T*#;UtfTisl@PKm{aXw44#E_&iZ+W9ZTR_r=6 z&m2_m{m6kkzqX!3#*2?~UiMyN#_>MEy-ecn!hd?xp7cDYwKCp5+vvQ2I4IU6^Up3> zLawf#D#$SvCS_JR*(U0(D@i)VQ5O!3f*!(S*ZY%zX{zj$5(gWsm{gIm$-dqtYsDv7<-!X-i91a%OR}N~- z8@@90PXcWY;>mnY^&54_`013iKQanB6MvTAM3i648>6v&Z>+Ps`s8w0CyL8N(TTO{ zoP~DD=Tb}uHi_E`6SqeQqh)ksm2p+f&Z=$lb2$l-{Efs5j<;?O-b_nmIhO96XYFu_ zp5_4MLi4zOfynMYWO7uAJ3KHZ(fkNI0Ne#j6`2OqwiHV)mKj$g+Ue^rITTT_QoSSR(Red2TTZ!=lsKaQiGW5Ah1AJ1Kw z8fDVgTxYrB5qSM~r_K&ih*_MYQ^6By+s-i@+Z_fR_xJ{SRLT~s^Z ze?=F*U}d5&vohfFg>KdF*d*#z!VNp-?{X`0xdbx3W-Y5UOyWlBbZW(p&lcA34X-%PP9D^lTtiNpy#YQXEYRn%>dZ{26~~dQh z*upst!Ly1w=ldf_=RmSdlw{AQJ*3u+v=I9oz2JVkU=OByJzP-V z;+ZlNQe1hwJ_5nXTJd2KYBjR}JMsOp=C48!GD!(Q^m_{$H+op_M|WJInGQ}Cs_*xNW|@Ebcs|#fJCd!PG4>v|&?n0=mg~!pNPhp6$ZNUqh~)Gs ztb{+=1Dvq9+wmCx?*jfm=SsR`3=v|1)!xp#rdJl0H&S)K6BNN*_1mKv#ZVoy^{rJl|ueTcfXGN%P|`irENlF;M4# z-mcgGC}A_yw@%Y7>A8Pjr0c?Y^=}&Mx!2iEzm?08(L+1vlM%2_2|9+~((LN_F@F=8 zcjLim9{mxVTS%ro=#SgHar8w*eW2~gt(BucHx^sZmy(t(=d&S~E>riA}Q0nDM4x$Nn`{{B_aI({_?QfJdDw-~JodW1LWOMT&49Mk1xmW%Jp9e&SQMn)R(MenbLq zZ}Dq=65;i9jQM{e5{Mbg_`KMXt@!(TX(9R|mMNw9bz~8LBX*wZ4S8e!M9bh$B&vCC ztT+9MkWg-y$R}?+5Iy&XvuE_Z2;OVT?+uRDPe#%#LoHs>z< zf(P348|nNYTd5Oyzuln+M1H>?dGNBr_UAU?PUh_!zJCujeu7=eSVhM9W;z_oy2Euh z>xo=vTP{>3{mDeV&=vzOL;jQlYSCV9_EDSu-0#Al4E}6w{o-(-+IS{*{vq^~K{AhC zKcDs+Bh-IfS;Z5PSNeEu6#gNZG8wL6g}+DrtS)56UdH*5Py4m)jp~Tjsm1d-Puy>Q zt<)IBVtlHsTOA2(M#ST~Xx-|G(g~Q~N1eUA7g9kA$I1H zRR}OkAVte}oj^&&E)Tu&G!oGpRuAL69n{+DsW zUo_aA8sw6xD#p-tdLFkYOZzSA#Dc_(SYJ zd?VM_pn{=G?HvDyH{5(JdOzJBxDX#i58TZYMS9eV!ZplbF6L?iZjOOzU!N2wj&*0fVGzi-oGI z>nr4AE-oAvSyy}nCbT5hPK6zJkqP;pgy3|K(T3hMAJ4Hha)IZv?ukHEx;N^^qi0mG zjwX&tI28?sY}Oyl&*zw;=Vf}B{9J!$POQc!3dQBEsF5LjdCPI80{bN?U)^P7bu6Ej z;>kRvKEubQgt*Z63TGiK@{1!?Ka@g_-z-(<4&k+N*D?`oloV%N6XlQLUT?MMg}-nC z$pyRR{$O$cZQS1TAY8vj$tkS zRUyfZ-9Gdsc}F9%zMm5wBu*zH%li4v!zzKUcqjJKC-v6L854oAi17Vq44rrmW#_~) z@w}Z(GrIN?=3;U9(rD7#jn1`Vy7IqM#3{9iCJOheZAaSBf^Ye5r-o(xT1ThRa8|%~ zJQsdG;OBgc+%4kFT_1hXQ4)Xo(eq~0U*@=}zvd}2A4#HqXr{@6_vyR%y6|dh^NUM( z#?!w=#v5X}dFQg+EY^Gfc^~-gKJeQY?u+r;(I&qgVdb|yto*jKMyx$h2rjU!^EFBw*a_o zsFjt;K4kgiyx4c_=YJ7E?HvXuImOwx$A|Ex$DUo zcNKcY$aVjYzgGMOf2Ds7{6a+}mLC$r>QL$;JA8Gs+{6Bw-g}*wY zkwWd9`iB)({wX0+m@CFR^(W1zU)cm>pAcoOiBZ;?s*g0mp0uu3Z86e=_7Tql6Kh1) zF5zWz2D6>Y-{QkPeMgCO5}CmGpUSCU(wTR5KcCTxv|S~CQFVWFhZ>AiWSvhhr*Yb* zK64C-JWB{U2ot;gYsE$z1!I=ge{yyTugX`yBKGlsg+FGB`;X&(Hm8yumS{3Slcb|O zFcb$CI9;&7FG?G+z>@w)>E(7#*i0s1o|)I-G-8SFESFPcrZn*JbAAYh7cZaRBpKfB zHg;jgOyog9K~R66E5X9l4OB&CkwXsKEMIW8| zf*#$6NAu2$@9drOUliYYvh9B=zVkra|4e-6?zaD@;yb&w{qKnH{HzVfcNVnyUyJYL zdJ28=WAzkj^Bd*EQx`4IQWve$8u(n*2wz_pX_RlxxUPR!qdSe()KpsC3DH9}xHquh zYN$_&TmA0u$)wI;uDSMLCGy*VlN~hIn|bnzVPFVt5b>X+U&kJLd1hL$#8B^)V7Zc6 zK5-?N<4ji<^v5Z5&(@YxXc^zh#B~kKHldq&D}maCS|#fixt}Q_D71_f3!BW`h~Sa? z*|lObdX|6o2d8jI6G<*&{S+CYI+iob4s~7Z3q8htz8ZbLoHvmv!c9mYGesWZq?lVh z4$>UU3C1=O>*e&1#CTJ)l|41;@U`MNQUpyPha7=b$Rr!f#rBk-5Wv4m|LxOABy^{! zsO<1*9ua_;LaX%gT-g04IS`Tx_tR``$Iy(`v50@$2fEZnzV*UCJ;fgXn9IrPoRM#(wTiY0~wD9}5pxGjE|xOCjll$n`^67&Y)F&3(Ar>Q?bK zkG6+|R=q7-I~9uym2suRK=f7~XXUpSD;B$53;N;F3|~0;k8JHUihqZ@ebb5)I$P?u zn)ZLY=gfG>e$;R_=|YX;A*-#H#%=WD4#Y!xv=!OfVxP7QcC1#gW9cRxWZOhO=UlcT z4@Q-WH~mU2s#LIjY_!M&Jc-+tnW788dr|8z<&JRk>TGR=Kiui@R`DXaf3~*M2P>wW zkL!e)?1U|9CcFPVTefmQ*vU+O(p=Q>Qj34DmYMKg#dAL3F zscl?Gvp?^1mt||^9&KZ`R%NljvE6htrzas?RC=|Q9&M%Z z9Uo}@jb-H$)E(GUC&DuY`z4L}1@j>8Da%1z01W#Pw&3N-NY2fHR}jhhycx;a3|xK= zh#}-->-He78$fi?m$yF`a`x*wG}M2K>jp>@pGaWNB#%t0QBz+vAP=(S;>s@^RC`z) z&hwF@sL|#}cmd&-;CM+(5gl2ysPIE28p@q6V#6;-?m(Ni$s6ifB}(@= zUJ{!&PS=w%aW_thdVa{#wEKj$9zvs{j2%D?>*~$=e}pow`ID8{k-w{WAH$V`rXXLtdo^?wP+w@ z#dnq3na~ZtpAPO+w8bQ2UBQSF9-Cx$X$RaiU#{R5TlUBUuF~CcX1uRIG}Mtja-An* z8Olp7V}CMjxnEh0eRzNJ8n$a7LTR}xxFHfORa}aZxvFqWaEIciFYJ@qC|&9ol_JOU zq9giokKGn(<Xl^t1p!03+^G#oY^lF$g1tD z1Tt%3+3(os>v(_2W8EFxT^nq4Oza?&C{Dk#qHd)=Sn22&vR}|ov3JNmHt_&$jLUCT zwP7bJuo(N5)$yW+xK}S|%`*FI=V+ma!thK&zVj{Gt9er#rnN;LHu7qfMAn7r?u?v>E8K%Ao|mBD+E^W*>?0yG0KP~L zh8FaiDE~U`s`00)rMiFT`#iK(jvGdAcpj(9;noC^uA5uo5_cf}9(`|Ah;`;Ga7?ay zjRon+4vv384r@}0lO(%MbSq!d%5I6tbGHZ;0vvoj&>;*MWiQON?r@7bUP*G%zQzQ( zNQTA)YI*|%d{3*5zo*gnPA+%hHp@(+~^-uK-xj>jD7^ z+gBB7*KgY9g?Rff4U}(IeGtzVJ#cFDcZ^(vSj>CE}F>kGx>afNl$J-kW#|^%b6+w(tCNbxH0mx|>tgwoD6n4It^L4{Ff_ zicx<=VgcREspEpbRn6ghY^;9RXuYb^NTaG!!KaY{@gb(h`9wq(liLhw?(}xzu9!0; znj%V6DYcV^h`dB7UoY|!vHmeMMN>Vhx7J0Y!ERPrDU)VCjoZ+a)T|nHY?!?m!NW`m zi)Q9FXzL8B_8uvd?w95b66TgvWi^rX)rfyumF86723EX8?Q=P^Q1+1s+~ub+5q3UU zXp3`|6TWa4x*45)5A8|pzOv3L6i=pGE&GrD9~?`%E;@^o$G%epd)R)OH1z*}W)79e zY_xLaTAVySqwy3&7X z<%(m7s43e2*l@8z80MqGa=5M6VYg`h2R(5V6o$?4P8f?jR-)o6dot zC)sLD~9k-@xVi%AgZ57S)*TcAGtBAU2Hl>V;7rVXnwJgCy9Uh3r%O8 z+lfZ)d>&~u&gY*ayY+Yh4s;4%pr_5CwO`|q*=K5YXz2O^(Hy2_TfD;&`996%m*CP-M`al_? z)PX1jCQs@u$iWu|Ie03D-6MaL!$9o4bdu@9IA<}T8DV$i69s*p&_sOUw-wxLpHY`G zX&?vyo%RvR8XW%!WVXKPQUB2YP}F}N;;4MP3)}lO zN3Ql@WtZBXrj;8KSt#u;pHd-eI3P!_*TMB^cUTduGS+63N9|X??R+T82}rp)x3Z{9 z#KUoW;DeDTrLE7Cc9-Qz6H0dGxuuQGF*u46%*3ok+;VIU9;KGMk~$*GKdsak9=Vth z;ErAnbwX$4XBBoRj3$5Gk)n>oSW*US%^>~t3fphNm5#F?i{aNm*On)tQqJxYV;c6E zn1?&Na^fGe)>=yfR|-1;^LKdcO6Z@II+^3HvPy!xI=D-t&4Pc+(t~BUsBcf98!NS% z{;fMa>=wO^RJ;~(gK81pa>wrM#S`C$1*hy4b}v=y9oaayxiXX0-kG0S-xr}BNnSjI)G0r)&7Q(1F6ZSMEf8vBjk z8|gD@-QD1wXeoLXjIVFFOE)eM zO`mxPiKk_;A1e3#ik#Am(+bnLv%q>a#V;vXY|ekk^Ok}y zfWV41?29}Z^CwQ!2PP0SPz%KUoJETW-B46h@LK{)3dq|Pc}esw=Q%Tds|I~rFybzY zr6R{>$x|GxKMt1I@H|Gz5)^KyAB=nIU*T)Xg$6Xp&tP%Li&yMrAU2oczVWwT#AaIFBD9^vrv=4vf zVx0N2#W;P#X&D$xR)#n#Y#N~UyF){rCP0nT{jd>Pzn9@7@~|TK=R4Hb>^_cDrsjLj z08BT}J~^2FB<>$g!s)6QzQ#JMex^xyp|g|XPm({$SM@2s9)FUF^(nuQKgk&C>6h>) zxku~gf5e~U)4G&jg+ED0%p=@&*YSUp|1y6PLBAS}V=!Er`xs|Dnsl+OY~V~s;kFN8 z*>tanWjSn1R;id$h05vofnJ?!Lf@nx?U@>j0)2l_p+7Ac2j(a?Xn%9TE) zH)t09!(zD&C!-CrvNdbLKXcCU1$#R#mV?tQmOv}bPj26lXf!m)$tl^+jm^my>WqZU zg2G7r*<5ad%)`x&z!ddi;Z<0~7hiMt@Jde{}w3H;uqepanXY!(-0z zDdQaKdG(B0MbEUch#>HpZG?aOWF}_-A=!cJP71Mv(eYT{P?sI3sjUu!r5xFm`?uj- zq=7AQ^R6_g`-c20^n09H{&~tYZ-y7qc)-S5HCyk9_QJRhod>9E>o>za^(hnFRUPhq zk2BmWbEI)}7ecq^#)JHk!&(861L}8&VE!H&8&TtoslMz*LVn=!7KwlH-cWcvutkjN zQ-<<@*(JDZ*%-R0=o>7NcrQroY3&I$hZer*hg9tCW2l1b3tb|2Y>>l4gcxMNC&stB zDS*!<7(*88`YI*{b>neJ48rp!ySyw>?onqY_E&t@G`+t}K*)xZ)3iJl+Ye9ZF{iO7 z7hzA*^Jbg(W5%qe_G5qRG2!33NliOSG70dz&wnY6`1O z{7@>aN0P@(Si}!;afQ8F2ES{LfUz0+(5C27o0HI^8AVOu|7$;`(85!31~94A1p2?< z!28?w1MicElQ7&BX1v$wU($F)|3{45cT8ra=R7uTtXll5fuPA*KOPZgGF%ny<_kjcpKBPoKI&JRqy zf82dU<#o=DlhKo5XsFTvybM!*W)u8Y2b!w((n*z0cUP|EoI1 zmL{fhJxfB!ptddw3| zor|{)orX`Z*=xZ0hQ0p|oNFKd58zyXNWl4`v(6aKvmQ@^^TIedr=0f?-zpqu3{dg@n2cb6LvfE zUzzyt&1o2WRO@GC>v3cai08jDdy|6y9*^h0*=*vKIlo2m!KhKjNal1TAuR-p_-`rk z-%@{_|8m|NIaqY9xaro`ibQ6J`CiD`V5nX?{ zFnqU9;P*j3UhK+%Z0VXTnNhH2wn=FKqjJ@SMn8Sb`h|~AB~@NSc$FkqUOu&Hyk2O+ z>(oTN{=ZY=b>&g$v^9Kw`)E8qUk`sU;j>kERn#mYzDmrf>NQ>e9UA8JX%0r$=nh7g z84gBLQERw6v@zsKzn(`!D!k$ZoUnfhLE3ZB9_Q02Og*6=qvps5@mVZC#y}^&Wfz;V zKWSf%`YHD1u%9qt;ds#xIeIdXKSz#@_dE8lps$9re}%~3fov&}J~2Ixksm}VyrUlN zskednq2&p=0JFNKK9;8?mQU*MM>KDbH;%--Jzm93o;ecB!xh_fpHkxMSnGca548HS zH|2NMn52c4{p< z{uImKw^vKw{?s1rrR$h>N{*?!f7G6hI2es;^mpP8!i4twIqBp%KXB5?RS#P&k%E2Z z{9Z$#jWZ=$lIHbEL9TI<5%Fua-*{s?z3XUPHm1X(aLcgJDAb0BH7Y6c zLd49K=fMJqwCL&|&J`v=f2g}K0RpdKB#zhu;qM^@jz1JN!y_?%KK}$>Mq* z%$Hci;dpzic@^FDdwrAZ=z98fyw&Ek>(J#R^Zd6JoNoSybpwAaRv?G2X=?t9^RrC) zSd;xVReiJ|W`9jJ+lw)4HXf>})M8Y%oPwj6@9=i-;>tfy_&r6|YksXoYYWoi9Vhj? zUW`(v{Jv*^SAVnqr+D>F;I#X3ZtBn4kA8tO*$>Ch-;cfdr`wO=Qqq1%!Rg3jCHCZ% zMl*dR1Xm7Ykr01aZl!fq=3k$1UMdZ_#i2fsZ`DjR+WNv>c=U?q>AXM~`svSzU5{t` zH~VjOhW(!q_e*m=5LwyKH2oq`6(o#=D#kDH3^R`HHQ|^)+@%cWgQ9Ycb{QyU+MgP4 zYnxPP)#{b?cAUZapLqK7fA-Hi{|}u6-_jH47swaQwt0WkjPMJ#sxxyj1MxsPNbO#xcIpIr>aOv)T9a6SY_{&;ZmXCb zrsaPQ_qS2Ysc6}ozb_z|?ZSQP2YMd9$%8QKbpi7w?7wQ$S3^q`!j9}dfZMuj`26O zKO>FzvfpMgxtp4|r%At!;rE;TKWl;Q3$%ajd0q4g8>zlMy=Z&(^fO?zonbVC+No>$ znKo@Z;EAW7_cJ!F=qv3)Z%nL0_@&yK_Dd}pljxT!&;}Dq)wh=?H20{n!D2#hY^I@e z5~tY=6S_L_X(QUE^^4nJv4F$$#uS59-PguAM{nNStO46ivsX9K3sI+Pw&5?t8!UhF zi*kr`?=gMG#4ejmSl7+OAjoV!O`M_j%@~6y*4%7c=-pKi=lHGBWFiyFP5Z z{e54|cxcScWxb}IvEll0rP>O7x~ zUn2F^F?#b`dZWHY4{Le>E#9!29gW)Q_&R_VvMj%oi4QE(_&}OV{c9e`Vw%fv+Gz)^ z7UKtv!T5m?SY@kN$BV22M8==ph&QdC)29cWEu?{f2*ytR;%b z;xiGdeQX51SxRrr-dz>4&8VZ@b>2oD4s+yqI1IypugN+b<}-Zz$KbF^_=MZQ53g;4 z9}*n?G+Mx+Z@6_gv8nW3e@C%6C|em8SquvSh(8{V2gIZeG==l!ctBi)dD-Y;bUGxqYMO_z;qnmADOG>3*8+y_e-V$n}g&U&31-o$Tm^;0wirzq2S z+n(PJatKM`a-Xu1Nm6ecOfQ#e_Ds$0l6fyAoy+O`WC~$pkRX(KN=tutsKCjj2o4;z ztlk*ngyUMc>#B7GlJLz{G-TDSv+1mGUiKbm2|rwK5!#$1=HrvR1Uf`Ss)fDj;B_DE zl!EVTy&?49nD*%2Ha?0TWe4&z;XT(M>|rbTGc_EuPH)(wH^arC$v@B=^(uNuvMQlm zfz?cr&(l@a6A0xF=XZZ)`!C_!Va7MsQwyQw%2C#sy~QC2bO{Sz2{ig)D0c;oKDQc} zH^d;j4Qpv8fA)&$=?{A*5p4}@Rp2t_|@H}$se+PAMggZop7~Fj%-KHc3Z_Kzm`QDKT?}WgM+4?P}DR^fl_ovZ+2gBE0)4R2` zAXi($y9Vma&oRJ$7+`m>m)20Ho^1ygl2sa%Wo3;nS z`VfJW`YyPhelIb)dB11E1@kd{_k!uWDQHXU=LV+x#{_EQ;WS<0t}iav`a`*1H!WVh zo!&-98t~9Ypr#v_GrX=#9Jd3;ZI7?)vAR^I`zbZ?P?I=8jgPgu=jM1}Yuz%Pi>%V8z>v z2Q}isvK}^0EH2Wk$)QYj_^x=#N2U!?-|l}AFH_VnrH4=Vh?mx$MaxHe;MzIOX_aQa zVX+wTRxH^RE!QDGC~;!9CQd9%n;3FnBJbNG4vV8{s`GZnPw;QcApa*!@J>u{fA{!@ z7hr;$yKA!Q6M0dsBc^Pc1k`ewSpxc?dmIN5_vMWm3G;`q*!{N6qLZ<1xDxPP0J48A zpj#-2pP{ zS9XFQEyIbxA-=eK98+q!L_ekW?lA)A<;-e2f#a+2gSfJ4tRg9{(=ohheHS5?JCy5W zngc(U8GP>@O80~)vd=NT;{J?u);)hxq{1bv<3gQ^Y0ms1AUz(XRt~kVkmmMk*TY({ zj%NJ%QiBduTGjqH!3AuW=1!1$Oye`!f&UA3@S2-!Vo>UI;s+w7-%deksL8!c&3hHi zwpn8G_e1(n>Yi-#Fn1h{ALechvnX2(6X_lmdQTFjjqm>!_q|dd|9x+KU#Ne7U$6Q1 zY7D+9zWmD2BzPCc=tQQ@Pr5b5Pk4-)Mic!rOEWZ^#TP2i?qw#X0o#Obd)zmosJ!Va%fYr+J;93`xqjz<8Cl%^$wD)v^?U zV1Ad5VS)QtU{W^I1Tq9>`$K;{%CKab$YnGUIQO-fbgAap=P9!IMItTaquIrjaH8<`|cxM&WW#T!b~>8WjlX}72*3OozaMf^e3&&j2~KB>52&xUiHJrAT7eNsuBU(Aa(Y7pQgxv= z16xWc;4NAzOWtaN=;|A==jZEt{$;sNo9FS10lI`c46yvjc>C%NF`nsRQj@?lFG7#) zG@f}5^UUD}{x-!opB!{1e6vaU>QwwQGpSofKZvOMeSetK9b9bF^u$PpTn6Pw*Uj{g zM;YsCt$x@Qpcuv~Fus2_zup!4;XbXccq$bJ*f}*qpZ>E<2hilM;>h@sOJ=)Z(uDC} zpaHSh1>1q3!<>FChm0y~V;IU{YN%ds3@ljd>v(txJp^Z+G&xc(?%Q;HAYR>I3|`+w z3?9!lX)3Baaop8i;>XRv5T7SJ{2mYArH3BknE3-WY$!3t3w3`<0MMgd%m6AH0TxTp zDb+u?lio+}H0%pVNE7b*Qdx>VDl&RCyJrzKCoILb$H|oKyNJ9i&_x(swm_FpHOBPW zCjQ*}Pd}eOzd^Gw@#i_1RJhr?V~PA3=py*@wCm%@=pRaSGJ5az$(P1Ejkmq8KPC4b zZ{prfUhSuo!Y7oTz4w|{nt`6;l1TLGyi_Y0MAu% z!z?%yKgG{(fm){P#{^_@b;c=ii(A|3Bp4txA6u|F&nvA>N@c z^|e=JCL`WXnXRp;b%}}7*ZxN5^v@)5`Y*pSBizd07WhX3D|1Cr~v94Yw~<=c3-erEPN6z~Mf=z%dGt@wsf{aZQC^{RF9v zDBDYLnk*}#fb^uH+KGL<*mPp`JiVf>@%3Cj4*i|9KJoKLePV@kvmW7c!XQYWUPat= z?i9}cAw4;YjofVqi@_G^c|SNDD)5RN8qc|}pYeZ(1B)T7j-__F%CXtTd3&$veAn7} zd(UF31M)iKOY8M?Y)2O}T_)<5RKNGO#01oFbiiEw;}b9;<+vOkyn*Iahcy4;i~AMh zAX{Q}N~|IQbxynfqwGPSbu%ZRPQ;V#TJ~vwc7s%uj@X^oG<*sVc1_R(1m^(}){ve- zVS@m_ttH>X=%#0LuL7H{{0S|3!mUO}w}>vm`L0nu)s(e7%k-9ON-lVP8ZJFRc=O8&NG9sEZ?-@VP^Ipl%H}9qA*CaoG<41aap7vbNM=lk9 zqnFcIXDX+GG8K_BbDYz_SUuylsAnwNJrsXe2YDyaLCy})K!_O$ay5<|;heGAj4@2H zKty~>eZR1Mksnp#Z+`C!x)dl8;b)8FpJJm?f6|S@&%RNe=J>4*T=&_nAr1&vZam>i zTa6;sM6MR2HnG#EtmjhpOwIfp6GMOIfRM>Jtf^J0fCr~2-zOE8@M5P~*gi`~ayNf6 zYo|tDI-%8VPRvjK=m~*g$of`vHy0B=k*jQ?6-88zrW1jJt=wD%yr>^y*BDkiq@we= zOz;Y(kc9AlWqZ|U2EDq+34-h``XTTJI(XeDGWgn+0Kxg{ErgLlIOAt?o1 z_YgS85H!ca_CDFKh?0JjeydTs^FKGsCUJSm1--k0>D`i3(Yrw{bb9A&A?TgbfP#BD zh>;SP zmE)Wzy`+&tL8-m803y+u#e`SdLEeM1tw2hznmvOM|u=B@PnpW->x zAOOzq|H;5n$6gi(&pYPmFdKAPB0T#U?{2*8XTdY)mL}oJwo?KlaTM<-xRkaG=ps517e!9FNJ@hOHT*iH${8fDBe!I zRCsE66cXyXlxf~hbKv|2z#Q2@hv3uMI=lw{L%^%YrE&1;_^}R?%P&oY*G0y=7MK1k zc%}Ai5?=ESc#U=4lc(6&b&w%M{Hmu-hy<3We!}Gjr-q@_}(4J*M;M=kvJW zllb#ksGY|@CY^uBN>PuRtCn7x9tWCpKGMf_q$h&LV!Yee;WVJ>Xv(*u!KJoGlW=h_ z(7ZLpq4X#%X`~ch%HD*N`EUoE%t4^!fh#or)zrD{sV1Gv#dG*vcIgmzF3ab@|C63Y z`qd?!zu{}?{9T{?Je^K`|J2T3vr$s~{QV5Xo!DQH`KB7H>Z= z_T5^1C*-`H$Mx?j>2g*p66r%EIvBi^=gA8xGtf!4>)e%m-fkB8|jn3s5LjS&^_lfUFiN-wv~_5%@@*Ve>)b7 zKlFyii8_CPpR=I&Ft|VQYm2CulQ|&V>3~n+fMpUGkNT9Ael7wns!-6~vg*RTSUtON z+r>Dx+0@-4T}*u70E>y+xd4klG#37L4Y|rskzvO;z9KXZN{PTN-q2kZT=H)q)|#tq z(75Y$$F%za+Id3{J5k5xJbZ9YZspHJ8yRwlA#jLuulV&kG?`UTHc`(^%a`kBf1VXwcvST?oQQhp z49Py_2i%ZlrJU|ARpwn=qTOzI8*yL zn_4m!%;F9X3Di?R1nTV}T>AS(HVqxi{-Hm6@gm_&nZwLrk9tL^7Q4TPk88X4>9{_0 zkxi7O+sn^BqYl-(_}M{q!wxQ2r+#?>XS;u&oLnD<2b^q7!bKlO9*+6F=zQZQ(L%Lf z1R7Wa;&>SP-@oY}R$T}J=z$*^>Li8QyJWfu#j+hT~2?+*z2q%9= z0v*Pvb?vYc5~6o<3YU2;2o{jPO9cakCW_)l>U8_zm(IBk?9ZYS+gpDxIK& z8K*Qu^i!V#KTRzvi--mb*Kk~odVC8?+rLqQ&O_21d9!j*}eJxfc)h{$QKobJ2lh${E zO%S-w2R_L^Pt7woLUJBfyr(>d!E1Aqqh1^l({(4j&nfFiod(fCSbunnIV6GiBQFX zHUjAo`a1FtF4->d_%DCw25Jvyy!`Wyz6qB*1tS-rmj&q8#}a%jh7W5_T>MC8S4?dz zqWseMx}VOec!X{FR$y{V2DrfFJiT6^slJ>vuaAQ;Gc9x@&78FdA`B)KC6Dbe!M|Go>NVLBLj=`(#wAL?Tgq6gEEvqxRM%7Qq2___O1kUDCT1Jy{LVvMB* z-7};oMxM01oNk}eC#J;}U`lcIC}R0jR$tFEGS6jxCy-gCIj1WMPq2UDSwxD)_%CuU z@fb9KA%~qLPvr!?f8>oq|HB*$(z*YZas9t-$}bR$&lh!c9H>4f)B!L9$jUmX0^BfF zuOR-tbyi777kA&itx6U|5M%6j;~JgsrK>vz;L0$&{y|G@L;2V$Lz z(zuhEZX7Y(>Zh>Mb+dW2S3VRM(*5d7)S9kSzacTZs+S%&^yz$U=TVe zq+o`*OJOym#(lNMj;QcY1yl`??o}T+AuI|JSOWBqNrEc~(~u7vL)xjAs!-nSc=)6M zK9Tdp0Dt3Jy)hWI(RzM{HIy2h(mv38{Kt9PMnxu=@GFaW*p?Vv#1K%X2DMS#38Q=< z@M(!C>TQf=*Xm%37SrFPU0c*(lIN1_eZxNd71{e*e)vn-`z#;+GWNdO z5B{g@eZCKV9rnJ`_u1a}===YD_P$s>VN*OH*D$`(s=Q%VC}4wCF}-&#ZhPv5B4ir=~vnL9m39?+YaG-!2Y5eMj3TrQuoRt~pb z4w*6B^<@^^4kXmu)z3ZSTe07IECJsxwwkOzsmvFa_`*F-$l+^e{vEz|$CKt+Z)Jt~ zn0Ea~js1Vf;vlUZ-v>=Dkd>p6 z2V?P}x_&$G4$$rmU9S!DUiF;0zOWp#gDr&}40-+viVS&&>rk$jib4=}w?%Hz>ARj+ z5Z^`doyaG6zg7oQl(^j@6@9>bV}n2BqWk(<)VY8CP}m73J2^Y%HC7YlyM%X$&Rf5* zr-5Kv?*pT)Bvw7)Js1pj%=U%uvdowQcz$4Ec#di}V3g}`xz-cz=ntrW7aHY6onDa> zGc-c%{5#q`Ewg{v^}SnJ;TOU*YeuF*PcYappdoJ-v?Wy+#OfM{&(5Ozs4x2)sc<)U z+g*P}8b5;54z{L2ngDG;lD~I)m4lJ}Clc#)4)BCBKzsYp4!M<8*rX*V;`AFl#X$4W zMMc{Rw)&XLs!~xJo6^=nbK%HU7Wovqk!^=x7w^XjspxH35tUVbrBpL%==6B96W~Pc z=5@G;tOV!at$}f@>MJA9`zS|fgp)@8BUF!1`f#y-hW#&~SM&5J5kDuX73vg#DKyxy zwjo6etvZwSD-o~h{^3X~OA575 zL)l8CAMH}E)mBZVdnOtUYj$a0n?-G3F78a}hVHicyQ~1czNO9L&2EsMuCkc@Xi#i{}j+M`hLsQyxp6?Q>V%H&jNOWnbSXo&TGJKfR? zrS$!^H^?Z;Swi<@8n_c7>vJWb#CxoN0!Hu%zVWXNolXv$F>DGA8eD9{xIdQgQs9I> zQX70&v(<==r+ed)61^K`3xeOmT_5=ucecF+90NN`!Q)m9lRRN>qbK|zN$hv0vN1d! zt2m`n>5de?G^d3AuL8OHhkK;>tl#>TsBA4~U+S&u?t=Pgu)!vf3~O{tsV(wm`!6jMX#J+}cZ*;MpvXt1oS*OL`6OE-m$IsY0W( z{H}iL>-qIj^mG+tEY9^v*Kk()INZu&Lbb0M8R=k-Tt@#dr@uzJy74K@P|w-IINyp+ zZL@zc&A7YS)sJw&UeO3uTB+NA44$Rlg}P~TbrieEMdc zTnwtq_U|8;D?h2hH?sP>SHucWTTlsiBB^YaXdn?K!QH3 zt9R(VUZC~bCaG8Go2l0f^jaYD8z$95)$U|M`QD(c68u8;a}L}e;Te(6*a(H>oG*ly7vpvwTPdMX*A0}f672gu?sTl6!~1}bZhmG%`8HHXAeV|#kqq~YhWBW z{o`@zT*`eN>wV#T&MA>?&Qqx8mC&z1>dJKFl^Chzl@PgIHtV@v(k<+QFVYsb*W|jS zfr3+A?X3l4XuOouk9YSe##`V|kFO9Dd5dC|M<_A0^VF;GnUCcc@EQ)>;nnCN^eKtB_>9spMsU$@v3vlE+(+{-_uaHrRw3 zpdwvM2@BEGw^EAkMYcKi_wQ)xTjZMCezBHoP9KGn&3PSP2~_Wa)itj7aSJbj@gKhI~GSGd85t9NK0#NSaD9ZpF7$o=dZ|( z9XfYt5=T0J*syoYELzU~5Np3?)Y(LQ&5SySRJ7d!!Kg+KO>iK7%Oe8x+tff?T4D8e zpG5nj@V=Pgrd4>bCBaQ@pB#sw6Q9s9Lau62vomBb)8ybsmtMC(AJOx)X(W} zG`2(v; zu=K2dqs>`k_8*9U|1qi;d>Zdx5QD3c;GYjs=R~`*mjC>MrfEnVWuy_AGEQ>nWKlhG zn1;TgX?|ni3yyNAKWnZ&v}o9J%&lzTB=VX*NgN2n`y}vSkCp|JIEI{L=Fx^2_UGRp zk2iWn$>jZ9oStDiwpeOL2$j19!8v!?-n`)QzwFDLCyygf@l4|hA2G?zFM+oZx~ zaV$#bPoZ4Iz=@d@cD_@5KeQTUb0(2&!e0h$5h(uaiePRXl%@X ziGNJw0G&?;KNCHf$@HY&gdrXSKgglH zp(JytAG8yx#~emx$Px~4)`82&fQ*%ZFNZpF>K!$u+RP2MS}c~h(M_1RA^#F{7RsC2 zC04U97KoV1LC%p2B!p8x&VTaogkK}*DD+9P*jM2pkh0! ztj4i;*>A0j)oT^_`~`2_1QY?53g?LZ-RM((BGB%7HpK#OrTtpJtz9!7L60fi<0G*R z7W?}M@9$_n;&+GxJDjZ~_Yw&Ux32exuU-8tkmi_AS;8p{BBG95E4S#kPE-=RpE@4< zk;QM_&+$gu6~UCpF_eYV55@BRbPC}(6HM}+%x#vL!+`KP7khDOsk<#NY* zIXsB7R&+3@t9U#WWzt5Im;s@PuG?PXf}I2xB;0{eIJYsTKl3@bxKxNYr6c>aPRC%% zeq}>stj;Grys;BRSu0L=1c=_nd5@Yi^}CG=by>JrEgUxVsXyV3CaDj9KwlqmgnUlU zO)BhG5~jh$%3^U}JEWpfY`4N(syQrVf+MmCB|$>>J2BNCK%+vx69&Ld7NM$6%?-ES zCo7wCl?pk0?IW{OEVFY%?OkpdtR@wBk%pi@BEo%El|yhm@aGlr50ibGA!s~1+4T>% zFZa{6Alxi}Hk5#VS9-30a)|w)ujlZXNmo*Ld9Z!Gk!xMVwlBuNT!L#Zt*(zd)R9PD z4&k-3!KbW{mBz^V9KY3z8;W8Z3IT*~& z_J&+8OswcNCS~P+4qx^*spu|%SXoK(jS;TqjJ&Ea;F zj1W)01|R0&Lm5POAXLf2A!2r`dNuyOAe>aCx#QdA%xFL*X~fTl&wk=*4i{VOQ)=DH z5fUvPryGi4$Jgxa-*UAUO#oP(0>0g;+#f!>=;;(oJpbQ+YDqA!=b7#6MJXmb_~aC^ zD~{Z7kFVia9PV21G_aQ@vftoCI=zEk%p=Xcjc_>arCjS_4j`lRew&CN%TF;;ygd4& zZ@Be3rgCLOY=~~(iM><4_6T}M^52YU=(c+^%-4&$iBHnyG8U(&+0EA>-k9q?FJ*X* z-a`dofkpRo?oB*y_9@XgDKiS@t z%{K18;kUBC>RHgAJ}_uG5vU226_e`EjRj-6Ri75zNk7`FNvk}ja3A%!#sFU?!0LRD zE=l`cEcNzGkawNDDAtK`y%B{z;d0=5e-50K2`p%TQ@@5(uP33OK$nRva55cZQ?q`c z^E)8XALMzsH3;&{m0XRfAC6dohYjilE!jixvZr+q!Oae

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 zcmZ^~19T3Mt8bfrJMGg9QUK4kFeD`?mw`?>$gLO@vWKL6Z3&FwDO& z*nh%QVtW24|Ls;z6cqy902$<_RBv1mRbaoBS{2mlkod5r^V5HA2qhKTdYfAoUZ+L@3_22&f!IHiRi%Rp~4*t>q zH^xx>Frz<+}A{=Z;H7fYu9%$ff*Bl(9J z=zrG5f06vl?qAmbwOao1kM)X>H*Nn7H~|X`jP$Sd|0KEO|D>^mmz#^Rshgte#R!L1H;dSgWDcZm(;tm39i}=E(Mghkb2otMo5GX~Y!04# zD1l6~dCCyBjD0c$PIX1nyv@%V3e5xa!*tm^b~Q+<8T9z_Yb8nMpYP6P--K3MLMg>JW91Z^F#h0h zt82C!`BsI{lB(owWk7Girzax*^%3A!ZvI@y1Q+N|mo+QTtP3jDgnz%(<^?IMYg!`T-sh*V?`-h+rkXQe(D_6T9wk*rOfIZ>Fv zhNJsdx>iy;Do>FHEVUS(GR;P7C#3zxXQ$Q(mkpH?tV37*93%9+my;y|7}vnMM3?5Y zzWlcBfbTrDmh6W9(L^-mbODAxOSVw1YGh5T`VKNTYoBcJfLjcYX1t~&Dkg<&gNE&B z3O$jO7m1I`^@3{TO3!3&oH1E>nwn|)VT3}mX>y{JqH{j`vSToUHFSMHX*o+NVLo{XfBx+BJ zV=|XrV~X!z+bwdxN>bUaHWOJZ-&3E>05J$7Hjj?5Tu{b~Dd@|w+aQ=NN*2)Ls?})STgv8;Dsfd#W@V1VOkC8MTI}=BrixV{&=c&S2KsKbcE~@82D! z;^NNIgqq}5PVAvPh{bb~yS*O37~CKe21MWvoHIY5Fa(j`M8Nem*f&Hvd7xPW*=Tno zq9&=-esj1}%D#+c(yR4A*B@#ZnX`4VlFvT$L^&vMp?&y(quuNyK};d%aumg*yMo$G z&G!|&R*8wJS*VVf2=)p*9nBUF2}7xPzg0W6260z{4>)@;PD0V3N*?G!p(6ouU`Zjy&WoAo>3Soz7UDAVR-Rp?nn zrim#%hDx^*evzmw(i!>>(V)2RFzS91WkvB-WxrqW_a|!-*$p*sk^GXKTi7cpC2APW zwIkz1*B=|A9OZ6aya7Bq^980={GOxh?_EA7?;Z}P=jW?frmOeIrhNh~yjKLPYjeIn z+ba%n33^oY;tbi_^}7D(Fip8^`#M#I%}Fjf6mL1=N$)jL)4v?s8bMtR5>C2JU%~m? zg7V>O7=&DWQIszuAz(twtwRwNDzU5b@3S}o?}g|K5UFpcVeKv)_3FD38KDS1dPPcI zb{^*C5bTW9hSP6JxVplc*|C@^!g5yvcF`9mcHK)ePOEcl(MPpE9zyJ3tb%o;4p`He z^IGrIMpay2b&e(Fi9t*?@S*z_M}ZQ=g*YS~67GSnpL0JhO&SI1b#Xe?i*zRsdbHNE z3E4TuNgH-wE$#%a?k8z{^5{vpYtbCawbnagG6i0Hm@B_Lx|VQu-txLCJa}`#K6Fhr zufQz+l<;lVlfbm+1cry%W;$%iWKgsjzG!ua^jKcd7c}zj;(%&$qXn7}zRKJoT%0WG z$A`Gk06eAhf@!zrq_V{P;RMwZ&}FS)9%lpexka1O$#q2I@LVVnS`n4?z8d+CT8kW6 zjcwVsiO0VX&R5Ze;G;$lnMkNLg5xZOJXtGJ#ReaN3m&u7Q(wFN{(*crvbTDKD|l_U z5|fzXup$M#{|e$#En3NTEQ~RLdn!a9J)m;g??=zQt@L;DSg_eicYg5`9q2hpxvKTKa5c?gRpIpm!3``#%>t6x1|&!ZWAD zELh=2$QQA$vPI$mcS}`QotWFeMjPzmnbTEdUG&_tir*A82S{%4c9Ae)RlhG)4B<0K z!pd1a(M{KgP&k$YPsG@fi=g5YTrg9cu)V7dVRVT ztZ{A`;U;h|(Iic$&u_M}xO_mdu4j~UigHb2n8R-Zzh)S*6(P08e5CnimcIB!YST^z)N z<)G_=^-1S%+$kGI>`~#bPy4bSo9zpjr$f=GZutQhq?RcoBPR{SdeUQ#1=Ve6NP;J$ z#Ged7&@rDIy2^(6@(Dbq&mjm z@$`KHWtkzU(NvtGgJOarEgSSiwqzI%RR`4J>x4s7@6t4n8^Lnn9r%as{h{#TQ2l5W zMQ+->x>5c(Cm+*(-Zo`Mzj^dhy|E=i^k0+r7l-a*UR_O-kxObRw!Yc;kKSqzfU-xR zUmv{(!dexe1JDhT1KiP3#!r432GDCPYrIU`sxQlc`JG!-09y}V`-NxS!lOm-IxLn+ zPOs<;(ll8a9vAJ|b8*bG*ARk@*)rAfRP5sjxp_9MPr<%?a^zMfxFUT{=2Yx-Neb+T zg@K75XWs&a>C--BiNp`uY|CkwP~lneQ;-?ia3{Pg{}Yj@~{2n zKQ;$qg+5bny43aW;Fn2Nj-;(*eADo}s(&Haq&!nG|2O>X0?6u6k_Ooa! zd0=2`bK;AJfI%n|CgI>_{v67LL&ec)U9zdQZ><$Q*I{(8CI~^@)Tv#rZCldOwS8W0 zt!O$8|>Vz0>hwjY2RUgg$4o;)X)&(n&j0;zwsh z$IIM7!6Qf*W0%`&GwH428dPZ%K!YyJVCIqv)IBB(hTl41t&ET_W7Xvo-NmNo@|Tb* z;YEv*+$+~XqsNvPHPI@RYxFT8nJ2)ebW55D9K zB^6jKF`+XC(Y5*PryTX8YV-h7;Ypq}wV%VE_x6*a=$4scg#of11#+bxq# zuCn4QnL~)KgjLhjy|t36Su@E}OB3+~l4D2N)jGFDX+@seYOaX9QO_ZAPjOgdPg&rn zr3Kq_7w~cbd}6d8=cN6mcz$wlCf6Wou-9IvWFN6*W_Ej9A?Mnua4xYNQWyO---|KV zCIl@76+^Ym0;A>mLb0h+3E(8k+rxe=KZF^X5O}%l=Ex^cHYq2kum!ear)Raqq=^~H zEzGA#Xz4Lw1}i`v>%73t=`L}Rso2h+ik4Va3ep!iR80z*)`~pJ9~46KEdZ;5I%2Wf zS60=5<49jF8Z=sob#vnOdYm5I0k!4L86e44sCHeJx+5bKf0{<5VlQ%BG;`pk;bEpK zF<&s3Y|ScVT+SEs+?*G?su8mvLsUMe>W1ST4CuxD*HQ758ZV?dnjmTV!Y@kcQN!ml`R2;d(FO@XveGx-

`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) zG&I`I)B5Fj4B6f5uu1~r8+3547=zg6n(_O0^m}RcN~Z9pznnq zJhqr&a$U9-jk6$?mswA%wJweJeI=;_lt?$Yb(4xs6zc;R5Y}&^fz-jx$W_64W^2;1 zj7&Q_c3HRfPc18+OI@UYGnw=f%$$Fw2enNSWwi}DBf_`8gledRVt;PpeT=I3szlG* ziKxAX;#X~XC~jtr3?U-%`np2%h{0Vk^im%u8b$gvi@W!_%#@6OaH->bAVGQDq+sqN zp*2r;-;Z_I%JE~}Rc$0pOqPwi!5UI`7S)}dUqrPw*Lh0-p!>)aMcE8*iOiDGl6AEdH5P67d`K)Z zy~Wq_yWQ1hJ0z`qAC8gJ$)5E^$B&2LfF<=4(TYn3t_M&l0$LC4+fz-(A z7lG2AOc+YXDTxTH_NmO~v*u`|2aeH6`6v`5$E9@bq=P6$LwBguXS9C9lSZWmkS1@q z1@RuOH@%D}ijbanQDUomR&*T6ocHXbszkU~;xt0!Uax+!EICGARi{744#aLoADNq( zGIShFHwM@!Yk!wGTNg{(A=2LKMFWMszLb+v(F|pfADn!0at^WDhd-Vjetvv*+Mfym zr#S5NQxK*UrhCLnMYzepticU$!|J;&$AuX7U-ENuiU$_u+zGogZ2CC{;mN**O2yn17DM3H5ipbNs>EAy6#M@$4$v z(v7Fzl#EfN(qcJ^%Wytr(1dCuC#C<{&eW6=v&oTC}2AwHdJP==pj% zII1B^Ts?oj*aqc17!YFH)>Ic}94~w)8-Kn_DAK0XonC+Y%4SWr%OMv|-(7FEMQ8zs zP3GHwXA2NmZKK6N3lW?!#a|sO=em<1;(KB>8G~KB@aJIhe4s4*s4fp)r_dD)xugC| z)9vRkwSjh1a*e6U_tGDrPp8TsEt$60=s!u_n3|A!A+(+lu3Ge#`>eT?!Q-?yhJSeh z`Lk%==|1bSsXZ9k_>@++KRi<&MJk6>=hvzkR3q7=cCq5*fxUKd? z1J9KgC4{ZflyZpxy+ZRyiapAg`I||rJiQ;#@tl#${%x%bI8Ak3LiLj6q==d=WU3&! zLYPt%ozRdnF~_mxUKqJdw{$cEp?@Ml{2AKvj^@QiAP82XJKP8Ea7d-jYR(cLQ3;y! zR1QBY5W-}HdqV9*D-Kqddb?a<2?7A7m7dR0Lu9qRyBrD%dsi&wB%R&445U!cD-uL{ zZUKJn-#*Ui_no9(50}ddjXEkcR?`1`LV_bs^Jrir*RYEZkBya@8Pyl|#s?53uUh*U{#o3RNv4RB1$YUb=ZeJ4f+Ej{YEccjdmL^BaLmeYc; z=B}%8A;X{@f(H=?Ec$%A4S)GP+?;M*Ocrw}PV173B;;kf8DSdUYodn*e8-+^6?dws z*p!W0DMn?HsZyk_bCpVl*MZ-s*%#S%kz5yjdNlkjbc|LO4+PT)F#erqEU{aXUSNWQ(MNkXF^zT^x&iIk%@; z4nHdOWt?n{zfVqTNtA(A{{X?BUfsVVvi-f} zPa|R(l^=adi!X4 zr6aA#R4(_r6R0kCFxa5cbVxx-5zNdmH=eu7H)6Ot`i3R{HuIItdy+Q2s1a zKZA%NCuvlI+jOcd#WM~gv}~#AquxyyQ=`8~(pTzUHGi%3wmjFXQ`4-0DxMYJ$+fGM zP|?RURMrV}p9LlD&Iz87w)j(yc*RI(8`33=UU29UNQe=LY_u?*TX(iScvA9v8MDgh zD~wvIVogzQZ9goflEM5I>8pBbVwR%hAtni_(CK^^RWWyA6OjS!!A*!#6oabu{j;`{ zR@AQ}gMUBLhgoVmkxf@r%q|R6ol|s}LA!+;+qP{rwr#7i?KH{Pq-kv1jcwbu)7Z9? zle7Md|D4-dvu3XL%&d9$`)nu)vjU&QD`b}Esamg!u?H_IL|aJxd+73lLHF0Zsjw3A z0MP+brShmVRXv=t1ZGG6O>xr01e?2@nJn+9em8<%0xFJ@a%2Q%5M%rZwAddBP~hg_ zYI)j-*uP7WOH)dZdfo2>)n+Ald8$tzzDtus07~PTNfu~?+`npdex;UhxC+_17+bm( zAS0ue1rkfaC?QPN6tPr-SwS7Ub5>rim$a~u>_|Nc z^4azlD~hCC#$8n?5c?}f7ulnS(6XY`UO4pQhR(gno2IPi&r;)N^tC&L&-K+Abku}7a7Rokx9gV2!r;L!_Mx<&`caUxkgQG z&O;|q+HW1CxYD$*-L-~jSl!9PjYDR`m`pNvXB=x>*Iwj{iO~GRnyLxCstB_;$Z-kM z7m<^i8q?$3>uBQ~kMhL-veO6=<*F5s0x%tECv42lu-R`t@etCf!!18LMPeqW15{!0H5g_cGKk2K|& zf?mHh&e?laklIob!n?xQhlY|B&`os17!|7gkW_difMq;a%68%N`{*CzK0qg`9U60> zUwl7bEO@6v@Cg4J){q9JBkjQ7f~;P1?r_JoJv%$}JU)*3raIn_2cdh`r@#NtqJ&4* zeDK;mxw^NLmLN$P;opLFI3jx#LMzW~eQCq5F0Dx1zilbrR%ugU^6=Fcjkmr8P{FUU zC-e$_+NYYTxKuU^6cyLHp+H4ikK@b2;#LRo@Uh(_0cI$+b3pRGvk5ouiYtnscp>G! zf)qYKR!$_Yd^2Zrto74odd;0tvxY>tv0Z-s*`G&6L2d!w?1Ka;fBJ08I1b|H>1G{* zS;38Q>mclN)%6WGdQ~btDPho)XR-|VN}wZ#fxNj!j_7jFJ8g194fuBT8apXrEiDgE z{IP@$yQ(b=X1 z{SrZ4YQoZp#bRT#IkkBdJ#KQfLw+&x&gvuGg>Qpx=7M{Yn$fp#-vt=VRuvE%EtC$I z);Y&;59un0wBC&BXF&DqF6kr)Hp|Ku;PLt)A6Z<|6~bIoKsT5Auyxr}!iEyL8RQ8! zjWQzS(Qs)W9q}2P@K_<|JQk2ZLmX^PoG!JK<>KFIp8td1aqZNqp@Ug}hf}zg?wUrU zk~P8v7p&3yP&ta@+&=B@RJsG#{w6txF)lSoha-GrS8cXm1&Gec$CrUb3{Tr=b|T@d zN<*8r>Svyl?w)I(RbA*kD$dTkl?-9cLr#ZRwB+(HivZTab%e=B2gW(1BL7B?M;g28 zan(*zApDUh${_hSeehrdDRylO@h8)KiP*-YTf)GB|AAa7@T4%VXZAAzgY zSv}iMFvLt9E|6AGgd77d3>BA^mxKjo_5*?V1UBrzn5PKsVJa|>k_xmft?L;ZuHaOnFA#HM9k!(A2o&cuPU%`FcSPmR_n$oHaa809Jwc#!9h zYl}=0;@E-dKrunWg^s<@wy&}>B(3_sEQD~iSCB2^v~?3Ih)`*AtZe4`Jm$wwC@qUx znl=htz&16Rbm1!_A}AGU4FnEkA$)j--74ayzG)-((ylxv*Z=P|M?%b?Z^BQ`uHIR_ z&H=YuS4rv!%H8=!{yHr53{>>yk{JK+J|(d=qYve?fZN8pAmxFexwd*{Wi?r7vTICQ zGpE0+Lf;%3p8~|MYrDnRj}dpJ>8tP{cadWc-@GJjftRO&_7gSf6Ye3W?Pqg8K zKLE}LEW{lrWw#{>dZ|i`oJ|L7|IfNaq}+8gdA8*Cyxzo8V+YIMz>0aqJis*pCXvEC(3RwP!EaHYQrb zWqJ{zh@;cX_4_4JaCu3q6W|czwax&L32)z4)3>Z8(_evsyFDSid)VZNCM7H#k=V;_ zx9;Qig-xkLzopJsp-0WMK_1;xubvC1R*a+3SHb-YlL&LI_rhAWgH%3UR&5md)zkl# z!AYP&b!9b8=nDS}vt{R3+-njAT-3R0?oahpUS;H?wph(UyvXs!J3#S~TTVeVR-s5E z-#npP@8_^I>gI6`3R%>{R^ILfUwQVOC|tUAkoHE(hj?Xqf86NL%EPk3JD4>lw_35z z7W13PI>H1Z`9y)(wePv(^36*yp^_^jxY8`j@_A9|a^mR3PK(xoj`_izS>IKR=Wz+q zHq`(2niFODIa@BSdH^#+dA;?K$Z|>s*64;Ap}H(nA#fN5SKoWXhHG2b!CJt;F?PxF z)nA{JW$m@tVx_qw-<(woRpM93MMJEccono4c8j=O4U8 zM7|G4Pw~5wX*YF`R4vY%rfI`V;Iz9%N1bk)wb5zr-9OaW(3B?rP|l0iV(>Suc`qeF zh&oW2iVi%?nF4%AkxN~tB4HLAg^LBovXo-P{kv(>wLksk%{(QVa!+bvukJJ>PhLa} zVudOQ@ML1?99&le_06g?h`aD%Qd?T1+Q8y|VXd^#!%I;CF3v+!hdy#n4J)=3Bfe=L zmJ1zxnloa(mM!0=rObb0Y2dE+W0)-=3mr=r89feRp#j&f3?!kw6Q#YYHpMd$rDA#u z%=d3a36^b<=($ecCv6*CrDrWcPB>g_>tLpJ{7K|IkUaSB1NKXQ&7*ZXk;yt}cN9t& z9UxFw^Js5e2d3H-k0>GknAK8bU}ak0~2lp3=qr^|z_>NUp&kq>f5# zk8L+*7X^4|;C)cl%TsIcXQA##%qw<3nX@E|XlUq09q3H^p{p=Tjk&i<&_nu~njZAa z$_Sntl-@x~U*N=ihIBPPfM4|;Tkti|Y}){_ZJTFisdOg5&P@&l(SN1mMDAI9)PUNN zfU@LRmqT1O*dI4z%G>cDI4i+jmAz|8fmZpux+xIFHPp?_fMF2Jpg@oW4xIH05UUSc zg#~lm!_BfP2dJF?PUWi-#2{W>@ansjipnWV6!_aFtn1idgaN_ONs2a&)MUtkQ!vw_ z9-_dC`ZFZ$jM+b?2=dW<)jdW1rTO#i?)^x!DNe=X3!YY3=H^ytV(x=xj;$Rukzp4}FJ|h4f^hsN}v;__$whZt?sZ z4H*N6&<2U9X2^;d5hiP-QQQ#OwXpXDXbX(+kZ+{$PR>dUmhkATS6u4T{RoQd9APGZ zL5bl9Z+_OU)DQ@PyfAcaDqO8-uTorO`VC-Me$O9zz7N;-M>zm|5s$ZIMp8OOFrmCt z_aF2!&eo?e%7!(RJCui(atwMd>sHh!dOKpbi?C|V`gRkZA$wYvivKS(yBiffx!?Tw znJ}7y(NO&*6+yPB=QKNKjPe=aeo6N8?El6VCzWI7Md~%`#de1w?8krdOB=7WnG6G` zD5=iSPrMYMY!O33`uDRYdHUz|wRUB#3L@?t`;MyYRr=!X-&#YardS$5Q#ttY7+?OHq$-3*( zgRjnP^?Z+|bDvApk=fUF^My2NrBDFp++O8ly;H=6G$z&G8sPonc=WUv#By23CN>Rg zGnl~^z1S3dGgFo_FrVn;*bOUv?vOXf&%dchHaPCdbRhmNZMY88A#};y)oW^-Z;0Zjl#tJf?mW@v5-flu-?x<7E|N|$y=s5AFRuimSGjP@Sw~lu=?XnR$rP2P zSKthCT#DPYG78bZxO0BsMSxth^b(nivwA2jP=5tH5SxBt98=C83_egUfNe7wpcC=Hvo6Z3{2F^vlQN3DzXvz!kgN#@?ZIZLxAoi`MFNZ zs@!FUZnCqamZpKaMK=J~SAdzF%!H2AYyes(QC20ExU|Fc#TBUe+)$qw<4-VAyUJDX_TwRRcFuI0vzZ zBkM}&BBz8nHEJcv8H}l%69u0@0}cZh^J0Gn;o;mrEc(eCzYN%B-&w;hHLOx7iC&F4 zz=;x-n);y>u_3lh61r4NHIf9^lc{k9DxFGu?5YgcWQ~8eWlBn~mM0U6?*Fl1s0fvq5ykHe zTkDm~JZ&J4cGR$~7TqagWHI|(`I_pjdR+E%39=5+ zw<0=SO5C#{IdP0yJ`qfO_NVtD0Iwt%`~p)qgX^cd!vVrK;|T3Uebu5iNPic3EaQ6@ zv~>?K-8f9gsgdFk(T$0c_E^+Sx3wrxZwT`yRL0W26r0HisMwdOImajfq0npr>%Mqx zquNs`m>;l{*C-W3cpaGya``YqC@F%#zrYtL3n6>fM3f`1*R0a49|~8VBhFxcTsU{X zHBO=xM`>W~fIQ`toScxs(vFVPwiTLFNh-Fma;WO+)pZq~zA!ZS557H+C*c(MJBAVgpan9}sht_w* zT81j8E8;3t=Ul^+;M^76uZX|&b_y)KT$)<3B(5i84q|BN`y}fBRr9(H8>hnTo3rn; z(*n=zV_HsLJT~do7@&g_a7VV$+{6i_IGCVRtEG}dMfnSLxQ{~+AGrgKeLKW0fXXKu zsw>KXw9C?)*IAg8CR5p*SUNh51_<~7o8gVoYOYsi(NPY@rDr26^x2Ms3eft zZqTY0S1f!ym_{<(a0V~QY_G0;R_2qFQjW-!OnD%l_q3c#QndIZJwfqzI)$rI001v8K_5x08QUke(-E_7!X1gQ8}}Gz#(mBpREnY=HJu z_HlZ)qx-dq_<3D<2ve2vIN;96CPE>Nen$F~L7me`YU%L4f?@7jbwMl>&pXE~LstqT z3tf?iov<+rCvku0?Mae|NU#O)@xu>@UOxSc+Q0&jsRshL1x*xwVfaTzv?JRCRnqn= z;!b$Q4B?a!OJ<*+vNhT~z3_J;I-qeRF8kHoZbQv@ucklguol|jWWemkW@DhK1*%S; zMDiNAi%y=E<}*p*ew=QN{$2OahC;K7=^_$YT4Amx$PXkGwK-ps4`i!S>(ic`G1yA6 zuxGbAYKBJ(UJC4WULTd!wLeEZhsax=+MKrF_a~GeF|5CN3prN{A{Dj_wg8qR1xkVu zrE}=1axtxMOQaOkwGfaqYGf^M9JRepo>ln7jF>+}nw}<)h`Q`)kDHCG59z;)9yZ3o z_bW_-P0K~AK~X3N+K(m-Hc{m|J>-^VxZPcCuUz+$iJb;_aU(pd{v3?*N=q#clUI^4 zrl{!?QRJ__&u^zzX@gtKeq+)Q zUbADR)oz0>@*C8tm{^yE+?@$#L~Mi#2lq1z?~qk=hn2B>!=w5MmNbBH6?K)EFIIe! zdZ=gHL6@9sByBHq+T$c{P=3|^V6noR%CI^CeL}+)} zA`>Md2^+lg8;Z|>4hi;_l3y(Lx0AQV*!PC7O45&dHe9)Hyk6N;V(e`l%dwtQbm1Rc zduLA{1IH`Tk^DvM{qw-*OfFptKO7n5z(XTiw_%~x#Gzl4s&Pv5nTF`V)|n#_){)Vc zdi&o=Q<#w7;j>`jeHjpMx~RV&X=X3pTo`X#<8!}tv*c!l*3raqHb+5n6fn^juehd= zslBTO(#iK6LqRw2J*N#JUsN>2U0hjW=IfGRRKzW(%=pTN1;GQ@^KH~duNU5R3<05n4pMI&nZ zwvkT^2K7u(2m}FtL&TaEhA@nUXOHw1xoW7<*Xkc$f3tWVw@xHQH+Sun;ZlOeaQ`K` zLrxpx#`nk8=Xd~0bz7odt~dv3n4*@HQ~ibYVk&0e_V91b>Zdf0paWK56m9thj&_T1 zjnCP?Km|Dv&PVM=i*k&a@;5amUTa`D5ZF7ou0;mINbPdh=NX3l`DE(t*3z=5#bR?D z*R~@fEP|eV`=L+$_M~F#$sRMhG0?mOk)axk5YrwJ=w^WKn7ewp4$Ucw8z~rteCjnA z6Q><7M4o^>3{$)`$=2_#;z8PUJ*gsYGby;oPkG6Bd7o8u>V+mHnJBLS9S`3!+o0Ji z@EDj_ZC&hbnmgN!yvp)YH3LK}7D6?_Tt_vHtawEl5-`oFrD4|H&LNbhlYdL`$gJ}X zwq;DUuu#BDV65?DNGyS^topU7UB22f21%+lGy#nD2q&=vv5T1hyk&Z%Q5bikA6%=tS0e zci{JJxbm)~t&-US{JifySC{E+47C!5m7`%D)S^JH?5#-oOunh$#2FbUyP7OU%N)%4 z586qVEEJ70YblTGs(R9mJ4N$;ii**HgS^Zt`PcQV^3~75jd4S+B{2=4eQLp;p zhHn5G+WWxtZ^tH@l?JT<)g9BOT#RjskooTSVl^)Dqn{(Q8n``{8Vp&%SyI)uA!jn6 z&;rmAmTQ~EEmW!(8fC6E==kWe;3%-g!D|b+VmRlUekS4*xIo?Qv%|5;Qi!4gpX2j&3PofRSHBnif zUCC>P`Z8?K-tDGiWEGAME9R3@eYR<3DqB3!( zl)eU6vJfYYtZ5|F$uy$kCL(+178A%FWRjQ5W87}eLDEEv_e+>@Q$&#xmlFX2PG?s#xCxpKj8SuYW7ih#%!3pxLgQfz3zKfL3U;br82N=!9=A!U`7RsN z;)CchFT{tTex3cDaNm^1i)|3J{>FzIio&nI6zhs+X5lw}&Pn&rV23C{+oU?04DMyWrn2g4}|cl)|YSb2TaJ2|_TPHH(lHC@%$t#4p5~^jdi1RCw|o zA#v$m=`|fLMYB5&OShT865d}+DET&`2MUqny{&&26JzghD_6~%JG&h3_5aSW9+OVn zem1R5IBGmN%p3Bz>2Bz~KUC9gaZV4md)%Azx8n$0G(9o(aR|*-eVBcJTXT0}V^S;^ z-1v8fbdkvQob%@C&{84@Kjz_xWP8)mGf*C6;UM$;x%F?yyZZhQkm%&wkhpopZ+?63 z{sCzyESRjB7>)by8>8cgGe`UF75CH3Q{j|*+wY&r>B&sNzCW)%x4SlRKi*olr(W+L zf%i_|H}l)KDvqvA8-vg6&8BFe!s|mbeKR^p@beX`YkB(g^UU}4iAeG6bam=;`|410 z;qdb=*7q%&=qrK~=wg5KQtbHPJl%c1I;1jL&<1C-zh)8*Y{81 z_a>y%%dWb&Ft4{c!I-7b!rK?Y;-&jBA8|vD=&l7lho7Ior_t?;!=lCX?%Za>)ThMl zlVaM^=EsHR#4ab|8E}63>2>?kW%#w~=BdvI(f6v)72v7V>uuMtX|uT_3z%#FAo@(M zN*yw^$=a;k?5e0LdIhd-zXk-YzT36|AHH9EK35sCMFWq1AJ3m9UhkK01BNWoSY75! zIqz?PAmPW`3rJSa&E{O!vzyP`c~#rgr_SxuX0RY2-0@NO@-ju)`2ozI7A<}H`MzH+ zEq&H|y>q5-elCIh${J`wIz4=UeqI^wKYVfqEM58` zDP9=b8%%e8e1a&+f`Oxd`vwjDO+0{5yIwS0@;lhKZ{Sehz7c)<_RZDH(aeR(*r-Xa z9Z3-k^Z!nTJz#rof&KPP3NN{*3yB)A!1(ysn3y#85J9Z4g~fcT zPEI!7)Uy)MXEwIapPOx)pMDBm55p$k7%|WSuDa=ZsPf_c{GA3Xg*h-d=KX~M{u1)M zjfdYtKkBUOZPL=vvDfC;Yt&^WUSD@-IK1`P=1p~xK@w!4N1=r&<38#aE&AOUFx;}h zts@Qe75iV}UxdmvrAt_n$e1fisGyiM0|Hs1{QB`P!_zEhF3jp7l_-d><4Y}VRU;#6 ziZP1G8`vaV(W<&33VcE6Qh(6{C4F2lyJliaOiIb(Z6e2PcYBN?7qX>cMk_yBEKO9S zW(jl?31rxFEz|S$C0Hx%?CEIRa?DNN!To6#?X$C_iW@y5pMK$Ts0?1r=j8oW6YUlA ze*rZ(QE7sj`6bOt=~6v5!db&Ll#uU{8&QJaIzlNbv!P&lp%gg`orf|9n6)FygMNrR zG1$`=E+61-wk!0)`-cwHo7bDmef8CwjT=Lpu)&(jTAVWGeM`Cu2;>Hh{G&fTz?z>l z?!|ggHy$Ly3dNmiZo-4c6jOt22f9$nPI$DLHp?-&y{>e4;0TS;EH-FNk5Wv0$)s2W z@7p~(rc+sJ3vFJ!ZI&7V?BlbgHZMm#$Swb)Hi2L)`k^CpY}Kbi*_2gV^V@Pr21axE zNQi3RCCJQ9#{_^?i!HCzr;(93jBmR;kEWco#<6kyD-@%JzoRUmz0sDKw~!Rw0k?r# z8CQdN3NdK-55-|@^LnemSJ60R%R}|Wo31h^F~zc_vlG@->$uNC?SN(cV3*& zx)orSMwkC=B!Dx12iUN{+s)(tFmyK)>Wf-J8kLR;;mP`@N1Sr^fd$!1!|p(?Q*RTn z+V}F(gx)Z#JQD6TfiI|VWv>+{uhS#bC@rd5K-EAsIjVX$b;lJ(fx159I@_=9z_-c| z{&Z|pJ);qo#?>I)zjWgtcP)zO7+14mQAX9G7haG2N#3qG2y`?@!^`1ai_x~~Ex8wu zpu1I~^Np~lJ zb2-#0r`V7XN+U5o+>Hm`RX^R5h{Q3aY?tGIMs+1IOqs61^u~CAJ-jN| zh5Z-O$P+W$B2c^+F=M;_ggE>JO;~tW-NfDYlRlOx-U*qgD9OkaW^C@$`{prJar7wx zBDaJQ`rk`^#FUoqfyKaZAnUI_R)Ha1cYFB$23Kp-$6MCU?vA2SCF&2%&{!4=sX=9U z7n54Whm_t-WBct0JI3a|Ucy+X4D}LMm@%!Z;)o%wSU?6>tM;CYWS9ID#rbY}Vs~$h zwbNMp{K|BzlXlnUiRa!^bPmBr@rU)le9Gt|#jz(!m$kn&F5#sE5#&G1LFTmcFNdEP zI}ab=Lv!O>N~*!g-+rk5uARi5t)6nLT-;0IBj{B7nedrbGg*3+Hp5oJF*T9jQa{b7 zp+zGzy$`%l_LiT8*qoH!300+?X?UX*((1LHCYWYyo<|Fq$Yxjzs(@FIU-0Gy4{ML0 z+~`eEyEB@M|Mv7Zk(!(~<&5q95h>0+60aXL+f<>7Q$GO{i5q^C{p%0Iy#@BWG)JPs z7aPu{Hq?S36PNY(wNZN5`MN~lzJ^P_fjC)FJo{Hd;tH8^+6T0-afyu=`4y!X#`zsu z(dEeal}aX?wUR+B=%f`Mxy0c>{KYt&wQ-N0s56lW(dfn$uV4O?|O)G$^w)M(RsPc9t$|v0gh&d3d8I%4Ay?|%u zhV67p={i=ho&CTT%)KwVTZdqJhv-FM5Jm2bv8FxF^~T;tE9SBld5_Q#j0JPKa?zpE zhJS*XOo_L`?&?=P@WZyaW_L>1#rHFVcB~2bq3zqp1_ph-eP-=VA5o}R$PQZyApbs#vWSi^F}cf zBWbUSK0%B;3<3prnZ(4QcXVbeGCI!*2GerR<=$^%fyq!H&4 zHA75@S%TsYG=97RuKk>Wr$JW_yUTS(LC>?^=$E)KS2FX{-f$GN6$$4}MtqS62+ago zJBamL3a!1D1EA~TG>)8=-TYrEs>iHeL=gLawuSE?XQH@BTM~ShtvlAN9w6r1+A@%# z&6K;`Z;9p!)C(hW6I3nI*dLBuocUG;LnQRnHjnkR9siLrTlLD}?ylbNPbAdyy*J7pVhtPeJ>m;R{ z5#eN48AIY%b>V-OZdhMEXiO5fjn>c;KYz#T#{c#0Vi(wsV{ufP zYwb&w)>3FsOtTGwCyRAMcEu5=u6)Gnx0hC~RL^$m=w76(a5$R*Q#mJ7IT9QTIW*dSY~4Xr zUM~^0qmT-&ASUk^gvKQZOy_QqJUz9vAL`<7PUZELNQqZNBPt(HDpoj>GEe!fIf8^! z_d{qDZ_29uM2ZQE_amquIpMVkT>)Dy;flj|FRFiMrdnD*1LYpEOvEc9SIkW`h$Q=h z;4e6%c63)vg{E46l@jDsgVirXmb!sujz-_t!j&!dl)AuY+7Vf!Zu{t(LiLliEK>yg zt^;ER>A@RxgKUW*A>LQ`#MP4Qzh1xdr-JkV-~RuL*inHRGVJR`{1f`yH7 zt5GC4Ako)hO$~i8JAKeC&09aca6@*{?oS6f&3O45k3_48<^w8vZKxQCdd?_}eM_Q= z$K-v1Z<&Ab_iHGkUr2wr9u0QW`pbeyH#oCze@0DlFFl`L3VwiBM>>QJ8;y$n3-GrJ za@o0$<*oh0%LgkmRM#dCkmDON%Q-k_hcg6~0M-?nLjFBI=-^qWPi)l2i(kck_ycTO z+!+rEpC91@E6e&;G}7<`!tAI$)w18=|1Rd2!;dbF;cGxo`xqDKe8yRGzchc=3xgv#|nr2Y3sqeX_)s>VJ=ptUV|@$kX;yE4JG(o*Zeo5 z_@cKZ(#j{uz21fcGwTP$x}PHfO*(=|e7<=qV~hL_{F-+aMOehN0rKiKiR+xDZ}Epn&`b>=7pUK2x^TQ`Wc| z)=L!I-YCqxRqhUjc4P`N(^ujY|LA1wRQgn#C*J`zvdQXE?m5=&ok6R^l+dK`18$5begy=Ps=J1mp^HnJb9m#+ePVk*_3v`umLsG>}8S~EonZ&_g>=(j-o zth=#K&|C_r8doxTP}$m1RCko$$@8fY4>=Ul|*E5(;cdYnf@4x<&!E zn!H@h4g5p({CyRgP9YQ2Ew+9Ch(8WMMU`y2Zmh*!bOsM6AGSPa=a8c-kjOCS>X&n2 zJX9Z93GlJ6cM8<^dpSz9a!l*TPxTE%JmyQ+=pSbQIa-O_~$lCS&R{vJsMJc}WKaCf=`~Y_sYJ9<`dr4MzaOpXnA81}Tj;i1nUh)d51K)3>4hpxD1=jZGSEtIw|F)KC-onY^tt{(jdy>#+5V^?|E z*D!f%H57Z)#07*E-qElWtKWjBH!up|8^-1_r7M)$0)E!3Kqowb8mdf{l#$&3R4FX( zDqmD62{l<*g&B2Nq4;vI&ttME(nFkzZ6d#^bVEP;^m_~j7EMggiPiunLK-%+G>iWN zZjD=H@YGG1xdTR;nP&Tp@JPn@x)4sr_|BqHjk4#QlOF08K7kB<9#U=c9-( zQ-c1UUN7eT`nkjWRHp84*K$ZCV-8Db#YiC>FO}g!l*N4#!ccj-J6RucQkB5R2yFgb z4wwlo0-`M&+=hO{>{;LlPewl`<#paAuD|Z;XF>osiS6JGow&c0Ykk05<28N%Ivh)h zPFxLvNdc(@E$vg&QDB6wF{0@LXK{zx9=R2jJA2*C%(^h=yiKlw%4e^$${Q(V66rPL zgL%l9^z|6dj#|p(Vc>!9CGg(^LE`IUE2JSQ9t-U2SE~c^+c&cRoCt*asPKSqf}QG| z5c1HcCbgAp_4G{+x>!PRBeb#_aya!o508eB?kS!{NbNqwU&WD~2TKJFFT8SaUD)vB`<|oTX)+f`E>?H|hi! z1+Km7vZVTru~Z_`J(@n7+o@0)^iVY-tP{Mkl(39AZl8WFEM}))fsS`a+pT+DyCzMC zm*y&ClBM!r^3mjBSk_%-43oI3uxTvqSesh>UHHD0o7{cN*Vmv%8$2LsOMyf)eiQ~H zzIhUvgFc)WUX;KO)kV~}kfzV}5XGed+}=o{r#y^%oUPzdzl;Qa&Dy#GLv+0CUzQQe zxO={9Xu7CDPe9n3RzW{sC>^}&S_#oj5b*&~z(iXq?~{veqaXV$l~cA=cftKMPnjnIVGsy#;_dI4rq^<=7KuevW= zrQk2)x3e3Ji?{^w2zNc}AgZW3y?hD4*s|$+FB|2aAvIG6+3!1kU(&YcL1=jg-V2AX zYr`d$!r5=2g+-2So1U)2oPHelxj7%tNvUWXPuZVbM3cOj z)y64cdfE5X&9p?2CS1#ohhpNUQfxge2|)P8o)s(!$nf5&EZb$VLu-nC-JK=MOxv;qX!#sR9wc2-zPRlL$S-AcnZA>jY3ao-ojb12i83QQ8oRj zk(7oowUo=tUIu97l(OOpfq4sXpO!c(6N7?d;#mV^8Zt8Z263LD3C13C(Vhe9{b!|W zIXW#!I)i6yjgda2Mv1z+FqxYr%*Ls*K4WM!JEJ^L>>rC))ZOLaDZ?VXCfxlY_1LkC zEpS>$*kk{)T2lojAADu3s49YZ&~4m~SiXaHU>@Z^6LDZ$VO0h9&m=v;WVxeQtPZ5> z_oLK~I>CuM_&s3#S3_c78lpc!KlDfZ_RWSid2$g+6o|-!$q7~J{*E{Tj`^MU^uiXo z+~HjG?}CQ-)r_@WLqo%SBZ-u5!==ah>&B|b`IwGwMWgjpW@_g6#kg%!m5-^r`33jq z^Hj@W*3S!{`$S1WupbD%%wfp1=z$Ql%Hk2onVvO676BKAKQWTmBaqUBtE6nO+fjlD zXSve60mLe#y1HTv?1)48x6V9GF;+?#q{w*QD065}GX(zSWs+bZja(yJGRIx4A0{cg z%-~5eu3~8k!Lw%%3`cCe4gWrn5eb`&w(ok+=X4 zQ4x614gFx1EXD$L3w|(GUVLx_PrkP&S%VyoPLFBXhuWKAOn6$rYsFt8Q>QU&s}j#0 z1z3o$#ksLcC&AR4w2)ijj$0=)6L?6-#gNnANJqH&jc{T)`7dpei!2<6s`Y9y9ImIU zrlV(wSkhn+O@!>2j>oHMLboeW-r5FRvnb*W&v9u|!ZZgUN)8LI`p%xojGbBgvzZ2_ zflaWQqL(3SRwq?^l6o-8nYmbH!HD9m0x^rM2jm%U$2mz!oE%5J+OVwU{GGW!!1)6% zw?{uoBFMwc?1b^IX-_r25k`+(Q<`DO*4N&&ElJygArbl?IrFb@80EEqEH-)~ALrFm zQSdbgNS6NT#?D+M>~dkPt@!mUP87!{j23baOB@JZGZ6PfV%bzWjUL9$yja%EP+e~8 z13hqQf0U8p$!ZA-3OXXRkTJ^w0D=+30aewrn>^DfoBi0W(>js02O^?Fm#ZbGo&*1At^lXcC^D}m5G;pQWxT1P?L*abr@MYFb(v0&O7wW z!#=>ZgI(^yk3>IOlO1%TDaT7^V#Oe66`bpeku{5N>3cS1@Qqo~r3I?KHz2p(qEosV@e6 zVgFG%3jVuHV@{`BT4Wb#JacmL+>Tq$r5U0zV=a+je6WdX9>i^yXV2p* z{nTE(QpP-VHJJ~g2}uH1b;+K#MWULi^W>w0Y9#y8{U~hbtAU66~`*6jgON4QWN&=!e${qm6r$1`JlIO73{0VaTZSjXbLH&U%dE7?z=I* z=eX|Vjc^n4*ioh^=uXO>{ZB{(v~CysX;r+HN zZ*NH0$$-h!g~PW#vEIxVqm}zblu;?l&?V`IP)GoHO?9IZCHMs$~q^I+L}Nz=21u`_Dh-3euKYePY|GKV`CW5ic&( z=iIBUVWT*lHWy11-b>r9+4IdZv#d&~VElt*jV54&RxOAY;?zbPr+6;Yshu0 zJs(3nTbZCK;u=cV(nTqHQ~raJr|}-cFTe|MUUyr{j`El|lJzljKn(q|F6ub^iKoiO z86b@!Umq4xjxj#~z_^pgU+x!q^EkNw%5>Vn9<@*Q!kMRX#zk_j_(8d#5KVD;%YXqj zZ&ff}(IT*kzyE0bFn{d2=hQiKzjs#N9=VT~n#Z49*Wnm=t#VHc;SO?HpxEunV zZ2KF>Ep{@`_E#D05MZ@Qt2UHON{;N+wBn&tM)(37%QXJD?bbJ9DUu#D**op^d?^N3 zXFIqqknMi+SkW~smz`8dFgrSfNU^!z`8T^<1ctwe3|SH}v+SQs)r=J}jUs&ECb(IS2LR_Lq~ z;(?AnXLEJ&vBAW036dF^E0$5`ZD?8bwe?0kvwNeAXoZ@l_@met$JyY|1qN641sQ$H z@NY3|watnZy2+RIJ)g#ozD$e89J6Kw@>kHcBNYD3B@LZYdhetVDt)d zrccJDEcQW0dUo5@yMufROZlIBfAdad&@um-2gP@IIOcmOc}UbAf^$v#Nz{6(sc)o!)3OHUf?7hrkQ82aRD$x=cVXnb z?zWUj)L53t`5Co1GJwbhRDK$K-VOScTsj$G7I_|Q{8+^3I;>1wOu`gbHAvdjhz9Ffe2#GhT8Fy?1DOci zQje{dZXa=L=x2@LJ_7(59!QP1ic_P#bFnA&U`+YwUn8C#s2?5?=bQIyv1#@2wLijs z$;UAX1)CXf?O*Ow5RK9_WvMpFcv(x5MAK1AlM!Ulj44m(YO~c(>Y8HO*h8Nsn^(Bm z6v}G0F6dq`lzXHAF(8}aYBU^bU%x;ceKrmDHPOrh%TA((7exUB?p_W3CAOo1hZpL;-&7G<4MU7qf)tPqKol1ilP9-NYxE`!y zLXxjg60*22cJTrC6F=+9k^_h#aNEj#z|&G$Zw`KdkKZ9)FqrLG2tzT_ZTi2{e1*4h*W|4 z#4_EZI>KK&!C5nO$9a@JAs%idA%Ft`Y(VN?`>$dLu4e9~y#{^J;k*yu_3vIFe_jjS zC>8tMOn&r#p(7B{5x>I$Zhi&!rzIo%l`wHBGrvsS^#f`P|JdIAxp2{KzJP@z7D>kc z>_jpSNXecgD!ai^za%cRRQ9%Y`&=w<$=|L`v2`tnZZ6Ot62;eZ(cpH`nCEb*mZzF> z(SH5xI51N+5Xd4iFJj5cF>7r9^jMdp%bPx$I)*cMc3rpGaq6-uO`AP-Gk5l1C!o!m z)`?4#uLAgRBC}=1v1Un5nBTV?m@VoGWHB*kF|lUVCQlz z`ZrZTjdMZ_x2b&@cz~(FPuTq}kcO4^uD~niBjg2=&zQQD&ev-NFXF>z=)$)%@P{A9 zU*P!vy`BC?;V~%86F~cxd>j5p;F(`RCP@3zLxXD_Izq(UWNXSNGU0#2{io{6U@fLz>l?)UtxpmC z2ZZ1H1d3wx-*5e&&lDh_%=^##HAA)fLZa~g?}uwqxk9k0ARy;VX(+HLoB(hse_#PB zNiaDx#Gz3>A2^5MiWEcvy1Z}zxt_DTN zfquQu96g>9blL^u!5p7zc_YzLv4L>AFNI#FLuB{Y%tM@ja(r}$9w7?GA8l)HL4r%z zKP;CQGY^@u;p9dz&hT2Bhg+a|V_I@b$CKq&Gg-+BOlbSFj+HH__bu`?CZb}k5ONw68enkf$s-M)qnsZqD^Af&g@yeDF?h2 zZ-YwEvK?0X)p_bVFgnZ$MBEm+lNla2joBsBPO*F% zinNW70{@D1n=Z9{Zuz-~V-B$2jv2*CQ-c`jA}R8m8^uLK+EjCa8Ut%hTewKo^PC}^ zbw4Oio}{QT>Hu)z>Tw>C%@ACoD+h1^-&1`s>$CYf2c34>>&3rCbrq+Ufu-YCr*yhm z0$z?#20oq*7;Mu=scG(`MGf5o6a0d^s-5S5gLW^DArG8C=4iU*lf`g(IOpnfn61)D zFqP5>oS}gOz!5bfx2(ZXNK*6og|HaNHV@tDB;S_=On`1}Fd2HIqTz`WZ9~WT9+&~0 zvtKLI#Wm39nPQ?ZGkhM635=%1m`Tyw4E;)q3B&GUfRB646>N2~pB9al&B0&_OrlWs8w25tjP#H^cQ?+`EeSg#R!jnQkXR$5Kri9zwT0;3>vdt^hwqGsn zZ47u98#VenOgH{MTB!^D)-DJ6eL)QpFaSx(tju%ab{GDsm+{+_Iy=5#dpN#8Nmx6M zge2J^8Q4dLfKfAX8darZwQF|oj$6V2QC8z3HGqi^EJtm_M<>|s;4_0@G5!K}djtDX z)4$H!Rj{zzWR4E*wzD7zt0~k&+<;!?`S3?uSus)0ccHy&jGxQQ!JDW7!o%_$=1y+~ zeJsQBEu-z@p~SF!Wj?8h6#|nZ=wMVOOvC)XBxKVW-#2A79<~7+-2G{qfIMmYiRl$N zcYq(`O`yvtgu>$qMSy`6KyI%9shj==nU;&NKga4b8|x(nF4h`ne?}1gJ?eWk^>Dlk z;a434(ms7Nk46&{K*4WuaZqAWgg7g{Vek&=c6O{{akzX6H5 zFxl{|w6me_9tw`I2d(@?7y);3#4Iu({m{OL8<-d(Qb44wNi~wp3s}p(6 z%mYWU&TV+!D@^uSk2Hf3ftHJi+rq>f_Qzy&NuzbE!uy z1m$XsZ*CiDKa)JyH4q#~up|q(Xwf)n;w~7!C3Me2MR;A>o6aV->xi%PK$lllf89|6 zxsO|vZ&oW?bP;A7ODjwc84II}6-la^n)$1~n7RL<+pudRj6F}FIu-28on`iNRN%>O zP!@GWE`ah&*^@fQc^(WZgTwiF>WuBYY&M&r=n+yl%97>8kg2wWz+3^~i1b&V5eFh~ znkIjI<5*T_cVk9DzZG9ALW9jYwSj&7*jyn(scTt&vO>8GGf-mz+fzfT*0|>=fte|r zWyilNZPtmXq5EPR&nl*Kv14^hYy+H$D@xMNx=@`*kG5QkNP8l*RM4UZl_le>DYTVP zx_Csuxt08*M{e$@>3dv;PTMg351&X4l3kivd{xz)DEB4<*b4PIul;E^SZKc3{6f7H ziVaSjZ|gI$tQ5frj5L$cd!Ib{+|BNBtQKII7?N`^o2O@S5S6o)Gcy5mT9}3)u|M~e zOdsN>rILUSQ_dZ|OuEO)QONzzdb60bq0LXYVNy5Ou~jEe=fY{gJA|RHmr_IXCEQrG zR({d+EbhtmJ}SSJ#U&U;l?!8$)ZM3Y29$?1fstra+we{6wdUn@bGgSttRZA)AR$y9 zJ>0SmtdX;Vj-6`Oy`Hxxb%>n97)9|9W1F;;LZQn7*d6OX?(g(jYae%3OFa?lR;u^` zfi2}7JewZF8gYLCe{BvPwfHOl{Fx4ag2W5ref3$xvW?mO-Gx;~^xWuqEv=P>OW(7D zL?iZ8AoYPUsI=qIM||{m{`mSbM&kW)b2HJhg~~sr%8|Y2J$g*jC*7L9EiJ1pzYpEG zN{r;Gn1SVJS^nE(uDo+gCu$;zxgHdMsUplv z?2AyLxk0e6sX2avzhD8>D(VR*iP8?#GwPkkKH6!teJ3U=pl^hlZjEqKO}d0Kr567c zrY^!QqT!%^agfjwXc22Jz-8JrVpeNuGjBBXVWW^ztCm^TU7(-SGx*kRV;CHBGG_ZC z)S*M_JO9)Nn8;UC(PUsFmmw+p!BHVEoRW0dYOTqX#S@JXlT30x?9EeYxw>J6DN6wn**9bhl5UK-*0HO>zo{{C*jOLSxa%MFcW zb`&uf({XTvQin-nNQ55E>uwr`lLT5ngGK7Ut38wpFf+z8_&N7CGYMxkj)hX=5>^hU z&od~!=^sjEdj)NCg%=1%Pd~!yPovEUW51^dVbKd=-ARO?zkWX z8U1h$8 z^x30)3xjhkTA>xyvbQElOQil6Hlsk-j}@c{ThmPz`b3Mn>Nq$p98OjXYNp>o|!8Ch{q|a zev=OnP9)>Tm{FT{j%BBFkeUhWGsWfy z)Nb%_^X6hTSv(;dl+c(XmWvH`r&&~8XTE|>(&S3df&iZmd;sO`6lX&h@XfZ-V}txpD?JmM%`oL&jv+ zg-fGF#q>dK=k#^%2q8I%Y!}@Y0o~rz7vkK50uESfZ=nN>lekYQLy?aK-28L)D^F+H zH0Ua9!&PS=oEgTcFSuL40zWx<7Y|F2-8I4R(Tm2p_1Q^-ttG2V!k!!*qDl&YKW9-e zVeQG!s0=$^Tk)Uh{CyT<4+h z5c~YOQ!$&CPe@Hk?U%-Oof(@%$8NT8Ww{V#xfluxTz}6Osk;-(niNkME_aVfE`)gGu!zGxBMKC7JAak znnv$apGG~U-kx8j-oO?C31_`S4}ks$!1zMX)IzQRww2(R>c+`8XxOLNH>tgQcx%Vp z?wYyvc~*EM?k@Q$%~SR*?)$u=r_?#MP(%^RBNAa0A!8G7fLMYs5aOVR3! z!`|wPAK8j9DPt4kSYvprl(jYUz2vBnsH|yDdq9t)S@Jdy34yzxmr+63onlT8%Zv7y z(R=D^W=J=M?byzHYL$(p^)R}9l<0n1Zi5D)jayn zjDDZ+y=okN-<1PQSvZY!<=WK={H>q5ZR}jO=~pywDOor zvth9>&O$RFpIWHft%6;)YQEK|am_Q2R(^Cz{r)L0wb1+7nPfH7_dspm^86*RVBWli z;^f&G(iqigTfeo7WPU>*xKLz@a^5SY-d4 zfXoia*m7z&N6l4F2lUT+H+x2Y>R+u!%5=oQPV`nCmwphyAQKZ{&t1y(N~y>}obX_x zsklR{Ib^RDft40Opmqc)XX8Zq!)bz+7NlGqc8WY*t8_#?pYg2bm$)E5yWZMuXV;o< z`pyATx{~%@vcufZr=nf%PSxylA4N%&Gb)TwOOSm4=2%To&6bEysKj6MOC(Z;B)dlf2#V>Adzjc zk}E+2y1EICwi-+L3&F(YAE$*%ySM4j`4i1Bl^K?tOw&w`42HAU)C{LEuA^Kf_uUWp z|H?-H(Oy(EE8I}O+t_?@KtO2H3h+>{()uJ(Pymc3Hb&0QDVnez7#6sGU#3axHk8mL zpe^xrN7S&O8aA>zftcY!s)NdCfdMP74H-6}7c=y1jWlNk>J^Xmit0_)71}A4merBv zlOj!!&DuJ(UQ0TE9(&@v)EWG~1RIm4^{a#^oqbN;as=b}-H%B?vNR<@)XP)%lDEF;Y$wrJ>m=*FAg79p&X6Ew zE!4CQrZaBqY82A%j}l3Fv=q+@{%#;M0UcBsbwT?hJ{VhAHw_ApocP7kKRhR7_fSf| zDTRQ>ElT$+o}o72C>|FAZKJwqB626rie-!{iq2xH?4XH-E(@E^1u8rrFpMU`$_N-i z3-$DD(n%?|O;;u7wyuo4G~6@n>cv5N9Z6Z%TWBDHoy6hEu2m)@`n7$trY(ZFnd+NV zvVq2E)K&~e0KF6hN-tg(&6vyK8mugKFy6nIuQNiM3l2|cF3X>e?;xoPGFdMnfir7T zzMX%T>B|u(ZnP9e&X@Ot$--S_o&umdGN+ya1lN7jc7bw$tVwoAiGDmavYdskiNlX) z-!II~ekWGhr;+jhJ5wWYbqa5)8-vYCPkTn4F;Z6(cyUFip`2zM6FiL|%edFw=ZyYb zj;dp7bHvGTYg1S&K7}^l6KXUp=XW_@t(KVGx;&pFy^P^!&yAs;^j=D|x(^se`)6h| zibS-zPl>oN++X>#Ml*Gjjt_I6!m|Z_ReFuV1SAMy`juwphrCm1kKFXBo!zTSG`rvSU29ThQi+csxBU z-_(G%K+8auoNC73Rr(2ObQ+|CVrtyVLs0~0^R0bIEY)c|E`Sf{Rv+<-Rc#+N2fFd%%EfYBJ!Pym zpQWD$qX~~aPxxN+zZ>$h-o0?``|xvKJWE>=L&Rx2;OrA`&9~(F$t=9?jqGCRq&WmI zrFl#$$Ha;qQgUws%fkRBw;D)8n|EFGT3lL8A6yek&9sN3o3Kkd=Qj#lR6sq}otWpT z8l{9K3?(vg^A>I}4zjMv!|mnLh*T8wEvAERAKEwD!Fi0nH%Hw8Xj7l~)#WYHXtihQ zPmD6Z&w@hRIG>}*=tl4eiBFKH+okvL=(v3dTd6`I@0oP@T^S%4{;Yv?v1BiXn2M(R zrH34dUg91Zj6(z4KfGLKmMs!$-i_9)oY6qa4!ectn8H+RI*2NI6dir0tK7jOi$V3; z6dlGT{YU29sE1L(L1UyHH;@muYebOlz}X|%X(c6oe{(c)LSxKVw-4KtZvv8?2M=Kr zbs$BM^1yM2A`@`QH%acZuEVS+CW#P4d1>C^G*dhAk~x@R(GXlaDTj);zVNobzGRL>eqpW4L})brC9}@#+<${N2ZI zu((WEF%)i%L`&uf1he4cVBTn1j=O%T|`(juKFzO(dM- zAFXIbTLt*c08a1TkVoLr=nJc_z{L4hR0!)?yGfuyF!KGm54NMmVkuMlo?K7jEx>Ea zkJPZXDZmh+KL1YxrUe{%z8#Qd!nQr-%v-Yr}y3OAo8>X z(*q#X=ovC*oPa5bvZ1{$zQjhys%{*0dZ?S5tQ{e$E31mF=nuqyKp$$oA^-T~yo^+T zLCW-rzFuiMXZ-|V?LUjq7uF(ttB+^@z&m=0mLITBPiOqAWke_PjgG9Q%<_N7lLS3A zTJn>ae#X}{4?)}X#hv0gaow8mQE)CHy#pWwF?V@y*!?63Twl2TfYx4U9DxGMzDTlh zq+BsagLKkX&sy~ICgM8Y4c$=Y}ibZjoJ@*Jt{w*cIFlonThkS4}z1pI4yQakq2VAH#!)|CD=3tmmX8?gL ztox6v+!3Y_6PkCpUdmBF(dR=2Z)&kxK-BI$-Ce@AG!yv4nH1Ejy+KMpOh0!^P<-(} zt(<`Rou7!#FBlh(9Dj6JQbwlFt=GM1sGGZ3V}4y%>z~-)w=NS6nh6_ZeLZPxRg^fc z4j{x<)xyj4cd+j?q@lk^#1-VGUjcw}VILPSucK#Y`kyXn*Dx|x1hNOdiynrWTX_RP zeEtH!FLU-q4iQB-JZ2Fq^kFm}3^&nXyl5jr!h25R?78{6xL7Y`xw%~&!Vwp_{(M_r z8fH8)Nq6+;>sx5Jd-XOnz);@a$&5FwBLtw-oqg32`!lc?O$u@73*l4Z1pws;11RGq zw)%O4{GOD5PFe9q8mrwv9%*rFAGrXKij`v}sQg019QA{(oK0HbfvuJsKt!`c{mLy0 z8^kDUo-GWGa3;bj0*+K>%*qc=7iR&q_rxfIkXwD|sg?zE^ZvHN+M9)qK1SE$@$FA+ ziY}=?c;}MEr71(@bs;BS1Gs#ak-a=mq&jt^vQ8X4xTc-qN5?BGS7NpfH|}T^(o`G) z!?Z8j`U=BkG8J4}?U9m`e>~cfBb`&gDLiT2I%qS0ser%8VO}wiyhjiKr*m(P*9Y)J z8~~2MJSK+siiwcbdVe~fcrk}iB}Og-ddne$iP;$or{oYmGZGC&3H5P~u_F$jqd+`r z#7V1ibHwaijt0tqmsBwf4~tWlTS@>!`Z25qH;AwQtM%kR*~O*WC$vW}5D>rbj32}Q z5X#nXLW%mnGk)EXw4zVnAn$Jw{r>@>$o{{e!f=kBw{K9?H;C!~fD9E-aQ}BC;#FFN z3s?{kk^k~ne*+Yhv@c~8Y)VZMBa#Ag2+ev1TUb((5Kayh88FoHk#X||+=lh_sVOKC zo%0~=G(Hs+N`Pj7ocUF@^QZHt_Z7E=$NoS@7^q8wKd~8g+FpWkfK2GW;1cm^r8J@} zHNX3nh50A$(gQNzf zV`l!Z#ySC28b8frJ;SswBxX7+XaK`-`7o=p?01M4x?YO+#m>9%NK1DeN$D%HEC#Gh!+ zTn>SKOQrweqIx5Ex!|%kW~w=3TMqc+aVeSrDzac~RyDf?y#VP!mjjP zM+!>paPbxHoGe!-MGkm(~~cKip+cnYJ1!BqmVesa^hDgeA~x?!O}TOA4A7lqh_t-}oR{L^+w=e**SgU; zRXFo-=`mKxtJ%E#8Htd*DV9&t0d#p-0QX}}RNP7zSG595#R`9}O1XoLA>?I-_1N;5 z<#@CiXK($9wNm(1?dcA^*I)!Rce)E87A}9PVDT_%)&&-X5GBsD&JhjA42T@M>{v*o za(C7srw%z+6Dzh78*`egi#9@eMwEGoXEj4oar;gh2Iy+ZEMr9AC9q^#(U#7z42vU8 z;2e;;(z<5b&@(bKl5x_-n*}Ulr?G(kMe-XJ3H;ThUea9hvE@%e){i*Vi0T5EycJ& ztLC&j%?w!a)Q2UjR0e&E8;$e6C4#+9aU|YJ6V5pRQ+HvZQ;PJ`wzoWg+6PCtFc-WU zg{JV48VPeul(H!7$eI@Q}An`$IO z!W;9*FsUGz{SMU6CQ-3}1hTzU1&5jO1vWa<)k^7YDDey1t!zSZ@Hb8F+0GTto9MRP za^vQm93-tS*pdtOgfju8UmBuEJ-T(%B@_O7W($f}+zRy9@wK`uRbAa;AwD}INWJ_e zK)%$Z@W~;GFQa_oMb8qrA(HXGVZrmQ+fv*i$F2n$ApsFkkHtCH=G$JKW`M#Z?z&oXiJ0G0cO$@^@55F zwP}v35IZ(Pq=EvJdZFL;?blqgyWQB4!;G9dYf_B3aJgZ)v*a%7BqOL)#exM5u%1w6 ztDrj*AgR2{k^EAQb^KA8ubT0ZK|gM%gB4T5xvjlu8&yD?x(@r>*m)C=CD)CuyRHJ~ zfYUD3y|Fv?B-joRbC=lio~S_$t#^SC=0jQmWtDxHr0%Xmw9z=jp=CV8yLeibg)oH3 zQI%n=pBn8#mYuiQa;lVsZ-sc;$lLCjv&7q6!|gXE8qBK zwFXZ=jX`S)&O8Y#33TB}dTwnS6=GGw*o(7`5B6@lMk?+=&VP?GHe8jNYVHs9Vtl(N zR-odyo|$w2zkH8-XE~R7jHNOyK4(*wl&EVYJS$E9<*7v7lr_?SpA3vLB|}&>#r+@# zpo6QYRQ~pRSr2bCc;pi|3`=uYi(z1hBGF&7K`-49vS$o~?l*cJesNd!BHSO4nH#Ex zzZ2tC%JqHm;Bim!45bQg>HjLgX6=^!rZ@`_5C;eWR`aVPi1)2ndf0)IFZCX~!4@~@ z3pc>BmyDnX4BFs#v9}`29{d2@s;$;cq0QMs?g(|7s@#zc)d#1KZOiQbqqDU0q_#wY z&G>;*D;pqKj&n0_(y3FEg~Mgf)8g99#}#+bb|3qbfJpw)z$>Mc%Vo(qBm2HYQ~Z$m zgAqQ!w~w$-NJ0sn6eGOT;>HOCVr7bxX5VOm5YfB~0*peK+IZD_@ z6E^zG{N6)JXrd)|kZjQ2h>P<%-Uau=uFm$3U&iQEKq@!sCRy+l%3P;YT=RDw$CjRz zgWIrMXO$g1rto_W*N_xRxJikq97fn2obVPvl}D_QORNcH2)sn}eJAA9^@sH@)zCAu zLkquyGPdZ|j*;IdczIOOUnISbjdi!9GCw~h`Oa~!snB&v(xqoi72FieEKU}24TZ7k z!v%q}doTc+Scm%()ZA`}0fXD0UXm~uIFQF>?xU(6%ds3Z1SKMmp*fse8yGtc^K3zY zgSXP#*ci;;=MKNno^8ra@k{)h_CBPuaj19qs-IVW<@RBMDt13V@%V_z?)OvBWN)0p zOMx1o<>Bpt<$fD@kd|20xGYU7==&t*D%_WaF{8&Pday?@P3_(K?)%{>-o^8g7FRbR z{|MuMfv$9ng}W212m2D?%^l=<$H#X75b4|yS8{(1`|-swGa5#(P~r??&b$e3JO zF5WkB)P?oX8EzIh`KxcBMRc8Df{NBKdW)77k5eb=1`W0zF8{;G(d>LggH%=`u@RHV zJHKhJE*Nd12m`LbEG!XcK}2OmD1b4!CfUwqSLeH)!+mB;e03qk_VjJ%`G?d2FWXo4 zmkpb9&EP#T-xC)Iy~@6LzP}>0x<3>oOu@qwz>jQs4O2n96Myj|!jf-$tv<9DCDJ>( z$%Zj*G=^NnYYZ&snV*IX7jd+ZH(JVqXFlUE;xm5zCB1N7f;rl#XC+O-g;g{~ z$6(b~)BN^k8%>V&p>zzDHk*zsSLCuWAd|B`MqrZ{i>ifXR~n46aY4qmWPad`@hS^M z6;dwf3&H_igXhbxh=Cg*3hfR?Lyre6nx!co7 zpM^8<-}{r%t`H{PWEcA4l(}O<&cXbp3_b@n>B6PlCtbHy;`W=Q0q@L#d$d~H`EKfn zCwoA~aZiJMpPw@|uU-RQ6TA$NS?SI^GPgtkm(98X>C$IquAs>pFGKZ@XROmBP!i-O zco8xi^jumYbIyonG2014o<(m_!>Py{WF08SB^%ZVnGK!;qpoF=7E+DEbg6)6x}(qu z4U}VoH-rCqvEfNUreJisP@p3OfuPg4P-r9f?aPf;p!w{yjd-EO59S5nzM`#aBde7u zR5|^r+7O0}l!bcu<80j#6jr}?N_#h4lJ!p>-4EEq{eBpl zA69d2~lCxInu->8cHgHV^Z%p*!oyuFoek+}IK>?eI_lF_8jW~`416|q$ zg6dBF?P72*a~`nE@aG{wB4_Ew4U~5;>9BA`g@tS<>FQCzSk`mk73?!gUBy=Zl;{*c zJOQm0XGK>~H$0yqiekWuka1>*{^#BO2-5nrLmJ%oMJ3o4=rbpUBmgbj7AyY(6?bvnG3YBI3gfv=a!m zzaY!Ig_L1mJYk1X7q+Muaggjp>F%rFH+{2<3y3J?QJwGkOb1pg!9GKRwzBHhO~N== zxo&tzzwe{A!nSQ+h9p=n#Fs%3Ugb~4|LVOQX}=5=Tcg`!lyH~<=PmRFKhwYZ7wO;G zPG{;q>^+t%t!)Z8kRY=f>WmR-!@gPs`hg<%1zjY+s)E*^TI#f$KW>QA@oa7?@K@U| zCvsZ5{D>wd@qPswff^7xF|Tjf4lRz0u@?>s6mpAnu@2??O9EMfNjF)?Er)dOCp}+Q zA$$mlW-tC?Fs&q8?MO1jbzkTEi$)vq>Luz$^X6jQU}OQ774&?8)1gNQTOZN>7C`Qe z!;7hgYC*Yiie=&}PQF!xzs<4&am?e*vTh}(?5jEYxL0`_jK8eOAni_2UP}G3ffO4@ za(;&s#Q`BV44}KA*FR2K2dj3Z@Fl0?*-D!8(3S^p;I2D&Mbm)^HT-BV9U|J#Z(x2P zg5;RbROo;#xiUSpt1F7g5<1qvq`oHgcO1XM!QWth6FTCz@%pS*KehPfP9jyKFX^Xd zA>Il6jIMScsJ#`NgAHSQ(QcqrpOY3=GTPsm-zEC&Jv;JBb&x-9yg>o}f-2d=Ee&lx z?6GB>l!?CC6sg`^Ad~MFpn!nhM430}g=3&IMh9TrcSs3*Scwi zc!%Ga;YuR&u=t`3Hb=G~TE@N53mzxS%X0NVHi{gLp=Jnkz2Tx05xoiUM@FTlec2b{ zZT@|bI)OjT;u~b~qmXoN^wu2Od2NH!b?MaKFmg2~d>G-pR6IX=92QM|3G&~o`LD4o ziDZDiT{JF=rs+tXZ(Xx8&8DJI&S)|W{cr=x`2=FW>NPhq-`J^UfYPYj&I%6lv-tYb zhlEO{sXFPlz?@=Xag5Yvi(OG3@jpid?s5Y3IJs!51$5P?bdXdN%n*jyX&$rn=Q>w8 z67rjHk_uWpVyX2L0zo1ghpw%B0){rIn-)NrBy9E=4-TB+ZoET79}QPZ1A=WBiwW7Q zTlvTa(uH21>)$N@MaY@G+Y)vG;nm(5F_oEvo(!YDa12a9&%3zWzIEy=H3!*Q5~;9N3girT%bz}T(-sRTDsiO(ZD?<;~3z3 zixI6Yofp1Dty_7AopMhl!1le#CtP#u&q2g%QI({GR$MpozEc1d*|zBjj@!yb@~t_c zC!ZVkH6hwBI9-Z3wS`nx!x#wnDpZfkb`kQ-jYFQ=HSi5cw;TU@Zt!ep#2R!Do?Kz8 z$#9#P(uflH!Nx6MJ&g>@PZ++W06=9!0PF7@h8u#^vWa*$)kE6~`UF7|<|$DTB2iYM zZ7?#v$^|JZC`+nIiFN8a=vR=Or=^ejB561xt^T;=@yFo^u_>5Q*J9b(HIkV*asC*> ztyz&FNJ=@9yYv&?0BO0~SYU})9GXnc-|k}5Q_uh%oDN!io}xipu+~Nob--EI$V+kG zy@!<9hR*aC#SK_Sa=0OnT$x(uuGS%G0QP-&?j6v89 zTtJ?2I4gE=%FFwURX`qa#_5-Z`Qsl*KaCx-ePH=-SHfDy=qzpqrk`}QeAheytCLPq zzxAOWp#t&_cIqqicfeH6Gy&{(ZF?VWVG6$zhlVmsBOb2ha-Tc{ev)nLPP};+E|_>H z0zY>yo3PDu#Hw-z-?*X;P(0`clh>J@W+{_FmiBDH?9-^~HA#0C6}$y<E!d3|rUpud3r zv&#>-Q47(HPSu?@>#T9i@0ulaKH;g;TZ3sx={i4i{BHh$5%>FcC8;P5g_jIws~mMP z=tgD$YjD=kyJhOQ!sGtFr1ydA>eEgNU?fH^!Y(RRMc2anWXGs1>>kidAPN$ZUryUu zTU%T5bQGN75dA|8Pz3C&E+Br7c{ziM@!a}hFfKf5F;?X%^P_9c84UU0{^G)p>{fGA z~k_m56Hc%PX=r4MHD68W;M87Tht$rkjwd8 z4=(=rVz=En{JAbnvYo?Y&#fswqUl*P=H8T*RQ2DS_}k!VLJeWg&yKgbQZK zs(1};Y|4T&i}L~*t8CVPZJ3_B-Y7o8T+8jQjaB6y-KjtFqH(t8dzgRSI&#~ZugJpQ z2|wcpXJ#t*Fy~{U-@VID{Y!$#NwhVf%`nCzI-uj<#hxn1-986RT;z5tb9qNR5}(yF zz2`96Sj_GxFZTqf9Y^+5<-ix1`)yZHBI z6T_9nOlkktx*E`SH}*%SP#29+kZ3{Jjpwk~VJ7Nh)Y!^Ja<`|fZ9e{abVmqVIHrDZ z^i!p%dP<3f76qu zm`*j!=I~OZ&~B>soexyaFcqymxpnGKll)bE^v@tUM_H2|@|WZU_a7r=5Ns%9tYz;^ zcA6MQKB>PSsyq=bzy-xMhomGs!;XD^Gdd2o@R+k4KWt8jBT?~+)=D^{H&nqed5`b{7LaV`}_ORR9T zm@?oE|FqXoxLUT*ZSCgC1$TPusd)B4kV{t2 zWSDdVbcyuoxPMaZnug+y&676rJlT{W3mRo`{(-MV^xgxazY915;|nQ3xKbvGVQycS`1yQbmC%U!vC-)E}>G= z;DPxEjt0d1M<4H7{lZUV6g&9q_6_X-`b8Ap1k{N7LC@4U`re;QTtqEnkRHbF0|p@X z5iW=eRmFvWF@@TvKbWU&XyGsO1(poRFbq=Syc!D?#z~4Wxc z)9~p04*3Fenf5|AaD&y(;~fBh7d}-NZhv!)F#lX@b;03KP2oewB)WS9Z8+eS)i?CP zOo9Jyo#s11`1Xzku$Tz@GlmTIK+g%orm=!75+nd4S<8wljX&B_4xR7%;l~9i5dVz> z9`)S6a13V9NVF6L+1g)E!clI(38f+S++T?W7*o7oA)PznNwpXhR?>zO)h@qLehCIE zGpIb+LC%A>qA#K~%Z3zx@MJ^nf{X;hAC|Qan7)uM_1iLI+l5iwP~1)M=4biE4(N}Y zk&SmkQ0`yfBJY*$fP5xsVxj>w=sqLVO4;xwV^~yUnnajBalb@l7(*4_>82m&tuJ4G zT30k3kH5ITL!T8QVF3lLBtUzt&ZaNC;o0A@`7=N!!kUr|s6Nh=ibS*C(J5W~JLinW z*EWlLz7@1dXe=E8C1ZSRvUXwiO_jK|t^A>cUh-AMo88xhx32g+0uI2P_e)QR4>rGv z{0wEUrg-d}(lOPjrSf#hU#J2D#EPJJyA=^yZjjC1A8HPV@ymat^86`G&snL5ozjCb zmBLa~GLz(7Bs14vK>esoa%_i_;2MjEeU#u-sZr~{efrx2BS|ld=>)tq_EHU$Z;9xH zj#gzkyCUIrYkZYcGaXamYd88A?+^4? z`Skx#-wZ!dCIoq6<$*ta`EnTUaS4@Ht9$>=z4+T4~rB^(P?Palhkl-A`JRS&Npxq9C?A5 z9u#MXPF(PUWW$0{V!9B*CFxx{VVEdC;+P8LRzYG|doh_oqq1e*2uEQEZE0?uG*t8P z6q2>3CFfZUXi5N8r3+UaX~qYm$%7YFlyAwbiP4Q49y8X6`KlU|^45)0#ihwfjC6d} zB-P%kEgW`tO%f%nBO;ozq)sxKhDR9iC#k^hL%UzBS$oBCurl%5q$&(K8RQv-8^-mQ$fCEfQHZamNUr z9aLAoF3a4bh0jg#f?h3PRIqGcf6>9XOc`MHBV!1$Q=}rJcol=IJq|vtY&tvL06poO^Y1sE? zdDgQ~1yv)$tK}3L)-wWoiX1D`@H4Ubru&E{gseZT&KEgO%Rl&Xyl>R8I;wQeG+R|* z6KmEw*a%NN2RmRM2>k~U{(<4|o81+pJrBD75`d^(5rh*|*`rLKxcujP^G{f_4cSk+ z+8_&1E&Q@wbVEg)ZP%X1ePRzs5Zof{;jA9i%2t`7n%EG^`l-!o%1f`YlHj!3X-DWA z`{J8=4GlynNk#ZG_v#+4GE3>GX8Xhu&#JlX*Y|8#j}#VhM_)2Ofn}cv>-*6C=L)5( z5&G|Mg7{g$ zG%uMAIo1uC{y(a|0l1Q`TRXOG+Y@VI+s-7J*mfo-wr$(CZQI7g$;6ody!ZR-yZ5c? zu5(WBr`PIT)m3|)z1H)rXpj{a1TB5ewF`1T4n%NHdi+afaz8>ggthr~L*giq6@G-Z zECv>Xbr{1@WN|h$KQM;yA)tH!Qhb|n7{ka=P~9{{w+$FW+d)6Z zai|MiBDr+%5NB#GMIJ)4f{Y?3uZr(MlQg2*)NK6c8gt9td2iR>fIX9!Ww-*{$lRke z8{*&N?V-V6xV{@1f;=nbgU8<7(y00nK06nLvnOH5&4;?Kogi6(8x#Kv>t zzwuSSR%n3d*vd5lO5h_5FRVoD$Pj&sKnO^u*h-UCUFO$YtHl~PYRTj+TBc9TRXCGE*;0paRnNF?(cZN zS^Jj8#eTuDSE%M|XG57+E|M0^_|XHF(`%+0HkJGBs2eZcOtECrq7ffOo9b^1*Ih3p z>#S$iKHO|covKY%Jxx~8$7>#S(_n{c8h6S#qXHMU$aYx@=F;sTnHqZyE4sAni4DHXNq1; z=szEuJEPXOnr;UQ>i9HMmjrQPRcZ#^N9y-QYx z98e$t5&U~lslXSrVp(#G={;=HSF1t*u5uYXVUi%B45H%5nx0r~5vWAm?vp&MvhlH^ zJ+73$ooQfAw~}+^jcj%{=Vl^w&zN_5{9^sqg`QFUJ`6QrQiWC{L!^CjbKKgBn69Jc z$5H-;9`sgHnRnz1Yq9cDMtR{02cwjfXc~>2teS*bVwM~kc83%5{AMmxTY4z1AGsqm z4YmHqSeDefg9k+=*M9*Jhlfzt0slPkVrYn*q;U{EL9#Q19JJn3Tsy{$UIxOIPCuJe7PNvq>?Ywzw zRS&faCS@B+K7YY5Sk<~3Avu(;F>8^oL1S+R*#Ifo+{)>KL~0t~o+tGSyJ88DINBw7 zI`cfW!lJ2a7+=yqu0vY25@8rfMN)++nyUfU*`(4YO&_?~?9`@N=?AVu*(GvC zY-!g2>Zx)B3Nub-L%9X(Y;xWlkbIGL%wbyGAd><7;AqBJ*AZpRwaKoiN)GXnw@kGc zZC@6y2BQhMp#hZ6b7u#fX`2!@f1m`E7A;~9DBrd@@kYb2C|L zVbFi*&F9#Dg43Ihr*ikBy_#jE2}d>%{RKT%m{t~0=A1)!+d`uG!@P7?^PCqa(EbP- zRj62VpYkdg#Fn2x-}|TU1N??$W191#n%Asipn=FIN*#bKkhpcvaBQ>4_zS9<2&}Iq ziW#c`{!O&vgVc{v{4w-a_`d%w@MVugU`wS5JL2Mb-`8oNwi&}HGA>4!U}4R%+3*`* zjo~Px8&8b`PfcG+f>J-*)+@w!?j@B5?2;fjr2R$jJO(uflw6`9Utg)hDOU>^K5xsi zCAX&rC0YQVw?BW{q3%x@O zN(pxos#O$n^HM2)g(pcIb6v+a1g@FeLT&vZZ{DObaRhS=D>Rl#mq5UmBs6YcRqBFc z>=ppq$6ci^AdH3~Ob=y30;?5Nfl%~Qs;^Q;>%2gz9o#ONR2>d^PB>Mx0^wM=D;=c61{T-EPTEJWCycjgpn(x=X~K{3V%4%kYX{)kFo1hS!g| zYB!cy0HIc3?8#x7me!uO+sR68oq~%zXmG-;7#Z&W7ViDS1ev{u`NjiGsMu&NHkE1gX}+`KinvDp#ROa{sT&L^ywT2g0g@h%Kw01 z`A}9t|CL6yHhQ$C2LcYES_REeRQ{b~JzTTijsQw+n$!N%TnRlj*8>Hvb;%MX0qMVv z{>j%GfCUH!0&RHyk2t-N4+>stl^HPo+vovQ9sid%*B+tk9U!s*ruByp3KYbD&HVGc zsHYC|n83kKV4)#-D$opJs+>6*Y-^(*3N|?A|5Zm3xhMFM2kZ;go{AfU((^A5*}j$2 zQg|RBev+x5K`6ukSVR2f`5f))riKrKUALs6aOZcagSfaLZs<64=u;9mFlms&wT5c3 zlqd>n1)4c{9Sd+suV5kq+k9w9uRZP}#yPNVOWGtNJxH&)%$7fUQ-TjqS6012T zO`Pf6DDuSsSO;i9@+4GENviev#F&zw@gA2BP4N3o9V;IVnsF!ZXyql>*IJ7$CQ)T7 z^dd^2$xv#rWg+1($J^lH3KCLW>x>ZjVkK+~bdA3o47>a|(kKjB<%D6Xq9}i+FT-FG zW$_`VMWAROuzw?zVb6g?H@!JIuFqIGTGpVe%tu21EI&&z`8g@XAHxD95&drLoEYmpf!6|& zhat_8+w9jWX~fQ-2<$EH3BGcU@Dt~+26Jn}Q5^SEMJ>r_Ig=YXRBpye*D`3LO`IW6 zkYpnTXd#r|GNi(CN1JOGKwVnm%|)@;G9-OTkwHw#r>TQ!u*sEk9Q5&k=Wh&+i@m=k zmP>V&>vM=W@K&MLrBDmy*f7B!R%6%s-_bE(jWpIFaz{Q%6D=Q6aAj;{Gv+Oe;p4i{ zv_TrZg?Vnmy34XQGGfY0qNhIwX3zVEAop_uxJUi2z&7%-FOPp9JA+vt#sig>lH^JF z#!KA>+M%+j4Y4n&TAiZN0aWWL(!*%qFAo)b8&d}cUxO}{nz)kran|u;q4q_b>Z?EJ zleXHL!%a#!zt1VUO^S6|jR$*Kvvt?IFzPZuc<+(zsGvq5xvq=+b`LRRb76%H4uV1k zL}(x*QfzXbnY9q%hPz?K*^fY627bbLnK?7~vy7W0Pc}7oW?~uXQ=r?Hj$+DfQItg@cIewjs(XI5lX9;_U_m9&Dxl4oex59 zqOM=gfI+w@d&{%k&%I)1jKuwZ$BSzgaQgkIXPwlXEBH41QdbkE4Q)p*dlJORmvn3D{SGT=oQDilcK_j)4NL$&m)!k^ zY@UB1=P2KWYGHL(;ktpMmFL3Qo1xO9({FYV8-;43ae82iz%9$UvQeL!tK?bu4<)F3 zU#c{Kc9_sW{Y+U<9vGuW^?tSekE?B=D&KR z4^fOlAh3nkNn4`kHiOz@jObr72b);Q9U50r+Cn?$H)aA17!PtIrLuX zcE|t8bBC(WEbnF9<0~vjc77HGBO=<)-oL(qeGza^Ez8brQTaynk?%(g;K}le6Oo4@ z^3TP&RRxV5nDrQpUFqi^Sfzxf$+<7tRqKuMC&IpUhMpsZRRirsxs{cCHd_9)236$k zV5@ky1f7jqpkf`{?nS-bqOoawhXm~<47PRq`=gIo!YFeafN@Lx(ztC4Wx|Z!%JOIc zYzh9QK$}od61aAhc6H?rAo}r+4Ei@IJRP>*6Zuuoe914h+C|RG3f}RL1MeO2OD*VM z^jo+t-rsvWtaGiYS46*0{5sjth{Gltt-)nI_51K|sfs5`lFmrlT~letRM%Z|CK67` z?|tCq)6|?u=7&E8{CVG`cl{we9YPyI+VfLmj77am_VMt*0=0z90ii+3!;)^<``SKr zD#2iok{RJ>EVdG=rFINI1Asb3`Qbd_D8IWXj?vVp>IlZUG2?4~nJ7)vNaFSlcJ1(C zRYGX6DVb6S`%5th3!5Z$VB%nLOGl_+SaS7a_;VzXNOP$0FXW1|$Qv@ECl!(ZQf}oi zQ$h`6L&d8;*DbHk1{{0q8n*QDps^EO&9qUjz*Z3}j|b){@9|U7$PasYHA-N^*d$08 zxhY1dLNFzKco*Is2|u5egQc#0+#bgW4s@s)-kl~mh1r@RC?4vkbEQy?NR-@!yxyB9iI(VKBdEnXYzLb? zoI!(*#H;Gt274w+1``htJHB$ck8)nUO%K3^yEF_sK!w=!LiP9dtO^=cJGVx5gN>WmQE4PgHYO{-}qqAz8>e ziK(s7Mj7DN8*)+wTU2OQNeA_ZCdmHo;{%i-5}lbT^G{W(5Ones_70ueku?%j2pJum zBOIDM^IMzmNqOC+z14rQWBqBso_@VI3Ck8O%spIb1(@*PoX?IMUUZsB1-@nreb2By zfkc`zJ8KS-8d!q{WH zzG)U zuS#ey)hYx08Zj7$nD?*|KN9-*ZYQzIFvb@wj>+})Ybw_3=Q+A$_qKhgPfHQ%4_OL- zsqd}cUJOY$q&E&9E`*+kKoAWYK`^e{68*I+0A#I7ws@hP{utpg+Nn7PHc!d)={)An zIa)TI*Kt~qqcEZp6KEl49MX}o4ev;f(PFc;iXG!`mcx?cBTpJ!Z2Z0CX}pl(nf1#g z+oU8lHE)8?ECF?GWi3`IlbHzJR&YFBfQk^(olI;1q4lIK!8ls*&J#0~dma`K__z`2QJ@a`$+!mKNlT-37dH&<~!T_L8PHeIv5Jo!%9ySB` zzcvab%2(>?EOe@L@MO{GftEaXfagM2dLXGk-dXANZR7)wy%!1p1v(;%M+hZlwYwYN z?=9N|)fLcpW$J2=Eq*EszGL{~9E>)%}Tw%r*{}BNplCH@oKX zcZiBZpy+oaGfss^O-|-uk1z>h6@Yh_K}^#Fv-z;f*)j#LSj?Xa>aCz$i@Nr>49A41 zj7Mmq0Txz!hkTA}J;FI5Kp7v+;=;o_jKMC5G~H2$i2Aw<#r&dF`BVv_j_Ws$ zYPhsZDHpx#3`Qnl`5%=y-@Mz*;vbLCWW-$|O@qa#_s*1;DK7|X5cSn#)&awX4fpup zD>|k&D!E3eaP-w3bMqPTA9IHG{Z!HCVS?}FB#U|llcQXo++2paSM$j?qlTSFu}#ij zvQzM77`>BEqhab-PRyFghL^sPLmFAkM;``8^zlFkAVF@tMNOF<1hDq%dr1@)I!e>e{oACpjK8 zmk^wOvo3pLMeDx4c_hxgX>4b25UZr?M6!&#jbf}Cdb9?1Qo^B=D3@SRO!k>sn7(78 z*}9pxWSLpqfi!e}52%5W^rh?a7N9w}MC%n*dQ zl1IsUx)?j>6EG44q!_Igg;@N^bmu_oUm;y{1be!q>)gX}Aqeb#4t8y+SKMgBrJ6gX zy6spo~@zS55pE~_Aq<~nY0x~#>7q>%o^{qiFGp>OEz3i_4hh9J}S zOvAk+=|kLXm9=PTaWqQ%p*0wr4BSmsHloFtKkeZMIBzNX5{0Vf#Y&(zi6^RTtICVp zxN6e6mQ%L2QR&_!$&OZwSe-kuqH?4^qa&&^5~}A*6#&3-QTGgqKB33Mk$L30 z=2kpO1^j!JsJ_zR2xgVf=<@43N6IldBkS&1!W?dmSS(7yb$Udr{jK1aXa~0b0M!B|4npDZWqP5bb{qlyQ38uK^f%rkS#dlf2HW4OKl#%@L6F_O4Xr6C9*e@ML?d! z`uCOs!Z0$4K)JyULUG4(lkc4q^z3|;dG?Db0w3w@(|D}inty2FJcWWgRr(HftJ_ln zX4}LwP8br0Ipy1JGn_Wrk6SD!Y!{Pc*4zjU#TJ@$MK8B`bQB{~UCuH;Ifng2Uh+Y+vHA`U>Q7 z22-b+gRA>{EIwH=%V{o^`FN(qK3dfX`D$V0=CwnVbkkCJ2zu*m0N@(JL*phwelG>?+ znf4^}e3O^|E0oL3>oAE?bJF*T{G}OOyC{YJ6o!vy($KKp>h)u~`_>Y`rW{Xi{l&6? z@un}*t9#-|S1{Qm+^QPCvT1a|uORl})Mrmk#$M+_M2!c^gHnf%h*!4HU%1b`6|^_Q zjwgv0EzL^PC2=}&QAf1n2fr^LaX`J#yV1lye}zG^f^zlO!VwiKKGKOSe~_s2#^(27 z(f~4UXKmygcd_9mK21EpBeuEQo>k$Sdz&>_>bP`Q%bpAb*cAB3rZ!{BlaA@SDr7&P$~(aAkYl{qQY z*zZ1=?cH5N^=>KF+?b+e?yENwJU(;jl z39Vgt`Z2ZnPPAIm4@w7z#BEsJhSAi@WhGqg=YjKtP@KUG{rAvoqVO7i+5JG0{|a4P))}y-CfjNla(@ zMOWJXPsQd$yXI3*nVO{vj0gVVs@JV7c*3jyI)nuTFk3|XU&I*-bbD}0_wtt_9kMe(dSHq8*bdrkFI zH(3^iLN(q}u85imxGZ!dQ6`k01>AO}ck4`hKk)0sC!RLYJv68yTv26wPO}Ji z4wJTTr07-4r(U23{j`Oe&ICjG`&ow8tUuj3pi?gKmdzTKG3tcKb4zdY0cWY%;t#1;7F0x|}{#^lo82mjclMDINv9QfV zXxm!!OAPSR11Xa$`HyVqyCk2m$?Y)72NEXW;6k*AH__1WD~h5!InuE(KL_yv0FUb+ z&=V!~NL24e!pFu&?Cae|oib*rUep5%w520IXVwu|Uvr7(Nb7Gm3)?Y`_%`bpcs&NY zaRRpNxCP7_LTsNyF%mMDxn;EIRWEp%3-4NVClBghqlx5RDNkjVuS`1aXEtL#(POL5 zlF^UjjKDYSrSR-U*tC(o59yZ!s#P4UG4<+$*lLAu3mE#apbhI0wW5$MePP>l`1C=a zP!Xv)o0Fa`C5;M(x^okV+-7GAf6Mn((AxaimHJ(N<6r*v8Z%V3lAR6TmC~}#mMkf$< z9zu+`CmSE&Jnfppr%IRlrY&_qRQ#DFz{;_sXW3R0iYONAoVaI;O8nD&nCN?lvrtQV zzMAmoVz=Xu>tSLJuIO7e#U~rZXG<&7ug{kvVgk{(?-akniiiOh3tSfX$+K4)3#B=I zgPk$^d^(eN3nNBdS-Xzq0NpO*7b4B#{9S0_PhXl9Vu!FCtKEHdOLI#`Ctcfx8BX(X zpZ#&>L?)b(=avM&%4nl5Gd66shmgBL-4pe_(U99Sl}`xYh^02^p5a;qwS;i|Q%$Iv zvOZm7(HHFt@$bEy$RVHmdyXGnP^UdyeyzDa{Fmk&uH`3SzRuNx0N9Q%c8v4cxa6E* z%QyQx1ppG(`Rw5N8+@JgU&f}z2fNQ_C%n_dfKpLP-`EIpa86;Vlqg|~AgbzQ8S0+4 z9wB*^Q2h-vTX^{fm=;T2Qyz6l{ASyRyez27X6G=`P+qM9+trP}+B*XRhhXcc%RI0g z%@U}lM2fz=h1ouO0D?!*SH8bNUfLra!<<{gcC+(%!l`!3k{zim)Of+Ex9$RK-nH)U z+CQlf_Q5<2Iwx*7m?okv`Xp7M;1h1X4coP6b8QbaS#{O+9AHLdkA$PO7D7z8E3TD1 zQO{`~a(l$2Fea#4N)l@@7b7sHEcg*HGGOEwloFiby9=2*fRN>m&6P~Ahq8;=Lc2A= zs8LCRbCI$VEq#yxo4QU9)F6I7^ zD7q8OT>l^hz_43%Q>6!SA0)CxZbqo`Yh0pv4LDBm$T?1FTXvG&GHj=;S(u?l(&s%a zZwZ38fyD-jcQsM!NflC^B0Y{0F7~-6EFo}buiUS{t?ubg*z%Q;bxXC7ZT#5d!p~Tt zh3^=y%W~V0@VXy=l3=7lW?Oo)bYukG{|o*7aX@fY<(qto04G=Jy+n3$ic54(2<7Qm=Xj%;rD%-WE)0yei;w#V9g1QeS zm2b7ZK>gjy+>aAYL2iUS6R(*-3=5{B-vB95UQ+i+`_5X&F>D+Qz1_y)vuKnB#arl) zc&q>o-Bwy~JCnA(`FPmuWpeBooc)oUJ)FOn{FK}h4zY;u;M-q9%>JD4k2ZunBB_u) z-$+pcJ$dhs4aF=Y`$Y)FtyoHUBqd>G(xH$cqEJX{f60<8t?k~}^Rt~Hi$%@JAOk9s zVWB5rDVwDarawyU5}}j1CxYn+B?~i@<^=K1qF)029SR@C9K_c!ImNX4xHV`vB}BgZ z`X+cKCm({3A%h;S*k*7DuZ>>S$Wi~+&94z%J|b4%iAO1XaW?lA-3)xY^g^hKzCy+! z#r_SWenR&LDl`P)SXD>|T?b#%2NZz(dwy@Ao;OC+c#ABviu>qtmTGsdj5M`9U%q9>8Gl0Xh2UGye#ap>P9NBGSsANl@MG1BC~|?iq3b70oZ{JI-~05 z{W23n+&n4n1~vv|U5AD=4>%+3D;p7Ovp;x**5U`4Q_sPJ5>h%khsc0;uaGDK zY=z^hi1uGjYR0xS7zmzoaMOW{^)tb4goNCIN-0wvqu88y;sh|b;1U!W6Ohdcw95gm zWZGP3-0=9G0aN2fyBaYXs!ndyh}^;&2R4M64hk66T-;8iM!u{W&Jph6IQCQ+ymE2) z7yN{$k^0H>^Y5bl``5z8Hlu(QB4n#M5_YD!eNkl6#8OwufNc?FkQN?oy{O}#G5LkW z;6V)OEKl0jS=oOs*2uD!#GS+*^>N756jG%nh61b2<^p*oAVjE;M?gekc!*LX&`dI6 zSu2b?LB^E>a8MGN!-^L+>VFuE8MfCaI!wKxk{_WPRD$(Ose8DXP~ZR}aDJ)teZ==y zjO7V3Jij^;UG@$C6lNmD;8CaD;Y&q5k&FLBq~}ks-zGD<+!lf=LH?ERaQNHMuoD%o z@vd>$o#@8+*SAhK8na;Xp8fclY%?f@`pn-p36Gzjmu-}2%C9Lg_J@3Oa%MspYz=HJ zHKWTd@`(Fg2dfutpj=J>87ZY^tZze*V2%>+hg5`Ihgc%z6CCEg)-gb>E?&FAtDv8d z7kv)XQ8+6Z<*ubM`fJl1A@EhOM`BIG<#GhLcb%@6sLQ28tVu%p7+0?8ZOG4^w|+6u zw#l)T*}bjbfJIp|XSj*e$+JFo=*Nm$o?4^iPNg)*IBoc`zdaBDv5|Hp7G^C{&n+EC zLD)j?F8tx2BH9>vdo<6C9OJ@iR!^XWitu=zPMpqhm8Ll?@@G!_JPMmygN9)fyWh{? z{~*G0ELqkM$-_K8u82Z3sZxxdVhSS4DY| z;N9Al-JT9>Wi7e@1&5(8l@^Y~e}YG|tRKztKgbDdhiM;3zo1A3Q%I~Org(P4VkP`GvKB0m-Y4?%%=-oUmqw+Z z>Zsj}{-iDr3F=FGw0F;-@S=?6NQbw8JBQ5fBQvJ;mXnkbfI)!xr@Ttm#-+I1-L;FF z+q>v{ITOf{!l%-xdAb zNEt8^voRK2ounswzQW2l+_Xa!h=3c`daJaN4W8E)e&}00DYE8uDVc<9(N3-tg+4Rv zuykCiDmk`pGvDc!%B5^de!^mNW}@+#b4|~e2fh3*0&J?A7|Drb4M?Rc95=9pBw8y{ zs{eLLTDA)p7{zEix5%!r%xO~(D%^~H_lciv5-PtddILcZX0o+P6pUYCbD zFn&$H5J(PoTHt#r2zwWq*ydT7zqx~Lm}Eivw_PM24`w?+=NJfFw) z1UU8R)nEJl{$oWj@H;HQDrJrUKji#yV8b%o1!6LehRi~BD)mn7do4LG&oXUSeY($@ z?rMtzzq9k3Q|HYIUsLipc?`sT;$vG|#t(5(Yo3!e6TZU^@)4F@O7TvOZ&x;K(gd8@ zOh3jRal5~aa@z=0@R8RyP3n(aksM`x5CIe#;iq@vtHeh$Ryl`7Lrtru20j_!hP&Do=(QC_;|WS+vNCN~QG2mGNdHkg(aWEoMg_1) z4mr|iQYFf&m4&c+j9o@}EN%?VfBUA(DR9@gtmKvEEZl{(;xk}x>ygwL{=)Z&ellxw zE(;zKTZni56de^5(6iHjEg-n758ge35pQMc@s;}1Ch<8vs8CXZmDy5_L58KlZL>^H z{W%U5$sH*IV>(=*23eYRwZ}iMe;L4SGVx%$%YdohRTHUI+qA6t@W@`6JI7bF6XVSZ zB`Ml1QE8C0g%B?@3LEOcZUCbq)I@atkq%3^H%suCUMmo}WDYCizlCWLv%=Fa`R<0F>zyJ{8#47ar zCi|kG>z~{dU)&KcmF>a_fV0j_ZdRo*=sT=dTvlm@or)&)E;~+U0AvSMPQ>B+~`VP#-KZb&b*(hwijMX zq5Oi)H&`upO_~fcsh>tFM~MI}Jb8g|ap`2mpXm!le5o| zer%cEsckZ+td9>ACduVC!e;Yk zyqX=k;-`125fFj~{?Fe$@Bn6PFZIRcs(H`k@Ze~_!pm**&2`V#;q(FgzY;qrBW*hT za#c*Fu+y;4NthL>CXwXvRjg+6%oIQA%hrL^nO9{ulxF?M!&}bV-h!rrKd=P5m+O&u zD>_~9k{n~P34s=9I+I$~>E+E0>&}-+5Fw%G7lwVY+9S5mxyyMDajSNsw^U{? z#`wclYGAXT67VMK5Iq61-w!S5r*TH#q_fI3bP_>%vl}Ij!XIRA_KtA|`Sr#YvMmP1 zxuLO*VN!o$r0(PC`SUqa=Jct1plVKn#HRJvgZTir3rXqwLaRWCRX|Uu(>E>erH|Y? ze9&;O5){cMx2MdIU&}(%X9n$l7YpnRg^ckP{hI#6s_)RL#QYcVV*(KVw{7m=C$qAC zLhh{Wnj$!zs|E{rKm94mmj2GE5`Xv%tk0oeGT*t1PhvILF-pKu z;u-qD8~94VOmaTJJMNC?faUwtqbu|2b)nu5qE_2=vz@Zj37wv-kag+=qbZ?@)UqRz z6xMDKNX+hwHSuqj^+lSU@Zt$zrAri0@^-}x78}7I5W;A+q6jW&S6xA@HOd`VC%NWVV zyrnvxQ!wQMhMMI%jG50L2ef4(HNXApQK;BMXNz7*H&lPJX_)J=t{_UWNRyiTw%=p^ z`;t?Y%wPA4yT?9%+sG;=&Em@g6aA7&wRljjaK)pp#BnPThI1BzK322dpJQmnhOHLj z7PGc*mB8>?FKkW-k6M>*MU|J+F`hejsJ4~AEr8V#fNZ*NG%+GD(T|@LnyVtS3*XY??hKj^<_z@-6eNAhopS}LOZ0mh1w9Jb%)V@z~ca*_3gc?d77!Ltl^6& zkD3p*imX;sr%-%*0K2A?JIFs$5qWG;Ns#0_Co@8cogap?$hYd%+u6!;yp+${vB|t{ zcq<c4(*nvERfliQ_kNKex`JrW><|? z0tn=utqxzb4*~>DBgHzB1MK&0Io^FR!+CzoU0dw&`%ur|zN_?(?eh=G{#ujpi4pff z+NMEYoNj;A7tV^_662y*We)qRF_eqnq)s5>&d_r0*d-W_tZ_BWinY}W@0`5XbGE`> zT>N-aUs_ZECx38SIq^&>_F-G{fh75%4~ThrC%8jytNa^ROG)hb`C1(P0u}iJ)gdnK z^IcL;6V-h(OjR6}@Ams-G+z?_WcKz;TDV4r-ITQ3p)sGXrxd!T%z?~!W(h;EQg%W> zF>N_#$|U1Ihpa7w{(W0XyWGu6dcwzY69phyjJ246mKIa4AwgQ>+jwF6QP(;kzRR|R z0>H*NzDtp)H$;KWHclzm5H8JRnm}(RdH)2w^$K`vrrbR{)%pm9qItrVTtlFA4i8_# zZZ0jb28i<2l6CwC)p%+*MxZnj%eXLAyQ>?;O&aa^YzgJ7HtTp~+R?DwJsOoKZemxK z^bZcc1oxSwBkaY553=;5YJl85CzU5(VppK_&N#(Q2I06q8|CY96Gg8aReP+oz&OP- z+c>z~y(QJ_)}_>S4()g?(4{NuxMuoMY}%2v+&v=It1;DU;(C0SbqEEmDQ^OUJlQK# zqED=J&n$(YNdob=af7Ltqir_IbWXGbjLUJYwD4GUa) z6Jzs9yNbB$_#5c(>*m|l3cHEpYG7N*EU~d-PN`JL^9B-qEECvdx-r$|%?Pl_hA4A? z@IzIbPj`PvgS9f6_fUV~Z>*v*85yVaf|;<+!&*xbs$1o22-fOH9nxL*tyPly~K(= zLp&OllM_?{8UtTf#gfUXgAO>e6c)rZnqcN7sBP z@nfzU*zFKa{fJxTpbzA+N78@rG@o~_|H&a|$wsOcOKizC+&tl<6V*3JzWU(aWPJa5 zlg6-luT%IPGSv-ac%!jpO0j{t`kt|K?FlN}Vs|PEkjvkEx4QOnVe>If&h>RP6;+$Q z@zQDY@tyN)KOTQqknONk!S+Ly^UIs_>op!9Fi{~K{aarMPj_1012yk+-0f4o@dpHf zLzZ3~3r}(uRpj5<8y24Wu#yrUIk&~d75nQHDcHEw8=}%h_e$G41`R<%uLEoA=(nj`JEVUGX;LP7;RQHk624xsQO{>%N3o4=vHC?Ft-EUl<>C>1FG9sH+q{&5f&R0PNw7=cK= zGe^ZqW!y)BPF1i*LvFP^LlFb}7Z%S2n^zc!9fbJLJhH9PFk3EAME^}NP$2p1KMSnG zM@9RGVDLXv02)ODoV%l|WBmP|;kIBRvj`@hr!!%efmMJ3CnCPim?REQ(>7%JmZ2bR zHZc_>FYajIXrQ#^9!vb22kg67jAZX^e{bLMi(uL5%k<%04_B?FREh1LC@b^L&U z#(v1CH$x;Jf-D%wq?^^aaA1tY6qyz6Vyg{}D!SMyOo2RtGt4Tt6-8r6vhEuSKFQ`Lu@*Tw`oxu53mGmJ7eKyvqf$xHoU4odaPygJ$aizBU0 z^#(3Hf z6vR@VZWDy85*|-tbcIeMb(}0Po8uIXZW|~@-u&N_2%bzfoPup8>o|X}QNWB~2-_h> zEnf6t0SI;Lqv1TWx{Z+_+$Cbm#x`C47($D3%QGRWns^&^xhGt2iW#V3k->NKx*2f| zZr!DcWr-WHRfTJ!DSCcJkUafvBXmcxZ9jgaP$45|Fw@c}l85|7=l6WRMvQP75fF8t zKK@?pp4}_ za<>Gcn90Lqsf~=8iYLbIXGw{jfhUB}j4RXrlb!xYjv-#CZfxmm7=qZKbJAL0Rfd~W ztuW;er4pPEBcWBQcnd_Uhk~vq!h)!^9RP|udzYLVl?c6vOvdGdneaCVP-hE$;4vZYLk%uK%3x*dWpnB8n8h%JL8Dr4NuGXb7Nxv->ZE13c2 zaplOqoxp|Vi(f`X(Hspw5AInxl#qGXDO~}a;?mbKp$bfW%j}d^NUD2TE~mWPGXO=) zol@8q1#!XrG@E_bECMO|O-=)5G+zUciR~;p5l*(NZr+Ni`aC(YCw8G$!Hd;PgPJMe zmuMs|x5O^0C3|Sp$pLq@ivcXPgG#{sW+~WOI9<7Ju0<~lW4uML-7TN`l{g8UzSZ~i-K5Jb)kwtv~f6n~%=h_^hcg}D?c?ptany7(u= z2>lRMRIYUeb3?HH`Dm=g1*%UTTp9`2sn9P#9vix^{YH?EaJ?ebhFuy2zwg1o=9RxsS$uv?5#+GMLY%F zXK7GTRWZOn#K2PSLjph!C>{AK3{%$hSH}M4CCU0*B}&bCHdnIq^tMLkn$|1iY`yB` zrF5s)`;}5G;^>KMIm%g#WIm|19?FrpWIuz$H9_;y-I| zoGlu3s*nw^4L9-|3gCa+aQ}ntaknUg1O^5c#2_H_|E#J6|3R)pqoV)YYR%+m&NU7+Kz)G!mv1RIr?q*Yy$JGF1rpT1|BfxbHBw1W0Zl9s{nJtk=#0EI zoe^~v{=ZDRf1YR?SM0+AI6t>kR18#-)Mg%3xBq(hhuQ~VzAW2;1Oe$oN(F`;IITIn zsP~ZnLWrU6lWhT`1Q@3OL8K~qqe8ach@xJg{TKF6h@u%|%98_(Uyd1CG*Ku29lrR( zv>4n0O$4yC0>c+l^#6uP|2zSOwu5;AkPC?eoXY<3)(w?oS+<=_|Owu(}9Vxe~bdkm41qjt<-3A=A}UTXqw?cCe_AmL|v$&RTc5{c8TO6vc3ewvw%eIQbP$L$zaQA*39DXUuU<%JQC~T zLjkE6T~V4i2a-OG#(YRnm^{}iYX)k!bY{3{11o3jvd}t(gPUIkC**B%<@_bR!O_vd zRvaN1Cj(OSX`>ei*v0>kt9Jm7?A_LfC$??db|$uMO>8^q*fuA&or&#CY}>ZK{O&M~wN~v_4`9lyCL1#{s;U)KcbJ+ zDjkAlfRI!fo=+ zV(KRuXj4%uNRW`76w{^?z4IxWmJ&_T&)WWI=qcXV3SThZRv8b?UY>ld(E`gBo5}j@ zjPMk9^a zvE1&UgLtp5A=B=_(P~hg!>t%9a!{RUr`K3O7RM;!M7rvjRbwuWcf%a5la)9PhqQp-h108IWpQx0P%oJ;IGB)Z;sYCg>0l1w6DL$DuYKNpJB0SlzCN)cx5gIe+8faa` zk$Mr(D;U8%I=Q9@(*U4M!f#{J5It)s?76q7>a~04=*y_f{u48Utyw}pgkx$w+8*Qp z=Ui_Il0nTNV%KB(ABq^Y^twN8?%!F0=I*vg7W+vVMV8hYd8J3PM6w-H+9{ck0S-)1 z+4gyEI_5$G!?Sm~q&}@+^~*hwCQEzdytcpuhU$(#hZ@H_sa$eJKyPpmFcMbK-WdDw zO);NzCVaeijci-fdfo~5^ax0{nSh^FiZKVxp4Uw(6`|!KbUPHDk#63SP9yn#EBk}o z0-kH`yK>D59~l1B`#?>a=($8<0VID4Rz}_h&iE{-kB6y`GgDW0p0a_gAYgy(uR*HX z1CB7d@N2&Ym$*8Sbl#w=;Ai=`9Lge>*iG9smUW)t)!W<~Fd~$nw;*45*!~hAr@Kz@ zHYJwk$xS0R4dGWOl6~O%%eBGH(Bgft?x`>l1}e_V4WyT}vZdYU_z2QeONaWrf?6B` z`7Fv8b{+}8ow2TJq?pU5E>;XESHc^i`%urs{yB>r{bGQvV%_&dq4NMdBm8%d`HHcm z{Pz_n*8ddF)M-H^&{SAKB>#Wcz<;VVR7TFk(6^HN_jeuqpT2?iuQL0MUjJ`7_mt74 zK>Ih#q>uey_4>P1PNDp}5dX8+u!UfKJ=%{Sd;;H{1+T>@7O4;IzW_6RVNrHSKYoa@ z{?pL#TFi=&0+9ZV_@|bu$mXg0d^ZIbxE9_Pq`d$1gMap?@%5n%ApP;f(loVu0*Msh z4dtz}@bLBLX)==|ah;Tu2nq!_Xdw`t`_`_o|2S3tt);K7L*0Y=QyIg+m+fCOul3o*$N$zmE$NCqrr$Os7ZPE6fp zE++rwNS??`843*&0(mV+7I@p}LVMdX*cXon8zD1W#bjkzVw^CgvoK5RsTmxrm_b`W zsfq^6V$kY`)L16^0Pl z%eKcNT7WSGjR_&Xb9xQdZVrGIn>S9D8!>M}u*O(V?3 zj}faVlIu~NgP5IfA)Vs|myx;=Rd&ti)9gV_8_ONYzlfz?gdH+L&N(U#piUz<;GPgb zTRt&PwEvw5qAD2Zm(EBdoANtma>hPPP?$XZAv!t+Xxlh{1^BQB3Kr18p0H;HF4gPj zam;_~pijHZ=U_{^yH&@E8GX>JGadFR1QfX~0!}=?G=~i<`s-7Hmikx6jGq{Iuw;gG zf1VuP#FzVRE>s4b2Dt%OrNBc`RlFenYmy5~>rij&%QSEWtOlI{T&1jif>A;cWngz_ zwqQD+X4)U~!{>+lOK!lo=eDyttGgH>0((yxcoums8vE+L<_bmxnAdaxL>@04PrfjZVnanO1*lInt+X${cov&M>2BVW+;FW@T&n1eO(KKMNxeQ zSvr*yoX7JCuxk(2qrw%G2scQT?=8i!f`di`keQJYQ-hRtYdcS_BQ~9n5iK?k$?6#b zQp>kDxUdJqC>^@3tlToxky0{u?E09X9tgbwE*p9H1W7>6UIZSV+Q5I@j5x_ zNy-uu49{JD<2w+?V2!9+G=Vc}>{I24=_A#MwK&xx;amaX{(uNU|T7d zbb(U7-rwZwwA(53P<*{{K7BU8w(^#yK%e^TBx%Kls8ZB*N zD2BLPr##3xco5v<)XEFsUW$__P)EsS5y0EPh~!I{v2E-*ad~A%KsOqC&yIT}wEbRe zlhg680&}3Axp>7Y6P?Y;E;vUg8iyB+OAIKwP*E&eqFvE=iMAz?JtQJ9mN7kcEZm3u z%)oddrV6SO2Npwxff6weR~9M`3m6z&utoVHc0>UnddSzz9RcGb#0ZB;_QQRf_S)*w zxpcUFmdr(_k_9ZI>yfX)eoG@)W6F*yLQcnC-2wVI*Em2m{dO}S399pzu*Xcn@jZ)O z2Bg!t@N7>mZkf*`c_~FdnYW`s1z*w}Wz7f^dVbJTliI;NgLDM8gJ?P_c+k^6L??xQ zl5PWZ-D9KT5#3ZdWkprhsK)Cbf5JS&c>9^qI$bEvDKZm2{~+v!_$1#J4uB6%xBWr@ zB0w77y=RP_jr>BsW_rg-v|^@8A)Rgl(=9yyLc5lv&Nk0&pddU^>HPxr76a1wjqIn` zs7yGI9;e)eXdhNgYNed|b2XSOn5majQr-pN8{OTG0HcQH1XY}vnY8*msM6Wj`YXf$ z|FCHNw*(fdOSq0vaqNWg4y3zgmjUqt?M$_SxD479wHl>{;wq;WyFoMtj9Q-**7NM9 z{9mJ5^B+TaeocIpurO!)l8NLC^4!I~v#3V;M9YYW!gKeo#RE!+$`2x;^=oN7MRj?A z0M$Cf(p3?7Z8SZTmv<}+D7uAFC#6H{AcKX*g1dpfVp?#VVEj}IO07lA-l2MjJRqFtQ2Urg8z=R!aQ9S1Yu2h7PtQF@S zN*lCH(q$%VM=8(aXwcOFMXI}c5~CBqghRQ(u&K}-=!D_i3Tz-Ag$77wdYfG`4nigE z4!_Vf`I3SAu4AJpEFJRo)3<>*$?dW=`>+88Bzvl+cFTM?Y?NNx8GMmV4Dyy2>1W6sTIRV*5kC_L@T2;zNJL;r%bSraMOW=-iU9ipEmS1~#5$7DW zm%UbbCO+}bfnF;&m6owT?+1J-siy`Fh)-s^Gv5TmGI_!*U5?0|2G2bN zem0fr=;|jMe^csF zEaQ{Ag)AOYP2+`uDRJO9)gRE7ykBfbfVao@UhClO2++oE^gKelvOFkuWFrd(10yBe zsP)-s?!$ zsL?UbeX$9$m~35DmIDL$L{O-+$SH|qAs;D|n~C3W*GcD=fqH#YxDJ1258%RFF?#uPQ#+n#iv`3viE}<>YY|QW7EJtP=v6ymHunSpKBRx< z%6W|Tk9bzPLEqBw;p;o|!7G*lpl=Ls1A3I)i1sdqS&a}>H;rJp?Re<|K0u0ZIR-gM zO@@+RTSPp0Yaj7?k;IelLbbxIELc>!pIzo&oU=2AIm7AOSyqn{Vcuv4;u}d`G*rSpwBkcl84DOXhl7KRO8wl?> z3`o6^NOLzVxf7*l%ldoDl>NH+4vlN%7#xmY%7o2)h>+>6n;AKp^-l2IEhTZX>Dvb# zz&>2-hGW48l|uMLoJ|e9>lE%}1QCX*i+MtTve5;A!S%Ia073}|j1sn}M@L31>oaAq z_#IQ2QlhG_FZ26#5v3{O#L`ZjhXE70m-gT$&h@oJ0KuTu^p#>(bC<1$X?RGlj|XB6 zhK5i7&^gXIviMj1J#l9D8vHgRUBUTE z2AY(jPops}PWetA-Zkk4wW@S3oUQr%I>;NqWRD{(Igel0dg!#3ee8lM4=p;=8e>Yx zV$1+mYvkYb$+)qua_=>)+7a{tDtOfAT92k~oF0MqR8^mxM*a#ZUNz3J&CpJI>q2xLN zx94Ys)3V!f%@LaeK}k+uw&^b5MP`_+LT-ff;YJxKQ4+hb4V(oAD-sN53aMh2YHBwl za4=d%pUrfw6>7dblz)~7dJVGs;i*C&Wb14g=eRTOn?ZSmKQ;74T)-h{P3e92y52RS zqzK47-z?Bimt0$e+?o?f+obVvkg%lzSx9BJZtz}vsPeZHrTM0vzsM<~R|aQRNfpbWcX^*>XjpArfSNU+!`-W>G#1(DrpuFJXPEkoJI7kzkMNzcyzc%vI-*fc z@5tKxdl03z%B=rHnsFhauA2eUciun&t~;-s`lc{}F*q9YXW`j;SfRbuTaGMxX~ z0_3y<&;PG9b6GquY7Z>u9|03r)@T+=1!req?t`bXtwozp+rX_DoLB3sm8Z;RY(_Ib z-J$cy(L{09@QDD9QCFS33%TD~fL+G1J$=-hL;)?*j_heEskg*gA1}whb!7z&xVge1 zji^=>+`|usvqVzSD~RL0O+wq*qO|F z40>6PUv%lDQ^36G`)sV9j%k7bGX)<*-urNu|^@ z(Y(^_>=x)mU__1OC8;fb^C=NLoL^YadlIyYy_rG&~3Tu#UaHeSP0dGM4%+F9VqMVb!O{Hv$7&KkQ2yfDX(Et;3kX&_`n^w@Yz5_@jgAU=;b? z#JRX!!uE%37eH5n)XM7YwYL=kI-wE90oQzDi`)X%?4clkv_#CTfX`dx?p%G9PmqX}Ef3BJD1>U9rhXg^4}iDzUH& zy%<1>1R!l#`;G@zaB#)R34P@8;#k^PStJQBX0s8*2}s%qPSt_lO(BhKfHI_X+Dj%2 zGKBUYP`gf!*k{g?{Z-WTBqWF%viK;>_K8z4V#R)YXI-t3u>)NM)pUd2C53dQaGNqe zm{)8OKw_gDIzC-FZnK-J!A;Ag3p5P#{GDK?8%l;g#pYeLi#7Ok66s&xcFH-=*6Ll2 zYyDAL0+3Cxp~FVfuU}5NNgQQ3hF-jL;an4#A_UT52O6UVTD((E`oUx@51iDF9}<4X zI!hDV&qPNW!Oo={z=+zfmI->0@;?u$03+v&1#jVqe?FB6iAdIF^x*^U!dsAr;q-O6 z*BW|Zj+TLm_3Iw;ebr0AM7q!rowh*-0Y(*C-zPq%7Td&8M8Crcyi=et<3g5sRfS*9 zkoJK)(ALODf)CJEka|XkrLfbQx`x58pIUYLL97n42<35s;o8_Ibr12IA;jM9nOh1u^Co=u1uB8?B~CjTV8h6_5lQb|iY^Z2aQBN@!mG zvA3U`>1?EV1&yDicj7PoV%h~()q)AqqTMwEN^ygaFGPK20FSW8i}#YQxRgv3DrCn@^H+*1Wd}5@*6Bt-`hQ@plmEVwPKz#+w zZEsCOefc}xxM6q$r}mVjoD^#p7q@3X%orHAjVGUEOgl5Z3`vbU zm*kzi7M{>cGG(Wy)~FS;0LmV;=9#12ts{`MXQM}2Mt7U=sH~fimvmsF4b&tf&5Pk+ z!>3d6Bi1F$o6-0nd6v>2E-HPlo1FVZ+51GXf+A`AtX@vigQnDj7}g=SBq(&a1p4+g ztB5<&%2_5E!+lZsu6a&WDr{6l!Bq_veKux=m8w3jJDnXLKtSD70R+`ru{g`8Cs&AQ zJ77|Bv6AdKu$h=9)5hZCm^Vz%B!H>$wnXy?+CP|ajbvK9vwQ!%Ra-RKn0f<0RXu0<^jwEOCAR5M+S&XMS9( z;eMvkAM~@&scRM2OxV{-(U?^aC|T`BFlqeYd$uMM@-J%jxgm*xXGOAF_vqZJoE8g| z&MZ!i_j-3hz*W^RCSi3)aoE)c#Zbrx??1Z5f;Kn~L(seXlVFgGzJaZ#YvGX|x{7D; z@F7yd0%Cqav>Q8;)L6PnS%nPktHM9sW|r_kj{}8=DS%?Z5?HvdxUyaj#X!3}@GUX8 zPaw8uc+2b9(%zrF;pe&<{!dmbZ|rcdqy~-!1xJ#IqS(BPv)i81fmXC|?3&m*1{U_@ zUve4XOWN3lb(=uu_T{tNgU4Q($k-y&X5=lzMHNM*k$}}F`}(@xPk8)C1f555b`JGm z^i+#$X#nKK%7Ao|juUL1b^=%TJo6T>N&rUATlU0LPT|YM{`Cnf3U=zrY=o^xR(|<31=vFb+7TIkU)6>NBfR($Ioc5eMgSm zIHx2sxJrv+GCqaS%}l>8-|>VJtrQ&-&0Es(1i;<1+h_u$UhH0KJjQa;VT-j?12Q|F z7<-lS@}jA-#r!CHr*AA^>vSV+`mYuB~!2CpEtXl*$6DY z^2`j;OzZIzj==0L5t;^1t@h?Ul)^oh_}U^&q+|`7 z8^9l#hcNz}JR*@>RU>6}{7k#}b8N7Ukm5`f85DqZR?$%36{26EaW(K%M#Vzg>ltAD zv-A%?#9N{vqQ2SLF>J#!!rsr6^OIBVj$O(CsxVU&<214neBaJf*?U4V=rP^O-a%~V z#qHnMq^QaDy}Wt$yG> zHO?5=xEr}kKf~9eeO*-oy%<{0s6O&3WLeBd`8STJS#~So_m=irb96xmTleW&{cP7M z9&?IB757kN!k!X>87~!5|hwt#FN2Y?%ec>w)^aG>A>Q`%9?GE)r@w`*fW&y1t z(z@-_S{xF|=er!cXsOVIc4VQgep>@i`C9At^xc}5>YeuN-C*JywOGmSG$n_d@J*o) z%cvdWDz&ity$0Su{DE8KAkVwVcH!y@f%ovfB}zV6xB14iy%~xxrH?{IkB6O%>+_y@ zv)uehP(>UiC+j9le`J31tNUchS_7ti+6qi5l-1Mp{rTH)P-c@$S1Jq`xyKcJ;Vv(0 z0>ew=E#Adsq&fPPd}+vs*9y_iGH124&TAW&^BPC;bWdYm3w_IYFm^4J<=bTC@!0v$ zX1aW9%Sw#o!!eTY5@~s$*~w`3k8Xf2DKG0C*G-f6%CAi46aWpcD>u|@lYoeZmjo1^ z86s$c;fU)Xx*b(*=(4{O?hEK!Ia=N*W-temw$d`TvhZh~D?_7;y_4HX=Zl**s&9b& zS1S2RSrxB~XX>cogYs~;C&9&fTLSG39sRMz={xEb*S4JO%3dvRS8V<@bAXz9%_;3L zH%^VT=R9SA$-7Hb@Rm``7XUA1nWI*t3yR`)tDo7sIiuUAs0xWOe5?OTlx*KH?_9}d zwF$jVW9X`3TC|BapS4^6aIFdbZ?5K>{i0ggk7{n=oIYe#qCHO6p8$cfcP16`mrK+r z78xl$F~Pm6)R}_HY4$@N{#0}`Jk9>%1c~dfd>4Mfv^y&Df~h>zNWg;zob?XVVEqj0 zCm}#$)f5_#_LDf3EBI#wkhr8N@)kq?FWQh{|HkVyBNzmR>#5uyzl4XI-lM*Bs*YI? zM1+%`GZpWDpQCBf)c=`5lpY{@XL2@c$APP3r&at6+FdAg$7*t^_HAa%zNf^o=qI+h zrnniCTU99J`T!zT$_1cus^Mb-TMJ4o2T@Mjv1{n!KzOtv;<7JE%giAt+GJErBp-ME zt)_93Y$4Ug`!QvUsilADXwzZOcn0%&|FO-azX}tKP=9eIwG!iFeN=$aI&DQzEg$%- zh1c5XSvnmPVrhenTZIS0(l}}#zz!z27!%CyjXrOx0sb4vOWK(VY#rHj zPDjo@RFaL1=~yaY@Z6{xCd+11=b6p=g>^72-17hyrB*dDWl#=uY~qoVZ^bLkTp-&_ zbL9)a<^H=n*Z$$=RHwY)QgYhrsyq?9tW=ndHSzJ(EYwt zYCfV`ojSJPH4C6Dh%Fr2mYd_V2lR;dLrIsLocVzRPLRPIMgaiRTa^t7wrWH^$P_v+H;Yd=`XVH+b%bbXQ43m6A{d%nMF=_(uF$0i@K<{>NJe7;emaRh1#TQ9c za;3C94a@khj%KzsiDUqTL)!?E76t6_ZD1wqA3Un?CYYk|=F6RE6N+US^*PHv9N?Sw zOK|J?6lS-3yM}5jtIGb;1=bLT2ph#JvlJX@GTGtr7bpkO04s+^;CYCzYa*9B419GD zha36U`U+smmILCdr?-sL-PiH@-Pbjh>v`^w_OFh-vR%G}B?N3;-TzxfF)nw0$zoURjK!Np3L_Od@YtfjxdZM_MvmIm4y}qoGIdgW` zngIS;COCN+72OQM*xJiFSl0{I<%aWg7YehS53HcEgsCtmIDOTrR>Z6Kkld=urDo8j z8~)y6QpZYG7f zcV0lI#qSZ*j1s5xp#$K{zK`&6IAL9U%!AuL6?OgzXDE$b>UV&721kR%)t~cKCsjBF zukI>No`H_J5%n=hFAl(tM6~YGb6v> z{k1k{vny%%^9ZSSH(XgUYH*kM4Q>C14m-2I#rjP`pl2pWM8{REOl_W-0pyO1x8PtR z6Gyg5aXEd`BIoqyxH?@xv-rmbPp(d~_<4cl2#$8|r<~I zg6y+C-e!4}HBScF)gBQVXXDEspwIyf7=iLEm?{M9flp3M&%A-X1O28we~K}!g_>q! zCY05c4|$CSm& zXxz`tEmN{6v!3d&mXxzg%LV|!y1@>O>|dxvJKaUS0Y+Bg1h?IppF@%b06Q4BQ1C~vLB!MpOyGk+x@8Vr3Sz*a`Y)|Ane_{ zrj@$&v39~7o@g7C;fJ8Tsx9Y==jz4^$;9?*dJ>$^w)DC^T-aCna<7+N`EhRk%)d&a z?#4uOrF(wo$A*_l=f1%wYFCS~@B zh>IZfTiW5Z=G0o-Ol9;}IaRsr4Fl;t(^re*?C5FQn6eiK@50m|UYw&;jegc`bRXcE zJ~!e<|1;dPTTryBy_xaPiTl7du1*gn2D&d!2 z_6v_L!;(07G0uV5LNMQ4=fNf?LDs&K98lF4BJV4jLZv++pq}J@!d=Fdg}uPegDkL8{xhuYX@%7Y8z| z-d+&j)m>1^8U6yq*NeKw%=3@n=&^fy9A5789Qae= zp)jHFp^H027!Tffsndekt8y!IWfT|>lF>AJRgP&IA(Z18w$uv)$^^ibeVNl11+Y%f z#9)gvdy1|GJDga+=c*Knw!jPS*Yd==LCDYC`d~lkIrRYDIOu0jJ&qrG<_lMW^qmC6 zul$@SEWM(yAGO+mAJxNe+V`P_T~E1s^xyusknO63Xo5M=g}}2JXc8@%`X;$(w#hsF zGoKve*E9AgF7b`n+0%N2RmBB4zw?-U$zB(35L0?ha)Z}Q>^%&)tmAqQg4NJ;Jf@2R zXb6a@TY~^}t+wjD3*R60!BS1ZmWY-igE2K|k(41$x~+|?w`UpCSY@54O8C`Pvydjv z%?U&&FE|Nu9%x)Vrfa%EGd`JL?`WC>So>zzA!Ub|2lkV-AF3*hpZfIT#7N5nP0jJi z6hCk*4C z#VcDk57=)djtS^LOeyr#Xh&qY7V=Ic`2PrY{(+tLtrEF^v#o-mQ?-{B%0m$nLPnV*515A*udPFhn` z`J%DSi)X)oZ$1wFoW+qp@@cRPQo+_BXW_Y<;AOeHydAz1m;Vv9XN5)w-L|2vdI{Uw zq10q;3OjKile(rlZcuHTZU~^fwt^&-aP&0guGm)ij7B0MCM_hQ6%smf3Z57|*HOdN zW;37FNE`o4zYjgzDlOd32!8h+OY7fa&)C5#0tg@NTKToKF z35SOqNA=>G74|CF+icLrvYI0PK>k_1V{?yOp|~->fq?2v-YkBYa2H_P9n#M!Bs$&! zoum^~2?Zxvh$>ROs#b)byDfu~RJ0${$raNWfr1TguO#S90}MCRbh`*=YnIkfWub=- znUEv+G;P71JpCQa%@1e;h@$RnEBuEY6z;hKJvA3!7yr3)|^OYnj^8eY_}s|Q=O5kf7`?~YVANPIMepgG+rHS z3-jW!Fa*Itu(u0Z`v7a4mf20vt;}@JA^k*2R6N7Ep6UXY9~sc_?hX@$GNWF@*^N zy(!L1`NN~Xbq>h=wQ!!VaYI(V>0ajuHnpl|uj$|tq1uToR3O^V!{2BI>S8&rh_m6p z3ZY_E7{gx%Gr(8FlZ9w6V%Ar$Gu))v^miPpx6ru$xD}Z}bDb%+%^_3W=5o4xFx`Vj zu3=i*p%bZ^FU%5j$*{tH0JzP$Ss$%3(`u3WDMMpxR1%=(O!t-&aD{Vp$hBzor)MIe zH~X{0q-wET7XRlL8mD-+#jfw4QNeZic*79IX;wA0yr11enhyClfD(W;6ZqQv@2NJ4hr-0)xROl;2AV9}-Y= zM!@qkm)`)WcxQ!F8mP;+dTG9GbwTJSfRMskF(au{qQ{@X#P8aAcil38rZx=z{v*=v zTpEE8yC51ouV>O_umsXkIl6v8XU2mcLC(^=86{Kc!b$PNKPB^HS-x(8~Y#W-t4-b@{Wm5uZWW3UBz?eK0Xc zmWhu5BgDOZxI`Oy*Hegx@k|RxA?(1*dgJ-D$~WW>?WmJpCtZIDX+6@?AH7eUr9ZR# zBfHS~b@z@g22>btKwNMQso<9An_&28y?F!pb5_x#!_)&g@`)rtj@1Bx^~VK{Fp<8* ziW;zp!F@(?BdE;`?vN&x?uaH_WZUb%gu)Jdx**cpAadqSKYYu|l-@`Y|tx|#tY=}SflpL06cpQjDDA|DY-CZf-&Q5MVLmNcQXoFF|(oi#dK z-FL;#!+&gMYFdy*3&@RK4R?G;AH5N5z2#Ia`QG*|0a>S*MZ|~t`R9gvqe22q@mu7y zcGA$U;I6n_*DqZ`!Orq;N*e?bAyx5M6)4l@62skiW<+@Lnw85$$}6TK#Eo3bF~Na@ z(}t=bxHBS{@W{YT)6&9~dMjsyNmzQLfOz6Bm0CB%p+S=Vz;1<{bvjR2Q<0NCAH#9MKtnW&g6739cYSoR)X;iYv;KCl?rfVJaJ6gNxRe_pu>ezx49{K`4W-bS;RNHg7;FQt^gZSJ zIiLTa)jauh2SKDHLAx zyb7M|k_e==`7aPN9gnF~uL|s;XjPoZnc((sE^tg9&lw9A1vX5{x!#+z`v6V!<$wS) z_Ba#@|0matL4gs#AoEy|!D8B|?JcQ$i@R)4ws8IspSXxJ2IrUqsoyWQ)JAg`A7`nU zd!a5UoK$Xl+eO7jNmlq+^Z)$ z*SMIYm)oTNDbxMO)xynR7ENm8)$}tV&82DZ8($MRgqUA|!^0Y}MV%_O!9(Q0vwJz9J<$y*5~{vdHU@8tpU>$Gjt zP4`xg_~YmmLpca!2l)Nzi=d}O9J)Nx6i$V%GiD82T7#bnfs>B@Z6$yE+*kL&D zi2)RMCHrvz>R(1B)}~8~tyLMjEM$bDNo8_+N>wT5QRA50(>V%R-e@z>xh8n+z4$^$ z>)v&RY7^F(Pqk40a0&7 zgIm7r#$7$ejDCapl@o&SF6-T+YqYVdCo3qd_~RVF0l$B#a^A}wxv!ug)_Q~6nXTxq z2TH2Aq|V2z|uAFcWa&XkVmkJse|8t2~GJ>m+9aP zX*;YUd<_Xty_WSf{7$NdAp#VZICuW+pE+A8ZMHtFv}1yca$H82rWE(U>Ned)>!7B* zRHOkEkk`sueBz?}e3`Q$t-&&;G~KfTI$mVHP66OG^Y*M${h&+VEIq^1JrWrK;U zm@A&ExX($nl@BYqCbc;e0d2&;5KXc8xzv*sNYp7FxvOW z_kNbUp%E8ZdUji!r{JG5waclz4SRXIc%e#);#4=}z^6B<Ugc-aZl&AL&L$A?Yd3^wr z@xn4^@1~a;@=v(0>hTQoHY-pXRcrd3!sYwA<}cP8{Rk_>Fin7oDEXN{aV{QMs*!SW*|QmSuLZpBi3+QbcEU+< z(g^IT#A*{#{V!BL4ca0l(-B(bvE=kg+^O_%2Ge1$Z2pu~=CvfQ@@CjtZQ3Lc*nySG zu6}+W^CfhKk{VWH!DgW`q9!twXp5#JnkH$JJSvWHVl|SJiMqz&sCb`*RSCfIOm>p? zJo-;BDiIhAxJIyRXy+Fd@RF=2jS#H#OHqEFre zHtZHRGw_&|GI(k64(1IP+(z?y?p>c$oC4>dXZXeA}@$A#751qmbyb zSOR%`sQ1@ge=Y?eZ73c-m3=BcfY?rz>Q2$L1z)N&&F(99AsOldeY68QZ-mn1`s$2G zk~_}#0nHdi{B590T7JgOIT;)l!~0KkYan%%mTr}opX@Yc7wd66s(H*QIGN%xZ6mjF z>VNcV$({TAhOf|}8wN0y>?HhB5|pc@D7M5c`qSV3kc}VNq}c7G&Yo)lU@hZG5dMolJ!fbS9T$4Rp<7)4=!tA=KN&EaT-=(y z)3vr)3@D@~NWBKAm*1f}N)zwIH6&X%WOs>>>QcrklBvd2rHZ915*|e!IJ~40$=7;f zu+K}2n}iR^lfT-?leXk;nY!>msUrSNrfF=MF{u+Sd1STWn8}f3mz%e#58PYRv3ol%(EgF z`4|me@S@x5^G1nzSx_gOa!R0Z@kT!$9IQ`}pW7fb^uQP<)+DRw?00zJz>Sfv>ErYU z6Rk2CWb0?FU?{MLbQ-h89-0)^SX9g8h{}*AX>~Z@>;N6@;>^Lv+cQB2GuM@%HUtM^sLr+q|B+6PnFsj8r*%VkuJRGf+Nd=PsT-%Ui z(JDcsO?asH-;Xpdu)YoJl4usiRR>!HTZCX&LD-3LdJu%inOZn>%AUp5Gf@NdaJ|6^dWc>xyeEY^u_t&@6F4;PT?v%D~ zmUI%8LV~r~F=aTBtvXH+MfFsFvAGv<|T#Q|%5yDg*-hJ6P;XV5dF(nGI+k8f@lp@QA~fzt^Z z?P3AoHA!E6dlLE-*3MJ~bSh=fxsf=hKfP2{vF8RqW=PY@hUjII9(Tw`*gXfIL3ePa z--Mtw0Kqqq8H`nFO=0Xv?zBFVeNn32ykFF=|pmw=z2o<>Ew_xkD#y`xULx4VP&jqK0+ic1?P+v7IEt50OtaENN>f!MVrlA z7IoT?B%$dFLU$BD{(OvK0Lnm&sWJQ%d(=^L^hTj4I+VsR^Kg6$!>G_juM)Okh3id_y+xNYP8?wx z3@DzXYi2*dFQ2CI`K`};S*9TW>va|kRq-^EvNfuPy1PB8eR?QZA9pAjJ4T&r5q|G1 zRjhg)?F*EFU$jB?C`^CKxQIR5yLd@wC>3?Tu$em*;1{903 z$4j?;oev9b)pon42r%DO%;vFjqJFtl0NFzDqK6z58#uNPG2s~z~K7n9@ zu?7@@|3y{z5pDS1-1qpz`D*CJ5Z@NNyz$jwlo?k@VZeh>I;~m14GcZ{iogK4xuMv@ z$|=E)orB4lfNCal6jHj}(j={#o;?SS`!>QQ^4(@~56D!Ng47+%lpz6ZYV}vVM6&aL z9%?3)<~@SFgXE%&cAr<{nDFH+!Sl+h`-T|tMnZc>a09@{Z?ez}R*TNU6~jb#B|=V< zrrG39lj^fDvxvEYuIl$~Xqf@mmvzhX5@LT|q5F6#Yk3;|I9?X=2rH_a8EeEZlFXj8omA3Hv903g0KL zX#(*>d%^Hw`CpkN?YbAqHPulbZ_$AEGs{rYZXyjnTG59Ww3n%TcYHv@UR>H;K!FCW z@jY0G`zQ1R4mrC1FMKcmS)D=Xj#9F7pcB7A(Z`_{L8UrPmlXgZrX71I$A z>Rqd-LxJje1E9eA(o$Lva9@#O+=`?Q_01#Qt25HPPsG*+PYKgQ3WnVMdX0*5y@5l56P!@P8t9uUCngBQ`~xEyY1nGp{5Q&Wf|mef`p<_{E6{)_lxKZBB*F; z-Kx234yfI68Tu_FXaHEUd-Bq&O>xPU0iE8jKiAaKfmfD47LOa*lsDx~K;E?|5l#!6 z5oz`->0v2Lcn4|-vy*RuxQ@6Mok7R8#NvtW4u(nfNePld`M?x1J1s}&MK!IO^vmw~ zgzh|Jo-%I3OqF_G$LW%RZ;5;k6<=zbRpVoCzr^?VGD1d_Z=pP}@BZ(Y`Jan_C{lR{ z{BP?63bYm+JY*r5|C$V3W-ew|e$StYzc2g09i&ow-H=gIH`$TlTaM|GTOs}nn=)H+ zM*BU6xcWcXmT#;W`QG3zNNEvEv=DgO=Y%*dt8{)U-|Nq5!vHy3`DI=8c@p}&Q3f>Y(i46arQTsnf<_R(u|NP$e8K|X& z2HEDnx4kSmPXqp5^aW~>qC+MI0{rjr#oy<9ssf&Z75{C7mHX}G_5JuEE2<($Cn+b! zU}NZNV#{FXXhv^oV`AsT@UK^UI~#g;8|wot8@n}j#83Qh8!ebehlF!dx>W(i_$I1F zVvC3(n%m?Q^UQD&Xi}45oYyV4!c9EsVq^-M+8;I~r(Cyyn5XMY_wuhx{_vRqNJ%ap zKFsz45D|?Lk}=Z~2!PMqaR-+>#`)Dt*>(%53gouTZ~Td5DS2LoUYI_etX+FK9eUHv zr3&e*WxQV2H?PunCT5DK1U1L;gIV405a9k9^YaZIJ)M43C|Alv=!Uq)eKNlI!v`>g zI_3;p)gLYZqDzw`1a9!7zB|FVnnMa+;+rRL4&b}hC#_#^USN*o?kThNfgw5Zv;3cV6Q=256=MtdO3Zbz^GUt?DSS5x-KZ@u@TQoXL0*QQmHwAf3jv@Z&Y z5UsD2>b3V!UN5_dh%19Ih5X4jgtRcjm@LJpu~bHyqDI?TM|uBq&Rg$$&HVqTPoG!% zet+9J=XcJ%=lb1y&wlH1uBiFac6{0WT$c~C9VuI=l_8&34u?z}tFEJT@bofoUUrRR z?RC#ZCOhW5rg_>O9&H5*3E73^IdZOdjMWXg{CEHCdb2azG`uFN2U+9M(K-nq^NdtC z#Jm{aerBR(#HPY!W$w4AYwt9~zHDfjJMrAv;Ieq%5UR%a?laOqa8mT&7b=%_mX?~f z2mSR_`2~sXb|C$F?o{C+$~{zaGEi%Fw8}y*o~?nUTUO4#|q- z&{z(86=NOB^jel4^BXnp`j+0$?ABv{^iEr(S9bVuP4BU0fR&`67>Zv(&c%jFiSHhHM?W@ad4U22_`YwH@t&V&(#iMkvdgxOtBX;ZU zFIMKgRvTW&MlF~7q5tQ?f_bVjg}+Z*t6KY$2d6aH>`+x@{q|5SZLam!owTT|q0VB) zCbw~^lX6rZ#~o4BYx3&V%W`bH+`aj?=23N?4bBZV4;v~PDs2tf2Ol2@*ck(GRUC}34&PmD6lCeW zV0zIm8YgOo)sw-V##Pn5y*u+iUaj@untr-E`@K%|-DgD)FFMw;u#Sq3_Fkuk14>54 zO=|p6**4}t6C>AmVc!RHJF6J&qQbgsKE1oVSYZ?HUb|+0?Wa$KdxYX_ z?~1oCJKi^awtdv89e$GKyTgG)y#iO@P za=Xt^w>M2F4mUr)bFt^ueKp41+O<^|7|%9k3@^xPEs7|tWcp>jKYO&}$j0LGB~=#7 zj2$oq_eo9@-9xuW9WCj5H1B!S@>?k_m*bT+O6lip^;bEX`v08c)I9aVZ!<6TB~D#+ z>NefG^7+As7tCBa>kZ_Rzg^v1{peVzW8aBsZF9WmJovu<)Q|n|*{q72DUSUK`qvM4 zz4$#d%hq>zF#oJdpwhO(gQZU*++_{9;}_EMHF(2)RK3Mx+ zyEySjk3OGM5pw;{ssr1vmr$ZsjO!`Msd|~kIEH6?ovxl?Z29TZ!JzW*BIob%938*Z z{n??>@dpbmj3YfeVgeWMW!>kj`_eJC-lWxI>ZhVXGouYprr zX1kXSO{?jA?yla{my*4&^Tq3y+$najD1@59;SV zu<7)*skfPo4G!i%{$OOnEcduw{AJCR&1)5|-&|iHcXQk~<4|nApPak~MG4f5!mtRq z=u0$34C4rXrDN}0;g6yvm(SAxywQlaaK{ba0sw&D;9o_plnYCCiD>g&1AII^f)-iN z^OV$#wi_Z2GKT-#QjCuATu*~vA~WI=qM4~S|3(9D2pVKHf}dkDlA_Y%SV?Ilo;`4s z$W6z!7DL=;faC8NBxOU4P#XLs%hm^b6h0>*E|MhM0m`1g4A;_!vfTkr8UYWZkoFLW zhye(GMKek5aHAxt9TXN5G|1U5;zUNI#YK_y!%z|>Ok8UeME)R$5rxZf#sonZO9vVp zWl6{d^;C~Ft7%(`hlI2ppcah;UQ?dn(&%H8BrS*D2{G_fJQz?sz^;(*E#LC=q>RK! zsa}=VNwzUlo=DN9YpaTFL>@aw;#vw&!%2C<)rqc0m$ZqDXhR4cJaOc>At{;^VmF(v zK{PONnuj2E(sq&i!~<-m1)j0kpgx_9e%L2SHj6^syhPU^S%}8O$|M1z1R->Y-&f%@ zVb4ix*AfL8di{hiQzMqiB56i)MX?!8MVes=yHOnYGB3*!h z1?J{SdMa%txWExKXk|G#e&xp~otc=-N{vV$8H=od({daHHv@1+dR)Rkgc1$!zp4BS zEs_n=X-v|FcdnM;@f}e*;$JvOIsnN83>XKdyd|<=@l}R2P3S571Vse}4T>rFH!+f_ zho4Vj5NkNDCKua4(%B8_Lm3H$flnUy9*`!?hMvOw=D|)+jfhHTrSc2$@onRagJE?u z=}?RZV)pn-OX~uK0A-|kF_UI7QzJ$c2d(ROr3TCgQ#l#*5va;2YCP^PJEE>hPG^d& z8IbqpMAz)A0No3|jYKTylyHdrcnGAu;YTi8HG5dW6d|oXXUo@S_9s^)E#pyOg5jvH7tom@0{K^cz2agB%X8 zEUnX6k_JMTesIh8ngQlM6k!*Fdj&>q!UBhl$V( zqODd?Z- z-3F@2BZ*Upc;=+&p>>R!XiyC5iJk#>8$gGN8jssjL?I%=a4o_*3|AIf2RnEcVe6?5 zv>XRo$it!HIHHVKmKY91VHnP!@wh`}d~rHK%oN!`p(NhQM;4X~6w||{`rv8)5f??U zKKIy250UmW6e2$yHy3poG<0D|d8RrTi8%~Vl2qgw9JiJ=6k`4iu=v$^(dk;U=Abm) z8i@?gyDP@(lHvz-RByL*gZF{ffnb39QKH7<-nu8?(f#N;GQ8tkr`LQ1ynMg|-iR8H zE8igCg$K~}Wq5|aS&sP=>{{o__~iRoz{?Gz(+S=Jx`JT+6K7mvXEbstr$rL_Fq%C2 zzI}d|IkHPPUW$2Smteq*mU{J%?9x!XfY%r~f=e+@Ya{aXG3>6t^muabM7)t^7L0wv z;AlI05W^&pqD@5+g#AmQP+|X?$wuH%1U~{a1kfFMG(zFTpL}HAC_a)3?;YPZaj0uN9 zk#cWc49oSxFl|yV+?qfoc(J%apdcN2;~g^1QO5I#R3#~dxEAgk3j(Gy$K}4?=C?Ub4fJm z-3cUgMl?d}5a(~v6-j-M%&?0`W^|+oP&SS9F)~3Ezfu9iEJ)Hz^AK;W=q(ExLMKu0 zB(6r%tu_fz;Qb0Zq$EgswE{`<#VumVbdp8TZt0TLLMo4Yvw%uGO2Ca6OhHLx$(0|^;#3lmILc-4w?up#;hl)9kO1L) zfXz(=FeZ*9lJ${lQb)TPikQdw-0Qy~n*Wz0+$mB^MJ52DJmfJoli*@MS*fMNzJL_0!Ogxyc7 zMoUsXAi)-1Yf3D3tw1oC|Co_L2cClCq+w%|f&jx)1%T)je5^2FP_wu+t#rT!eFT)s z6kL-u-NeOeF$}C}qQ>K%TuvigE7c8%z*L+jsYYDFR(iv{GJ;0*e*gv9@1^0&B-3A| zA=C9X3jkW_xEcvyn~nex+Y!K&NKVJ8qP&h~Rah!QC>PL(>{Q%T(jxKy0g+xJ7Vf4I zVYTXJq|pn-iJwcxFi-(r)WCt%ej3qsTisBGLV8+RM1Wbq=K!MUz^9i*8+WKh^w=_h zgC$4Qc-%*aXoT8w+>q26QjaoAz+(>6;DgQMgkHljE`Fj}dMjLao<_`4!DV-2;^R{3 z-riS7Bf>Lq6QKe)U8T-XCCqtuk0w4%)eQtUJ7seVO83K=sMB8kD#kNNfrTikLsbbq z!7XAQI$|Yl?4{0DC3u%w5pRlch#_0PWg%M%U!uQh5H@VwL-Yyvc*7(j?jK?#K78dLp$gsL zal_xxh#Qme34~gvc&mV1G31B!^;;SdI2qUBNM^8+j%CF%^?GR1_gciaPe_Nfk}^lS k5iXY5?>X>)2^HTKpYKNlyEzPFgRe_qQ^y(vH&C$u0*ZTossI20 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 zcmbVP`F9&v75<*>cw}XoII5ixr?gpJ*^Z)y(zL|s;@C1#BFV1h#54iSv-Bj7Bh9Fq zQE|$?wCqrJT4*WIva}T16cj_x;qWtuzlp>5W+Yiw9~97&Ng55ej#g%{f&SKTni-StW;~vr2lksuI{gl}gPm zEobI3%bAPm#6ogff6pcsvI6mKh-?Ek8O9KX4eT|s4<8bk=uV}p83F@2$1Ye!pVV^n zeQLfuwv9knW%Sty4j8z{#D{UOz(cno+7Y&v??z^)lBs2S?qcRbW^O67JijnEpIBH- zCg{9}Z^x)Rs_(>u+JlD#ire|2W!5$z@6#VTa7RoW#W8_URmuEfRWUbW(JNsXys z87HqM4csrVyCdVn7)5Ug;{w79<2YglPMC<}0fGB(CQN{l@g;w@fj_iF)@dET1WAeV{7RdExn+nCA~k2MH3fW zN2C|R5?QzvrSf|BDHE6VZioO`y%@qL372zf^npI`X%ox(zyJ?S`>P?aeBGVT$I|K8 zHU2wz?%e5e`LyeXkwe~qGEqQL;IJP#kA937oN8Hm@fqp)ex3EFtaOBR3iHzAklY{X z=I0<*w?yIfv9M;~s)-WH0{b=dGChtUDBY%8O zTNIFpgNlKtO;q7FUk?A=Wye;@yue-VHJ14Dj4H@lsXZIpPWkrKOgw|n>b&)|tiG6S z+yXdWg-uiSQod;_A+F(B1D`YTd3<4uOSYV206ZsYGtqTY4mYocPo}X*6(_fvwn`y0o%^_=&*dw<5TuFNk+k^=6;YH_bZB8k@3gm8q3iRCQ7MB_QIb-X+Q2g7d~= zpSNn!SEHRqbOoPe*Hc~sUVzK)byKCUL ztQ&sFEhnCwYwfUp>V)&FE#n{%3DVkcxf(^Ei5djZuNp_&@;+F;xwcSwh`juQ!*lLYzLryYoshaNeZWK`>8w?>8(r6h4+wMSCbvFD+qOJP zL0`&DWz9(|Z`H}O<&$MaXE7W0`bp|LzO9SZ{yCH5RrDL#LYvDQXt%svcaXc?d55!n zL~?4@($CnTTlL5%G-KvQ(zaDl1Qc`VhQP7zO+-hB%H(b|Z8*gH+XI0g^Z$tM(%I*S zIA(j#-=A{!Bzidl4vgP`xDMkw?&_=K?j?V?zqgM2mfqoZ4}Qkq2>SRt#NT1;#$H11 z!_T>51`zlKUgS*ZdO-;d|6iWfGI`=n)Nwfd9!8(KfoLW+empW(2iH#4@lYKfiyedzmqW15qX`;%lHX-=MOPO_X_YEC}E$(82hQ?a+HC*V1X0geyQ)O#?9d+CPzZ~_O} zvK+!W9A;Z^1S>e^a~}`*HMo;0UcxVF1KR=o3NI6J5Q}&Pzow&JC2Ak{e#2FEOdM$& z*ErKQjzm7QftB>c@eQnIVjHmQ@akBvFL+;drF%8tLG2+qaP|3?}pw}{Pt+%-aohSby$IuKJMONw}sn-KhX;Irg#Hya!+%A zz@G#CkU2hFe@frC`1LZ+}HIsqyiGO3Xj&FAo+S3L!&;a@? z1$L0_Ac*w>-llZ{qX4UaoVoG+PDbrOO-8R0D2U1?B*XVkE60!cahgG0zz$l4f(Es&R9)RwVyZdMyj z6~&EiKXjEq#*6OtgTMdIIUfYO!Tl5C6z(r;|2L;R6ASPW4XY zX?wNUGM8pa06*>Xk&UyMWvcY4bp!3PtX<}JT?#geJ1#Odm*#eD=WWbs+aVrr^pt9w zORXOgv%dVIjZ4~^p|wJOA~lZ7xMJZ`8&~m}K&=~YII<_*P31iHz2K=6#i5cNvPZS& zJnjc>>~(|4i4uC9ZI*8j)wA2%N;inr7VBlXUEfbCmoL=*U(RdA*4Q?1Yzl-NJ#AM|KEQH#8e>G_-D59n_7t1lA5VrohZz2A=i) zV?iEhq=mOKT4YWWjaa%*>#{dwKD)Bzs$SA>78(N6yDhY1VKXe}%iNiJdd3^b(?!egW%eYExL|Uk_%`Hw_CbT-iLMwYTvFrNEb{ z@-}_TpOgk=we%d;k63<ERX)ToP>{ALD~j=+aewv?L)46S&9m#hj56iYi6axe{8HqOBo7?EDwkco7vPwJ0o1?;9uw!OBB6WKmU zF&h?!F=8NZV-y8}xf9H$^n%$gum`EevDXY##8lMFB$94F+gP!70`B4}8zu5z#F&9` z8xxommGL9>y+V9AU$<(K8T*ejZ z;HPW?g|mJJt_iGZxIB>VzH;__FL=R&=eS|J9R`j%QbCeX7^kixPx{_#x$CPxl$~7* z8;Z)-yg+Rows%#utv%DQuJm^#(Hhyg%qII@EHK~G<)5Nf1PtY?Hd7H8?O{%|WYkEx zVbtiQB_KAao6fu2(D8oVIwPWcz;?laXwzL`BRhx8hQUbau=-yDF2zh=sKJ zlsG#doowrgU2TUXD}TL z#X=_kHl>*1fMg(WmEV+}6TYe}_k2uTuk+;43fjT)XNZs7WH8ND{|4TW0I)j_xPhBI zu`?)e)!^s!9-=iDj$u5^j%Ppc&>_$d7kJ0t?^BX80_Kfjd33v6w)fmR}AFy@F@bp!{7J{(=jia7h;} f`ig$bc(-|%!5u87*1_G>F5y0{MekuOF*EZQY;Y4E 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 zcmb7ETT|0O6#ljs(v%>zC@82@<b{g^lRd0hknw?$Cr?TwCW zh0=2g#_?=h_zd})=i6rBG#B?w${=4ggEI`1&x9r9foK$3-TXq+_gaMr@j>C$(I9d- zt08Y-1m~#I(gf=9pOLcI}UlM2^M#@xi8hZ z=S+pWGGHjz{<_y{OLrb(({{sy-7)DNFj^CWp_g8mf`u1GZtGWnx zy~b1S^OgvOPqk*2Es`R-p8A%wT^@FPs%F1GJyP|*>38nnB!%at#q3tym$@4J#Wnaz=F6u+k(fX(tkYKeuQ+k`*gM|I(ynLKd}UNqD{jp9d}_hX?^usL4%c!+k*S55E-D+ zlTWXb$=!msK?=z-lGfworG0o{WUPQ#;cHjO){>$sAQgahl1@|UxlU8~!Tpjj9Io5^#qi)^UkChJ*w0<=8j3=MBYlqluPZeW?Kt` zIN+V9)4d6A*6^5)GdL^gc@5O~py;vW^+3V)#yry#j8?IzD(-M=Bv0s=RP=_4^02bG z!I%cBD-iiTU4@XKwEU2(n6-4A!?d88C&%rKHA!_pwBgZ8CBH5jmmr0-23yBCGDNUg zv6^Y+DTY#hDaJX`5!afs#ptXQf8rJtzi6kWkED|` z!N?(aYZd-$qADGALy?D#H9`fkH6$4D`Jlr-q2s&oRzag11q8cp!4v`@dzawt_-+mF z(D6O^UV^D0E5Mj}fl)eVrOfClBWF4(!0B!gHx? z_oAIj*Wa(>-FOfEJ?_}4LJ+)KQx$~(>W5D6KyRhk7fI8iftG{pU{d{D=S z@L>iUH_N&P)}QBAW^M*)J3eO8H)1rZJ2o8gQ*qfQ*N8u=rH}Y&sQhphS6rk`X!vo#`Z6W@nj5E+WOGI;)0fR!iL~j2@eJyfulw<2HJzH}@YUEaP}DHRXV z1l>SYO){^=hBf>mFIH7`Z;$7hT($=sCyXnokI>@hbX>zryz#NPJZds(-d`(Bx~@?2 zLT(;2lWs}K{QOD$l8#T|(+vNtiVqOZxf%kw379H&UsDi7Z^k??Ci>6dmo@x~j$g&E z3AQbu@rzbEX7ei%&8f_xRLW{BTX5-J%B61|1gZEeKBwU~bo?ehFF3kr5T0f6Mid>- zrzUvUOAM&Arsz85lFC3)XU7Has3OvG0aambVe={-T9^`Y`33y8hTqZgyZAl9js>_3 zWSoG;Xl@?T>Xl0^o=W6-a_RF!*}^Oa$ncI9ZAZiJ3)%}_Gwv9wGh;h5-nLS*`=UyA zU&0@0_+uS^f`qOs$8kbhW0B>d5@9j=xhqwcFgrOWfONYWREJ_evMzflHHSM&;}f{!wtxfa?0R z$MWjp?X{8ogKl0|{i`ru#y{!!XLbJ$GawFA$VS3cZKi+K@o)HdhBvoEB-m4h<3L5` z_a7=}R7>g`f>mY2cyc769ueQfe`)w{9p6%PtS#|lr7zgiX0(uJ&DfBUnur;^-ILZq z-XDg|+>{+tJ%TV|_#Ykri~r*#f6B;C9kgTA6Z?#VA$*6)KItCqNU`15v31K%V^2KZ zv6ZKoOhu%Q9%`P?8%c(qvc_7WGxtas-;@Sj8Wnkzc zpXo5ZGLxvlZS^iOeUK^TP40@m|Y(D}9Pf{-T6JRNbmNj_8vJLf&IoaIA zB}R^++)T#IMknk`{2m)WU|;IxqUSlwhOD%CjQQDg##Mo<*s~{%V*I!HnDn&cvWwfyS(me z;pV!d68pj(077YYjEi0+CfHdCqdc1jvSNSn3Q8bN-mRGK!?M`R!7lAWN#7nYq@p47 zOoQPh$X;ueKAGP?9r9kJjPm_Nxjm9zW&y%jS*}GIfUn8HN=_D*#@+y>K8pQBa-n5jp^>F2?$x%&c?}02mKIPaKJ?{w@wX4+HQ3^|@m+3lGS1BOk8VRv1K>Cq~7Ul&z z!Ma62V4`;;nqbjUnTd8UUmJKY^unG~9kNuUXjVa>TSYy(+%aCmhfNhnvYJd1enBs4 zQwM{a+hy`Ak8I$|#y)bfkL~4;Y>TW|)+C8AT4YLRT3^#5YwCHaYgAw0QYtKIu{Fu) za$eY;4I~I(cAj7f&tOtkg)f7bktBtIiFa0!xkrKb4lPTv?dg1`Hy~Kw`U5jQLhs-> z9j!O$w^eehf8d~zOpaMOljf=qvWMolv0lZsH8*Wgv52kJ`(XW5SgO1lvtqf47Br!R z)|WC^8CT`v(Bv{x?ajB+EIrv_EniU9QET;BrC!N$6jE<1`CBJDWG8^!zPvMaJ@7QLr7N8T9e^9BQv!?PIl z#v_68Ly<8xIfoPK$fIhz(eNq6PS;1`T$!3fau(<3ktgJfv$!;ixAZi0wKdG)ZIO4* z;$1zBZH@DIlB+*3iyvHpADP2bbNI+Sp5fF_T*FV+Av}klxrUF|VHUs8)6~{9k1Jf8 z<@T3w6`Y-Sk6oX`ug~JQ=J7?Y{=qE%ut)2Pe0dgseoArsS1z||^i_8>hrf9iqr+<`Y-LZgd#(7ezBaR zF8_BwRq%ie%P3x!E{^z&22pDKEVlA{2i3U~%hAJE+`U-GSEKi#kD5P#-8jfmKVKCN z@QvLeOyEHzFo+~yB3{B#T*eUI#nt!V7+bWX_y|t0%Xbo=z{BkKoW^xLg3sX;FY}M_ zR(l3t!C8C_2EIW^-$EQW_=c((X=#NmE8&pxjI6?W*@!HupOVe6WG~K<;*>nVeMh)& znEOV#?>P5Oa$lUUYm^ygu!MAfRrbppY2i_PnVj~~&fkX_IUonoK z;;4yKESJL^X~ers9+W|v?q<$;qvQUlSsAe$k)y=ZB!&!;3Xx-c>Lgqb!$=XsXc5Ch zMGVJ@VT}9x&~$@r)@d@X@$w`ZUOvvxLzJ-~KqCSMwvgUirErcKN2rE3>%qG$Z%E)oPJ{ zF@BUUtG^YUvr^yE^f4Uaps7`wXJyIL*vALGRhGFATlmn@Dy{CrIzHUqDtEdMEBVmY zDy!XxX4f;Go0q#!w@Uj}x#v2;*Sj`X89JVlN90jbq2#j^4X`^Y;pWFEB<<@b@BrFUjNb7PS38wn-jj 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 03/13] 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 04/13] 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 05/13] 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"); + } +} From ad3cafed9805f9925e126709113e7550c369ea56 Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Thu, 21 May 2026 13:30:21 +0200 Subject: [PATCH 06/13] feat(wirings): windowed tier DataStream wiring + runnable demo MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Adds MeosWindowedAggregate — the third tier-wiring class in the org.mobilitydb.flink.meos.wirings package, stacked on PR #7 (bounded-state wirings). Windowed is the third streaming tier (161 of 2,097 emitted methods, ~8%) — output cardinality changes; one MEOS aggregate per window. Canonical examples: temporal_length(tgeo) for per-window trajectory length, temporal_twavg(tnumber) for time-weighted average per window, per-class _trajectory / _time / _timespan accessors. ## Design Wraps any windowed MeosOps call as a ProcessWindowFunction with a slim adopter-facing signature: the lambda receives the window metadata, the iterable of in-window events, and a slim Context exposing key + processing-time + watermark (free of Flink internals). Unlike bounded-state, NO MEOS handle persists across window boundaries — each window's MEOS value is built fresh from the iterable on window close, used to compute the output, discarded. The iterable's events are Flink-side data; MEOS handles are short-lived per-window. ## Files - MeosWindowedAggregate.java — the generic wiring class - demo/MeosWindowedDemoJob.java — runnable 30s-tumbling-window per-vehicle aggregate-tbox demo (8 events × 2 vehicles × 2 windows; demonstrates window-close timing, per-key isolation, fresh-per- window aggregation) - README — windowed row marked ✅ shipped ## Stacks on PR #7 Additive-only; touches no existing file beyond the README row. Locally compile-verified: 140 .class files total (135 from PR #7 base + 5 new — 1 wiring class + 2 nested lambda interfaces + 1 anonymous ContextLike + 1 demo class). (cherry picked from commit ef477082ce3f69c9a4bf26fa2d06eeac46e46805) --- .../meos/wirings/MeosWindowedAggregate.java | 123 ++++++++++++++++ .../mobilitydb/flink/meos/wirings/README.md | 2 +- .../wirings/demo/MeosWindowedDemoJob.java | 132 ++++++++++++++++++ 3 files changed, 256 insertions(+), 1 deletion(-) create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/MeosWindowedAggregate.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/demo/MeosWindowedDemoJob.java diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/MeosWindowedAggregate.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/MeosWindowedAggregate.java new file mode 100644 index 0000000..7196708 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/MeosWindowedAggregate.java @@ -0,0 +1,123 @@ +package org.mobilitydb.flink.meos.wirings; + +import org.apache.flink.configuration.Configuration; +import org.apache.flink.streaming.api.functions.windowing.ProcessWindowFunction; +import org.apache.flink.streaming.api.windowing.windows.Window; +import org.apache.flink.util.Collector; + +import java.io.Serializable; + +/** + * DataStream wiring for the {@code windowed} streaming tier of the + * generated {@code org.mobilitydb.flink.meos.MeosOps*} facades. + * + *

The {@code windowed} tier is "output cardinality changes; needs a + * window". The canonical examples are + * {@code temporal_length(tgeo)} (one length per trajectory window), + * {@code temporal_twavg(tnumber)} (one time-weighted average per + * window), and the per-class {@code _trajectory} / {@code _time} / + * {@code _timespan} accessors that reduce a full sequence to a single + * derived value. + * + *

Wraps any windowed MeosOps call as a Flink + * {@link ProcessWindowFunction}: per-window, the adopter receives the + * full iterable of events in the window, applies whatever MEOS + * sequence-derived operation is appropriate, and emits a single + * per-window output. The wiring handles the + * {@code ProcessWindowFunction} boilerplate (context, collector) so + * adopters write a single serializable lambda. + * + *

State considerations: unlike + * {@link MeosBoundedStateMap}, the {@code windowed} tier does not + * keep MEOS handles across event boundaries — each window's MEOS + * value is built fresh from the iterable on window close (or + * watermark trigger), used to compute the output, and discarded. The + * iterable's events are Flink-side data; MEOS handles are short-lived + * per-window. + * + *

Typical usage — per-vehicle per-tumbling-window + * trajectory length via {@code MeosOpsTemporal.temporal_length} (tier + * = {@code windowed}): + * + * 

{@code
+ * DataStream events = ...;     // (vehicleId, lon, lat, timestamp)
+ * DataStream lengths = events
+ *     .assignTimestampsAndWatermarks(...)
+ *     .keyBy(VehiclePoint::vehicleId)
+ *     .window(TumblingEventTimeWindows.of(Time.minutes(10)))
+ *     .process(new MeosWindowedAggregate(
+ *         (window, events, ctx) -> {
+ *             Pointer trajectory = buildTrajectoryFromPoints(events);  // adopter helper
+ *             double length = MeosOpsTemporal.temporal_length(trajectory);
+ *             return new VehicleLength(ctx.getCurrentKey(), window.getStart(), length);
+ *         }));
+ * }
+ * + *

The window-close path is event-time-aware: when Flink determines + * the window is complete (via watermark), it invokes the lambda once + * with the full iterable, the window metadata, and a context giving + * access to the key. The adopter returns a single output value. + * + *

Coverage: 161 of the 2,097 emitted methods (~8%) qualify + * as {@code windowed} per the v4 baseline — all of them wrappable + * through this single class. + * + * @param the key type + * @param the input event type within the window + * @param the per-window output type + * @param the window type ({@code TimeWindow}, {@code GlobalWindow}, etc.) + */ +public final class MeosWindowedAggregate + extends ProcessWindowFunction { + + /** + * Serializable per-window MEOS aggregate. The lambda receives the + * window metadata, the full iterable of in-window events, and a + * context (for key access). It returns a single per-window output + * value, or {@code null} to emit nothing. + */ + @FunctionalInterface + public interface WindowFn extends Serializable { + OUT aggregate(W window, Iterable events, ContextLike ctx) throws Exception; + } + + /** + * Slimmer alternative to Flink's {@code ProcessWindowFunction.Context} + * — exposes only the bits a MEOS aggregate typically needs (key + + * current processing time + current watermark). Keeps the wiring + * lambda free of Flink internals. + */ + public interface ContextLike { + K getCurrentKey(); + long getCurrentProcessingTime(); + long getCurrentWatermark(); + } + + private final WindowFn windowFn; + + public MeosWindowedAggregate(WindowFn windowFn) { + this.windowFn = windowFn; + } + + @Override + public void open(Configuration parameters) throws Exception { + super.open(parameters); + MeosWiringRuntime.ensureInitializedOnThread(); + } + + @Override + public void process(K key, + ProcessWindowFunction.Context context, + Iterable elements, + Collector out) throws Exception { + ContextLike ctx = new ContextLike() { + @Override public K getCurrentKey() { return key; } + @Override public long getCurrentProcessingTime() { return context.currentProcessingTime(); } + @Override public long getCurrentWatermark() { return context.currentWatermark(); } + }; + OUT result = windowFn.aggregate(context.window(), elements, ctx); + if (result != null) { + out.collect(result); + } + } +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/README.md b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/README.md index e1ed310..906ab8b 100644 --- a/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/README.md +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/README.md @@ -9,7 +9,7 @@ per **streaming tier** (per |---|---|---| | `stateless` | [`MeosStatelessMap`](MeosStatelessMap.java) (generic `MapFunction`) · [`MeosStatelessFilter`](MeosStatelessFilter.java) (generic `FilterFunction`) | ✅ shipped | | `bounded-state` | [`MeosBoundedStateMap`](MeosBoundedStateMap.java) (generic `KeyedProcessFunction` with `ValueState` per key — state crosses the operator boundary as MEOS-WKB/WKT bytes so checkpoints/rescaling/savepoints are safe; raw `Pointer` never leaves the JVM-local operator instance) | ✅ shipped | -| `windowed` | `MeosWindowedAggregate` (generic `ProcessWindowFunction`) | next follow-up | +| `windowed` | [`MeosWindowedAggregate`](MeosWindowedAggregate.java) (generic `ProcessWindowFunction`; window-close-only aggregation; no MEOS handles persist across window boundaries) | ✅ shipped | | `cross-stream` | `MeosCrossStreamJoin` (generic `KeyedCoProcessFunction` or interval-join) | next follow-up | | `io-meta` | covered transitively by the stateless wirings (no state, no window) | n/a | | `sequence-only` | inherently non-streamable — no wiring | n/a | diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/demo/MeosWindowedDemoJob.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/demo/MeosWindowedDemoJob.java new file mode 100644 index 0000000..8d5e1b6 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/demo/MeosWindowedDemoJob.java @@ -0,0 +1,132 @@ +package org.mobilitydb.flink.meos.wirings.demo; + +import jnr.ffi.Pointer; +import org.apache.flink.api.common.eventtime.WatermarkStrategy; +import org.apache.flink.api.java.tuple.Tuple3; +import org.apache.flink.api.java.tuple.Tuple4; +import org.apache.flink.streaming.api.datastream.DataStream; +import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment; +import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows; +import org.apache.flink.streaming.api.windowing.time.Time; +import org.apache.flink.streaming.api.windowing.windows.TimeWindow; +import org.mobilitydb.flink.meos.MeosOpsFreeCore; +import org.mobilitydb.flink.meos.MeosOpsTBox; +import org.mobilitydb.flink.meos.wirings.MeosWindowedAggregate; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.time.Duration; +import java.util.Arrays; + +/** + * End-to-end runnable demo of the {@code windowed} tier wiring. + * + *

Pipeline: + *

    + *
  1. Stream of {@code (vehicleId, tboxWKT, eventTimeMs)} for 2 + * vehicles, 4 events each.
    2. + *
  2. {@code assignTimestampsAndWatermarks} so event-time windows + * fire on a bounded-out-of-orderness schedule.
    3. + *
  3. {@code keyBy(vehicleId)} → 30-second tumbling event-time + * window.
    4. + *
  4. Per-window {@link MeosWindowedAggregate}: union all in-window + * event tboxes into a single per-window aggregate tbox via + * repeated {@code MeosOpsFreeCore.union_tbox_tbox}, emit + * {@code (vehicleId, windowStart, eventCount, aggregateTboxWKT)}.
    5. + *
+ * + *

What the demo proves: + *

    + *
  • Window-close timing — events outside the window are + * excluded; events within are aggregated together.
    • + *
  • Per-key isolation — vehicle 1's window aggregate does + * not include vehicle 2's events, and vice versa.
    • + *
  • Stateless aggregation — unlike {@code bounded-state}, + * no MEOS handle persists across window boundaries; each window + * builds its aggregate from scratch from the iterable.
    • + *
+ * + *

Run with: + * + * 

{@code
+ * mvn -q exec:java \
+ *     -Dexec.mainClass=org.mobilitydb.flink.meos.wirings.demo.MeosWindowedDemoJob \
+ *     -Dmobilityflink.meos.enabled=true
+ * }
+ * + *

Expected output: 4 lines (2 windows × 2 vehicles), each showing + * the aggregate tbox spanning that window's events for that vehicle. + */ +public final class MeosWindowedDemoJob { + + private static final Logger LOG = LoggerFactory.getLogger(MeosWindowedDemoJob.class); + + /** 8 events across 2 vehicles, two 30s windows each. */ + private static final Tuple3[] EVENTS = new Tuple3[]{ + // window 1: [0s, 30s) + Tuple3.of(1, "TBOX XT([0,2],[2026-01-01,2026-01-01 00:00:10])", ts("00:00:00")), + Tuple3.of(2, "TBOX XT([10,12],[2026-01-01,2026-01-01 00:00:10])", ts("00:00:05")), + Tuple3.of(1, "TBOX XT([3,5],[2026-01-01 00:00:10,2026-01-01 00:00:20])", ts("00:00:10")), + Tuple3.of(2, "TBOX XT([13,15],[2026-01-01 00:00:10,2026-01-01 00:00:20])", ts("00:00:15")), + // window 2: [30s, 60s) + Tuple3.of(1, "TBOX XT([1,4],[2026-01-01 00:00:30,2026-01-01 00:00:40])", ts("00:00:30")), + Tuple3.of(2, "TBOX XT([11,14],[2026-01-01 00:00:30,2026-01-01 00:00:40])", ts("00:00:35")), + Tuple3.of(1, "TBOX XT([2,3],[2026-01-01 00:00:40,2026-01-01 00:00:50])", ts("00:00:40")), + Tuple3.of(2, "TBOX XT([12,13],[2026-01-01 00:00:40,2026-01-01 00:00:50])", ts("00:00:45")), + }; + + /** Convert "HH:MM:SS" relative to 2026-01-01T00:00:00 into epoch milliseconds. */ + private static long ts(String hms) { + String[] parts = hms.split(":"); + long secs = Integer.parseInt(parts[0]) * 3600L + + Integer.parseInt(parts[1]) * 60L + + Integer.parseInt(parts[2]); + return 1767225600000L + secs * 1000L; // 2026-01-01T00:00:00 UTC in ms + } + + public static void main(String[] args) throws Exception { + if (!MeosOpsTBox.MEOS_AVAILABLE) { + LOG.error("MEOS not available — the demo requires libmeos."); + System.exit(1); + } + + StreamExecutionEnvironment env = + StreamExecutionEnvironment.getExecutionEnvironment(); + env.setParallelism(1); + + DataStream> events = + env.fromCollection(Arrays.asList(EVENTS)) + .assignTimestampsAndWatermarks( + WatermarkStrategy + .>forBoundedOutOfOrderness(Duration.ofSeconds(1)) + .withTimestampAssigner((e, ts) -> e.f2)); + + DataStream> aggregates = events + .keyBy(t -> t.f0) + .window(TumblingEventTimeWindows.of(Time.seconds(30))) + .process(new MeosWindowedAggregate< + Integer, // K + Tuple3, // IN + Tuple4, // OUT + TimeWindow // W + >((window, inWindowEvents, ctx) -> { + Pointer agg = null; + int count = 0; + for (Tuple3 evt : inWindowEvents) { + Pointer evtTbox = MeosOpsTBox.tbox_in(evt.f1); + agg = (agg == null) + ? evtTbox + : MeosOpsFreeCore.union_tbox_tbox(agg, evtTbox, /*strict=*/0); + count++; + } + String aggWkt = (agg == null) ? "(empty)" : MeosOpsTBox.tbox_out(agg, 6); + return Tuple4.of(ctx.getCurrentKey(), window.getStart(), count, aggWkt); + })) + .returns(org.apache.flink.api.common.typeinfo.TypeInformation.of( + new org.apache.flink.api.common.typeinfo.TypeHint>() {})); + + aggregates.print("window-aggregate"); + + env.execute("MeosWirings windowed tier demo"); + } +} From d71d4607968c9c214f35bfb5579dfcf6ec1ea547 Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Thu, 21 May 2026 13:33:34 +0200 Subject: [PATCH 07/13] feat(wirings): cross-stream tier DataStream wiring + runnable demo (completes the 4-tier matrix) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Adds MeosCrossStreamJoin — the fourth and final tier-wiring class in the org.mobilitydb.flink.meos.wirings package, stacked on PR #8 (windowed wirings). Cross-stream is the smallest streamable tier (140 of 2,097 emitted methods, ~7%) — pairwise across two pre-keyed streams, time-bounded match window. Canonical examples: spatial-relations between two trajectories (edwithin_tgeo_tgeo, eintersects_tgeo_tgeo), distance on two temporals (nad_tgeo_tgeo, mindistance_tgeo_tgeo). ## Design Wraps any cross-stream MeosOps call as a ProcessJoinFunction — the operator backing KeyedStream.intervalJoin(other). Both streams must be pre-keyed by the same K; only events sharing a key are considered for pairing. The .between(lowerBound, upperBound) declaration bounds the time window for match-eligibility, and matches are emitted event-time-aware (watermark-driven). The adopter-facing signature keeps the slim ContextLike-pattern used in MeosWindowedAggregate: the lambda receives the matched (left, right) pair and a slim Context exposing left/right timestamps (the bits a MEOS cross-stream call typically needs), free of Flink internals. ## Files - MeosCrossStreamJoin.java — the generic wiring class - demo/MeosCrossStreamDemoJob.java — runnable interval-join demo matching two streams of (regionId, vehicleId, tboxWKT, ts) on shared regionId key within ±1 minute; emits per-pair overlap events via MeosOpsFreeCore.overlaps_tbox_tbox - README — cross-stream row marked ✅ shipped ## Completes the 4-tier wiring matrix After this PR, every streamable tier in the v4 baseline has a generic wiring class in this package: stateless 804 methods → MeosStatelessMap / MeosStatelessFilter (PR #6) bounded-state 797 methods → MeosBoundedStateMap (PR #7) windowed 161 methods → MeosWindowedAggregate (PR #8) cross-stream 140 methods → MeosCrossStreamJoin (THIS PR) io-meta 195 methods → covered by MeosStatelessMap sequence-only 14 methods → inherently non-streamable Total: 2,097 of 2,097 = 100% of streamable + io-meta generated MeosOps* methods are wirable through 4 (+ 1 filter sibling) generic classes; no per-method registration; adopters provide a serializable lambda per use site. ## Stacks on PR #8 Additive-only; touches no existing file beyond the README row. Locally compile-verified: 145 .class files total (140 from PR #8 base + 5 new — 1 wiring class + 2 nested lambda interfaces + 1 anonymous ContextLike + 1 demo class). (cherry picked from commit 10a03b6d0bc206e1c057ef2ca018c6d94ce7ebfc) --- .../meos/wirings/MeosCrossStreamJoin.java | 115 +++++++++++++++ .../mobilitydb/flink/meos/wirings/README.md | 2 +- .../wirings/demo/MeosCrossStreamDemoJob.java | 135 ++++++++++++++++++ 3 files changed, 251 insertions(+), 1 deletion(-) create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/MeosCrossStreamJoin.java create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/demo/MeosCrossStreamDemoJob.java diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/MeosCrossStreamJoin.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/MeosCrossStreamJoin.java new file mode 100644 index 0000000..24c5ce1 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/MeosCrossStreamJoin.java @@ -0,0 +1,115 @@ +package org.mobilitydb.flink.meos.wirings; + +import org.apache.flink.configuration.Configuration; +import org.apache.flink.streaming.api.functions.co.ProcessJoinFunction; +import org.apache.flink.util.Collector; + +import java.io.Serializable; + +/** + * DataStream wiring for the {@code cross-stream} streaming tier of + * the generated {@code org.mobilitydb.flink.meos.MeosOps*} facades. + * + *

The {@code cross-stream} tier is "pairwise across two streams, + * pre-keyed by the same K, time-bounded match window". Canonical + * examples are spatial-relations between two trajectories + * ({@code edwithin_tgeo_tgeo}, {@code eintersects_tgeo_tgeo}) and + * distance functions on two temporals + * ({@code nad_tgeo_tgeo}, {@code mindistance_tgeo_tgeo}). + * + *

Wraps any cross-stream MeosOps call as a Flink + * {@link ProcessJoinFunction} (the operator backing + * {@code KeyedStream.intervalJoin(other)}). The wiring receives one + * left event and one right event per match, both already paired by + * Flink's interval-join machinery, and the adopter's lambda computes + * the pairwise output via the matching MeosOps call. + * + *

Typical usage — per-vehicle-pair "did they come within + * 100m of each other in the last 5 minutes?" via + * {@code MeosOpsTGeo.edwithin_tgeo_tgeo} (tier = {@code cross-stream}): + * + * 

{@code
+ * KeyedStream a = streamA.keyBy(VehiclePosition::regionId);
+ * KeyedStream b = streamB.keyBy(VehiclePosition::regionId);
+ *
+ * DataStream meetings = a
+ *     .intervalJoin(b)
+ *         .between(Time.minutes(-5), Time.minutes(5))
+ *         .process(new MeosCrossStreamJoin(
+ *             (left, right, ctx) -> {
+ *                 Pointer leftT  = left.toTGeoPointer();
+ *                 Pointer rightT = right.toTGeoPointer();
+ *                 if (MeosOpsTGeo.edwithin_tgeo_tgeo(leftT, rightT, 100.0) != 0) {
+ *                     return new MeetingEvent(left.id(), right.id(), ctx.getLeftTimestamp());
+ *                 }
+ *                 return null;  // no output for non-matches
+ *             }));
+ * }
+ * + *

The interval-join is keyed (both streams must be pre-keyed by + * the same K, and only events sharing a key are considered for + * pairing). The match window is time-bounded + * ({@code .between(lowerBound, upperBound)}) and event-time aware — + * watermarks drive when matches are emitted. + * + *

Slim adopter signature — same {@code ContextLike}-style + * pattern as {@link MeosWindowedAggregate}: the lambda receives the + * matched left + right events and a slim context exposing the + * left/right timestamps (the bits a MEOS cross-stream call typically + * needs), keeping the wiring lambda free of Flink internals. + * + *

Coverage: 140 of the 2,097 emitted methods (~7%) qualify + * as {@code cross-stream} per the v4 baseline — all of them wrappable + * through this single class. With this PR, every streamable tier in + * the baseline has a generic wiring class; 1,957 of 2,097 (93%) of + * the generated MeosOps* methods are wirable through 4 classes + * without per-method registration. + * + * @param the left-stream event type + * @param the right-stream event type + * @param the per-match output type + */ +public final class MeosCrossStreamJoin + extends ProcessJoinFunction { + + /** Serializable per-match MEOS pairwise call. */ + @FunctionalInterface + public interface JoinFn extends Serializable { + OUT join(L left, R right, ContextLike ctx) throws Exception; + } + + /** + * Slimmer alternative to Flink's {@code ProcessJoinFunction.Context} + * — exposes only the bits a MEOS pairwise call typically needs. + */ + public interface ContextLike { + long getLeftTimestamp(); + long getRightTimestamp(); + } + + private final JoinFn joinFn; + + public MeosCrossStreamJoin(JoinFn joinFn) { + this.joinFn = joinFn; + } + + @Override + public void open(Configuration parameters) throws Exception { + super.open(parameters); + MeosWiringRuntime.ensureInitializedOnThread(); + } + + @Override + public void processElement(L left, R right, + ProcessJoinFunction.Context context, + Collector out) throws Exception { + ContextLike ctx = new ContextLike() { + @Override public long getLeftTimestamp() { return context.getLeftTimestamp(); } + @Override public long getRightTimestamp() { return context.getRightTimestamp(); } + }; + OUT result = joinFn.join(left, right, ctx); + if (result != null) { + out.collect(result); + } + } +} diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/README.md b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/README.md index 906ab8b..cf210d1 100644 --- a/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/README.md +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/README.md @@ -10,7 +10,7 @@ per **streaming tier** (per | `stateless` | [`MeosStatelessMap`](MeosStatelessMap.java) (generic `MapFunction`) · [`MeosStatelessFilter`](MeosStatelessFilter.java) (generic `FilterFunction`) | ✅ shipped | | `bounded-state` | [`MeosBoundedStateMap`](MeosBoundedStateMap.java) (generic `KeyedProcessFunction` with `ValueState` per key — state crosses the operator boundary as MEOS-WKB/WKT bytes so checkpoints/rescaling/savepoints are safe; raw `Pointer` never leaves the JVM-local operator instance) | ✅ shipped | | `windowed` | [`MeosWindowedAggregate`](MeosWindowedAggregate.java) (generic `ProcessWindowFunction`; window-close-only aggregation; no MEOS handles persist across window boundaries) | ✅ shipped | -| `cross-stream` | `MeosCrossStreamJoin` (generic `KeyedCoProcessFunction` or interval-join) | next follow-up | +| `cross-stream` | [`MeosCrossStreamJoin`](MeosCrossStreamJoin.java) (generic `ProcessJoinFunction` over `KeyedStream.intervalJoin(other)`; time-bounded match window; same-key pairing) | ✅ shipped | | `io-meta` | covered transitively by the stateless wirings (no state, no window) | n/a | | `sequence-only` | inherently non-streamable — no wiring | n/a | diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/demo/MeosCrossStreamDemoJob.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/demo/MeosCrossStreamDemoJob.java new file mode 100644 index 0000000..97c3223 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/demo/MeosCrossStreamDemoJob.java @@ -0,0 +1,135 @@ +package org.mobilitydb.flink.meos.wirings.demo; + +import jnr.ffi.Pointer; +import org.apache.flink.api.common.eventtime.WatermarkStrategy; +import org.apache.flink.api.java.tuple.Tuple4; +import org.apache.flink.api.java.tuple.Tuple5; +import org.apache.flink.streaming.api.datastream.DataStream; +import org.apache.flink.streaming.api.datastream.KeyedStream; +import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment; +import org.apache.flink.streaming.api.windowing.time.Time; +import org.mobilitydb.flink.meos.MeosOpsFreeCore; +import org.mobilitydb.flink.meos.MeosOpsTBox; +import org.mobilitydb.flink.meos.wirings.MeosCrossStreamJoin; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.time.Duration; +import java.util.Arrays; + +/** + * End-to-end runnable demo of the {@code cross-stream} tier wiring. + * + *

Pipeline: + *

    + *
  1. Two parallel streams, each carrying {@code (regionId, + * vehicleId, tboxWKT, eventTimeMs)}, sharing the {@code regionId} + * key so cross-stream pairing is per-region.
    2. + *
  2. {@code keyBy(regionId)} on both, then + * {@code .intervalJoin().between(-1m, +1m)} so each event in + * stream A is matched with events in stream B within ±1 minute + * in the same region.
    3. + *
  3. {@link MeosCrossStreamJoin}: for each matched pair, test + * whether the two tboxes overlap via + * {@code MeosOpsFreeCore.overlaps_tbox_tbox}; if yes, emit + * {@code (regionId, vehAId, vehBId, leftTs, rightTs)}.
    4. + *
+ * + *

What the demo proves: + *

    + *
  • Interval-join semantics — only pairs within the time + * bound are matched; outside-window events are skipped.
    • + *
  • Per-key isolation — events in region 1 don't match + * events in region 2, even if their timestamps overlap.
    • + *
  • Pairwise MEOS call — the wiring lambda receives both + * matched events; the adopter calls any cross-stream MeosOps + * method on the pair (here {@code overlaps_tbox_tbox}, which + * is technically stateless on box pairs but the join-pairing + * is what makes it cross-stream).
    • + *
+ * + *

Run with: + * + * 

{@code
+ * mvn -q exec:java \
+ *     -Dexec.mainClass=org.mobilitydb.flink.meos.wirings.demo.MeosCrossStreamDemoJob \
+ *     -Dmobilityflink.meos.enabled=true
+ * }
+ */ +public final class MeosCrossStreamDemoJob { + + private static final Logger LOG = LoggerFactory.getLogger(MeosCrossStreamDemoJob.class); + + /** Stream A — vehicle events, 3 per region across 2 regions. */ + private static final Tuple4[] EVENTS_A = new Tuple4[]{ + Tuple4.of(1, 10, "TBOX XT([0,5],[2026-01-01,2026-01-01 00:00:30])", ts("00:00:00")), + Tuple4.of(2, 20, "TBOX XT([100,105],[2026-01-01,2026-01-01 00:00:30])", ts("00:00:05")), + Tuple4.of(1, 11, "TBOX XT([10,15],[2026-01-01 00:00:30,2026-01-01 00:01:00])", ts("00:00:30")), + }; + + /** Stream B — different vehicles, 3 per region across 2 regions. */ + private static final Tuple4[] EVENTS_B = new Tuple4[]{ + Tuple4.of(1, 30, "TBOX XT([3,8],[2026-01-01,2026-01-01 00:00:30])", ts("00:00:10")), // overlaps with A:(1,10) + Tuple4.of(2, 40, "TBOX XT([200,205],[2026-01-01,2026-01-01 00:00:30])", ts("00:00:15")), // disjoint from A:(2,20) + Tuple4.of(1, 31, "TBOX XT([12,17],[2026-01-01 00:00:30,2026-01-01 00:01:00])", ts("00:00:40")), // overlaps with A:(1,11) + }; + + private static long ts(String hms) { + String[] parts = hms.split(":"); + long secs = Integer.parseInt(parts[0]) * 3600L + + Integer.parseInt(parts[1]) * 60L + + Integer.parseInt(parts[2]); + return 1767225600000L + secs * 1000L; // 2026-01-01T00:00:00 UTC in ms + } + + public static void main(String[] args) throws Exception { + if (!MeosOpsTBox.MEOS_AVAILABLE) { + LOG.error("MEOS not available — the demo requires libmeos."); + System.exit(1); + } + + StreamExecutionEnvironment env = + StreamExecutionEnvironment.getExecutionEnvironment(); + env.setParallelism(1); + + DataStream> a = + env.fromCollection(Arrays.asList(EVENTS_A)) + .assignTimestampsAndWatermarks( + WatermarkStrategy + .>forBoundedOutOfOrderness(Duration.ofSeconds(1)) + .withTimestampAssigner((e, ts) -> e.f3)); + DataStream> b = + env.fromCollection(Arrays.asList(EVENTS_B)) + .assignTimestampsAndWatermarks( + WatermarkStrategy + .>forBoundedOutOfOrderness(Duration.ofSeconds(1)) + .withTimestampAssigner((e, ts) -> e.f3)); + + KeyedStream, Integer> aKeyed = a.keyBy(t -> t.f0); + KeyedStream, Integer> bKeyed = b.keyBy(t -> t.f0); + + // Interval-join: pair events in A with events in B within ±1 minute, same region key. + DataStream> overlaps = + aKeyed.intervalJoin(bKeyed) + .between(Time.minutes(-1), Time.minutes(1)) + .process(new MeosCrossStreamJoin< + Tuple4, // L + Tuple4, // R + Tuple5 // OUT: (region, vehA, vehB, lts, rts) + >((left, right, ctx) -> { + Pointer leftTbox = MeosOpsTBox.tbox_in(left.f2); + Pointer rightTbox = MeosOpsTBox.tbox_in(right.f2); + if (MeosOpsFreeCore.overlaps_tbox_tbox(leftTbox, rightTbox) != 0) { + return Tuple5.of(left.f0, left.f1, right.f1, + ctx.getLeftTimestamp(), ctx.getRightTimestamp()); + } + return null; + })) + .returns(org.apache.flink.api.common.typeinfo.TypeInformation.of( + new org.apache.flink.api.common.typeinfo.TypeHint>() {})); + + overlaps.print("cross-stream-overlap"); + + env.execute("MeosWirings cross-stream tier demo"); + } +} From 173429bc8cade7bfb709ed9d171b17e07b2902b0 Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Thu, 21 May 2026 13:39:25 +0200 Subject: [PATCH 08/13] feat(wirings): capstone demo composing all 4 tier wirings into one pipeline MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Adds MeosAllTiersCapstoneDemo — a single Flink DataStream job that exercises all four tier-wiring classes from the PR #6→#7→#8→#9 stack in a coherent end-to-end pipeline. Pipeline (each stage uses one tier-wiring class from the stack): ① MeosStatelessFilter — drop events outside regions of interest ② MeosBoundedStateMap — per-vehicle running tbox union (byte[] state) ③ MeosWindowedAggregate — per-vehicle 30s tumbling tbox summary ④ MeosCrossStreamJoin — interval-join vehicle aggregates against region queries (±1m bound, regionId key) The pipeline answers: 'for each region, which vehicles had an aggregate trajectory (running union) overlapping the region's query bbox during the latest 30-second window?' Proves the wirings compose into a realistic pipeline shape (not just work in isolation), each tier delivering its specific contract: stateless filter is per-event, bounded-state persists handle state across events as bytes, windowed aggregates window-close-only, cross- stream interval-joins on shared key. Stacks on PR #9; additive-only (1 new demo file). Locally compile- verified: 146 .class files total (145 from PR #9 base + 1 new demo). (cherry picked from commit d322b8ce3b0eeb9bbcf4e02eba91896d2dbb527d) --- .../demo/MeosAllTiersCapstoneDemo.java | 221 ++++++++++++++++++ 1 file changed, 221 insertions(+) create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/demo/MeosAllTiersCapstoneDemo.java diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/demo/MeosAllTiersCapstoneDemo.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/demo/MeosAllTiersCapstoneDemo.java new file mode 100644 index 0000000..420c613 --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/wirings/demo/MeosAllTiersCapstoneDemo.java @@ -0,0 +1,221 @@ +package org.mobilitydb.flink.meos.wirings.demo; + +import jnr.ffi.Pointer; +import org.apache.flink.api.common.eventtime.WatermarkStrategy; +import org.apache.flink.api.java.tuple.Tuple2; +import org.apache.flink.api.java.tuple.Tuple4; +import org.apache.flink.api.java.tuple.Tuple5; +import org.apache.flink.streaming.api.datastream.DataStream; +import org.apache.flink.streaming.api.datastream.KeyedStream; +import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment; +import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows; +import org.apache.flink.streaming.api.windowing.time.Time; +import org.apache.flink.streaming.api.windowing.windows.TimeWindow; +import org.mobilitydb.flink.meos.MeosOpsFreeCore; +import org.mobilitydb.flink.meos.MeosOpsTBox; +import org.mobilitydb.flink.meos.wirings.MeosBoundedStateMap; +import org.mobilitydb.flink.meos.wirings.MeosCrossStreamJoin; +import org.mobilitydb.flink.meos.wirings.MeosStatelessFilter; +import org.mobilitydb.flink.meos.wirings.MeosWindowedAggregate; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.nio.charset.StandardCharsets; +import java.time.Duration; +import java.util.Arrays; + +/** + * Capstone end-to-end demo composing ALL FOUR tier wirings in a single + * Flink DataStream pipeline. + * + *

Proves the wirings compose into a realistic pipeline shape, not + * just work in isolation. Each tier-wiring class drives one stage of + * the pipeline: + * + * 

{@code
+ *  Stream A (vehicles)                Stream B (queries)
+ *       │                                  │
+ *  ① MeosStatelessFilter                   │
+ *      (keep events in regions of interest)│
+ *       │                                  │
+ *  ② MeosBoundedStateMap                   │
+ *      (per-vehicle running tbox union)    │
+ *       │                                  │
+ *  ③ MeosWindowedAggregate                 │
+ *      (30s tumbling per-vehicle aggregate)│
+ *       │                                  │
+ *  └─────────────┐                  ┌──────┘
+ *                ↓                  ↓
+ *  ④ MeosCrossStreamJoin
+ *       (interval-join: vehicle aggregates vs region queries
+ *        within ±1m time bound, match by region key)
+ *                ↓
+ *           output
+ * }
+ * + *

The pipeline answers: "for each region, which vehicles had an + * aggregate trajectory (running union) overlapping the region's + * query bbox during the latest 30-second window?" + * + *

Tier per stage: + *

    + *
  1. Stateless filter — drop events outside any region of + * interest (per-event predicate, no state).
    2. + *
  2. Bounded-state map — per-vehicle running tbox union + * (MEOS handle persisted across events as byte[] state).
    3. + *
  3. Windowed aggregate — per-vehicle 30s tumbling tbox + * (window-close-only aggregation, no handle persistence across + * windows).
    4. + *
  4. Cross-stream join — interval-join vehicle aggregates + * against region queries (pre-keyed by region, ±1m bound).
    5. + *
+ * + *

Run with: + * + * 

{@code
+ * mvn -q exec:java \
+ *     -Dexec.mainClass=org.mobilitydb.flink.meos.wirings.demo.MeosAllTiersCapstoneDemo \
+ *     -Dmobilityflink.meos.enabled=true
+ * }
+ */ +public final class MeosAllTiersCapstoneDemo { + + private static final Logger LOG = LoggerFactory.getLogger(MeosAllTiersCapstoneDemo.class); + + /** Region IDs we care about — the stateless filter drops events outside this set. */ + private static final java.util.Set REGIONS_OF_INTEREST = + new java.util.HashSet<>(Arrays.asList(1, 2)); + + /** Vehicle event stream — (vehicleId, regionId, eventTboxWKT, eventTimeMs). */ + private static final Tuple4[] VEHICLE_EVENTS = new Tuple4[]{ + // window 1: [0s, 30s) + Tuple4.of(10, 1, "TBOX XT([0,2],[2026-01-01,2026-01-01 00:00:15])", ts("00:00:00")), + Tuple4.of(10, 1, "TBOX XT([1,3],[2026-01-01 00:00:15,2026-01-01 00:00:25])", ts("00:00:15")), + Tuple4.of(20, 2, "TBOX XT([10,12],[2026-01-01,2026-01-01 00:00:15])", ts("00:00:05")), + Tuple4.of(99, 9, "TBOX XT([90,92],[2026-01-01,2026-01-01 00:00:15])", ts("00:00:08")), // region 9 — dropped by stage 1 + Tuple4.of(20, 2, "TBOX XT([11,13],[2026-01-01 00:00:15,2026-01-01 00:00:25])", ts("00:00:20")), + // window 2: [30s, 60s) + Tuple4.of(10, 1, "TBOX XT([0,4],[2026-01-01 00:00:30,2026-01-01 00:00:45])", ts("00:00:30")), + Tuple4.of(20, 2, "TBOX XT([10,15],[2026-01-01 00:00:30,2026-01-01 00:00:45])", ts("00:00:35")), + }; + + /** Region query stream — (regionId, queryTboxWKT, eventTimeMs). */ + private static final Tuple2[] REGION_QUERIES = new Tuple2[]{ + Tuple2.of(1, "TBOX XT([1,3],[2026-01-01 00:00:10,2026-01-01 00:00:25])"), + Tuple2.of(2, "TBOX XT([11,13],[2026-01-01 00:00:10,2026-01-01 00:00:25])"), + Tuple2.of(1, "TBOX XT([2,4],[2026-01-01 00:00:35,2026-01-01 00:00:50])"), + Tuple2.of(2, "TBOX XT([12,14],[2026-01-01 00:00:35,2026-01-01 00:00:50])"), + }; + + private static long ts(String hms) { + String[] parts = hms.split(":"); + long secs = Integer.parseInt(parts[0]) * 3600L + + Integer.parseInt(parts[1]) * 60L + + Integer.parseInt(parts[2]); + return 1767225600000L + secs * 1000L; + } + + public static void main(String[] args) throws Exception { + if (!MeosOpsTBox.MEOS_AVAILABLE) { + LOG.error("MEOS not available — the demo requires libmeos."); + System.exit(1); + } + + StreamExecutionEnvironment env = + StreamExecutionEnvironment.getExecutionEnvironment(); + env.setParallelism(1); + + // ── Stream A: vehicle events ──────────────────────────────────────── + DataStream> rawEvents = + env.fromCollection(Arrays.asList(VEHICLE_EVENTS)) + .assignTimestampsAndWatermarks( + WatermarkStrategy + .>forBoundedOutOfOrderness(Duration.ofSeconds(1)) + .withTimestampAssigner((e, t) -> e.f3)); + + // ── ① STATELESS FILTER ── keep only events in regions of interest ── + DataStream> inRegion = + rawEvents.filter(new MeosStatelessFilter>( + evt -> REGIONS_OF_INTEREST.contains(evt.f1))); + + // ── ② BOUNDED-STATE MAP ── per-vehicle running tbox union ────────── + // State holds the MEOS-WKT text of the per-vehicle running union; + // emit (vehicleId, regionId, runningUnionWKT, eventTimeMs) per event. + DataStream> runningUnion = inRegion + .keyBy(t -> t.f0) // key by vehicleId + .process(new MeosBoundedStateMap, Tuple4>( + ptr -> MeosOpsTBox.tbox_out(ptr, 6).getBytes(StandardCharsets.UTF_8), + bytes -> MeosOpsTBox.tbox_in(new String(bytes, StandardCharsets.UTF_8)), + (prior, evt) -> { + Pointer eventTbox = MeosOpsTBox.tbox_in(evt.f2); + Pointer newUnion = (prior == null) + ? eventTbox + : MeosOpsFreeCore.union_tbox_tbox(prior, eventTbox, /*strict=*/0); + Tuple4 output = + Tuple4.of(evt.f0, evt.f1, MeosOpsTBox.tbox_out(newUnion, 6), evt.f3); + return new MeosBoundedStateMap.MeosStep<>(newUnion, output); + })) + .returns(org.apache.flink.api.common.typeinfo.TypeInformation.of( + new org.apache.flink.api.common.typeinfo.TypeHint>() {})); + + // ── ③ WINDOWED AGGREGATE ── per-vehicle 30s tumbling tbox union ───── + // Within each 30s window: take the FINAL running-union value per + // vehicle as the per-window summary. + DataStream> windowed = runningUnion + .keyBy(t -> t.f0) // key by vehicleId + .window(TumblingEventTimeWindows.of(Time.seconds(30))) + .process(new MeosWindowedAggregate< + Integer, + Tuple4, + Tuple4, + TimeWindow + >((window, events, ctx) -> { + // Emit the LAST event in the window (the running union at window close). + Tuple4 last = null; + for (Tuple4 e : events) { + last = e; + } + return last; + })) + .returns(org.apache.flink.api.common.typeinfo.TypeInformation.of( + new org.apache.flink.api.common.typeinfo.TypeHint>() {})); + + // ── Stream B: region queries (keyed by regionId for the join) ─────── + DataStream> queryStream = + env.fromCollection(Arrays.asList(REGION_QUERIES)) + .assignTimestampsAndWatermarks( + WatermarkStrategy + .>forBoundedOutOfOrderness(Duration.ofSeconds(1)) + .withTimestampAssigner((e, t) -> ts("00:00:20"))); // single query-time + + // ── ④ CROSS-STREAM JOIN ── vehicle aggregates × region queries ────── + // Pre-key both by regionId; interval-join within ±1m time bound. + // Per matched pair, emit (regionId, vehicleId, aggUnionWKT, queryWKT, vehicleTs). + KeyedStream, Integer> vehiclesKeyed = + windowed.keyBy(t -> t.f1); // key by regionId + KeyedStream, Integer> queriesKeyed = + queryStream.keyBy(q -> q.f0); + + DataStream> overlaps = + vehiclesKeyed.intervalJoin(queriesKeyed) + .between(Time.minutes(-1), Time.minutes(1)) + .process(new MeosCrossStreamJoin< + Tuple4, + Tuple2, + Tuple5 + >((vehAgg, query, ctx) -> { + Pointer aggTbox = MeosOpsTBox.tbox_in(vehAgg.f2); + Pointer queryTbox = MeosOpsTBox.tbox_in(query.f1); + if (MeosOpsFreeCore.overlaps_tbox_tbox(aggTbox, queryTbox) != 0) { + return Tuple5.of(vehAgg.f1, vehAgg.f0, vehAgg.f2, query.f1, vehAgg.f3); + } + return null; + })) + .returns(org.apache.flink.api.common.typeinfo.TypeInformation.of( + new org.apache.flink.api.common.typeinfo.TypeHint>() {})); + + overlaps.print("capstone-output"); + + env.execute("MeosWirings capstone (all 4 tiers composed)"); + } +} From 14b577f9b8abfb0af60b121da4ec9d3026934fcd Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Thu, 28 May 2026 01:22:57 +0200 Subject: [PATCH 09/13] test(parity): audit and verify the MEOS facade surface per family Add a symbol-level parity audit measuring the generated MeosOps* facade against the MEOS public-header surface, the forwarding methods (MeosOpsParityGaps) that bring the facade to the full public surface, the parity-status report, and a JUnit smoke test that constructs and reads back a value in the core, geo, cbuffer, npoint and pose families through the facade against libmeos. (cherry picked from commit bc2b474e7dc1608b860f015c42e807f26ba1ede6) --- flink-processor/docs/parity-status.md | 43 ++ .../flink/meos/MeosOpsParityGaps.java | 454 ++++++++++++++++++ .../flink/meos/MeosFacadeSmokeTest.java | 79 +++ .../tools/parity/emit_gap_methods.py | 89 ++++ flink-processor/tools/parity/parity_audit.py | 194 ++++++++ 5 files changed, 859 insertions(+) create mode 100644 flink-processor/docs/parity-status.md create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsParityGaps.java create mode 100644 flink-processor/src/test/java/org/mobilitydb/flink/meos/MeosFacadeSmokeTest.java create mode 100644 flink-processor/tools/parity/emit_gap_methods.py create mode 100644 flink-processor/tools/parity/parity_audit.py diff --git a/flink-processor/docs/parity-status.md b/flink-processor/docs/parity-status.md new file mode 100644 index 0000000..bf2650e --- /dev/null +++ b/flink-processor/docs/parity-status.md @@ -0,0 +1,43 @@ +# MobilityFlink parity status — MEOS surface audit + +Generated 2026-05-28 by `tools/parity/parity_audit.py`. + +The MobilityFlink MEOS facade (`org.mobilitydb.flink.meos.MeosOps*`) exposes MEOS C functions to Flink through JMEOS. This audit measures, per type family, the share of the **MEOS public C API** that the facade exposes and that JMEOS binds. + +**Headline.** The facade exposes **2156 of 2156 public MEOS functions (100.0%)**. The MEOS public surface (`meos/include/meos*.h`, excluding internal headers) is 2156 functions; JMEOS binds 2156 of them. 0 bindable functions are not exposed (listed in §3). + +Coverage is **static**: a function counts as covered when the facade declares a method of the same name and arity that delegates to a JMEOS export. + +Per-family runtime behaviour is asserted by `src/test/java/org/mobilitydb/flink/meos/MeosFacadeSmokeTest.java`, which constructs and reads back a value in the core, geo, cbuffer, npoint and pose families through the facade against libmeos. The cbuffer, npoint and pose families require a libmeos built with the extended modules (`-DCBUFFER=ON -DNPOINT=ON -DPOSE=ON -DRGEO=ON`); the stock library carries the core and geo surfaces only. + +## 1. Reference surface and method + +- **Denominator**: distinct function names declared `extern` in the MEOS public headers `meos.h`, `meos_geo.h`, `meos_cbuffer.h`, `meos_npoint.h`, `meos_pose.h`, `meos_rgeo.h`. Internal headers (`meos_internal*.h`) are excluded. + +- **Numerator**: `public static` methods on the generated `MeosOps*` facade whose name is also a `functions.GeneratedFunctions` export in the bundled JMEOS jar. + +- **JMEOS jar**: jar/JMEOS.jar exports 2699 static methods. + +## 2. Per-family coverage of the public MEOS surface + +| Family (header) | Public ∩ JMEOS | Exposed | Missing | Coverage | +|---|---:|---:|---:|---:| +| core temporal / set / span / spanset / tbox (`meos.h`) | 1279 | 1279 | 0 | 100.0% | +| geo (tgeo / tpoint / stbox) (`meos_geo.h`) | 417 | 417 | 0 | 100.0% | +| cbuffer (`meos_cbuffer.h`) | 173 | 173 | 0 | 100.0% | +| npoint (`meos_npoint.h`) | 118 | 118 | 0 | 100.0% | +| pose (`meos_pose.h`) | 101 | 101 | 0 | 100.0% | +| rgeo (`meos_rgeo.h`) | 68 | 68 | 0 | 100.0% | +| **total** | **2156** | **2156** | **0** | **100.0%** | + +## 3. Bindable MEOS functions not exposed by the facade + +0 functions are present in the public MEOS headers and bound by JMEOS but not generated into the facade: + + +## 4. MobilityDB SQL-surface cross-check + +For comparability with the SQL-surface bindings, the facade is also matched against the underlying MEOS C symbol of each addressable `CREATE FUNCTION` in `mobilitydb/sql/**/*.in.sql` (PG-only sections and helper symbols bucketed out; 874 out-of-scope, 113 SQL/plpgsql-composed functions with no single C symbol). The extension wrapper occasionally renames the MEOS function it calls, so this view is a lower bound. + +- Addressable distinct C symbols: **1335**; bound by JMEOS: **1065**; exposed by the facade: **939** (88.2% of the JMEOS-bindable SQL surface). + diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsParityGaps.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsParityGaps.java new file mode 100644 index 0000000..34a9d7b --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsParityGaps.java @@ -0,0 +1,454 @@ +package org.mobilitydb.flink.meos; + +/** + * Forwarding facade methods for MEOS public-surface functions not emitted + * by the tier-aware code generator. Each method delegates to its JMEOS + * {@code functions.GeneratedFunctions} export under the shared + * {@link MeosOpsRuntime#MEOS_AVAILABLE} guard. + */ +public final class MeosOpsParityGaps { + + private MeosOpsParityGaps() { /* utility */ } + + /** MEOS {@code bearing_tpoint_point} — meos_geo.h · scalar / stateless. */ + public static jnr.ffi.Pointer bearing_tpoint_point(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, int arg2) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("bearing_tpoint_point requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.bearing_tpoint_point(arg0, arg1, arg2); + } + + /** MEOS {@code bearing_tpoint_tpoint} — meos_geo.h · scalar / stateless. */ + public static jnr.ffi.Pointer bearing_tpoint_tpoint(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("bearing_tpoint_tpoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.bearing_tpoint_tpoint(arg0, arg1); + } + + /** MEOS {@code geogpoint_make2d} — meos_geo.h · scalar / stateless. */ + public static jnr.ffi.Pointer geogpoint_make2d(int arg0, double arg1, double arg2) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("geogpoint_make2d requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.geogpoint_make2d(arg0, arg1, arg2); + } + + /** MEOS {@code geogpoint_make3dz} — meos_geo.h · scalar / stateless. */ + public static jnr.ffi.Pointer geogpoint_make3dz(int arg0, double arg1, double arg2, double arg3) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("geogpoint_make3dz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.geogpoint_make3dz(arg0, arg1, arg2, arg3); + } + + /** MEOS {@code geomeas_to_tpoint} — meos_geo.h · scalar / stateless. */ + public static jnr.ffi.Pointer geomeas_to_tpoint(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("geomeas_to_tpoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.geomeas_to_tpoint(arg0); + } + + /** MEOS {@code geompoint_make2d} — meos_geo.h · scalar / stateless. */ + public static jnr.ffi.Pointer geompoint_make2d(int arg0, double arg1, double arg2) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("geompoint_make2d requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.geompoint_make2d(arg0, arg1, arg2); + } + + /** MEOS {@code geompoint_make3dz} — meos_geo.h · scalar / stateless. */ + public static jnr.ffi.Pointer geompoint_make3dz(int arg0, double arg1, double arg2, double arg3) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("geompoint_make3dz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.geompoint_make3dz(arg0, arg1, arg2, arg3); + } + + /** MEOS {@code geompoint_to_npoint} — meos_npoint.h · scalar / stateless. */ + public static jnr.ffi.Pointer geompoint_to_npoint(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("geompoint_to_npoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.geompoint_to_npoint(arg0); + } + + /** MEOS {@code intersection_cbuffer_set} — meos_cbuffer.h · scalar / stateless. */ + public static jnr.ffi.Pointer intersection_cbuffer_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("intersection_cbuffer_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.intersection_cbuffer_set(arg0, arg1); + } + + /** MEOS {@code intersection_npoint_set} — meos_npoint.h · scalar / stateless. */ + public static jnr.ffi.Pointer intersection_npoint_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("intersection_npoint_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.intersection_npoint_set(arg0, arg1); + } + + /** MEOS {@code intersection_pose_set} — meos_pose.h · scalar / stateless. */ + public static jnr.ffi.Pointer intersection_pose_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("intersection_pose_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.intersection_pose_set(arg0, arg1); + } + + /** MEOS {@code line_interpolate_point} — meos_geo.h · scalar / stateless. */ + public static jnr.ffi.Pointer line_interpolate_point(jnr.ffi.Pointer arg0, double arg1, int arg2) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("line_interpolate_point requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.line_interpolate_point(arg0, arg1, arg2); + } + + /** MEOS {@code line_locate_point} — meos_geo.h · scalar / stateless. */ + public static double line_locate_point(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("line_locate_point requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.line_locate_point(arg0, arg1); + } + + /** MEOS {@code line_point_n} — meos_geo.h · scalar / stateless. */ + public static jnr.ffi.Pointer line_point_n(jnr.ffi.Pointer arg0, int arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("line_point_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.line_point_n(arg0, arg1); + } + + /** MEOS {@code line_substring} — meos_geo.h · scalar / stateless. */ + public static jnr.ffi.Pointer line_substring(jnr.ffi.Pointer arg0, double arg1, double arg2) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("line_substring requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.line_substring(arg0, arg1, arg2); + } + + /** MEOS {@code mult_float_tfloat} — meos.h · scalar / stateless. */ + public static jnr.ffi.Pointer mult_float_tfloat(double arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("mult_float_tfloat requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.mult_float_tfloat(arg0, arg1); + } + + /** MEOS {@code mult_int_tint} — meos.h · scalar / stateless. */ + public static jnr.ffi.Pointer mult_int_tint(int arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("mult_int_tint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.mult_int_tint(arg0, arg1); + } + + /** MEOS {@code mult_tfloat_float} — meos.h · scalar / stateless. */ + public static jnr.ffi.Pointer mult_tfloat_float(jnr.ffi.Pointer arg0, double arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("mult_tfloat_float requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.mult_tfloat_float(arg0, arg1); + } + + /** MEOS {@code mult_tint_int} — meos.h · scalar / stateless. */ + public static jnr.ffi.Pointer mult_tint_int(jnr.ffi.Pointer arg0, int arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("mult_tint_int requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.mult_tint_int(arg0, arg1); + } + + /** MEOS {@code mult_tnumber_tnumber} — meos.h · scalar / stateless. */ + public static jnr.ffi.Pointer mult_tnumber_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("mult_tnumber_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.mult_tnumber_tnumber(arg0, arg1); + } + + /** MEOS {@code nsegment_end_position} — meos_npoint.h · scalar / stateless. */ + public static double nsegment_end_position(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("nsegment_end_position requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.nsegment_end_position(arg0); + } + + /** MEOS {@code nsegment_start_position} — meos_npoint.h · scalar / stateless. */ + public static double nsegment_start_position(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("nsegment_start_position requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.nsegment_start_position(arg0); + } + + /** MEOS {@code route_geom} — meos_npoint.h · scalar / stateless. */ + public static jnr.ffi.Pointer route_geom(int arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("route_geom requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.route_geom(arg0); + } + + /** MEOS {@code spatialset_set_srid} — meos_geo.h · scalar / stateless. */ + public static jnr.ffi.Pointer spatialset_set_srid(jnr.ffi.Pointer arg0, int arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("spatialset_set_srid requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.spatialset_set_srid(arg0, arg1); + } + + /** MEOS {@code spatialset_transform} — meos_geo.h · scalar / stateless. */ + public static jnr.ffi.Pointer spatialset_transform(jnr.ffi.Pointer arg0, int arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("spatialset_transform requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.spatialset_transform(arg0, arg1); + } + + /** MEOS {@code spatialset_transform_pipeline} — meos_geo.h · scalar / stateless. */ + public static jnr.ffi.Pointer spatialset_transform_pipeline(jnr.ffi.Pointer arg0, java.lang.String arg1, int arg2, int arg3) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("spatialset_transform_pipeline requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.spatialset_transform_pipeline(arg0, arg1, arg2, arg3); + } + + /** MEOS {@code tand_bool_tbool} — meos.h · scalar / stateless. */ + public static jnr.ffi.Pointer tand_bool_tbool(int arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tand_bool_tbool requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tand_bool_tbool(arg0, arg1); + } + + /** MEOS {@code tand_tbool_bool} — meos.h · scalar / stateless. */ + public static jnr.ffi.Pointer tand_tbool_bool(jnr.ffi.Pointer arg0, int arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tand_tbool_bool requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tand_tbool_bool(arg0, arg1); + } + + /** MEOS {@code tand_tbool_tbool} — meos.h · scalar / stateless. */ + public static jnr.ffi.Pointer tand_tbool_tbool(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tand_tbool_tbool requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tand_tbool_tbool(arg0, arg1); + } + + /** MEOS {@code tboolseq_from_base_tstzset} — meos.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer tboolseq_from_base_tstzset(int arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tboolseq_from_base_tstzset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tboolseq_from_base_tstzset(arg0, arg1); + } + + /** MEOS {@code tboolseq_from_base_tstzspan} — meos.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer tboolseq_from_base_tstzspan(int arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tboolseq_from_base_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tboolseq_from_base_tstzspan(arg0, arg1); + } + + /** MEOS {@code tboolseqset_from_base_tstzspanset} — meos.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer tboolseqset_from_base_tstzspanset(int arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tboolseqset_from_base_tstzspanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tboolseqset_from_base_tstzspanset(arg0, arg1); + } + + /** MEOS {@code tfloatbox_time_tiles} — meos.h · multidimensional tiling (windowed). */ + public static jnr.ffi.Pointer tfloatbox_time_tiles(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, int arg2, jnr.ffi.Pointer arg3) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tfloatbox_time_tiles requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tfloatbox_time_tiles(arg0, arg1, arg2, arg3); + } + + /** MEOS {@code tfloatbox_value_tiles} — meos.h · multidimensional tiling (windowed). */ + public static jnr.ffi.Pointer tfloatbox_value_tiles(jnr.ffi.Pointer arg0, double arg1, double arg2, jnr.ffi.Pointer arg3) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tfloatbox_value_tiles requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tfloatbox_value_tiles(arg0, arg1, arg2, arg3); + } + + /** MEOS {@code tfloatbox_value_time_tiles} — meos.h · multidimensional tiling (windowed). */ + public static jnr.ffi.Pointer tfloatbox_value_time_tiles(jnr.ffi.Pointer arg0, double arg1, jnr.ffi.Pointer arg2, double arg3, int arg4, jnr.ffi.Pointer arg5) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tfloatbox_value_time_tiles requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tfloatbox_value_time_tiles(arg0, arg1, arg2, arg3, arg4, arg5); + } + + /** MEOS {@code tfloatseq_from_base_tstzset} — meos.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer tfloatseq_from_base_tstzset(double arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tfloatseq_from_base_tstzset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tfloatseq_from_base_tstzset(arg0, arg1); + } + + /** MEOS {@code tfloatseq_from_base_tstzspan} — meos.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer tfloatseq_from_base_tstzspan(double arg0, jnr.ffi.Pointer arg1, int arg2) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tfloatseq_from_base_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tfloatseq_from_base_tstzspan(arg0, arg1, arg2); + } + + /** MEOS {@code tfloatseqset_from_base_tstzspanset} — meos.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer tfloatseqset_from_base_tstzspanset(double arg0, jnr.ffi.Pointer arg1, int arg2) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tfloatseqset_from_base_tstzspanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tfloatseqset_from_base_tstzspanset(arg0, arg1, arg2); + } + + /** MEOS {@code tgeoseq_from_base_tstzset} — meos_geo.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer tgeoseq_from_base_tstzset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tgeoseq_from_base_tstzset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tgeoseq_from_base_tstzset(arg0, arg1); + } + + /** MEOS {@code tgeoseq_from_base_tstzspan} — meos_geo.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer tgeoseq_from_base_tstzspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, int arg2) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tgeoseq_from_base_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tgeoseq_from_base_tstzspan(arg0, arg1, arg2); + } + + /** MEOS {@code tgeoseqset_from_base_tstzspanset} — meos_geo.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer tgeoseqset_from_base_tstzspanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, int arg2) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tgeoseqset_from_base_tstzspanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tgeoseqset_from_base_tstzspanset(arg0, arg1, arg2); + } + + /** MEOS {@code tintbox_time_tiles} — meos.h · multidimensional tiling (windowed). */ + public static jnr.ffi.Pointer tintbox_time_tiles(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, int arg2, jnr.ffi.Pointer arg3) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tintbox_time_tiles requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tintbox_time_tiles(arg0, arg1, arg2, arg3); + } + + /** MEOS {@code tintbox_value_tiles} — meos.h · multidimensional tiling (windowed). */ + public static jnr.ffi.Pointer tintbox_value_tiles(jnr.ffi.Pointer arg0, int arg1, int arg2, jnr.ffi.Pointer arg3) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tintbox_value_tiles requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tintbox_value_tiles(arg0, arg1, arg2, arg3); + } + + /** MEOS {@code tintbox_value_time_tiles} — meos.h · multidimensional tiling (windowed). */ + public static jnr.ffi.Pointer tintbox_value_time_tiles(jnr.ffi.Pointer arg0, int arg1, jnr.ffi.Pointer arg2, int arg3, int arg4, jnr.ffi.Pointer arg5) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tintbox_value_time_tiles requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tintbox_value_time_tiles(arg0, arg1, arg2, arg3, arg4, arg5); + } + + /** MEOS {@code tintseq_from_base_tstzset} — meos.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer tintseq_from_base_tstzset(int arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tintseq_from_base_tstzset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tintseq_from_base_tstzset(arg0, arg1); + } + + /** MEOS {@code tintseq_from_base_tstzspan} — meos.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer tintseq_from_base_tstzspan(int arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tintseq_from_base_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tintseq_from_base_tstzspan(arg0, arg1); + } + + /** MEOS {@code tintseqset_from_base_tstzspanset} — meos.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer tintseqset_from_base_tstzspanset(int arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tintseqset_from_base_tstzspanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tintseqset_from_base_tstzspanset(arg0, arg1); + } + + /** MEOS {@code tnot_tbool} — meos.h · scalar / stateless. */ + public static jnr.ffi.Pointer tnot_tbool(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tnot_tbool requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tnot_tbool(arg0); + } + + /** MEOS {@code tor_bool_tbool} — meos.h · scalar / stateless. */ + public static jnr.ffi.Pointer tor_bool_tbool(int arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tor_bool_tbool requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tor_bool_tbool(arg0, arg1); + } + + /** MEOS {@code tor_tbool_bool} — meos.h · scalar / stateless. */ + public static jnr.ffi.Pointer tor_tbool_bool(jnr.ffi.Pointer arg0, int arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tor_tbool_bool requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tor_tbool_bool(arg0, arg1); + } + + /** MEOS {@code tor_tbool_tbool} — meos.h · scalar / stateless. */ + public static jnr.ffi.Pointer tor_tbool_tbool(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tor_tbool_tbool requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tor_tbool_tbool(arg0, arg1); + } + + /** MEOS {@code tpointseq_from_base_tstzset} — meos_geo.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer tpointseq_from_base_tstzset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tpointseq_from_base_tstzset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tpointseq_from_base_tstzset(arg0, arg1); + } + + /** MEOS {@code tpointseq_from_base_tstzspan} — meos_geo.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer tpointseq_from_base_tstzspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, int arg2) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tpointseq_from_base_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tpointseq_from_base_tstzspan(arg0, arg1, arg2); + } + + /** MEOS {@code tpointseq_make_coords} — meos_geo.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer tpointseq_make_coords(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, jnr.ffi.Pointer arg2, jnr.ffi.Pointer arg3, int arg4, int arg5, int arg6, int arg7, int arg8, int arg9, int arg10) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tpointseq_make_coords requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tpointseq_make_coords(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10); + } + + /** MEOS {@code tpointseqset_from_base_tstzspanset} — meos_geo.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer tpointseqset_from_base_tstzspanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, int arg2) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tpointseqset_from_base_tstzspanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tpointseqset_from_base_tstzspanset(arg0, arg1, arg2); + } + + /** MEOS {@code tsequence_make} — meos.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer tsequence_make(jnr.ffi.Pointer arg0, int arg1, int arg2, int arg3, int arg4, int arg5) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tsequence_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tsequence_make(arg0, arg1, arg2, arg3, arg4, arg5); + } + + /** MEOS {@code tsequenceset_make} — meos.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer tsequenceset_make(jnr.ffi.Pointer arg0, int arg1, int arg2) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tsequenceset_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tsequenceset_make(arg0, arg1, arg2); + } + + /** MEOS {@code ttextseq_from_base_tstzset} — meos.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer ttextseq_from_base_tstzset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("ttextseq_from_base_tstzset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.ttextseq_from_base_tstzset(arg0, arg1); + } + + /** MEOS {@code ttextseq_from_base_tstzspan} — meos.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer ttextseq_from_base_tstzspan(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("ttextseq_from_base_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.ttextseq_from_base_tstzspan(arg0, arg1); + } + + /** MEOS {@code ttextseqset_from_base_tstzspanset} — meos.h · whole-sequence constructor — not a per-event op. */ + public static jnr.ffi.Pointer ttextseqset_from_base_tstzspanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("ttextseqset_from_base_tstzspanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.ttextseqset_from_base_tstzspanset(arg0, arg1); + } + + /** MEOS {@code union_cbuffer_set} — meos_cbuffer.h · scalar / stateless. */ + public static jnr.ffi.Pointer union_cbuffer_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("union_cbuffer_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.union_cbuffer_set(arg0, arg1); + } + + /** MEOS {@code union_npoint_set} — meos_npoint.h · scalar / stateless. */ + public static jnr.ffi.Pointer union_npoint_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("union_npoint_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.union_npoint_set(arg0, arg1); + } + + /** MEOS {@code union_pose_set} — meos_pose.h · scalar / stateless. */ + public static jnr.ffi.Pointer union_pose_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("union_pose_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.union_pose_set(arg0, arg1); + } + +} diff --git a/flink-processor/src/test/java/org/mobilitydb/flink/meos/MeosFacadeSmokeTest.java b/flink-processor/src/test/java/org/mobilitydb/flink/meos/MeosFacadeSmokeTest.java new file mode 100644 index 0000000..93165d7 --- /dev/null +++ b/flink-processor/src/test/java/org/mobilitydb/flink/meos/MeosFacadeSmokeTest.java @@ -0,0 +1,79 @@ +package org.mobilitydb.flink.meos; + +import functions.GeneratedFunctions; +import jnr.ffi.Pointer; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.condition.EnabledIfSystemProperty; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * Per-family runtime check that the generated MEOS facade calls into libmeos and + * returns correct results. Each family constructs a value through a {@code MeosOps*} + * facade method and reads it back. Runs only with {@code -Dmobilityflink.meos.enabled=true} + * and a libmeos on the load path; the extended families (cbuffer, npoint, pose) require a + * libmeos built with {@code -DCBUFFER=ON -DNPOINT=ON -DPOSE=ON -DRGEO=ON}. + */ +@EnabledIfSystemProperty(named = "mobilityflink.meos.enabled", matches = "true") +class MeosFacadeSmokeTest { + + @BeforeAll + static void init() { + // No-op error handler so a parse error returns rather than terminating the JVM. + GeneratedFunctions.meos_initialize_error_handler((level, code, message) -> { }); + GeneratedFunctions.meos_initialize(); + } + + @AfterAll + static void finalizeMeos() { + GeneratedFunctions.meos_finalize(); + } + + @Test + void coreTbox() { + Pointer tbox = MeosOpsTBox.tbox_in("TBOX X([1, 2])"); + assertNotNull(tbox); + assertTrue(MeosOpsTBox.tbox_out(tbox, 6).contains("TBOX")); + } + + @Test + void geoStbox() { + Pointer stbox = MeosOpsSTBox.stbox_in("STBOX X((1,1),(2,2))"); + assertNotNull(stbox); + assertTrue(MeosOpsSTBox.stbox_out(stbox, 6).contains("STBOX")); + } + + @Test + void geoGeometry() { + Pointer geom = MeosOpsFreeGeo.geom_in("POINT(1 1)", 0); + assertNotNull(geom); + assertTrue(MeosOpsFreeGeo.geo_as_text(geom, 6).toUpperCase().contains("POINT")); + } + + @Test + void cbuffer() { + Pointer cb = MeosOpsFreeCbuffer.cbuffer_make(MeosOpsFreeGeo.geom_in("POINT(1 1)", 0), 0.5); + assertNotNull(cb); + assertEquals(0.5, MeosOpsFreeCbuffer.cbuffer_radius(cb), 1e-9); + assertNotNull(MeosOpsFreeCbuffer.cbuffer_out(cb, 6)); + } + + @Test + void npoint() { + Pointer np = MeosOpsFreeNpoint.npoint_make(1, 0.5); + assertNotNull(np); + assertEquals(1, MeosOpsFreeNpoint.npoint_route(np)); + assertEquals(0.5, MeosOpsFreeNpoint.npoint_position(np), 1e-9); + } + + @Test + void pose() { + Pointer pose = MeosOpsFreePose.pose_in("Pose(Point(1 1), 0.5)"); + assertNotNull(pose); + assertNotNull(MeosOpsFreePose.pose_out(pose, 6)); + } +} diff --git a/flink-processor/tools/parity/emit_gap_methods.py b/flink-processor/tools/parity/emit_gap_methods.py new file mode 100644 index 0000000..ef895a5 --- /dev/null +++ b/flink-processor/tools/parity/emit_gap_methods.py @@ -0,0 +1,89 @@ +#!/usr/bin/env python3 +"""Emit forwarding facade methods for MEOS public-surface functions that the +generated MeosOps* facade does not yet expose. + +Each method forwards to its `functions.GeneratedFunctions` export using the +exact JMEOS signature (captured via `javap`), so the output compiles by +construction. Family and nature (scalar / sequence-constructor / tiling) are +recorded in the Javadoc; the wiring tier is governed by the wirings layer, not +by the presence of the forwarder. + +Run from flink-processor/: + javap -classpath jar/JMEOS.jar -p functions.GeneratedFunctions > /tmp/gen_sigs.txt + python3 tools/parity/emit_gap_methods.py /tmp/gen_sigs.txt +""" +import re, os, sys, glob + +HERE = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +INC = "/home/esteban/src/MobilityDB/meos/include" +PUBLIC_HEADERS = ["meos.h", "meos_geo.h", "meos_cbuffer.h", "meos_npoint.h", "meos_pose.h", "meos_rgeo.h"] +FACADE = os.path.join(HERE, "src/main/java/org/mobilitydb/flink/meos") +OUT = os.path.join(FACADE, "MeosOpsParityGaps.java") + +_DECL = re.compile(r'^\s*extern\s+.+?\b([a-z][A-Za-z0-9_]*)\s*\(', re.M) +_PUBSTATIC = re.compile(r'public static [A-Za-z0-9_.<>\[\]]+ ([a-z0-9_]+)\(') +_SIG = re.compile(r'public static (\S+) (\w+)\(([^)]*)\);') + + +def family(name, fam): + return fam.get(name, "meos.h") + + +def nature(name): + if name.endswith("_make") or "_from_base_" in name or name.endswith("make_coords"): + return "whole-sequence constructor — not a per-event op" + if name.endswith("_tiles"): + return "multidimensional tiling (windowed)" + return "scalar / stateless" + + +def main(): + sigfile = sys.argv[1] if len(sys.argv) > 1 else "/tmp/parity/gen_sigs.txt" + fam, pub = {}, set() + for h in PUBLIC_HEADERS: + for n in set(_DECL.findall(open(os.path.join(INC, h)).read())): + pub.add(n); fam.setdefault(n, h) + facade = set() + for f in glob.glob(os.path.join(FACADE, "MeosOps*.java")): + facade |= set(_PUBSTATIC.findall(open(f).read())) + # all JMEOS signatures, grouped by name + sigs = {} + for line in open(sigfile): + m = _SIG.search(line) + if m: + ret, name, args = m.group(1), m.group(2), m.group(3).strip() + sigs.setdefault(name, []).append((ret, args)) + missing = sorted(n for n in (pub & set(sigs)) - facade) + + L = ["package org.mobilitydb.flink.meos;", "", + "/**", " * Forwarding facade methods for MEOS public-surface functions not emitted", + " * by the tier-aware code generator. Each method delegates to its JMEOS", + " * {@code functions.GeneratedFunctions} export under the shared", + " * {@link MeosOpsRuntime#MEOS_AVAILABLE} guard.", + " */", + "public final class MeosOpsParityGaps {", "", + " private MeosOpsParityGaps() { /* utility */ }", ""] + count = 0 + for name in missing: + for ret, args in sigs[name]: + params = [a.strip() for a in args.split(",")] if args else [] + decl = ", ".join(f"{t} arg{i}" for i, t in enumerate(params)) + call = ", ".join(f"arg{i}" for i in range(len(params))) + ret_kw = "" if ret == "void" else "return " + L += [f" /** MEOS {{@code {name}}} — {family(name, fam)} · {nature(name)}. */", + f" public static {ret} {name}({decl}) {{", + f" if (!MeosOpsRuntime.MEOS_AVAILABLE)", + f' throw new UnsupportedOperationException("{name} requires libmeos' + f' — set -Dmobilityflink.meos.enabled=true");', + f" {ret_kw}functions.GeneratedFunctions.{name}({call});", + " }", ""] + count += 1 + L.append("}") + open(OUT, "w").write("\n".join(L) + "\n") + print(f"missing public-surface functions: {len(missing)}") + print(f"forwarding methods emitted: {count}") + print(f"wrote {OUT}") + + +if __name__ == "__main__": + main() diff --git a/flink-processor/tools/parity/parity_audit.py b/flink-processor/tools/parity/parity_audit.py new file mode 100644 index 0000000..7548738 --- /dev/null +++ b/flink-processor/tools/parity/parity_audit.py @@ -0,0 +1,194 @@ +#!/usr/bin/env python3 +"""Symbol-level parity audit for the MobilityFlink generated MEOS facade. + +Measures, per type family, how much of the MEOS public-header function surface +the generated facade (org.mobilitydb.flink.meos.MeosOps*) exposes, cross-checked +against the JMEOS jar export set so a method only counts when it is genuinely +bindable. + +Reference surface = the MEOS public C API (meos/include/meos*.h, excluding the +meos_internal*.h headers). This is the surface JMEOS mirrors and the facade +delegates to, so it is the exact denominator for a Flink binding. A second view +maps the facade against the MobilityDB SQL layer's underlying C symbols for +comparability with the SQL-surface bindings. + +Coverage reported here is STATIC: the facade method exists and binds a JMEOS +symbol of matching arity. Runtime behaviour is exercised separately by the +per-family smoke tests. + +Usage: + python3 tools/parity/parity_audit.py \ + --meos-include /path/to/MobilityDB/meos/include \ + --jar jar/JMEOS.jar \ + --facade src/main/java/org/mobilitydb/flink/meos \ + --mdb-sql /path/to/MobilityDB/mobilitydb/sql \ + --out docs/parity-status.md +""" +import argparse, re, os, glob, subprocess, collections +from datetime import date + +PUBLIC_HEADERS = ["meos.h", "meos_geo.h", "meos_cbuffer.h", + "meos_npoint.h", "meos_pose.h", "meos_rgeo.h"] +FAMILY = {"meos.h": "core temporal / set / span / spanset / tbox", + "meos_geo.h": "geo (tgeo / tpoint / stbox)", + "meos_cbuffer.h": "cbuffer", "meos_npoint.h": "npoint", + "meos_pose.h": "pose", "meos_rgeo.h": "rgeo"} + +_DECL = re.compile(r'^\s*extern\s+.+?\b([a-z][A-Za-z0-9_]*)\s*\(', re.M) +_PUBSTATIC = re.compile(r'public static [A-Za-z0-9_.<>\[\]]+ ([a-z0-9_]+)\(') + +# MobilityDB SQL out-of-scope bucketing (PG-only; no MEOS/Flink equivalent). +OOS_SECTIONS = { + "temporal/011_span_indexes.in.sql", "temporal/012_spanset_indexes.in.sql", + "temporal/013_set_indexes.in.sql", "temporal/019_geo_constructors.in.sql", + "temporal/043_temporal_gist.in.sql", "temporal/044_temporal_spgist.in.sql", + "temporal/999_oid_cache.in.sql", "geo/073_tgeo_gist.in.sql", + "geo/073_tpoint_gist.in.sql", "geo/074_tgeo_spgist.in.sql", + "geo/074_tpoint_spgist.in.sql", "cbuffer/166_tcbuffer_indexes.in.sql", + "npoint/092_tnpoint_gin.in.sql", "npoint/098_tnpoint_indexes.in.sql", + "pose/114_tpose_indexes.in.sql", "rgeo/134_trgeo_indexes.in.sql", +} +OOS_SUFFIXES = ("_in", "_out", "_recv", "_send", "_typmod_in", "_typmod_out", + "_transfn", "_combinefn", "_finalfn", "_serialize", "_deserialize", + "_sel", "_joinsel", "_supportfn", "_analyze", + "_cmp", "_eq", "_ne", "_lt", "_le", "_gt", "_ge", "_hash", "_hash_extended") +OOS_NAMES = {"range", "multirange", "create_trip", "transform_gk"} + + +def jmeos_symbols(jar): + out = subprocess.run(["javap", "-classpath", jar, "-p", + "functions.GeneratedFunctions"], + capture_output=True, text=True).stdout + return set(re.findall(r'\b([a-z][a-z0-9_]+)\(', out)) + + +def facade_methods(d): + syms = set() + for f in glob.glob(os.path.join(d, "MeosOps*.java")): + syms |= set(_PUBSTATIC.findall(open(f).read())) + return syms + + +def public_surface(inc): + fam, allpub = {}, set() + for h in PUBLIC_HEADERS: + names = set(_DECL.findall(open(os.path.join(inc, h)).read())) + for n in names: + allpub.add(n); fam.setdefault(n, h) + return allpub, fam + + +def sql_csymbols(root): + create = re.compile(r'CREATE\s+(?:OR\s+REPLACE\s+)?FUNCTION\s+([A-Za-z0-9_]+)\s*\(', re.I) + csym = re.compile(r"AS\s+'[^']*'\s*,\s*'([A-Za-z0-9_]+)'", re.I) + langsql = re.compile(r"LANGUAGE\s+'?(?:sql|plpgsql)'?", re.I) + addressable, oos, sqlc = set(), 0, 0 + for path in glob.glob(os.path.join(root, "**", "*.in.sql"), recursive=True): + section = os.path.relpath(path, root).replace(os.sep, "/") + txt = open(path, encoding="utf-8", errors="replace").read() + for m in create.finditer(txt): + name = m.group(1); tail = txt[m.end():m.end() + 1200].split(';')[0] + cm = csym.search(tail); sym = cm.group(1) if cm else None + key = (sym or name).lower() + if section in OOS_SECTIONS or key in OOS_NAMES or key.endswith(OOS_SUFFIXES): + oos += 1; continue + if sym is None: + sqlc += 1; continue + addressable.add(sym.lower()) + return addressable, oos, sqlc + + +def main(): + ap = argparse.ArgumentParser() + here = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + ap.add_argument("--meos-include", default="/home/esteban/src/MobilityDB/meos/include") + ap.add_argument("--jar", default=os.path.join(here, "jar", "JMEOS.jar")) + ap.add_argument("--facade", default=os.path.join(here, "src/main/java/org/mobilitydb/flink/meos")) + ap.add_argument("--mdb-sql", default="/home/esteban/src/MobilityDB/mobilitydb/sql") + ap.add_argument("--out", default=os.path.join(here, "docs", "parity-status.md")) + a = ap.parse_args() + + jm = jmeos_symbols(a.jar) + fa = facade_methods(a.facade) & jm + pub, fam = public_surface(a.meos_include) + bindable = pub & jm + covered = bindable & fa + missing = sorted(bindable - fa) + + bc, cc = collections.Counter(), collections.Counter() + for n in bindable: + bc[fam[n]] += 1 + if n in covered: + cc[fam[n]] += 1 + + addr, oos, sqlc = sql_csymbols(a.mdb_sql) + sql_cov = len(addr & fa); sql_bindable = len(addr & jm) + + pct = lambda c, t: (100.0 * c / t) if t else 0.0 + L = [] + L.append("# MobilityFlink parity status — MEOS surface audit\n") + L.append(f"Generated {date.today().isoformat()} by `tools/parity/parity_audit.py`.\n") + L.append("The MobilityFlink MEOS facade (`org.mobilitydb.flink.meos.MeosOps*`) exposes " + "MEOS C functions to Flink through JMEOS. This audit measures, per type family, " + "the share of the **MEOS public C API** that the facade exposes and that JMEOS binds.\n") + L.append(f"**Headline.** The facade exposes **{len(covered)} of {len(bindable)} " + f"public MEOS functions ({pct(len(covered), len(bindable)):.1f}%)**. " + f"The MEOS public surface (`meos/include/meos*.h`, excluding internal headers) is " + f"{len(pub)} functions; JMEOS binds {len(bindable)} of them. " + f"{len(missing)} bindable functions are not exposed (listed in §3).\n") + L.append("Coverage is **static**: a function counts as covered when the facade declares a " + "method of the same name and arity that delegates to a JMEOS export.\n") + L.append("Per-family runtime behaviour is asserted by " + "`src/test/java/org/mobilitydb/flink/meos/MeosFacadeSmokeTest.java`, which constructs " + "and reads back a value in the core, geo, cbuffer, npoint and pose families through the " + "facade against libmeos. The cbuffer, npoint and pose families require a libmeos built " + "with the extended modules (`-DCBUFFER=ON -DNPOINT=ON -DPOSE=ON -DRGEO=ON`); the stock " + "library carries the core and geo surfaces only.\n") + L.append("## 1. Reference surface and method\n") + L.append("- **Denominator**: distinct function names declared `extern` in the MEOS public " + "headers `meos.h`, `meos_geo.h`, `meos_cbuffer.h`, `meos_npoint.h`, `meos_pose.h`, " + "`meos_rgeo.h`. Internal headers (`meos_internal*.h`) are excluded.\n") + L.append("- **Numerator**: `public static` methods on the generated `MeosOps*` facade whose " + "name is also a `functions.GeneratedFunctions` export in the bundled JMEOS jar.\n") + L.append(f"- **JMEOS jar**: {os.path.relpath(a.jar, here)} exports {len(jm)} static methods.\n") + L.append("## 2. Per-family coverage of the public MEOS surface\n") + L.append("| Family (header) | Public ∩ JMEOS | Exposed | Missing | Coverage |") + L.append("|---|---:|---:|---:|---:|") + for h in PUBLIC_HEADERS: + b, c = bc[h], cc[h] + L.append(f"| {FAMILY[h]} (`{h}`) | {b} | {c} | {b - c} | {pct(c, b):.1f}% |") + L.append(f"| **total** | **{len(bindable)}** | **{len(covered)}** | " + f"**{len(bindable) - len(covered)}** | **{pct(len(covered), len(bindable)):.1f}%** |\n") + L.append("## 3. Bindable MEOS functions not exposed by the facade\n") + L.append(f"{len(missing)} functions are present in the public MEOS headers and bound by " + "JMEOS but not generated into the facade:\n") + for h in PUBLIC_HEADERS: + ms = [n for n in missing if fam[n] == h] + if ms: + L.append(f"- **`{h}`** ({len(ms)}): " + ", ".join(f"`{n}`" for n in ms)) + L.append("") + L.append("## 4. MobilityDB SQL-surface cross-check\n") + L.append("For comparability with the SQL-surface bindings, the facade is also matched " + "against the underlying MEOS C symbol of each addressable `CREATE FUNCTION` in " + "`mobilitydb/sql/**/*.in.sql` (PG-only sections and helper symbols bucketed out; " + f"{oos} out-of-scope, {sqlc} SQL/plpgsql-composed functions with no single C symbol). " + "The extension wrapper occasionally renames the MEOS function it calls, so this view " + "is a lower bound.\n") + L.append(f"- Addressable distinct C symbols: **{len(addr)}**; bound by JMEOS: **{sql_bindable}**; " + f"exposed by the facade: **{sql_cov}** " + f"({pct(sql_cov, sql_bindable):.1f}% of the JMEOS-bindable SQL surface).\n") + + md = "\n".join(L) + "\n" + os.makedirs(os.path.dirname(a.out), exist_ok=True) + open(a.out, "w").write(md) + + print(f"public MEOS surface: {len(pub)}") + print(f" bound by JMEOS: {len(bindable)}") + print(f" exposed by facade: {len(covered)} ({pct(len(covered), len(bindable)):.1f}%)") + print(f" missing (bindable): {len(missing)}") + print(f"SQL addressable C-symbols: {len(addr)} (bindable {sql_bindable}, exposed {sql_cov})") + print(f"wrote {a.out}") + + +if __name__ == "__main__": + main() From df5c8707671e7935dfbee54703792d42e6b5d3d1 Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Thu, 28 May 2026 02:21:26 +0200 Subject: [PATCH 10/13] test(parity): resolve facade methods against libmeos and broaden the smoke Add a --libmeos resolution check to parity_audit.py that confirms every MeosOps* facade method resolves to an exported symbol in a built libmeos and records it as section 5 of parity-status.md, and broaden MeosFacadeSmokeTest with an integer-span roundtrip and a pose-rotation assertion. (cherry picked from commit f1325be2f2299f59a610a444590b4e30d302034d) --- flink-processor/docs/parity-status.md | 13 ++++++++++ .../flink/meos/MeosFacadeSmokeTest.java | 9 +++++++ flink-processor/tools/parity/parity_audit.py | 26 ++++++++++++++++++- 3 files changed, 47 insertions(+), 1 deletion(-) diff --git a/flink-processor/docs/parity-status.md b/flink-processor/docs/parity-status.md index bf2650e..ffe002e 100644 --- a/flink-processor/docs/parity-status.md +++ b/flink-processor/docs/parity-status.md @@ -41,3 +41,16 @@ For comparability with the SQL-surface bindings, the facade is also matched agai - Addressable distinct C symbols: **1335**; bound by JMEOS: **1065**; exposed by the facade: **939** (88.2% of the JMEOS-bindable SQL surface). +## 5. Runtime symbol resolution + +Every facade method delegates to a libmeos symbol of the same name. Against a libmeos built with the extended modules (`-DCBUFFER=ON -DNPOINT=ON -DPOSE=ON -DRGEO=ON`), **2152 of 2160** facade methods resolve to an exported symbol. The following require a libmeos built from current MEOS sources: + +- `geog_from_binary` +- `nad_stbox_trgeo` +- `tcbuffer_from_mfjson` +- `tfloat_avg_value` +- `tnpoint_from_mfjson` +- `trgeo_points` +- `trgeo_rotation` +- `trgeo_segments` + diff --git a/flink-processor/src/test/java/org/mobilitydb/flink/meos/MeosFacadeSmokeTest.java b/flink-processor/src/test/java/org/mobilitydb/flink/meos/MeosFacadeSmokeTest.java index 93165d7..b116f65 100644 --- a/flink-processor/src/test/java/org/mobilitydb/flink/meos/MeosFacadeSmokeTest.java +++ b/flink-processor/src/test/java/org/mobilitydb/flink/meos/MeosFacadeSmokeTest.java @@ -40,6 +40,14 @@ void coreTbox() { assertTrue(MeosOpsTBox.tbox_out(tbox, 6).contains("TBOX")); } + @Test + void coreIntspan() { + Pointer span = MeosOpsIntSpan.intspan_in("[1, 5)"); + assertNotNull(span); + String out = MeosOpsIntSpan.intspan_out(span); + assertTrue(out.contains("1") && out.contains("5")); + } + @Test void geoStbox() { Pointer stbox = MeosOpsSTBox.stbox_in("STBOX X((1,1),(2,2))"); @@ -75,5 +83,6 @@ void pose() { Pointer pose = MeosOpsFreePose.pose_in("Pose(Point(1 1), 0.5)"); assertNotNull(pose); assertNotNull(MeosOpsFreePose.pose_out(pose, 6)); + assertEquals(0.5, MeosOpsFreePose.pose_rotation(pose), 1e-9); } } diff --git a/flink-processor/tools/parity/parity_audit.py b/flink-processor/tools/parity/parity_audit.py index 7548738..5596e59 100644 --- a/flink-processor/tools/parity/parity_audit.py +++ b/flink-processor/tools/parity/parity_audit.py @@ -69,6 +69,11 @@ def facade_methods(d): return syms +def libmeos_symbols(path): + out = subprocess.run(["nm", "-D", path], capture_output=True, text=True).stdout + return {line.split()[-1] for line in out.splitlines() if line.strip()} + + def public_surface(inc): fam, allpub = {}, set() for h in PUBLIC_HEADERS: @@ -106,10 +111,14 @@ def main(): ap.add_argument("--facade", default=os.path.join(here, "src/main/java/org/mobilitydb/flink/meos")) ap.add_argument("--mdb-sql", default="/home/esteban/src/MobilityDB/mobilitydb/sql") ap.add_argument("--out", default=os.path.join(here, "docs", "parity-status.md")) + ap.add_argument("--libmeos", default=None, + help="path to a built libmeos.so; cross-checks that every facade method " + "resolves to an exported symbol (runtime resolution check)") a = ap.parse_args() jm = jmeos_symbols(a.jar) - fa = facade_methods(a.facade) & jm + fa_all = facade_methods(a.facade) + fa = fa_all & jm pub, fam = public_surface(a.meos_include) bindable = pub & jm covered = bindable & fa @@ -178,6 +187,21 @@ def main(): f"exposed by the facade: **{sql_cov}** " f"({pct(sql_cov, sql_bindable):.1f}% of the JMEOS-bindable SQL surface).\n") + if a.libmeos: + libsyms = libmeos_symbols(a.libmeos) + resolved = fa_all & libsyms + unresolved = sorted(fa_all - libsyms) + L.append("## 5. Runtime symbol resolution\n") + L.append("Every facade method delegates to a libmeos symbol of the same name. Against a " + "libmeos built with the extended modules (`-DCBUFFER=ON -DNPOINT=ON -DPOSE=ON " + "-DRGEO=ON`), " + f"**{len(resolved)} of {len(fa_all)}** facade methods resolve to an exported " + "symbol. The following require a libmeos built from current MEOS sources:\n") + L.append(("\n".join(f"- `{n}`" for n in unresolved) if unresolved + else "- (none — all facade methods resolve)") + "\n") + print(f"libmeos resolution: {len(resolved)}/{len(fa_all)} " + f"({len(unresolved)} unresolved)") + md = "\n".join(L) + "\n" os.makedirs(os.path.dirname(a.out), exist_ok=True) open(a.out, "w").write(md) From f2cab47abfe6e66c319fce1d7a0a685f2ff0e218 Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Thu, 28 May 2026 02:26:13 +0200 Subject: [PATCH 11/13] feat(parity): expose SQL-surface functions backed by internal MEOS headers Add MeosOpsSqlSurface with forwarding methods for the MEOS functions that the MobilityDB SQL layer exposes as user functions but implements through meos_internal*.h (emitted by tools/parity/emit_sql_surface.py from the exact JMEOS signatures), bringing the facade to the full JMEOS-bindable SQL surface, and record the reconciliation in parity-status.md. (cherry picked from commit fdb8315411e5998bffd8faf068bbd6da32ee5c9e) --- flink-processor/docs/parity-status.md | 8 +- .../flink/meos/MeosOpsSqlSurface.java | 897 ++++++++++++++++++ .../tools/parity/emit_sql_surface.py | 115 +++ flink-processor/tools/parity/parity_audit.py | 14 +- 4 files changed, 1025 insertions(+), 9 deletions(-) create mode 100644 flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsSqlSurface.java create mode 100644 flink-processor/tools/parity/emit_sql_surface.py diff --git a/flink-processor/docs/parity-status.md b/flink-processor/docs/parity-status.md index ffe002e..570226f 100644 --- a/flink-processor/docs/parity-status.md +++ b/flink-processor/docs/parity-status.md @@ -37,13 +37,15 @@ Per-family runtime behaviour is asserted by `src/test/java/org/mobilitydb/flink/ ## 4. MobilityDB SQL-surface cross-check -For comparability with the SQL-surface bindings, the facade is also matched against the underlying MEOS C symbol of each addressable `CREATE FUNCTION` in `mobilitydb/sql/**/*.in.sql` (PG-only sections and helper symbols bucketed out; 874 out-of-scope, 113 SQL/plpgsql-composed functions with no single C symbol). The extension wrapper occasionally renames the MEOS function it calls, so this view is a lower bound. +The facade is also matched against the underlying MEOS C symbol of each addressable `CREATE FUNCTION` in `mobilitydb/sql/**/*.in.sql` (PG-only sections and helper symbols bucketed out; 874 out-of-scope, 113 SQL/plpgsql-composed functions with no single C symbol). Functions the SQL layer implements through the internal MEOS headers (`meos_internal*.h`) are exposed via `MeosOpsSqlSurface`. -- Addressable distinct C symbols: **1335**; bound by JMEOS: **1065**; exposed by the facade: **939** (88.2% of the JMEOS-bindable SQL surface). +- Addressable distinct C symbols: **1335**; bound by JMEOS: **1065**; exposed by the facade: **1065** (100.0% of the JMEOS-bindable SQL surface). + +- The remaining **270** addressable C symbols are not exported by JMEOS under the name the SQL layer's extension wrapper uses; the wrapper names differ from the MEOS function names they call. ## 5. Runtime symbol resolution -Every facade method delegates to a libmeos symbol of the same name. Against a libmeos built with the extended modules (`-DCBUFFER=ON -DNPOINT=ON -DPOSE=ON -DRGEO=ON`), **2152 of 2160** facade methods resolve to an exported symbol. The following require a libmeos built from current MEOS sources: +Every facade method delegates to a libmeos symbol of the same name. Against a libmeos built with the extended modules (`-DCBUFFER=ON -DNPOINT=ON -DPOSE=ON -DRGEO=ON`), **2278 of 2286** facade methods resolve to an exported symbol. The following require a libmeos built from current MEOS sources: - `geog_from_binary` - `nad_stbox_trgeo` diff --git a/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsSqlSurface.java b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsSqlSurface.java new file mode 100644 index 0000000..b9a71de --- /dev/null +++ b/flink-processor/src/main/java/org/mobilitydb/flink/meos/MeosOpsSqlSurface.java @@ -0,0 +1,897 @@ +package org.mobilitydb.flink.meos; + +/** + * Forwarding facade methods for MEOS functions that the MobilityDB SQL layer + * exposes as user functions but whose implementation lives in the internal headers + * ({@code meos_internal*.h}). JMEOS binds them; they are exposed here so the facade + * matches the SQL user surface as well as the public MEOS API. Each method delegates + * to its {@code functions.GeneratedFunctions} export under the + * {@link MeosOpsRuntime#MEOS_AVAILABLE} guard. + */ +public final class MeosOpsSqlSurface { + + private MeosOpsSqlSurface() { /* utility */ } + + /** MEOS {@code adjacent_span_value} — SQL-surface function (meos_internal). */ + public static int adjacent_span_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("adjacent_span_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.adjacent_span_value(arg0, arg1); + } + + /** MEOS {@code adjacent_spanset_value} — SQL-surface function (meos_internal). */ + public static int adjacent_spanset_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("adjacent_spanset_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.adjacent_spanset_value(arg0, arg1); + } + + /** MEOS {@code adjacent_value_spanset} — SQL-surface function (meos_internal). */ + public static int adjacent_value_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("adjacent_value_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.adjacent_value_spanset(arg0, arg1); + } + + /** MEOS {@code always_eq_base_temporal} — SQL-surface function (meos_internal). */ + public static int always_eq_base_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("always_eq_base_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.always_eq_base_temporal(arg0, arg1); + } + + /** MEOS {@code always_eq_temporal_base} — SQL-surface function (meos_internal). */ + public static int always_eq_temporal_base(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("always_eq_temporal_base requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.always_eq_temporal_base(arg0, arg1); + } + + /** MEOS {@code always_ge_base_temporal} — SQL-surface function (meos_internal). */ + public static int always_ge_base_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("always_ge_base_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.always_ge_base_temporal(arg0, arg1); + } + + /** MEOS {@code always_ge_temporal_base} — SQL-surface function (meos_internal). */ + public static int always_ge_temporal_base(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("always_ge_temporal_base requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.always_ge_temporal_base(arg0, arg1); + } + + /** MEOS {@code always_gt_base_temporal} — SQL-surface function (meos_internal). */ + public static int always_gt_base_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("always_gt_base_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.always_gt_base_temporal(arg0, arg1); + } + + /** MEOS {@code always_gt_temporal_base} — SQL-surface function (meos_internal). */ + public static int always_gt_temporal_base(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("always_gt_temporal_base requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.always_gt_temporal_base(arg0, arg1); + } + + /** MEOS {@code always_le_base_temporal} — SQL-surface function (meos_internal). */ + public static int always_le_base_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("always_le_base_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.always_le_base_temporal(arg0, arg1); + } + + /** MEOS {@code always_le_temporal_base} — SQL-surface function (meos_internal). */ + public static int always_le_temporal_base(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("always_le_temporal_base requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.always_le_temporal_base(arg0, arg1); + } + + /** MEOS {@code always_lt_base_temporal} — SQL-surface function (meos_internal). */ + public static int always_lt_base_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("always_lt_base_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.always_lt_base_temporal(arg0, arg1); + } + + /** MEOS {@code always_lt_temporal_base} — SQL-surface function (meos_internal). */ + public static int always_lt_temporal_base(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("always_lt_temporal_base requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.always_lt_temporal_base(arg0, arg1); + } + + /** MEOS {@code always_ne_base_temporal} — SQL-surface function (meos_internal). */ + public static int always_ne_base_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("always_ne_base_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.always_ne_base_temporal(arg0, arg1); + } + + /** MEOS {@code always_ne_temporal_base} — SQL-surface function (meos_internal). */ + public static int always_ne_temporal_base(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("always_ne_temporal_base requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.always_ne_temporal_base(arg0, arg1); + } + + /** MEOS {@code contained_value_set} — SQL-surface function (meos_internal). */ + public static int contained_value_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("contained_value_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.contained_value_set(arg0, arg1); + } + + /** MEOS {@code contained_value_span} — SQL-surface function (meos_internal). */ + public static int contained_value_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("contained_value_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.contained_value_span(arg0, arg1); + } + + /** MEOS {@code contained_value_spanset} — SQL-surface function (meos_internal). */ + public static int contained_value_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("contained_value_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.contained_value_spanset(arg0, arg1); + } + + /** MEOS {@code contains_set_value} — SQL-surface function (meos_internal). */ + public static int contains_set_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("contains_set_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.contains_set_value(arg0, arg1); + } + + /** MEOS {@code contains_span_value} — SQL-surface function (meos_internal). */ + public static int contains_span_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("contains_span_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.contains_span_value(arg0, arg1); + } + + /** MEOS {@code contains_spanset_value} — SQL-surface function (meos_internal). */ + public static int contains_spanset_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("contains_spanset_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.contains_spanset_value(arg0, arg1); + } + + /** MEOS {@code distance_set_set} — SQL-surface function (meos_internal). */ + public static int distance_set_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("distance_set_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.distance_set_set(arg0, arg1); + } + + /** MEOS {@code distance_set_value} — SQL-surface function (meos_internal). */ + public static int distance_set_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("distance_set_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.distance_set_value(arg0, arg1); + } + + /** MEOS {@code distance_span_span} — SQL-surface function (meos_internal). */ + public static int distance_span_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("distance_span_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.distance_span_span(arg0, arg1); + } + + /** MEOS {@code distance_span_value} — SQL-surface function (meos_internal). */ + public static int distance_span_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("distance_span_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.distance_span_value(arg0, arg1); + } + + /** MEOS {@code distance_spanset_span} — SQL-surface function (meos_internal). */ + public static int distance_spanset_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("distance_spanset_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.distance_spanset_span(arg0, arg1); + } + + /** MEOS {@code distance_spanset_spanset} — SQL-surface function (meos_internal). */ + public static int distance_spanset_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("distance_spanset_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.distance_spanset_spanset(arg0, arg1); + } + + /** MEOS {@code distance_spanset_value} — SQL-surface function (meos_internal). */ + public static int distance_spanset_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("distance_spanset_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.distance_spanset_value(arg0, arg1); + } + + /** MEOS {@code distance_value_value} — SQL-surface function (meos_internal). */ + public static int distance_value_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, int arg2) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("distance_value_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.distance_value_value(arg0, arg1, arg2); + } + + /** MEOS {@code ever_eq_base_temporal} — SQL-surface function (meos_internal). */ + public static int ever_eq_base_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("ever_eq_base_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.ever_eq_base_temporal(arg0, arg1); + } + + /** MEOS {@code ever_eq_temporal_base} — SQL-surface function (meos_internal). */ + public static int ever_eq_temporal_base(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("ever_eq_temporal_base requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.ever_eq_temporal_base(arg0, arg1); + } + + /** MEOS {@code ever_ge_base_temporal} — SQL-surface function (meos_internal). */ + public static int ever_ge_base_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("ever_ge_base_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.ever_ge_base_temporal(arg0, arg1); + } + + /** MEOS {@code ever_ge_temporal_base} — SQL-surface function (meos_internal). */ + public static int ever_ge_temporal_base(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("ever_ge_temporal_base requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.ever_ge_temporal_base(arg0, arg1); + } + + /** MEOS {@code ever_gt_base_temporal} — SQL-surface function (meos_internal). */ + public static int ever_gt_base_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("ever_gt_base_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.ever_gt_base_temporal(arg0, arg1); + } + + /** MEOS {@code ever_gt_temporal_base} — SQL-surface function (meos_internal). */ + public static int ever_gt_temporal_base(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("ever_gt_temporal_base requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.ever_gt_temporal_base(arg0, arg1); + } + + /** MEOS {@code ever_le_base_temporal} — SQL-surface function (meos_internal). */ + public static int ever_le_base_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("ever_le_base_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.ever_le_base_temporal(arg0, arg1); + } + + /** MEOS {@code ever_le_temporal_base} — SQL-surface function (meos_internal). */ + public static int ever_le_temporal_base(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("ever_le_temporal_base requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.ever_le_temporal_base(arg0, arg1); + } + + /** MEOS {@code ever_lt_base_temporal} — SQL-surface function (meos_internal). */ + public static int ever_lt_base_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("ever_lt_base_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.ever_lt_base_temporal(arg0, arg1); + } + + /** MEOS {@code ever_lt_temporal_base} — SQL-surface function (meos_internal). */ + public static int ever_lt_temporal_base(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("ever_lt_temporal_base requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.ever_lt_temporal_base(arg0, arg1); + } + + /** MEOS {@code ever_ne_base_temporal} — SQL-surface function (meos_internal). */ + public static int ever_ne_base_temporal(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("ever_ne_base_temporal requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.ever_ne_base_temporal(arg0, arg1); + } + + /** MEOS {@code ever_ne_temporal_base} — SQL-surface function (meos_internal). */ + public static int ever_ne_temporal_base(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("ever_ne_temporal_base requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.ever_ne_temporal_base(arg0, arg1); + } + + /** MEOS {@code intersection_set_value} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer intersection_set_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("intersection_set_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.intersection_set_value(arg0, arg1); + } + + /** MEOS {@code intersection_span_value} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer intersection_span_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("intersection_span_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.intersection_span_value(arg0, arg1); + } + + /** MEOS {@code intersection_spanset_value} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer intersection_spanset_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("intersection_spanset_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.intersection_spanset_value(arg0, arg1); + } + + /** MEOS {@code intersection_value_set} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer intersection_value_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("intersection_value_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.intersection_value_set(arg0, arg1); + } + + /** MEOS {@code intersection_value_span} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer intersection_value_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("intersection_value_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.intersection_value_span(arg0, arg1); + } + + /** MEOS {@code intersection_value_spanset} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer intersection_value_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("intersection_value_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.intersection_value_spanset(arg0, arg1); + } + + /** MEOS {@code left_set_value} — SQL-surface function (meos_internal). */ + public static int left_set_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("left_set_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.left_set_value(arg0, arg1); + } + + /** MEOS {@code left_span_value} — SQL-surface function (meos_internal). */ + public static int left_span_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("left_span_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.left_span_value(arg0, arg1); + } + + /** MEOS {@code left_spanset_value} — SQL-surface function (meos_internal). */ + public static int left_spanset_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("left_spanset_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.left_spanset_value(arg0, arg1); + } + + /** MEOS {@code left_value_set} — SQL-surface function (meos_internal). */ + public static int left_value_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("left_value_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.left_value_set(arg0, arg1); + } + + /** MEOS {@code left_value_span} — SQL-surface function (meos_internal). */ + public static int left_value_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("left_value_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.left_value_span(arg0, arg1); + } + + /** MEOS {@code left_value_spanset} — SQL-surface function (meos_internal). */ + public static int left_value_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("left_value_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.left_value_spanset(arg0, arg1); + } + + /** MEOS {@code minus_set_value} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer minus_set_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("minus_set_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.minus_set_value(arg0, arg1); + } + + /** MEOS {@code minus_span_value} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer minus_span_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("minus_span_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.minus_span_value(arg0, arg1); + } + + /** MEOS {@code minus_spanset_value} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer minus_spanset_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("minus_spanset_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.minus_spanset_value(arg0, arg1); + } + + /** MEOS {@code minus_value_set} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer minus_value_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("minus_value_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.minus_value_set(arg0, arg1); + } + + /** MEOS {@code minus_value_span} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer minus_value_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("minus_value_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.minus_value_span(arg0, arg1); + } + + /** MEOS {@code minus_value_spanset} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer minus_value_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("minus_value_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.minus_value_spanset(arg0, arg1); + } + + /** MEOS {@code nad_tbox_tbox} — SQL-surface function (meos_internal). */ + public static double nad_tbox_tbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("nad_tbox_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.nad_tbox_tbox(arg0, arg1); + } + + /** MEOS {@code nad_tnumber_number} — SQL-surface function (meos_internal). */ + public static double nad_tnumber_number(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("nad_tnumber_number requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.nad_tnumber_number(arg0, arg1); + } + + /** MEOS {@code nad_tnumber_tbox} — SQL-surface function (meos_internal). */ + public static double nad_tnumber_tbox(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("nad_tnumber_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.nad_tnumber_tbox(arg0, arg1); + } + + /** MEOS {@code nad_tnumber_tnumber} — SQL-surface function (meos_internal). */ + public static double nad_tnumber_tnumber(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("nad_tnumber_tnumber requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.nad_tnumber_tnumber(arg0, arg1); + } + + /** MEOS {@code number_timestamptz_to_tbox} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer number_timestamptz_to_tbox(jnr.ffi.Pointer arg0, int arg1, int arg2) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("number_timestamptz_to_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.number_timestamptz_to_tbox(arg0, arg1, arg2); + } + + /** MEOS {@code number_tstzspan_to_tbox} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer number_tstzspan_to_tbox(jnr.ffi.Pointer arg0, int arg1, jnr.ffi.Pointer arg2) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("number_tstzspan_to_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.number_tstzspan_to_tbox(arg0, arg1, arg2); + } + + /** MEOS {@code numset_shift_scale} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer numset_shift_scale(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, jnr.ffi.Pointer arg2, int arg3, int arg4) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("numset_shift_scale requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.numset_shift_scale(arg0, arg1, arg2, arg3, arg4); + } + + /** MEOS {@code numspan_expand} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer numspan_expand(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("numspan_expand requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.numspan_expand(arg0, arg1); + } + + /** MEOS {@code numspan_shift_scale} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer numspan_shift_scale(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, jnr.ffi.Pointer arg2, int arg3, int arg4) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("numspan_shift_scale requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.numspan_shift_scale(arg0, arg1, arg2, arg3, arg4); + } + + /** MEOS {@code numspan_width} — SQL-surface function (meos_internal). */ + public static int numspan_width(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("numspan_width requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.numspan_width(arg0); + } + + /** MEOS {@code numspanset_shift_scale} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer numspanset_shift_scale(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, jnr.ffi.Pointer arg2, int arg3, int arg4) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("numspanset_shift_scale requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.numspanset_shift_scale(arg0, arg1, arg2, arg3, arg4); + } + + /** MEOS {@code numspanset_width} — SQL-surface function (meos_internal). */ + public static int numspanset_width(jnr.ffi.Pointer arg0, int arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("numspanset_width requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.numspanset_width(arg0, arg1); + } + + /** MEOS {@code overleft_set_value} — SQL-surface function (meos_internal). */ + public static int overleft_set_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("overleft_set_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.overleft_set_value(arg0, arg1); + } + + /** MEOS {@code overleft_span_value} — SQL-surface function (meos_internal). */ + public static int overleft_span_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("overleft_span_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.overleft_span_value(arg0, arg1); + } + + /** MEOS {@code overleft_spanset_value} — SQL-surface function (meos_internal). */ + public static int overleft_spanset_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("overleft_spanset_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.overleft_spanset_value(arg0, arg1); + } + + /** MEOS {@code overleft_value_set} — SQL-surface function (meos_internal). */ + public static int overleft_value_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("overleft_value_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.overleft_value_set(arg0, arg1); + } + + /** MEOS {@code overleft_value_span} — SQL-surface function (meos_internal). */ + public static int overleft_value_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("overleft_value_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.overleft_value_span(arg0, arg1); + } + + /** MEOS {@code overleft_value_spanset} — SQL-surface function (meos_internal). */ + public static int overleft_value_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("overleft_value_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.overleft_value_spanset(arg0, arg1); + } + + /** MEOS {@code overright_set_value} — SQL-surface function (meos_internal). */ + public static int overright_set_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("overright_set_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.overright_set_value(arg0, arg1); + } + + /** MEOS {@code overright_span_value} — SQL-surface function (meos_internal). */ + public static int overright_span_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("overright_span_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.overright_span_value(arg0, arg1); + } + + /** MEOS {@code overright_spanset_value} — SQL-surface function (meos_internal). */ + public static int overright_spanset_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("overright_spanset_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.overright_spanset_value(arg0, arg1); + } + + /** MEOS {@code overright_value_set} — SQL-surface function (meos_internal). */ + public static int overright_value_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("overright_value_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.overright_value_set(arg0, arg1); + } + + /** MEOS {@code overright_value_span} — SQL-surface function (meos_internal). */ + public static int overright_value_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("overright_value_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.overright_value_span(arg0, arg1); + } + + /** MEOS {@code overright_value_spanset} — SQL-surface function (meos_internal). */ + public static int overright_value_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("overright_value_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.overright_value_spanset(arg0, arg1); + } + + /** MEOS {@code right_set_value} — SQL-surface function (meos_internal). */ + public static int right_set_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("right_set_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.right_set_value(arg0, arg1); + } + + /** MEOS {@code right_span_value} — SQL-surface function (meos_internal). */ + public static int right_span_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("right_span_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.right_span_value(arg0, arg1); + } + + /** MEOS {@code right_spanset_value} — SQL-surface function (meos_internal). */ + public static int right_spanset_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("right_spanset_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.right_spanset_value(arg0, arg1); + } + + /** MEOS {@code right_value_set} — SQL-surface function (meos_internal). */ + public static int right_value_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("right_value_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.right_value_set(arg0, arg1); + } + + /** MEOS {@code right_value_span} — SQL-surface function (meos_internal). */ + public static int right_value_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("right_value_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.right_value_span(arg0, arg1); + } + + /** MEOS {@code right_value_spanset} — SQL-surface function (meos_internal). */ + public static int right_value_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("right_value_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.right_value_spanset(arg0, arg1); + } + + /** MEOS {@code set_end_value} — SQL-surface function (meos_internal). */ + public static int set_end_value(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("set_end_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.set_end_value(arg0); + } + + /** MEOS {@code set_mem_size} — SQL-surface function (meos_internal). */ + public static int set_mem_size(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("set_mem_size requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.set_mem_size(arg0); + } + + /** MEOS {@code set_start_value} — SQL-surface function (meos_internal). */ + public static int set_start_value(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("set_start_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.set_start_value(arg0); + } + + /** MEOS {@code set_value_n} — SQL-surface function (meos_internal). */ + public static int set_value_n(jnr.ffi.Pointer arg0, int arg1, jnr.ffi.Pointer arg2) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("set_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.set_value_n(arg0, arg1, arg2); + } + + /** MEOS {@code set_values} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer set_values(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("set_values requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.set_values(arg0); + } + + /** MEOS {@code span_bins} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer span_bins(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, jnr.ffi.Pointer arg2, jnr.ffi.Pointer arg3) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("span_bins requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.span_bins(arg0, arg1, arg2, arg3); + } + + /** MEOS {@code spanset_bins} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer spanset_bins(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, jnr.ffi.Pointer arg2, jnr.ffi.Pointer arg3) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("spanset_bins requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.spanset_bins(arg0, arg1, arg2, arg3); + } + + /** MEOS {@code spanset_lower} — SQL-surface function (meos_internal). */ + public static int spanset_lower(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("spanset_lower requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.spanset_lower(arg0); + } + + /** MEOS {@code spanset_mem_size} — SQL-surface function (meos_internal). */ + public static int spanset_mem_size(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("spanset_mem_size requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.spanset_mem_size(arg0); + } + + /** MEOS {@code spanset_upper} — SQL-surface function (meos_internal). */ + public static int spanset_upper(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("spanset_upper requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.spanset_upper(arg0); + } + + /** MEOS {@code tbox_expand_value} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer tbox_expand_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, int arg2) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tbox_expand_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tbox_expand_value(arg0, arg1, arg2); + } + + /** MEOS {@code tbox_get_value_time_tile} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer tbox_get_value_time_tile(jnr.ffi.Pointer arg0, int arg1, jnr.ffi.Pointer arg2, jnr.ffi.Pointer arg3, jnr.ffi.Pointer arg4, int arg5, int arg6, int arg7) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tbox_get_value_time_tile requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tbox_get_value_time_tile(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); + } + + /** MEOS {@code tbox_shift_scale_value} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer tbox_shift_scale_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, jnr.ffi.Pointer arg2, int arg3, int arg4) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tbox_shift_scale_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tbox_shift_scale_value(arg0, arg1, arg2, arg3, arg4); + } + + /** MEOS {@code tdistance_tnumber_number} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer tdistance_tnumber_number(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tdistance_tnumber_number requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tdistance_tnumber_number(arg0, arg1); + } + + /** MEOS {@code temporal_end_value} — SQL-surface function (meos_internal). */ + public static int temporal_end_value(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("temporal_end_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.temporal_end_value(arg0); + } + + /** MEOS {@code temporal_from_mfjson} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer temporal_from_mfjson(java.lang.String arg0, int arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("temporal_from_mfjson requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.temporal_from_mfjson(arg0, arg1); + } + + /** MEOS {@code temporal_max_value} — SQL-surface function (meos_internal). */ + public static int temporal_max_value(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("temporal_max_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.temporal_max_value(arg0); + } + + /** MEOS {@code temporal_mem_size} — SQL-surface function (meos_internal). */ + public static int temporal_mem_size(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("temporal_mem_size requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.temporal_mem_size(arg0); + } + + /** MEOS {@code temporal_min_value} — SQL-surface function (meos_internal). */ + public static int temporal_min_value(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("temporal_min_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.temporal_min_value(arg0); + } + + /** MEOS {@code temporal_start_value} — SQL-surface function (meos_internal). */ + public static int temporal_start_value(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("temporal_start_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.temporal_start_value(arg0); + } + + /** MEOS {@code temporal_value_at_timestamptz} — SQL-surface function (meos_internal). */ + public static int temporal_value_at_timestamptz(jnr.ffi.Pointer arg0, int arg1, int arg2, jnr.ffi.Pointer arg3) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("temporal_value_at_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.temporal_value_at_timestamptz(arg0, arg1, arg2, arg3); + } + + /** MEOS {@code temporal_value_n} — SQL-surface function (meos_internal). */ + public static int temporal_value_n(jnr.ffi.Pointer arg0, int arg1, jnr.ffi.Pointer arg2) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("temporal_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.temporal_value_n(arg0, arg1, arg2); + } + + /** MEOS {@code tinstant_value} — SQL-surface function (meos_internal). */ + public static int tinstant_value(jnr.ffi.Pointer arg0) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tinstant_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tinstant_value(arg0); + } + + /** MEOS {@code tnumber_shift_scale_value} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer tnumber_shift_scale_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, jnr.ffi.Pointer arg2, int arg3, int arg4) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tnumber_shift_scale_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tnumber_shift_scale_value(arg0, arg1, arg2, arg3, arg4); + } + + /** MEOS {@code tnumber_value_bins} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer tnumber_value_bins(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, jnr.ffi.Pointer arg2, jnr.ffi.Pointer arg3) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tnumber_value_bins requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tnumber_value_bins(arg0, arg1, arg2, arg3); + } + + /** MEOS {@code tnumber_value_split} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer tnumber_value_split(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, jnr.ffi.Pointer arg2, jnr.ffi.Pointer arg3, jnr.ffi.Pointer arg4) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tnumber_value_split requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tnumber_value_split(arg0, arg1, arg2, arg3, arg4); + } + + /** MEOS {@code tnumber_value_time_boxes} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer tnumber_value_time_boxes(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, jnr.ffi.Pointer arg2, jnr.ffi.Pointer arg3, int arg4, jnr.ffi.Pointer arg5) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tnumber_value_time_boxes requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tnumber_value_time_boxes(arg0, arg1, arg2, arg3, arg4, arg5); + } + + /** MEOS {@code tnumber_value_time_split} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer tnumber_value_time_split(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1, jnr.ffi.Pointer arg2, jnr.ffi.Pointer arg3, int arg4, jnr.ffi.Pointer arg5, jnr.ffi.Pointer arg6, jnr.ffi.Pointer arg7) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tnumber_value_time_split requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tnumber_value_time_split(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); + } + + /** MEOS {@code tsequence_from_base_tstzset} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer tsequence_from_base_tstzset(jnr.ffi.Pointer arg0, int arg1, jnr.ffi.Pointer arg2) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tsequence_from_base_tstzset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tsequence_from_base_tstzset(arg0, arg1, arg2); + } + + /** MEOS {@code tsequence_from_base_tstzspan} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer tsequence_from_base_tstzspan(jnr.ffi.Pointer arg0, int arg1, jnr.ffi.Pointer arg2, int arg3) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tsequence_from_base_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tsequence_from_base_tstzspan(arg0, arg1, arg2, arg3); + } + + /** MEOS {@code tsequenceset_from_base_tstzspanset} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer tsequenceset_from_base_tstzspanset(jnr.ffi.Pointer arg0, int arg1, jnr.ffi.Pointer arg2, int arg3) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("tsequenceset_from_base_tstzspanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.tsequenceset_from_base_tstzspanset(arg0, arg1, arg2, arg3); + } + + /** MEOS {@code union_set_value} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer union_set_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("union_set_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.union_set_value(arg0, arg1); + } + + /** MEOS {@code union_span_value} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer union_span_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("union_span_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.union_span_value(arg0, arg1); + } + + /** MEOS {@code union_spanset_value} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer union_spanset_value(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("union_spanset_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.union_spanset_value(arg0, arg1); + } + + /** MEOS {@code union_value_set} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer union_value_set(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("union_value_set requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.union_value_set(arg0, arg1); + } + + /** MEOS {@code union_value_span} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer union_value_span(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("union_value_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.union_value_span(arg0, arg1); + } + + /** MEOS {@code union_value_spanset} — SQL-surface function (meos_internal). */ + public static jnr.ffi.Pointer union_value_spanset(jnr.ffi.Pointer arg0, jnr.ffi.Pointer arg1) { + if (!MeosOpsRuntime.MEOS_AVAILABLE) + throw new UnsupportedOperationException("union_value_spanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + return functions.GeneratedFunctions.union_value_spanset(arg0, arg1); + } + +} diff --git a/flink-processor/tools/parity/emit_sql_surface.py b/flink-processor/tools/parity/emit_sql_surface.py new file mode 100644 index 0000000..f9e3286 --- /dev/null +++ b/flink-processor/tools/parity/emit_sql_surface.py @@ -0,0 +1,115 @@ +#!/usr/bin/env python3 +"""Emit forwarding facade methods for MEOS functions that the MobilityDB SQL +layer exposes as user functions but whose implementation lives in the internal +headers (`meos_internal*.h`). JMEOS binds them; exposing them here makes the +Flink facade match the SQL user surface as well as the public MEOS API. + +Each method forwards to its `functions.GeneratedFunctions` export using the +exact JMEOS signature, so the output compiles by construction. + +Run from flink-processor/: + javap -classpath jar/JMEOS.jar -p functions.GeneratedFunctions > /tmp/gen_sigs.txt + python3 tools/parity/emit_sql_surface.py /tmp/gen_sigs.txt +""" +import re, os, sys, glob + +HERE = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +INC = "/home/esteban/src/MobilityDB/meos/include" +MDB_SQL = "/home/esteban/src/MobilityDB/mobilitydb/sql" +FACADE = os.path.join(HERE, "src/main/java/org/mobilitydb/flink/meos") +OUT = os.path.join(FACADE, "MeosOpsSqlSurface.java") + +_PUBSTATIC = re.compile(r'public static [A-Za-z0-9_.<>\[\]]+ ([a-z0-9_]+)\(') +_SIG = re.compile(r'public static (\S+) (\w+)\(([^)]*)\);') +_CREATE = re.compile(r'CREATE\s+(?:OR\s+REPLACE\s+)?FUNCTION\s+([A-Za-z0-9_]+)\s*\(', re.I) +_CSYM = re.compile(r"AS\s+'[^']*'\s*,\s*'([A-Za-z0-9_]+)'", re.I) + +OOS_SECTIONS = { + "temporal/011_span_indexes.in.sql", "temporal/012_spanset_indexes.in.sql", + "temporal/013_set_indexes.in.sql", "temporal/019_geo_constructors.in.sql", + "temporal/043_temporal_gist.in.sql", "temporal/044_temporal_spgist.in.sql", + "temporal/999_oid_cache.in.sql", "geo/073_tgeo_gist.in.sql", + "geo/073_tpoint_gist.in.sql", "geo/074_tgeo_spgist.in.sql", + "geo/074_tpoint_spgist.in.sql", "cbuffer/166_tcbuffer_indexes.in.sql", + "npoint/092_tnpoint_gin.in.sql", "npoint/098_tnpoint_indexes.in.sql", + "pose/114_tpose_indexes.in.sql", "rgeo/134_trgeo_indexes.in.sql", +} +OOS_SUFFIXES = ("_in", "_out", "_recv", "_send", "_typmod_in", "_typmod_out", + "_transfn", "_combinefn", "_finalfn", "_serialize", "_deserialize", + "_sel", "_joinsel", "_supportfn", "_analyze", + "_cmp", "_eq", "_ne", "_lt", "_le", "_gt", "_ge", "_hash", "_hash_extended") +OOS_NAMES = {"range", "multirange", "create_trip", "transform_gk"} + + +def header_names(*headers): + names = set() + for h in headers: + names |= set(re.findall(r'^\s*extern\s+.+?\b([a-z][A-Za-z0-9_]*)\s*\(', open(os.path.join(INC, h)).read(), re.M)) + return names + + +def sql_addressable(): + addr = set() + for path in glob.glob(os.path.join(MDB_SQL, "**", "*.in.sql"), recursive=True): + section = os.path.relpath(path, MDB_SQL).replace(os.sep, "/") + txt = open(path, encoding="utf-8", errors="replace").read() + for m in _CREATE.finditer(txt): + name = m.group(1); tail = txt[m.end():m.end() + 1200].split(';')[0] + cm = _CSYM.search(tail); sym = cm.group(1) if cm else None + key = (sym or name).lower() + if section in OOS_SECTIONS or key in OOS_NAMES or key.endswith(OOS_SUFFIXES): + continue + if sym is not None: + addr.add(key) + return addr + + +def main(): + sigfile = sys.argv[1] if len(sys.argv) > 1 else "/tmp/parity/gen_sigs.txt" + sigs = {} + for line in open(sigfile): + m = _SIG.search(line) + if m: + sigs.setdefault(m.group(2), []).append((m.group(1), m.group(3).strip())) + facade = set() + for f in glob.glob(os.path.join(FACADE, "MeosOps*.java")): + facade |= set(_PUBSTATIC.findall(open(f).read())) + pub = header_names("meos.h", "meos_geo.h", "meos_cbuffer.h", "meos_npoint.h", "meos_pose.h", "meos_rgeo.h") + addr = sql_addressable() + # SQL-addressable, bound by JMEOS, not in the public-surface facade, not already exposed + targets = sorted((addr & set(sigs)) - facade - pub) + + L = ["package org.mobilitydb.flink.meos;", "", + "/**", " * Forwarding facade methods for MEOS functions that the MobilityDB SQL layer", + " * exposes as user functions but whose implementation lives in the internal headers", + " * ({@code meos_internal*.h}). JMEOS binds them; they are exposed here so the facade", + " * matches the SQL user surface as well as the public MEOS API. Each method delegates", + " * to its {@code functions.GeneratedFunctions} export under the", + " * {@link MeosOpsRuntime#MEOS_AVAILABLE} guard.", + " */", + "public final class MeosOpsSqlSurface {", "", + " private MeosOpsSqlSurface() { /* utility */ }", ""] + count = 0 + for name in targets: + for ret, args in sigs[name]: + params = [a.strip() for a in args.split(",")] if args else [] + decl = ", ".join(f"{t} arg{i}" for i, t in enumerate(params)) + call = ", ".join(f"arg{i}" for i in range(len(params))) + ret_kw = "" if ret == "void" else "return " + L += [f" /** MEOS {{@code {name}}} — SQL-surface function (meos_internal). */", + f" public static {ret} {name}({decl}) {{", + f" if (!MeosOpsRuntime.MEOS_AVAILABLE)", + f' throw new UnsupportedOperationException("{name} requires libmeos' + f' — set -Dmobilityflink.meos.enabled=true");', + f" {ret_kw}functions.GeneratedFunctions.{name}({call});", + " }", ""] + count += 1 + L.append("}") + open(OUT, "w").write("\n".join(L) + "\n") + print(f"SQL-surface (internal-backed) functions to expose: {len(targets)}") + print(f"forwarding methods emitted: {count}") + print(f"wrote {OUT}") + + +if __name__ == "__main__": + main() diff --git a/flink-processor/tools/parity/parity_audit.py b/flink-processor/tools/parity/parity_audit.py index 5596e59..8e6b6c7 100644 --- a/flink-processor/tools/parity/parity_audit.py +++ b/flink-processor/tools/parity/parity_audit.py @@ -177,15 +177,17 @@ def main(): L.append(f"- **`{h}`** ({len(ms)}): " + ", ".join(f"`{n}`" for n in ms)) L.append("") L.append("## 4. MobilityDB SQL-surface cross-check\n") - L.append("For comparability with the SQL-surface bindings, the facade is also matched " - "against the underlying MEOS C symbol of each addressable `CREATE FUNCTION` in " - "`mobilitydb/sql/**/*.in.sql` (PG-only sections and helper symbols bucketed out; " - f"{oos} out-of-scope, {sqlc} SQL/plpgsql-composed functions with no single C symbol). " - "The extension wrapper occasionally renames the MEOS function it calls, so this view " - "is a lower bound.\n") + L.append("The facade is also matched against the underlying MEOS C symbol of each addressable " + "`CREATE FUNCTION` in `mobilitydb/sql/**/*.in.sql` (PG-only sections and helper symbols " + f"bucketed out; {oos} out-of-scope, {sqlc} SQL/plpgsql-composed functions with no single " + "C symbol). Functions the SQL layer implements through the internal MEOS headers " + "(`meos_internal*.h`) are exposed via `MeosOpsSqlSurface`.\n") L.append(f"- Addressable distinct C symbols: **{len(addr)}**; bound by JMEOS: **{sql_bindable}**; " f"exposed by the facade: **{sql_cov}** " f"({pct(sql_cov, sql_bindable):.1f}% of the JMEOS-bindable SQL surface).\n") + L.append(f"- The remaining **{len(addr) - sql_bindable}** addressable C symbols are not exported " + "by JMEOS under the name the SQL layer's extension wrapper uses; the wrapper names " + "differ from the MEOS function names they call.\n") if a.libmeos: libsyms = libmeos_symbols(a.libmeos) From f8141d2cf7161e21bee38c44f0b9256302876728 Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Thu, 28 May 2026 02:31:13 +0200 Subject: [PATCH 12/13] docs(parity): record the JMEOS-jar / MEOS-library resolution skew Section 5 of parity-status.md reports facade-method resolution against a built MEOS library (2277 of 2286) and splits the 9 unresolved into the seven symbols declared in the public headers that the build does not export and the two functions the JMEOS jar carries ahead of the current public headers. (cherry picked from commit 8972cafe961bf9cbb155c1b967227a9850c382ab) --- flink-processor/docs/parity-status.md | 16 ++++++-------- flink-processor/tools/parity/parity_audit.py | 22 +++++++++++++++----- 2 files changed, 23 insertions(+), 15 deletions(-) diff --git a/flink-processor/docs/parity-status.md b/flink-processor/docs/parity-status.md index 570226f..e26eba2 100644 --- a/flink-processor/docs/parity-status.md +++ b/flink-processor/docs/parity-status.md @@ -45,14 +45,10 @@ The facade is also matched against the underlying MEOS C symbol of each addressa ## 5. Runtime symbol resolution -Every facade method delegates to a libmeos symbol of the same name. Against a libmeos built with the extended modules (`-DCBUFFER=ON -DNPOINT=ON -DPOSE=ON -DRGEO=ON`), **2278 of 2286** facade methods resolve to an exported symbol. The following require a libmeos built from current MEOS sources: - -- `geog_from_binary` -- `nad_stbox_trgeo` -- `tcbuffer_from_mfjson` -- `tfloat_avg_value` -- `tnpoint_from_mfjson` -- `trgeo_points` -- `trgeo_rotation` -- `trgeo_segments` +Every facade method delegates to a libmeos symbol of the same name. Against a MEOS shared library built with the extended modules (`-DCBUFFER=ON -DNPOINT=ON -DPOSE=ON -DRGEO=ON`), **2277 of 2286** facade methods resolve to an exported symbol. + +The remaining 9 are present in the JMEOS jar but not exported by the MEOS shared library (a JMEOS-jar / library version skew): + +- declared in the public headers, not exported by this build (7): `geog_from_binary`, `nad_stbox_trgeo`, `tfloat_avg_value`, `trgeo_points`, `trgeo_rotation`, `trgeo_segments`, `trgeo_traversed_area` +- not declared in the current public headers, JMEOS jar ahead of the library (2): `tcbuffer_from_mfjson`, `tnpoint_from_mfjson` diff --git a/flink-processor/tools/parity/parity_audit.py b/flink-processor/tools/parity/parity_audit.py index 8e6b6c7..263d507 100644 --- a/flink-processor/tools/parity/parity_audit.py +++ b/flink-processor/tools/parity/parity_audit.py @@ -195,12 +195,24 @@ def main(): unresolved = sorted(fa_all - libsyms) L.append("## 5. Runtime symbol resolution\n") L.append("Every facade method delegates to a libmeos symbol of the same name. Against a " - "libmeos built with the extended modules (`-DCBUFFER=ON -DNPOINT=ON -DPOSE=ON " - "-DRGEO=ON`), " + "MEOS shared library built with the extended modules (`-DCBUFFER=ON -DNPOINT=ON " + "-DPOSE=ON -DRGEO=ON`), " f"**{len(resolved)} of {len(fa_all)}** facade methods resolve to an exported " - "symbol. The following require a libmeos built from current MEOS sources:\n") - L.append(("\n".join(f"- `{n}`" for n in unresolved) if unresolved - else "- (none — all facade methods resolve)") + "\n") + "symbol.\n") + if unresolved: + hdr_only = sorted(n for n in unresolved if n in pub) + jmeos_only = sorted(n for n in unresolved if n not in pub) + L.append(f"The remaining {len(unresolved)} are present in the JMEOS jar but not " + "exported by the MEOS shared library (a JMEOS-jar / library version skew):\n") + if hdr_only: + L.append(f"- declared in the public headers, not exported by this build " + f"({len(hdr_only)}): " + ", ".join(f"`{n}`" for n in hdr_only)) + if jmeos_only: + L.append(f"- not declared in the current public headers, JMEOS jar ahead of the " + f"library ({len(jmeos_only)}): " + ", ".join(f"`{n}`" for n in jmeos_only)) + L.append("") + else: + L.append("All facade methods resolve.\n") print(f"libmeos resolution: {len(resolved)}/{len(fa_all)} " f"({len(unresolved)} unresolved)") From 02524dbd622638eae2d14625e6e4be3c89c324e0 Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Sat, 6 Jun 2026 09:23:51 +0200 Subject: [PATCH 13/13] Remove the pure-Java great-circle fallback; BerlinMOD predicates are MEOS-only The berlinmod Haversine and SegmentDistance classes computed a planar/great-circle distance that diverges from MEOS geog_distance (4124.39 vs 4132.97 m on the parity corpus) and were selected silently when libmeos failed to load, so the parity-oracle suite validated against a non-canonical distance and a missing libmeos produced a wrong number rather than an error. MEOSBridge now evaluates every spatial predicate through MEOS geog_dwithin / geog_distance with no fallback and fails loudly at load when libmeos is absent, matching the MeosOps surface. The BerlinMOD local drivers run on MEOS. The distance cells (Q5/Q6/Q9) now equal the MEOS value, matching the Kafka Streams parity row. --- .../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 | 44 ------- .../src/main/java/berlinmod/MEOSBridge.java | 121 +++++------------- .../java/berlinmod/Q3ContinuousFunction.java | 2 +- .../java/berlinmod/Q3SnapshotFunction.java | 2 +- .../java/berlinmod/Q3WindowedFunction.java | 2 +- .../java/berlinmod/Q5ContinuousFunction.java | 2 +- .../java/berlinmod/Q6ContinuousFunction.java | 2 +- .../java/berlinmod/Q8ContinuousFunction.java | 2 +- .../main/java/berlinmod/SegmentDistance.java | 70 ---------- 18 files changed, 38 insertions(+), 218 deletions(-) delete mode 100644 flink-processor/src/main/java/berlinmod/Haversine.java delete mode 100644 flink-processor/src/main/java/berlinmod/SegmentDistance.java diff --git a/flink-processor/src/main/java/berlinmod/BerlinMODQ1LocalTest.java b/flink-processor/src/main/java/berlinmod/BerlinMODQ1LocalTest.java index 7b609b0..9218e16 100644 --- a/flink-processor/src/main/java/berlinmod/BerlinMODQ1LocalTest.java +++ b/flink-processor/src/main/java/berlinmod/BerlinMODQ1LocalTest.java @@ -38,7 +38,6 @@ 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 9446c30..84950c9 100644 --- a/flink-processor/src/main/java/berlinmod/BerlinMODQ2LocalTest.java +++ b/flink-processor/src/main/java/berlinmod/BerlinMODQ2LocalTest.java @@ -44,7 +44,6 @@ 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 e1b7128..69e2022 100644 --- a/flink-processor/src/main/java/berlinmod/BerlinMODQ3LocalTest.java +++ b/flink-processor/src/main/java/berlinmod/BerlinMODQ3LocalTest.java @@ -55,7 +55,6 @@ 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 1f302a5..428e7fc 100644 --- a/flink-processor/src/main/java/berlinmod/BerlinMODQ4LocalTest.java +++ b/flink-processor/src/main/java/berlinmod/BerlinMODQ4LocalTest.java @@ -60,7 +60,6 @@ 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 f54e102..394932d 100644 --- a/flink-processor/src/main/java/berlinmod/BerlinMODQ5LocalTest.java +++ b/flink-processor/src/main/java/berlinmod/BerlinMODQ5LocalTest.java @@ -52,7 +52,6 @@ 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 4c18eb5..6a6fd2b 100644 --- a/flink-processor/src/main/java/berlinmod/BerlinMODQ6LocalTest.java +++ b/flink-processor/src/main/java/berlinmod/BerlinMODQ6LocalTest.java @@ -60,7 +60,6 @@ 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 fe9f075..e7560c8 100644 --- a/flink-processor/src/main/java/berlinmod/BerlinMODQ7LocalTest.java +++ b/flink-processor/src/main/java/berlinmod/BerlinMODQ7LocalTest.java @@ -59,7 +59,6 @@ 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 c644860..9dc6709 100644 --- a/flink-processor/src/main/java/berlinmod/BerlinMODQ8LocalTest.java +++ b/flink-processor/src/main/java/berlinmod/BerlinMODQ8LocalTest.java @@ -51,7 +51,6 @@ 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 6468ba7..f990031 100644 --- a/flink-processor/src/main/java/berlinmod/BerlinMODQ9LocalTest.java +++ b/flink-processor/src/main/java/berlinmod/BerlinMODQ9LocalTest.java @@ -45,7 +45,6 @@ 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 deleted file mode 100644 index cb6f888..0000000 --- a/flink-processor/src/main/java/berlinmod/Haversine.java +++ /dev/null @@ -1,44 +0,0 @@ -package berlinmod; - -/** - * Great-circle distance in metres between two WGS84 (lon, lat) points. - * - *

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 { - - 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/MEOSBridge.java b/flink-processor/src/main/java/berlinmod/MEOSBridge.java index 12570e0..4c7f3ce 100644 --- a/flink-processor/src/main/java/berlinmod/MEOSBridge.java +++ b/flink-processor/src/main/java/berlinmod/MEOSBridge.java @@ -8,47 +8,25 @@ * Runtime bridge from MobilityFlink BerlinMOD streaming-form predicates to * MEOS via JMEOS. * - *

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

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

    - *
  • {@code -Dmobilityflink.meos.enabled=false} forces the pure-Java path - * even when libmeos is present (used by {@code BerlinMODQ*LocalTest}). - *
  • Otherwise {@code MEOS_AVAILABLE} is {@code true} iff - * {@code functions.meos_initialize()} returns without throwing. - *
+ *

All spatial predicates exercised by the BerlinMOD-9 × 3-form scaffold flow + * through this class and evaluate through MEOS' WGS84 geography surface + * ({@code geom_to_geog} + {@code geog_dwithin}/{@code geog_distance}). There is + * no pure-Java approximation: a hand-rolled great-circle would diverge from + * MEOS' spheroidal result and could silently mask a missing libmeos, so the + * bridge requires MEOS and fails loudly when it is absent — exactly as the + * {@code MeosOps*} surface does ({@code "requires libmeos — set + * -Dmobilityflink.meos.enabled=true"}). */ 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; - } + try { + functions.meos_initialize(); + } catch (Throwable t) { + throw new IllegalStateException( + "MEOSBridge requires libmeos: its spatial predicates are MEOS geog_dwithin/" + + "geog_distance with no pure-Java fallback. Put libmeos on java.library.path.", t); } - MEOS_AVAILABLE = ok; } private MEOSBridge() { @@ -56,79 +34,52 @@ private MEOSBridge() { } // ---------------------------------------------------------------------- - // Public bridge surface — same shape as Haversine + SegmentDistance. + // Public bridge surface — MEOS geography predicates, no fallback. // ---------------------------------------------------------------------- /** - * @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}. + * @return {@code true} if the WGS84 spheroidal distance from + * {@code (lon1, lat1)} to {@code (lon2, lat2)} is at most + * {@code radiusMetres}, via MEOS {@code geog_dwithin}. */ 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 functions.geog_dwithin(pointGeog(lon1, lat1), pointGeog(lon2, lat2), 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}. + * to the LineString {@code (s1, s2)} is at most {@code radiusMetres}, + * via MEOS {@code geog_dwithin} on geographies built from the point + * and line WKTs. */ 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 functions.geog_dwithin( + pointGeog(pLon, pLat), lineGeog(s1Lon, s1Lat, s2Lon, s2Lat), 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}. + * @return the WGS84 spheroidal distance in metres between two points, via + * {@code utils.spatial.Haversine.distance} (MEOS {@code geog_distance} + * over two POINT geographies). */ 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}. + * @return the spheroidal distance in metres from {@code (pLon, pLat)} to the + * LineString {@code (s1, s2)}, via {@code utils.spatial.PointToSegment.distance} + * (MEOS {@code geog_distance} over POINT/LINESTRING geographies). */ 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); } @@ -138,21 +89,13 @@ public static double distanceSegmentMetres(double pLon, double pLat, 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); + return functions.geom_to_geog(functions.geom_in(wkt, -1)); } 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); + return functions.geom_to_geog(functions.geom_in(wkt, -1)); } } diff --git a/flink-processor/src/main/java/berlinmod/Q3ContinuousFunction.java b/flink-processor/src/main/java/berlinmod/Q3ContinuousFunction.java index 6628d05..9b3c12a 100644 --- a/flink-processor/src/main/java/berlinmod/Q3ContinuousFunction.java +++ b/flink-processor/src/main/java/berlinmod/Q3ContinuousFunction.java @@ -18,7 +18,7 @@ * *

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. + * fallback (MEOS geog_dwithin/geog_distance) for runtimes without MEOS. */ public class Q3ContinuousFunction extends ProcessFunction> { diff --git a/flink-processor/src/main/java/berlinmod/Q3SnapshotFunction.java b/flink-processor/src/main/java/berlinmod/Q3SnapshotFunction.java index 479854d..8c600b7 100644 --- a/flink-processor/src/main/java/berlinmod/Q3SnapshotFunction.java +++ b/flink-processor/src/main/java/berlinmod/Q3SnapshotFunction.java @@ -28,7 +28,7 @@ * snapshot. * *

Predicate: {@link MEOSBridge#dwithinMetres} — MEOS {@code geog_dwithin} - * when libmeos is loadable, with {@link Haversine} fallback otherwise. The + * when libmeos is loadable, with MEOS geog_dwithin/geog_distance 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. */ diff --git a/flink-processor/src/main/java/berlinmod/Q3WindowedFunction.java b/flink-processor/src/main/java/berlinmod/Q3WindowedFunction.java index c6dfa98..8c5e984 100644 --- a/flink-processor/src/main/java/berlinmod/Q3WindowedFunction.java +++ b/flink-processor/src/main/java/berlinmod/Q3WindowedFunction.java @@ -22,7 +22,7 @@ * {@code (windowStart, windowEnd, distinctCount)}. * *

Predicate: {@link MEOSBridge#dwithinMetres} — MEOS {@code geog_dwithin} - * over WGS84 geographies when libmeos is loadable, with {@link Haversine} + * over WGS84 geographies when libmeos is loadable, with MEOS geog_dwithin/geog_distance * fallback otherwise. */ public class Q3WindowedFunction diff --git a/flink-processor/src/main/java/berlinmod/Q5ContinuousFunction.java b/flink-processor/src/main/java/berlinmod/Q5ContinuousFunction.java index d14f272..40e3b52 100644 --- a/flink-processor/src/main/java/berlinmod/Q5ContinuousFunction.java +++ b/flink-processor/src/main/java/berlinmod/Q5ContinuousFunction.java @@ -33,7 +33,7 @@ * *

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. + * libmeos is loadable, with MEOS geog_dwithin/geog_distance fallback otherwise. */ public class Q5ContinuousFunction extends KeyedProcessFunction> { diff --git a/flink-processor/src/main/java/berlinmod/Q6ContinuousFunction.java b/flink-processor/src/main/java/berlinmod/Q6ContinuousFunction.java index 85204f3..77efd4a 100644 --- a/flink-processor/src/main/java/berlinmod/Q6ContinuousFunction.java +++ b/flink-processor/src/main/java/berlinmod/Q6ContinuousFunction.java @@ -19,7 +19,7 @@ * 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}). + *

Predicate today: pure-Java great-circle distance (see MEOS geog_dwithin/geog_distance). * 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. diff --git a/flink-processor/src/main/java/berlinmod/Q8ContinuousFunction.java b/flink-processor/src/main/java/berlinmod/Q8ContinuousFunction.java index fac4f1a..6c510d0 100644 --- a/flink-processor/src/main/java/berlinmod/Q8ContinuousFunction.java +++ b/flink-processor/src/main/java/berlinmod/Q8ContinuousFunction.java @@ -17,7 +17,7 @@ * *

Predicate: {@link MEOSBridge#dwithinSegmentMetres} — MEOS * {@code geog_dwithin} against a LineString geography when libmeos is - * loadable, with {@link SegmentDistance} fallback otherwise. + * loadable, with MEOS geog_dwithin/geog_distance fallback otherwise. */ public class Q8ContinuousFunction extends ProcessFunction> { diff --git a/flink-processor/src/main/java/berlinmod/SegmentDistance.java b/flink-processor/src/main/java/berlinmod/SegmentDistance.java deleted file mode 100644 index 62db56b..0000000 --- a/flink-processor/src/main/java/berlinmod/SegmentDistance.java +++ /dev/null @@ -1,70 +0,0 @@ -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. - * - *

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 { - - 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; - } -}

bwq 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 |3Kovbj@oZe^nSt8IZ?L} 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