From e1027c3d4867282cb6c1cdb12fcbfd1663150167 Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Thu, 21 May 2026 12:15:06 +0200 Subject: [PATCH] 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 Kafka mirror of MobilityFlink: regenerated from JMEOS PR #19's GeneratedFunctions (accumulate/parity-1.4 IDL) — renamed trgeometry_* surface + type-catalog/ transform/talpha (60 MeosOps* classes, 2,166 methods); bundled JMEOS.jar GeneratedFunctions refreshed. Compiles clean; legacy functions.functions surface untouched. --- kafka-streams-app/jar/JMEOS.jar | Bin 1210863 -> 1283894 bytes .../kafka/meos/MeosOpsBigintSet.java | 130 + .../kafka/meos/MeosOpsBigintSpan.java | 144 + .../kafka/meos/MeosOpsBigintSpanSet.java | 116 + .../kafka/meos/MeosOpsCbufferSet.java | 116 + .../mobilitydb/kafka/meos/MeosOpsDateSet.java | 144 + .../kafka/meos/MeosOpsDateSpan.java | 144 + .../kafka/meos/MeosOpsDateSpanSet.java | 172 + .../kafka/meos/MeosOpsFloatSet.java | 200 + .../kafka/meos/MeosOpsFloatSpan.java | 228 + .../kafka/meos/MeosOpsFloatSpanSet.java | 200 + .../kafka/meos/MeosOpsFreeCatalog.java | 605 + .../kafka/meos/MeosOpsFreeCbuffer.java | 1958 ++++ .../kafka/meos/MeosOpsFreeCore.java | 9721 +++++++++++++++++ .../mobilitydb/kafka/meos/MeosOpsFreeGeo.java | 3427 ++++++ .../kafka/meos/MeosOpsFreeNpoint.java | 1087 ++ .../kafka/meos/MeosOpsFreePose.java | 1009 ++ .../kafka/meos/MeosOpsFreeRgeo.java | 423 + .../kafka/meos/MeosOpsFreeTransform.java | 72 + .../mobilitydb/kafka/meos/MeosOpsGeogSet.java | 32 + .../mobilitydb/kafka/meos/MeosOpsGeomSet.java | 116 + .../mobilitydb/kafka/meos/MeosOpsIntSet.java | 144 + .../mobilitydb/kafka/meos/MeosOpsIntSpan.java | 158 + .../kafka/meos/MeosOpsIntSpanSet.java | 130 + .../kafka/meos/MeosOpsNpointSet.java | 130 + .../mobilitydb/kafka/meos/MeosOpsPoseSet.java | 116 + .../mobilitydb/kafka/meos/MeosOpsRuntime.java | 29 + .../mobilitydb/kafka/meos/MeosOpsSTBox.java | 775 ++ .../org/mobilitydb/kafka/meos/MeosOpsSet.java | 410 + .../mobilitydb/kafka/meos/MeosOpsSpan.java | 354 + .../mobilitydb/kafka/meos/MeosOpsSpanSet.java | 452 + .../mobilitydb/kafka/meos/MeosOpsTAlpha.java | 31 + .../mobilitydb/kafka/meos/MeosOpsTBool.java | 229 + .../kafka/meos/MeosOpsTBoolInst.java | 33 + .../mobilitydb/kafka/meos/MeosOpsTBox.java | 480 + .../kafka/meos/MeosOpsTCbuffer.java | 228 + .../mobilitydb/kafka/meos/MeosOpsTFloat.java | 537 + .../kafka/meos/MeosOpsTFloatInst.java | 33 + .../mobilitydb/kafka/meos/MeosOpsTGeo.java | 383 + .../kafka/meos/MeosOpsTGeogPoint.java | 60 + .../kafka/meos/MeosOpsTGeography.java | 74 + .../kafka/meos/MeosOpsTGeomPoint.java | 74 + .../kafka/meos/MeosOpsTGeometry.java | 102 + .../mobilitydb/kafka/meos/MeosOpsTInt.java | 425 + .../kafka/meos/MeosOpsTIntInst.java | 33 + .../mobilitydb/kafka/meos/MeosOpsTNpoint.java | 312 + .../kafka/meos/MeosOpsTNpointInst.java | 33 + .../mobilitydb/kafka/meos/MeosOpsTNumber.java | 382 + .../mobilitydb/kafka/meos/MeosOpsTPoint.java | 368 + .../mobilitydb/kafka/meos/MeosOpsTPose.java | 257 + .../kafka/meos/MeosOpsTRGeometry.java | 523 + .../kafka/meos/MeosOpsTRGeometryInst.java | 33 + .../kafka/meos/MeosOpsTSequenceSet.java | 32 + .../kafka/meos/MeosOpsTSpatial.java | 158 + .../mobilitydb/kafka/meos/MeosOpsTText.java | 271 + .../kafka/meos/MeosOpsTTextInst.java | 33 + .../kafka/meos/MeosOpsTemporal.java | 1405 +++ .../mobilitydb/kafka/meos/MeosOpsTextSet.java | 158 + .../mobilitydb/kafka/meos/MeosOpsTstzSet.java | 187 + .../kafka/meos/MeosOpsTstzSpan.java | 201 + .../kafka/meos/MeosOpsTstzSpanSet.java | 243 + kafka-streams-app/tools/codegen/README.md | 21 + .../tools/codegen/codegen-free.py | 187 + kafka-streams-app/tools/codegen/codegen-oo.py | 237 + .../tools/codegen/meos-ops-free-manifest.json | 52 + .../tools/codegen/meos-ops-manifest.json | 142 + 66 files changed, 30699 insertions(+) create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsBigintSet.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsBigintSpan.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsBigintSpanSet.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsCbufferSet.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsDateSet.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsDateSpan.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsDateSpanSet.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFloatSet.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFloatSpan.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFloatSpanSet.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFreeCatalog.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFreeCbuffer.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFreeCore.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFreeGeo.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFreeNpoint.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFreePose.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFreeRgeo.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFreeTransform.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsGeogSet.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsGeomSet.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsIntSet.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsIntSpan.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsIntSpanSet.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsNpointSet.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsPoseSet.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsRuntime.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsSTBox.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsSet.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsSpan.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsSpanSet.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTAlpha.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTBool.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTBoolInst.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTBox.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTCbuffer.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTFloat.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTFloatInst.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTGeo.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTGeogPoint.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTGeography.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTGeomPoint.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTGeometry.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTInt.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTIntInst.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTNpoint.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTNpointInst.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTNumber.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTPoint.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTPose.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTRGeometry.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTRGeometryInst.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTSequenceSet.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTSpatial.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTText.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTTextInst.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTemporal.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTextSet.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTstzSet.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTstzSpan.java create mode 100644 kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTstzSpanSet.java create mode 100644 kafka-streams-app/tools/codegen/README.md create mode 100644 kafka-streams-app/tools/codegen/codegen-free.py create mode 100644 kafka-streams-app/tools/codegen/codegen-oo.py create mode 100644 kafka-streams-app/tools/codegen/meos-ops-free-manifest.json create mode 100644 kafka-streams-app/tools/codegen/meos-ops-manifest.json diff --git a/kafka-streams-app/jar/JMEOS.jar b/kafka-streams-app/jar/JMEOS.jar index 2bc69e5cb0588e3a0d83dfe2aed2c99047f5a44b..48e4618f00add10f0c285701169c103c2667332a 100644 GIT binary patch delta 184331 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

*HY;%@24=)%UGA+r!Q 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

`-Ci)9s?Uu2lS2-6THk@|( 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

*Rh2q>OrSFssO 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 delta 110550 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

bnQ#N@`OdSH6_ONa?|Jl z?Le80H_c&*DZm3J0FOf@L6aqU(SH%ce4vL^g#(ZdH83A-2Y!cGL(GN0>m|>@{eb>3 zoH(XrKP~}2kts|N-lYfPLb86omkmtMU%5@_Q1mf}=!EnW`JjUJTf6_|uEu^yAL^&P zV18)luiXZeyKt|YA>P6L*f&PeuTCJ*FZqw0|4%gehy4GHVfZJ5DM7;nvcXA1SDc`O z0s3H7b5e2G03n&{P0sx5ChHNWS0j{T|9^3zw7p+RzAFD1#J#^2VYZtUPJD}e?o#K4@s~0nvy60lAkRS7il19+l$|8*5QTYeRoZx zuB5BLhuzTOC-gT(c!b`?uT*@v5D>Q-SxpmABq_%nX&@?ipuo^GpJw#_+Ud~2YUKzm zl+1q(GD@-W$P^uc<`5o+*w5O}`uHSAuiW415e&LwqqK2B|B97QF}TetKr=`y5oFZR zx2?6T<(`B7I38Hh*RWIbI91c_NB+K-*v&G%vGp93dbGA;N8RSe#-cqncv08etm7%k zF3w-By|z;Wz-;11)i`^ENM^A2x5d81GG4sq(L#8?`AlL+) z>H4`R+`CXEFO9R9^#=|n2IYsS(Nz3!CtH>+Rd-8ipm%^$BPOspMH7;BcvK>t-5{ET zh)rfB6D_M&$4CuuL{ z#D8*a>Iwnoq{2o&HMmcZk7DfU5bUXO)dJRrS8eJ>_Puf@YgKbBkZG z6o)mYyInUZC*n%ya~byL%QWQ`V4 zwv1}CoGtY%Nu##7TKGpeyQ%f|3kkqXl z8$Y+UTW3<)dFQ5ytjsJM^d6OnjoD4E&a5wkL#FQ(&)8ZfLkm`CpDnV@4_e+M2g=+H z2mANPM7gnyGL5q_g4#s=%```VR#j$J13($N*LoJn&pB$ zm<XyDaq{1Z~yx_!I-d=Z4SKCDocwZYxW#6 zLlf2L7GQ1{%bmVaVty4_maBJ>V8RW*Af(2jx3Q`|kVvCpZlNcYPaP94=d9Y`;vBE8 z#n9ru75Z^GRuW%Jm;A?TEnpgsRry7o#kADaTt+I4RMjq(W|l;?g{Aa1M=mbP_<6!T zsVvJ>l@o5^c*~AgEE|YHLz5tKSQJzy3pL{+zDLv+UiU1u%-6~y8_t(vPBl}{@YP=` zFM>bnDP|Ya#d6l@`MhDy`1g9)4oJ~wJRLdYV(Q_iE3={Cs$~fq!jA z!}GmF?y+O=UQX3vWhjV=c37(0j%fbw7%z&Nhz_mCk5iHmZS%Ga#krAs^4z3>_DzU- z;fo6Qh2|nPcdSvXEm&p7?~xly-CiHLE9dV9+zmZ&-TQ6+DE zg7J9^tZxLlqJltbeL4qPIj?c=(4Bb+4{m{6sZx%QBZgjT0wZzk;Wz)-uk6?~KWIl# z_{TlFJ+N4d!9JOT*5+Luqb6W9pI9d1QmyT>+u+)>J8RSxEj;dT~j$#xy~w~%33;T->?KPt13 zOL(-It53XFs!X^o|3-LFO7*&hn>)@o$MCGst|dO%4o<0&`>>L5B;k*kBDg}DIq0AT zloE`%GT4j=TMVUHMYpeWC9LwjBK~l0V3m*2=PW9qFE0*jo^JR!AO-Sz-3mA$zI$A3 zJW*@7odyYcIsV5R(MQznTiX`?zgc_=W7!?YGP}kB6Skd2HKXPjc2(v3qDZ2T%&55I zTe9Q2c;MEEs_K(Q*(uf@{&4N_9~q$KNY~DXX?-mt`6_+AnE{=ixJ))o?$hh0JaqUUBU0SbH+s6hn#3Rf&Au4VPyG!HP&CrNNcCrJ{Oqh&D|S+m4%^9N_8_W1frj*E`*rT%Uz zNwlnT`=GHlf(;xZejZIWt@11H?tpRX*==a`N2xTMNF3*1>XyGCwhPgYyyWxy`M;w& z*2Z`k#Hw!FYBNhcRxAJ7!m&z37e%Jmst2VwE`~r<>Mn(@_gczS2BL}rF$R@=2f8g%6n#v=ofaP zmo?~~cB{kD1}-mHsi&30$k%#`*zjlUXjL3~X;c|`Dmb977fAUwj1vOB%vmYfG}vWh zvZ7vXeKPn&(-|Ci9pM?(=IIFQ-)kuLMa%Q%Dju`rvHX>$QZ^W|GA?k08FCUi)7aVM z48EsZ=Fn_)Na0HBD1TLTD0aiZBKfVH z^UTS+CDn;CqFctIODkptd&)@YAs*7cB8{3tcFoeEy3jtu`a2Y~0Sob3@b;m6%Yh8? z{~{LlD6hN~2y^Vw#y#Mq&x5NV__Njd)qCq_jZg-O`tQrd91nA^ZR#rXj1~7JW)J?I z5WBsH=uvUn)2#k&dE`yb%#3f?>WNxC{AjUdCvT$79C_s2yWcqa{#>u#>lHaf=S8UP z843)upx6>=T(Ku;^%`>i>^3E|g~#*6cvx{`GM@P|@II&LXR8v!@X8MrM#wzrUsmuAzni+I|R9-I;y@s-os8;PrC3_&CEXeiOxBNbRdXM@oa){DNQ0(?zy>D0Px1uYr{I>R zv8AcX-SpcaP1A(HG9n;~xU&GzpDw3yIznmHX@kG4OJ*Elp^Uq9x0^_YaQv=ju9Hj4+vl_3}hgA=l;bJ zaZE#Bjx)la@(wL&I9W0hs}_kxH6un>-@ z{iQWmce{Q_ag7nd;{V6E4(GP#9Jjeohpo}7CqjL}mX0WwQrO?6fBQYQj3|x&CL;eY z-EW>|YJ82U?0o-l<^_Ns`}IVV+SCh|S&LK9|zC15C7>Tsz>4Kg98*g(|n-WOJ4QpK3>>Dv!rNX{iE;)N-iNhbR03Hh= z^u~UukS>fSxG}-4H$8WE!|}TyfYxc6#D53hWw`cN*t1fU7A&~}I0Z8yT}tP<{7SP* z%YA2yN|^ob1o&dJE{L_f_Dztg<8GVcr>OReb25vq zL3>*^?z=mi-d1~NV`l4`32hEczJoGle(W8OY1*>V8k9pDSGc3Luo-+K@cWGFqTLU{ zKO|6Fe9yxkZclxn%W@jGU{L!Cq?(_)QY4fbsN z3Wecs{WzDzHoiTfm0#iKlzsP@t8mePB$!x_7~9GGJ>5lPf*;xmZ40WC)&-*z_wJ9r z0k)F`D(0-Dp8?2g(~ba!xT6w&0A`6r}9K@G@sM;Vtkohbc$?PlUdo*pvcEkYvc+Goc zF;Ecx;l;IB0ig=}BQnTM=;fI3q`{ghFw>K7PjJA!$eZlqN75baz%B%PYmlN(iYMnD z?MhjARuL(?tneq=DRZz6R70qV4s-*gF>()@&p#=8cR(D%ug8zQWB&dFtiARQJ=Kfq z*8zPUyi+hBP6g~1{`AH_yLXzn4%z7)cpcb94}f_3d2c-wWqNG376@}HTl9$!vY7YZ z@(Tsar@!JHs!CoHj@+}{h+B)QK0$&1iK>CDkcOYe#t|R(jgLYXJ&*y|Pk3O*lV0fF zeu-*^mwrOOLEg>-j&Vi*inL4c+k^QQy1#2_R%4ZjKUQJk#bmPTS3f2f zqDI8E|K3}h64&cM+;Sa|n`RARuh!mB-4xf61!Sh|jp%FW@2B&5kcLPviqyNR!P5{~ zuxwGlQx<$ZL@#a#cZxGD2*L%=#R|kUpcPUBsdIc=CQ951=b{YK9}pa93proo>0div zKgV_ozKaYnYWeq#kr0x%*7~uYC(%dvG*i?Md)EOYjH43Hbr>#x6S!webbMlfcClgf&1Lk`|m6q7keS@;g|0;JYbuBW^ZiJLF~v z>41tUek1W3^abn#$cwOY89%$CmKNmez`E#4t{<`N+>J1CGIxU~96sb-d>ecb{I10&g!D zFPb;OCld(o{o9_f+va}1v-V_)}T*CL;N9I26~@^)?7n|2T0y# zsSDvpx;7Xob{QHG^3k8g7@683w4X54^8$XT#M z2%zXeJ>5+C_fK;L^N~^rT_6s5?RG^6^o)09fyM3`UQ>ep<-Os}Tgo6d4>CA0DB&at z^kb7_&eDIxg#@Tly{F&u>~YJ9BL|>8|Mvg1P)TYNm+MeD*bH z^<%|j=AniHXX<>r^-R+D52s1SPxSw3d-D-~8b^Ex2zdSftL*_vHVX$cclWw{_;gF@ z%~{`L_3_(67~?nc$`zW+V) z5!q_qs5R+VvF`xXwc%|PNXUw9HhX<$ZGEb)op?*-Xb5%-PAxslferS)9GEO@uo(-Z zujuUPw<*`2@sZ1J^&EQfW3d@C$bB7y#etbRc5(moeH?lv9 zrMt%cjL-hPf!u`xGuKs0v%c;=?qmWy=BieJ^En>Nl?71a>7vQ3En`LIxM-~DcsM@v z>w4yB&`^}9z8ls(+TyC?Xp-TKgr6haxvVYdQ$?vsE5p%`@lzbj^@;m&QdR|( z-LwAn6PLh^%eOh{z3K_U(nvlfV%0Jxw(l?J8915 zN==34#LPeUv#HV5aLfAZk1K95?gyiP8%H)r9@||Lo(~%d-5!97d^vNRgoqkC9TZ`m zR3oEdDp8ircvjm9&V_5I%h4(XXtUO!-#30ppn@L&Su%kPDJ`ozIwOg;=%UX3z?8-wP`KjX1Ly#r(lQo-VNl z=x;3UltkDTBYCg_~3kRFCui?jke zdZ>3EX}*6ZrOOO^fasdF_GLsm$25Cfc}m8o7fU`W>@Bvl(qG^(LbaR}O>ucLJiZ}s z63H`TD8-Ugx`=dC?ZzX;lJ@uLS(>>lu;7Ranc1x0P9F;f#7uj~UVi=&$<>gjW>KD1Ws z2wi;55q%CZzN6Sm94hk$gxk@E%;?qcM`OladSh03oZh%o*6XM?N~K<{jxsa_fKw7j z@dX;ZXJ0^gaaXCWSjgRqr!kE;z-%jZlojCI7^5Q8?fDa@=8Hc2??;(Zr&5#x1r-HO z6Zzb9i?14WEb#Hba9kjJrLQ&%v$ef%RnhuzX$fCSDwtU%+rh*4i}cuN+= zku7%pTshjaV|p?N`>IhJx4u;|q9!9I*}0Rb42xVvT?#FXN#%l}^1GOK2Y_w<&SILz zU@epwRg8LRy!jU_3rte=#sAVNir z9DS5e7u|NpW*@0qA7Vwu^<_FbLiHwshKbU)uJ;Fz`ty1LGky+TeTaM>%i+XOl z+B_=V{+4KVRPV)@aCgy5%A?>?j7PKh;xW}I=$Lh1Ip|AlfJ4OvjTne`G^8$oSy_M5 zsBTsJ8!5R_wIiZcX7Rf@Qbvz3-EVJ_ueMy-`?fk$w*U>gkrV@R4d4WcHRQ9Ta3VJs zaeAj;S?m=Na5Li0PnE}qjlE#g6p+A>!}Y`30B2ei&M~%~;kyQ06`xl|wANP=J~xcZ zOMw9amHB$#Yj9vM4RllbiD9BGYgT4J81t^L+U@i#%L1k=upeJ!jkmmJTSYf)s&A2o zN~21zqP2J!5EY9<3%EAB+Nwt=*~>MLg$_a>{=}_hEFM zQjt*74<$iJThx3VDYI0kQT?T&W!ER5IT=3t^^2xc-VB^10PKffE(%mAwS;i8d-8do zr^?`Wdc+|8f=5ylJm2vcK%sGl&1b5ZDG#dY4E`1nT*(tu%hSfauCRr#M=EbEWVJ??kP?cbLjF@^M8U^+wQzH!jm?e`J6^z+?Q zDK|gV1@<(BZ{3{SdL@##gr)lEs?_|K=iaXue^jF_Wn6+i$M*J9-Ax?S{*o@h?$}g2 zBQ&ccSqG2?=I@%U<;#%~v$(Yd-s&(II0m6@)Qm!#DzYx%&;4|86MWGihcI|0flACh z?6g+YNvhMMuh18nZqqH)uIDollBM2E`;0g~QPtu4n<39;Vz)HvA1ufw0AElr7s{nZ3i|kBjRb?QgS}+lt*FDoJ3zM@< zCu5Bc@;V3E z0uOMZRxxiyvHnY`re5rfTKzj_r95Gl2gxes-mr`_A{tM3@TAD`v(If4!LCJ&HS6gL zg7@jV{VXxck`mv?iULG*}dx-!y``X zEy%;z(Pf)eisw$JG8|%-CPiDQQf^C`kpZk+@@54}@gw+-hl(&pWUAMuFqS))(V0d_R~BMSi?9%#P#{FO<>SOEk&;iN{OxUh~4%ig-PcpCrE0 zPqCFc&b!>;J~^tnl)y5JJpS#Z0kybYAX7fs6{%`d2~bWN)qLCb=ow+ zXkaThyNMG{%(Q~TT&S=KUFk*?ot>06DP?CKldeh?N{<5?492@ zUpAg_b&h&fFI3mJct$u={^?*aHPRN*y(<@sxvuNfxNktTt!lB)z=XzcHjhh>dn0!^2!v1olEVC9cei- zQ5TT?gp%5!Jq^~JX&<*bwhoxR*zllo{SVwLJsUooeo1$Pa82-+wVk1KYWMkfJELKXqYJpuYcMQPNRK^^_{~#XEv2A`FN~e z;XAb^zGSjtR_l3gMs?avfYrv@(pdcBi-7Vx0eKcPPN7TDmHP|8*-_wQ*D0HPz|P3) zIJ(u+URZJp}K%+n?V!?XJnQ+ND zYM%0TRMf-RP~K%~Y#&E{O6&P=cb^#!({|;}H01k2-nTRV=IkX81}z#H&!pZ@Ds0NU z)G4J`BXiFL>~1#TcVU)3C98#!Lb10ty$_?7VTMW6OJ}&08kBk6rkos4M&eRM8q!jy zg4|MrsUmfT6y~o>ezsC`Z8>JVwA7OoI7W3zMTPQgJqwOha26 z?~2muZX@&MAB@-qRn4Ads1E`Oo@LDQ2P|*7!#B1rcKM$`?+ew@YSfH>ongAB?%PA- zHArLYb}X5qsk-sBXgc=8v|X*cN}rgl)SxSnN%O&A44Mmi|}m8AHL+8Yj!)@T>OlV^S+^@ zjse?!^yMQ^;4iar?+n$CAJ=tg^?Y{EE>&+6CF1XZ%DOHIm5;&YxMH()8`+FG`Ay4# z(q{wij+`Ve+g2UU()kTOjgsOH0pss(q+?PgklV zLWe&)woujDPv zy@GE^1t}lXjs3_|-8CI~hgjj>@L8e$!Tvy~B*=JYC-s%0hrN@$v)?=TFofar>&{?m z6h#0-CyEG)2+3*Umse6mGFUQHvIA1)9LXmE4v45h5nTvLXDK(FOOD7JJWS(6Fa5m? znrUO{W~66u<b86$&$)1e7;KUxs<8{HEtcoXDHV6qE22j7ou3}K953}cL99O~-J=tJlu zIOPeu@u(2qAkozT*AViiKhll1cV5&#*sXTsj{uOrzd?iPz)_&2fxJP30fWKKfz4iW z#htxvMqm6x@xND@J@C)laW`A=@4!0<8WaXnRr`qQiJ~PR^t<6M1#tcbp^3qLK)r(% z!vR<^v=5?#JH-Fe=qUlDXVC;O_r$SY{Npag8_D7)-d_M-Ea~qD)P8UDOJ6v68pNF3 z9}B)7Tpd^)m=*MFeKlC z2sgRk(|Jc7{MSVd(+|Kn!8oC?!SO@#!}3G(!*@V*z;r-$z;!@&z;-})zEvsuE2JwpHpu_O&i~K>?SRBUeg7X@ZvhlXw6*O9cMa|?!QI{6LU0cb0fKAe z3~s^QgS)#!AUFhPa3_NVm&-ZdSNFg5*X^3>>RH{@)78Cd_ulV**E3^IV$Q%A#s>^o z3}_5^42|7QF&sm9GI%m{GAOeD&72AM(dnSkAgG%`Q!?g2N`B}8wI>TxK;wM(c^`~i z2b^2zyEUaIh>n8cOz8_js~ix!RAKec4x4Kb-J z#+O?8+@f2I*Y;N(+TPM7w71h&KAPV0=iE1z=Dh3PSctcs$>Ct{<6)(L4#wMw zNuU>g;W~b~e=NW;kQSH*RJgD8qHa$tc3hYg+*-V*B$$*uhXOo1CL!NVPEF{&Mdmg> zyu|*(xZfIVdl0>U&#RbDa;j%)h*i@mOPwpz<0&u112PIGmG`9g!oU9r`350_7(+xM z0T8IBwGbP=d!skXg*P(@7R34&##21iv+Iv1j^&WIe*n@$Z67e&ZxW&ws1~eNK%y2h zoli0?iSc$ShVc63LF3I6e9bV80*(eNfhX$jqE^-JYYWLBy|4D5JHdPSd%6*f=h`>C zd)_O5gl*6MI|_h&8>0`SKYj-Ip9I?m{O?W3U;jkB{o4j!#6kcG-#6T6;(JdBImL55 z25>e=4m?3dMgOxs369UGy)r{JL^C7}6|;hjqQ0j0lXKl$!2f3#;WJ0b{|4R5y$3i= z`4IoF@c-|z{p5}AiEln&NzDK2WP<`}+u0M&Q`V z)%}irj#y4Y&c4nF&T`K5&eoWRW-TafOl`z%uX+p@Yo`Rnw zdV2LeSD?E)&#>6-8dLJY4dM} z)}uiocryRIEiAUX1}kVb&c(P6(A!lh>uXa7e`2MLoGdDqbGH1{h&8k>sv2x3j5}>& zyk@Uo<*!d_7U8Ukm~C5RRbdr`b&U`%?QEk^7P+<)soNch{b*dxpl}!4U%p*a`x1awS_MnOE=YdMyIHP z74(8FDE)hG#kL&du!>`B6W-=0QV1qWl=*O%0rbqLmC4cwjf|02L{_b1I3Uqhy^{`H zpbQ$PAVN~^hO+m~l-BA%#EP7(Ya(i4lCty5D`t7gkJjZ72$8xC<3~?5DEw1;--SSE zn_(FI`$tr8!z7`~z)Pf_`4O(lZQT~4VvMCxOn7NiX46DJr)G8a%yCpNzjMyF5Y=C3 z&|gdlEx#?MoqVsh;;Jr`?E*M$D^DlwK2<*`gm`8uHdetD7zmU`AxtE9I9QPf-4-k) zU-e~)wnn04MX*{3U&`ao{B~fBuB27>N#8q~32u|%Vx*E`MGjB0b9YLeUein%j70jp zz+!Lg!OZgY*4!ceww*t-3YET-w%)dJGDL<;w%)hTN=w?s7dMT=JqS3%ZX60IiY%>C zYT*RQDpf%{xE*zs1bA~I$!#{gq1U@ho|`D_m-`ErX(*a^4StriBKKq%a7O1F2Iy7vAWgOg@wY7`+D`Y~5KRN*aG&+s21HQodlU(sK6!BNV`h{q@T~%t@*F_<-*4n7t#lcUh z9^Yq1dzBb>kbQ83hnOu_PJgHwr(->3;X!yV*;Te8j}CDdVKmy1>(AzxQ^_0Wi%xO1 zb>mcs8m!=mw=pL;U%>O<#4viKi}gJ;&R5&sZ@013N(=C4U-;CD@2L1Di zm@=GW_aJ&7$7tupgSy5srOe~Z*PhlgQ}rUgd;Y?e88a-=KC&i!R=)Y&9qK6_-~X{v zOLVa0dvv*xxVx$-bwPd^Y7^@(Ynrd7tOMhHOlIcXb8E!O#~f_MsZO)Q{){~>-+pt* zti1BVjCA_Rh9mp~G=F@nHSYe07U}qxPDDML|!dlF8#zHGV#u zYiy*ma+87Mg1i9OGCU>zEPwh_vF79cm24Qd?DKbu)Crg`hq?~ac~P=+;xYvZdOn*8 z)q@@7uvC==)tn75SC7F1R;rrOnW8qRa>5PQI;Yrub4%G@fM0vgS8M!o^2z10FW2caHF+!dyS;MqlYU4j%G$2vC9L|aNO(gW?75*sn!p2(<1L3Ds^S- zj9i(To4iZ4seSL2mCE-$?tFH+h}oNa*T7V;{(7aLV7#2Yt^<0Q~{UnB9dH9yrjOyu^7-1!U?zFcuzs64Ip3E{Y{d_Yq@r)ab zZ2%r(AJhw3_mrMo@nOszHt8)lZ!3-!&d@z$4+=|{;+&uYKELS; z0wvwP>?st4hi|+%6$AwAt0@-e+Ki;*C3%eO*E~PW);waT+1@n&}aS8 z*GSlsaI;n;#>g6p9E54Ktao}fLm0L5Br)fd;>GGKh($#N%tV?>FSG0gj}B z2PXG#3s9Bba@v(T_!^l`i<;engt2tvUt*6@?0iBB6&W|Wpl%D? z5?-@b5k}%%2-1lB7V}nhiia9<7Uj7nX}O>FD(X9u+OZ<;A#lcI!Y+aEomwryzhlmm zJlq+k`0v6ewfRo*^y;UWZOR*_0H@`6m)<^}ZBRlJvWqx4uxX z_=mbol$Qz>t>q`p;6)nE4qYB$&}pjRzA_=8N~4=W5QOWlkZ`elm5uEcT0B;eoZ_8f&kzx1xM-S`s1c~(niUaTf{)xxqzhL+*BI#b*h zq){2vT~)QDV~RQ-7?tRaLmS~3S|YD-RWI6a>3cxnpp@)`23Or85-$GJ(|&_)BDa8R z9#^WeUhKM@a~ z4-LbEOL{%=EIi{q7>ixklf_0HW6k@GQH$+%2j2vlR~puW zw{8~dcm^VzUO`%#n80_H04iowRJ}5bPVOC_?#NvK&0n!e{tVIV+28$&X;ItEMjgs& zRX)q3E~*aWD5O=PPbSybHs;f0@q8K&-=QEvlTEqPZ^pX%UBr@Jsu*Q{nc)d(*=an_wzLdZMd~Rj@Xco zI((`><@}>(5tu?h&|j8uqNzHKqp?KB_EY^9sa#$-MLve7V-_bQfkkA8?@5ss7(MaS z+fCyMz_D@vx8iBcWA)Hnd6Gyg$U{c(gX3l*yvkv$P(1wo&3YbHY&%zABMP(HEJ675 za=q^(@w&x6P8uMX(UHL*s9L}lRk(#cYjMbQyh9RIzJd#~P+&Z+XxkwFKfU)+6n+Pi0Kx9fV zEA6()!Hv#msqaR~-7r+nqvZYkJ!5;-c!=oKkXio=Xc4FbHM>`vKv*86(h_WUOQj&3 zisl*xhtUU;i)J$&l0|s1MfyKugZ{9bR?(_bMXB^)cx3L#GZ~_O-v6>zQIf;fu*@1u zji3`Afe#hMqK0k$REQN-vhelSxT(dieJ5pNd8-FPY>Gn1FVI&xYnt!QZdX~B^$cJ3 zbDEC3l&k^X7^UN?LH1qtN&d6hjJdX24vlL1K^iOD#$(G;Z5mW-y^^_Fl9T!)k7nVU zawpx46PvtNO}JZY8N$Y5x=Ku*Ynw`-_TGHqa{?int;DY(O+LoDr-sE!p%$E+n769< zmanmhpLy3Qn1*WYH;1mWt3P0awXf@U4$ua{i9<@@vHj%liVh?##5NL*ttyIek zn2?Z=+cR0lhR)gym}m6qn)Q+&~kzv((<^ zy+pY(eT?LSxJrbJB4b>)_d>yRj$kAFlO~VbZMdtguC4p^@}-sL;Bkh<0sX!M(_|-N zttX(f)cArsYw4eB5D)QLQZxzUWy$DX{Tr=P{CKDUIq#2Om-Rz)ZMM#|!0?Wa-qo+9 zQT^Z4#Fsc&iA7s9m>GtZ6gKHCNKw{U)eVCyqBFFitE%hNUL(0HjBR#rT>K7iT9KJY zd&RKSD!Uw?2+GsvcpemcL;h+i)=QOG8-@TFi=XY5`fYzJ(^{>^Y#eZF0{X40%=Eqp zFAJJ=U8S|Ord;M^$o7vsjTx9u;uJDvQMKdfHbcvIbZxone~U`EESl}9}lT(U;AJt z)NzR6w`#du(4ta>U>G;?$p)2D9j7~n2;IE8%Ay2k1*i6^ zVXpVm!Ma`RQD3)D;uTlutm<5_rZGJE`EaA*eIj!os5-9$)GRX_ z(YM{+DKxllS@WvPP#qtyNbZeP`OM;z>6yiA@qJ{<;_JvCxx}YK{ZhHIoYD7A2ey15 zjiNWaAG#@Tc%i#F_Okf1u+jNlk@!OLe)n%dKeP02A>Uq`_VOG#f&qh>HHjXPdm(-y z>msG^gih^iHsNbqeX!$>UMnsIl{wbUwjAvee|&azWt&|;ep`DWm&CH6c)g`!GoEAXaxxe8{vBJSR3orG@lDw_!hP ziRU3da{qWj0w06(pt`yG#U>tTwpa3}CH%zTUR;9?g8K_;IK-X95~3ATg) z0yi}u-V|qaD2;Wb{t_*m>O;iPUfrkuh4ST#@QrZHsiZ_>chTdo(a#klMiXdvBHdSs3P_5iEw#eHg^{!2~t{LkPN*5$ZOsP|o<)8={Ffsl@!H!b7V?Ha1N_(MJhV^V2SC5U zJ@d)^f$9*)_+LkR^Sg=p^g|hpL11+suc=TS%rep>RA=BuADJnc?uT1wAi7V~RE+%X z0u`(bW(GUF6J|R4{@vfZ{qf|ZSpP2(1We~=$4k?&eqH4!9M3F7qV?aMccGFg}%2tEdq>*q(d<8)CUGB#7J(i{5IU;_pawfkiEE_DIo;l`o7)3(W35U zxs8wN7m>of&T2cm%Pg0|gCc}Y7!T|>a^mrlWa0qo4gcQ984L-wV88cXM?O=6+)Qn7 zjYJRZqx%fnm_?KQdzQ7Kwq;L?dBQoD_#$tY=c~cIAkCD80HQEA8Tr%SZH>N9drVUf ziJs&}^XDGss(C@(;wNmi=q8b z`9+UYJKw;xO1>D(qt#5F%tIc`=D@Y)-IqJwfi;P(?M($Q{GEVSUySYUd@+n}w!j{Y zo0kiGByzyHR~qy(Hym(m-s@Ix(t!cpi|&Vb&%Sew__(bxbj$%EM|gofateGceWKac zx|k20Zkxsyjo=r-@ay+agc#HTNcWt3Te9oM{eFJ9_oQIYpe>jH@_QICM$j_(200Xf z`c6(N>&t^Of$52B>j`S>iS+3XyYG5WwtH3xAX0_@H{|uht0-(hsK?9yH{ZZc8hKk# zK)lZj)W1jSn^)K&(c@Rbd;EpN+P+?>H}q$O$G>@XZ}^Y9TZR_`;`m2Uf4~nRt#nSU zt$3|>OW}S*NAB+&8kR0&W2U43=H8X+jKI5tKI^ZNF$OyZ^9SDo9RT(}R(h^LuAs)i zMsG21*T7TgKQJ{I>mS-EovFbieJX)j&^J{z^7c6vw36<0b;~{dY%TiFipzw&+o;P3$ung0qEE!@&4+yVdTs6FbN4+zZ_--x!S`B@Cs*iYC?u7GVg7AXRkNyam0`&KuP=Ddy$c{Ephz<=g zfJ4K-qTrV!v253F1mV@%ZnmOalm4!!Pe-*-Omd~xG)pDtIP9Uo)$SfB)fIR zcxsP$Ss(mA;qE^?>QkqEe1T5TTjr-3jp28^odo|jFE?rZrk^PK@kZU(_wFL>)!xMZ zqu$R}Ee^T7tM~2tX_R1Sk~H!WX!PVBD(vK`6hy#1eS`P9nQgvZnb={z)bW??eCecZ zRud!FH~eqBSRIt!XJrKQ|CcPsFuis2J zNS2*J9FAd+0b!vLv=g#48l?WUJ3iJ8h+ZOWZt>{@)vT<{>zN3dhK{hb`wsvh;>h&G z&_qs5c3D;8Guukf+gnuTUYF{!r7g|cW~Z;Xa51{Bp4FcD?X;%MV(t=?^;sEBs~zb$WVt%)H(W1Y)1~X#5EBxCFIdwf(IwqK7RaYK=R-^JM3Zn7;J*Xa3|8vEqVz@g* z#GP|_?F^@)ksxL`mi9*Qr8!7HM6l{4i9NMY(9$#K!1kq?h$A(qo*CdkMlR~+RsZ`p zM-FnuKJwA<-#`lp*G!rH3up6DZ5D0AVWtWX{G+}Pw5&^ZF9zL!ZdiqOvt4x#X#<_h zmymivmrq32`Z`Y0DtaGB^rac?e|TJzN7tjrxOc}qiu?Br>ynSa4~?D1EN!-jenYgN zmP8>EH0@6|Q>MhHg>wMBEwu==Vt+%!OS@Q4i&t-*RSZY4PnLqF)}TjHX$q zJo!8sbb#u4VjN=}&w1hPSY90GVMacQ?m8oeWXZjQgFGk_Ewzi6j#Sw_cs)4I_bD}s zA}u|3+8C`qdf=>p2QzC4CWB1_8OhFduCP{7U#v`bfeFsHm5I7ugkn+-ta@nz$ zVio1HPjVRkJ+~H9i<5@7Ra%da zzSgKW7?>7hF%Lrk!%>U?%Qe9!%E;!3D4ue1wzY)6v5rcNP-_NScwYefEgyQF8?8Xh z)VJfLhEJjmU#&@DcTIOOl_JoMBCutkJ!LA~31SAzzYN!uG|T^>HY1S{5t#e(E4yof z(#l%Ro-CbjW}TNk3pCotpPK!{{U4Fp=pcVkUDJWMq-wAW(BKj!kUVJ(RjEt_8v_!k z3NtI~=ilHTJR_yjU0nfSV^Sin?jf-u*8Tiz{G%jAG#T(i;@u^kwW20i#$<;%y^__} zrrA!0rlO4ozP<`M@Vgo9`2B6mZ8WAs8EZni*8ON5dz=Jm#5(Edw#488+|%avE3CuB z3;QK)_L@?_Hp|*+$(M8inhK(GN5Eyg*Ik8X?j9s_^PGqYknj=~Qws~}9nQ2H6); zA8rE6t-<>sbLR27Zr1ZRq><^bfa+lJ$AGX)V(rOFiaYiKpzl7p0?+Vg)iYlVAn!W! z)mUT7;Ul{eG}L#;><5pV>GBgM54vv_)VMa3w4VHYO z_*lb~j{!>S4_OK+@uZ-dO#vSLN`&u-dkRJcDRq?U()oMN2v3i&t-<0cJFdA=Yx*`h z+&a%vN9?fS^9y5@s)XsA0c<+SdV;XTC5=T!NQ@)Cnd3L>e!XS~K z=90vG)rd`rT1k)j<&^BPCPLlRR)Wwu>miTM8Ij`nclq{JHxx4yFq2&BR+KZ-Fn}^S z?YOuII|0h1tf{JLjcwWfQT1=WFRq&DOBwbpjt6MzwMZU`kE`@3e?V}Phl(S|$>rT5 zq~m?YLERQX{+P>rb>syNQ&!Cvn*m%qU-dgWe10PtWi6~s3lS?OH19nkob*85l5ZdG#X9-zbRsMaNeUw674+5kx`MI6bkL?(f;Z#Wq#mPzI#liAqLOUg0tp;`q z%d?0iANiL^qIgHDAA~J=FYyC}q3IJ~IM<(A5D*2Cf|AGMe!z`iX<_ll?jojj;t0Y7 zaVZou!6@!Iz)lsUUM>BcB@)62x-PGe306Fkgk>$fjl$cryTXQLEunKIVg>pqu-bx0 zMTWhtaZJMc7KJaW%>^!MWx#?GWu8D*01PxAatCwjO%_&L7)(O5HpN3LrE{lOl>UCh zKn~*iaL^QVHt&T5*cjdI6HVntd>@Q(ea;~)%SR+1#GnY6`1Hjefo!P>+QyQPo=+Bt z!m7|_GT)TelM#hwcIG@lEkJ@brdMi3@p---Fy0j@^w#`lsUQEmr1%*RED#_KrkCVIrn*go z?xlb*NqCbc;R14C3`wn}&IIN+l%U>n5|4JAJGNkWC_P-vlwb*1slA-w#k-qtv{lsn z!KOdJNg~k9hGXa>Sjw1YZI9Al_%&6Lt)y&E85vVb`TX8W0@$NXt_3gK=9%$WrN8ff1a36-0Ck`|Nr~7e+tWVCog3^W#(J;_O*OR%vtV9BwMimNd&Ek}-0BiJqDL^I98DH*@er{lG66-FO z8^%b3MS6-h>=f%C-}Nl1f-5n9G_PvcEn*tx3`fc|o(J+^0fy12EN!Vh*v1I`?noZB zF)WTta?UUVOrmW#^_0QH^}SVu4ERgfxiMgz+cXgj7DL{8#$c@#6FWm~e$A-^#BUN$ z=Q8v|OFpYvzwuioG8g-+G1oI84Ix>Nw|_`SS`feCuW#x}{-Ie~-|fA*0p3tAKw#Bk zrzzTSUPy2!K+(no;HnpP|Kr42C+)Z5v*~_;HNbRm4{;S-JDo>zkgF>tV(b2@bRq8C zf$GICV2${LMM4u{&0^S*RVRQr zwQp8qb~gBcc%h)aiSB$J^1{-@r*yQ5cp(+LT1yoN;NMC)1EdY4&J@82iJ#zj=)Rv> z7DP~Z{ah;U{-=1fjYuXjot_l_Nsu%QJiAaQOQAE4KMAf!BpVIUqP;=&5OT~81V;}2 z{E51)rZhH=n2Rl}9b4?-bPtFX{;mNZBj!ppD|)c#u;qk-SN1ZqRn$9<4PmEu6N*Br zuHX;>WBH^UPr5QDR#^x(zSZ5ZC8F`gz*$fLZLkg_Z^!5Z52EpDnB({#YA-2>EMHf? z#uRG@VZVXb$-{8U8fI5cUofEF{;|Jv%$HE45Yr7K_%7-1TrPu)STIJyWD~u#a42|? z$b9XVAvoR^blymh={NUf>%6`U%Wnj2l{4?12H}m2BH*b^0g-_RoB&$bysJIQjaOhX-@xw;KvZ8o-|V!c0w%*8#+g_$g)m&RlqDM5O+c(ONNMx z`Kdv1iBrP9DMmevoEGoIt_i8YtWX1pWQvUww<)&yJlr-ri^xL5+>A%AxQrev0TSC@ zWAnXjLW-5K;dt+CtJolgj$F=*8`b_aPm{EfMhD%JcVTO8lhIt!#xpci%GXBi_HFwp-07*{OXw;N z>Aj`ViLn%jkL4P@m_dxRK-Ds+FH14?mJ91-XXVf|>QMyoUy@-79Z*i~fG7F#Rez=5 zu&0Ka`{%@$7ZHSl_Fqb6&40f#@{$*bcq7}_nJ;c4o)`6|bolj>OFkt7u-#AwZ!lPb zpc|(-(=?)9kyOs)^BD`1^`L+ov?P5J z9FodqGL~SN-4Ed{(;<7^BkoYuJ4}9M&|mHXE-b-lgwVzUYkwN#oRFDzVF~8RIFCbW zx1jLl%RQ=4R&=AC0GM;&w6@tDJsm1d6xMfZVdzxph%=NG!>B-1djY9o7E@FJ-4TV~ z4OdbpqDEsY2p7)3B{jlpjM3Uon6~em(d!_#{d+`)}+9STdx_* z^|%>Q8YzI?#{5F^=-Xo(!LGu{7M|1{l^c1A%)=#bbQGERkwho(GbBtbW`%X4rf<8Ud*z&uU$pdwNMAvRkL!V{hyqhU8l~T4Sq> ztxj3FnbO+L0hz=lX^p4>Wxya0i8Q}-!*$#lS?9hptl4Ipa^><%LR&rN3pms6Q0 zoB;}by)woa)B!#Hp)~zf>!zkfpS|z;%xItlxwbww5v_F>MgnRq&Wy&Si^l zOo7B^Km`$F_YYNfu7exw0ChQF82fA3$BTOa1gyD-TFoDyXhcYFShSsgy8fq7uUyPMfu>yrV-CDLex1wdAMmOO&1<6FLl?iP~qgc~J*mi$F zOkQ zE3NrFw?tr3r zd#MZ9#NU3gF~;X!$el-^@S|{ov#tB#$375|Am*n2KC&H%sNDD@-cEu_9tqK)X;qN> z$L@?eF#28GMc!vwlx+JWzr!i)L`yQJXvSa*`r1fN6vUQwnqm6^HFWy3udg_{mo>E? z`X~b%vxqa!y` zBZ>`b%!Z9uOjAw@RcThNCbLmJCwbwlB}_QgQcPx5HyAmN^~OPnL$z@xwO?35xA5#q zvkF_@SO@+_%7npphWZ6UB1o3tCg`X9V<7a;pRdj2>HWhYha~JTjG8lPh`{i-Z`CTN z=e4#*5VV0U?9_R7##i4^0DM?O`~yeo}(a6XL4|^?O=@1x4jt~jfH@F z;%&g|OJzPQg*gQ_rpXpbT%ificPE?lA11QJ1Kr#3miu(l;j@Y~gKga%lzj>0^wd%6SwmBG&AESAnUR+E3d(AMdN_)y3LiTWzJM(h!J@XOYQQ^A za2Gd-bjQ?7`&3G*yrfT_hz9(uj|tJ;T*gd{z2~Tr(wrCvDQ{Cc6m=-^%6$D)%gVjJ zWaBE`GNYnl*oaGIaLU5eFVw(7wT7jCm9N=Min%iDlHZ^jeHJsuN|MER;XB~-l~3B^ zFz6)Qa>AElZs7ViLK@X7rtKl-sro{s2wEaKdcELT=ARtUr0LctW?EoKx&!n000JH` zGWWqc-jy$%|Lp&WMM&|Bfo+)90W)!hq@J`?tt}&ZOchIwjjIrdn)|3ODsj}RK z3h}woW8Oo=-5+vsyrHP@SGy0dm)i&umCiP=eccSh$M!w`@_6|fMviGelhg^UQtuH- z*X-ll@G)n#ktGr%*4~3Phg3l8lhbfnh0D%NRIQgn4d{x;o)p0MvTp@SPn}rpqh!9K z@u^Rk?RmRD!`EDHB&5l9_$&GwE~r7mC(MmT@fo97-oYVN@cQwYWtiTpWD^1LS=LzI zaa(n6!PUzspsq0|T|rj+-k33_DWa|GBX6|CKRLKvTf2uU(whxs@*#3FLZGe*Ct0$% z>is8>ADBnWWgCzK`JF9F`;+)bjag51N{7hJ;e-6jg$(?e{bR@YZYhrco~2*p(r-~- ziPW}t!?xn_SW5Wx=1>+_RqwRi2^C`c|tV(dFD=8FjvMIGoE;3a%Q9F~I5pX40dO z+;o(d=T?S73-7@Rgfw2}xFhVYw?Zv9de+Dz&0_0Cr3P&y_*qN;D(&oc;lf@2CJie! zHyLSq2ymMvCUeroS@_W?K<7ZsO_1GS zye;vrYg$31Su~`Hhsl(q5s>P^_<@*OVHQOPV{f?E!I%~3+Y~Xz=0iPgp#kGao7)Eb ztmA_jn2)VR&J7_z43hCth_ZvLm)z@Mum*H70@&M58`{XaVFb8Brb50*uX#m1Oa&1Y z&dVoeZ{6p`+0Z-1dyT#-OLyK^{G4w4E76pO0D4Q$3$qbJh?U*#jys}2h=sTCf3Nm5 z!edm;j6ce)Sz6@i;VXQCa20RgZ(_{8;F?reJc&zVM3Fg6NpG%`|8!A=wgk;D7ElJn z0?}kqM`kpYRpXke^Rv{LBAh-y_$9&YKQPdvAN-vmj%NhY@g*aQnGBZcDsm%^9UzbnW$J zE@#;{@f%sr$udg&o6VRb7HPr*wM4QGwAr=tat-6u2`Eo0AAAluuXLY3TOmi?L)R^p z9&axoQSomC7ZVL4mzaeZPrgQk@bOfS>AfW<4gt`!^pQLblu8|Yw$gb8y!f}YKu6aV zN#V4wTsje=vGfgXrkYRZ=3Uzn6R1aVD0>VpUkuGe?gkC|T9Cof7iG59d&);$@5M-Z zi#j;7TwIcz;*nCqE*M7XViXi0soVel9?PSA6p$g+)Ak(+h&<8>-RD;R^#VWZgv8t- zq4(e`4ZI6z&^phMkA-4P;XhS@d)(PA9Q<}+2tuKsu+B+Q{7Ns@i`>`51_=Rm3wU!V zqMv#Q4YJnEp}Og8Cj#l11kqG@MP>yQlJUCG^)!@9Fo22=YmT@kB^lF94H5nS(Wt# z;p=7i2|m?LtwfPs0QPUDDDO)<`b`>2!)sf5k&!%^!ZwWE(m_^~;xHX<$|c z97Vp0X|IE-k;9Hwj~>S=NW=9SbeEl@a6E~<`7OqLFbh*&^m4_mRh- zvjiE{+_VuH)kvRxietsTl1;P6>`X0+#*jMk7BS~@cDpQ-m*AuH;Oa(2?!`ww%(;&-aQR5_+i}7^AH>S{PdBrhT8_m@)&|$-akV{Rr zO1JKsPgC9sM-m@nTTg#c8pp@-jRc{1N2;zRJt3RdVtXdO^{3Ev$1M|gHGiEKs&->q z!t@4E>RbQC)sIBXZTzLWB}-eav^Sf? zV72Kbt+~l?PpNPDr;hyV(slYRs#{X07n{Ye(P9+0)EmJLbK*K5?g{HnyyAx_kAt50 zh5`<&6>>}&U+K+(#2p#ZmZEhr(90?3S|k{_{IDaT>5?9IA~-S#lJojwVqtp`JBk^9 z-BKJu%@a$HrIuKVi!rFln=324>mI&4=Y@VLd@M94wk-6g%ddfDwy-8Tistfeqs zr2pyavo*epNgjUhTo`*b}ileLC`l@W<5={a0 zFo;3XN{u*2)Di4Nf0QVGy+$U8;HMwmSzFpXQKIfa6`@r6VkPeRvX5z!OI{ER#;Swf zVQTOLUUVe=ECU7}KlLK-R9<~d_1mrP65O$e3{wT~YbG=(BfGH-{W&19M6Xyd!oU27 zxUbC5x`ISaw)Nps;S%lqX0rP2&&}lf_&YJmi6oCCT1~?5qutTlk6ds6)7S^C5#oCJOaBS<) zhuAfs>~vm1%awSCp2vB)`eD$gC?Uwj<_2PwR0%1mQmQiTI9_^)@WhW3LezQzp<+iJ ztrPAcA$hz0?xZ6^infoJgl>5X#i5CISTkW>o?UXkv2ycqsOg#R=k-)a0Ao8948 z$4xBWMMmEAv5SE$i#sw`h|Usy$94C*$vzm3l-E|?V6=2b1Zyig^hD=@x%yVZ&*Wt6 z$6WO193de~2krMSWD@Ll0Gs9ZUnTMap3 zjkAtpWNZFn?nb*@D@W4!C6GTkCxq3jq-OP1p&jAUcQHod%fkyuEdSuN{ujCAv)PkX zFS2mdy~XN3e>h+0OZs72KtWSc!RxEJ8ue>TTO%un^|nLdH07)C7GjIKFR5uT8`W!) z2`_o&iVh}_lFaUGIpt@X+7ri5PRqJnqPhz6F1cK`HY*DEY|1=~RR18p|KMWG7d_|W ziINr&!*A`cvR0BE*(WV3_3WC$27i+V0!prge3@VQK)@;FQ1JoSqJ9k-%&Q!GL%Ph< z?n!uK+UYI#lY1oxy^Wh3AYw@k+U+?Fy zJ#H^%?CACyc-wny`Ivb&XB&v7JahFH`wZAJQ8!M=Bfq4xRBAU-H>g))LMr+bFBFpK zjC~IBpT0=>s-5h{#r(wt-3`(CZE8;ynx&oVniFrKlsa?(`}8EDoZHKvhSxcVa2A4= zxGeurQ)8B#m`?Q_(G~XmqG&)RG5uGX$#8nQjAa&eeVEo#zlA9iP0N>G42m=@GUh^M z$}uUV3CkLc7MoM@XFEUsu{-h6c$CSJ4)<@eUgDhP@>=AlSJ$-nWlpAe4)27?jlDP1_LML3n&>HRi*>gZKvcDO5q zvI~M%nVUQO;P`BurkilO<}Z-L4sm|Lm`n7{EKRiOQx|NYJjxI0__XeA~$4#T3$HQE2eQro@1dR zVK2?7E-0No!He?}hu*?D()NO#+z85Ik+M7UaUa56A{H{#NaY*BCDV-VLl%iYL==dq zkI@}EH1XNf%V_V&W=5u#>XPU`w_#k=2PTp)l5b>(r7n3>c88Rsk)H-qt8&ABMTY$s zh<;95%AUs`j>Jg3moJX^zVz5|K`-z3iNd~~tp!%)$d#rClgaJ6x+sNgj+3!8(m!nI z&$mgR(17S6&nDI>WSJZq9lBc>Y_X^zg_v^28s!^nngE4oI~mptup;1&LZF1|Xc64P zhuuqkiD2ofSP8un*qd;l<%a=RfWI;X^vV-;xmpR$t2*Fr@e@jO7I$V&7D>zvyei8k z?4e><#+ssiH6Kb;PC&`z4)2JxOVX4N*4kL1d8kO5q{!Hh6(dfpZZsMfPJ(+tffiIA zp;eMk{eJ+5KzP4J0%r#`y+z|bSw*smv;5hZlibaOha)*cw_Lnr*p`n%af_hR_-DdfBe@Ob&6ID3 z%`LM#?7)-U4$19RP>os19g*Bg1!-8@;4Vn+s)6RDu)*DtZ01~@64b+8vIWUj3U_~U zP2(Hyh}Vu}jT3BYJT|%m$?1HcL50|3GmxAq()aNf0@a{yBzqi4)3^`GSqh|DI)G%I z(`Yi}GG#WBbI254yEHUp9+LCP5GX7*V=pB4CNokFz((wggX;<3kQBk!GovF4EtU5?}x`YhFUUy^@UA$hes z`qh<3%(X~fNBcL!9NfEyle_`R8(pn1%ffF)@)qxMM+uR)A<0K`%Njuqkar@X56@otC%-`QOX4*7a>ReyIr%k`-w?^$ zptj&oeuw1uyrZZtXdFffizAir zV!TU|N+AWlI-z1N*%^PNvU=RGzT2=rQ+cEcGH;^`7afx-AypsKSzpM9;xyC@!LgnoU z_U;>RYNU2TYG;2=)#$u*(k^ytSEP2+%Q=XonvvSWRnCgHBGsms^Nx0^hSW4yIrFC@ z)v1^B&UR`hQeAutv89WC_|?>=S?p@izeMOks+TXRI|R9RVeL<(W+Bxt@($S)@gbI1 z0jWAtgCa$r4U5QSH8BUNxqK2%A=t|S>!*TE-h8C^vYUS@h*QGy0b!G{H&XkEe1Q(Z ze*Ozx_d{xbk%-8lh`nTn4@Bx9cN5M}|CxkCkUCU#M@P-$j>C~ULUl(+O>@UlNFA+O z+fnnk_E@BjQ&nM}YV8R~ov2z%1ediZBXx>uEm0I}PebZ-cN3bmXCif$W^LVL?Kw!D zt65vutUZ4psS7k~>;BeWgw(~FDs`8&mm+nUW^LVL?G;E}saadsti2kkYurs})?SCy z^{Ta9-oCvNshd=5yY#-j1*uzAYr7is?d?e2p{mm5?%TVNx?8oj%iFj2B6Xi?ZI|A+ z4JD`}S3&UUN60S^EZ3Z>n*wr{;=tZzJ`N>W&_7=f8*4`>H#7^v?efsgKk+*Hd%F zxlfS#RP|R+gVFIhQeUXX^teaIS4e%W`m4t~I=)5fJJnx3`snxpsUO`M59zqgG@wsK2;P?k=AfpRcy@MQ(cg*)b15gA?j`{i%02QF>*w-Nb zV;C^pQNbPkF%lT%*yoM?SO{3yu}_cuSOkAqR2QzvZdVxJZlur#oY zVxNChz;eLyiVCinfE9oh75h990V@G3EB0ye0ILA2>cTbqRtMH_?DNKXtOcy?*r!K% ztP8B?*w-M&V*_B4qk=oaV{T=k34Ufo8=%z5iN(R$aJeUpr89qLVw8qXU@k znD33`m;uam%-7>Mx`7@iI=Q1b`hZ!EcN)ZS3;=b<0Cxn(Y+#P#9dG=`JYc@#9X)zu zFJNz7xaOUGf&KUnVBHhXIGnok(}AJ`y-ezHBy# z)5ieE${iASj6NPXK^zkEiO(kiC(EDN)MN9hz-f*^&GIvVGlh9RG5KuZ9ATa-9-jw@ z91HbEvG_vZBGIHL4qpOXDs1qH!IuM92pe4S_bT9ON1$fIwZL`K2JgJR0l0rr+Mv(b zn}J)T4Gre&ZNTlaN%vg66Szy-;GL)U0QX88^f`Jz@PH#wv*97&VPS($Y<(1XOxWOx zt4{z=3L6^5)Te=GM3bI)`W*1Qu)!ymz6iV|Y;eWVSAbU?ftn4k18+zhy#4SN@V2x; z?}vAR_oNLC`r!lML)oOeA3lEuK9M$f`{6U-b7_O#4_^XbIRZ5sz5%`!k-!rpzXyI0 z=J~|OpMal*d9K*_EAX3$1fIC~2k@udY-!MYe*^yrMcwf*Z6F;GmV0AiI)rpsSgyyx zbQI~BBT%(Goj^LN@5@@>mCU7GI!!;_FhYSmKk;DlvPkFn*C|{)g;IY&x+p}+?ITSR z?IQ7pTe^&NMTpXPDy0eOVbT`)naqYpAkDwo;Qa1@efnH*i8LB%*Dp7S812oq!(*Mb2cN>OCUW?SISacDo3QHkY3uQlwut*mPL9we=&;Ym$8^TQQfnHbi=(27(mzCnG(@t(Kp^Hbt6G(>j^eecZJ<(tNzO>^jiwFt$RP58DoR z7=BLJ7U}I8(G;b2Kzc`ADIZtujPx!prCgrc4e8ze#VDHZfpmY1OC>))wISW^On-Q9?$xU(1OK3ypvKlLL$;8M!vr$MA=`-@RD zpNsT7mr8zq+7s!$cvFE-ulx9DAEfssLS8xE?x6c4eE^Stf%^I8AfylWqbPnk6zRhp zC478x1ky(;O1OXgaWvA$c&jT~9*6YtiVA*yI1%ZS#1#VNNWCNB6r@ijxGG^kD^5rH z3}24Y%vngEtv2JbyjIaBUzF(2=vf@FcAM#dLAB3yfzq8UnBjE6Q%t|<#$Mb zuZ!^+ct0ZjlS_=tx?hm~)nAO#*6&FFVRyB-nB$}KUr7ILj~Vs)jzjqu8N(&Wt92%b zOvo)rS346yCfY!d(_AKwOoGjCq;n>P3^-u=>YIPbAd^)D_~@EPrl1ON=~+Ui>?1&F zqKZrtXR52yB|GhfEHfOL5uBZfG40(dGYXl};*Oq!*%cQ?W{h=#(=4Aey+*gs`8#xG zQDnvvmaO;m)}1PgBeR5fFYN7isj(z7ONlqU-hP)B%OJC?_!4hJcD3b^8PBhiE$!{@ z*U5j(ipWgh*GU4E*U8Mv$naqUuH|~|%dCnFA2r}w%4=U{4P@5j^Cb*;y}ULu>##2E zowGfXwlwRn@$t&c-pK5e+1L8X+~$^^j=`>${^s`1Y13-`bX+Z9M8?TH1eyJj zIe^3rx5aztL^}wXgN3b<)?VwXx7a5}GKV5_n4OTq`L$cQpOHBNnIm;r-R{U7jm$Cf z$dv|L_;JV_FKm@J-o)?Vn#hUBoFsp|BQjy|Z{3>Zryz5xQZ9ZS*DOCB8BQrysXGZ? zT;t&^WX={hBOHn{D$YfQ(~1pKVDH$t0GSIZk4&|vMZBQPv1WI@OJKy%-zV`BaRu#%SQbwdLJ_P>!-#%IZ84QBJ+^z@EIRN zR49)i^C+i2a8cTNyIVVZYJ&7QGEe9iYU(W=9ZJ@f%u~obt!qmAg!c@~-H#6Xok zrK8&l{sJ;D>UgJ`OC|F%GOvGV_yFBHaq!oWd0qU>vcTuK&>Nf8?WWHBXUGk5} z{G^~R$-f};s~9M9HhRa>@5uZiPJCMvmhJ&4L*OrD{uW0&Re~bnUu1s`@hj4jFh?h3 zgUE)27FMz}#phg}Urg$SzIt9M&{bm+6!~O_8-Mvdf9o6K<9zXFRei zkQ`@!e|pQ{Kznchv}u~83CONQX>^>ky`++rNGCfH*;TTux^I6%iJkj^vEzTrgfz6f zTiMl-U4t~sTS1QXlAi;zYazQf=P1%{Az5m#i|l%Y7If6AyaBS4vKzW#Y1HH)WlkER z5gQ{rIXi`BsoIibiti-@Z)=l=m`^IZDY8?uoB6gU&71ij+xxE`*aF!tsT)g9niE#1 z-q|HOV{2r$p}v1o@}O8+OU8D{Zck1e?q#Tgc0_h3YAGw17V2=>1=(FW2bFTy%Ni`Z zBil?^PQ|Q>Ey%WJ+jOw;K=HZyJ483tke!z8ATK!W{EuPcZEL70(XyS$&dAR6X|3@f z+2lVNJ4AiDk?j#tsI$jsi1Z;li+ae;cHd!cxULJvmv5Y-0x?vy?xM04w^QGJzZ4=sMR*B)1m(TpK zf&G^udpWr_A?ip|u0-~#?A2yzhm{VE1Wgf=`~`nqi|lorUyiFtIX57CBdto~Y@3C6zR$C+R zK4kB=gm!B}34IXRhj`zDeO&LQp+VPUvyUMAs0DOLpqqflk$r+L029#MX-+otC4_B$ z3fX_B`O>fi2F=%eIWnF__BrDcS%m0;*PF<`MdcYT@2mBj5vb0u^4WKgeK-4_Wns(w&hEkb zbl=PELkOajP9pmOvLDi&;uK4Cl=v9gPpE%9!{wS1pCS7>`=-l$qoqw);ilry3C3zz+h>~GXG zk58-c4`lzeJS^WSdi%M1|3>zo?7!wP)sW`C&b}Hc=$m%M8_^o1O~?h13-acSm@I!? zUA4A)bBA>&F&9QI!Z(Krrcug1aqt*&aeIhS#s}Mtxg>Hadsq@={-1#~av9rQ3{q(h zxjf&MrV^H7HbOuVxf1XC*#JwaAXnx4WnvVOLL${Ffy0m+&ih*owo;dffu9?R+^F1W zYpApi(w>}uj!@qRg^vdpMsAGLmNI`ga*HCzyX`{7w%(rEwYkmH2fJv8JhwPrYP8M!IBP0Y2hd;&@@4){LIeQr0ikg3S=+3U2`%Y1Z%kS&ngk}ugwgaQVYZ;jkG zRGyVxKQMzN3U_aZ-1fO0tdM^tt)i#YP&Asfzv zun8ZB-0?mzulG&(MC5ouhH`X-(*5$njy8oP8dQ zYMTTCuSD)DD}K9je4FSs$X)CGAwNa-^~l}e|4V;T{!Pf;to(oAmQwXr)eOj{rrSideC02nD~RpJ;YhVR9s?@AonPzG*B>S?P3xh zNA3w)yNvQ9*h?5|1jw-o`XNh(eBW#nF= zB$XKjmC$R*z0Q9b9|a_a`kTnT#cw5|klrTD(sz)1ms67PP}P$cGm%K|BliIxc4m^2 zDB5OxgxtqG;)QU2EisEfMeeiQ=XSAp=~<5Qz{~fZp}cULa=t|FE9>PzYxf)Ec+IMI zuZn+<+z*@pMJQlG{7y#DPsshu)5eB6WTjt``%NU4wh@0ZnEpWSPw@){7GNLEG10$~ z`-gHsmm0V+Zy+BK8KkYvegzC69~QZKeEge_A|Df}o*H5x4WGV&F@nA>hbewbc7pNdByKaw*y$x%39 zda=D$?`(e~a5VA@k-l<5I4>_IHU@bRPd2uZjFxO7VQjUI+PgwPL|uANdV9H-#vcxvGE7&gX||enaFp5Xl+Evq{4UDqv5I#?es?|~B>PT@yZJqkZ=tx`?jp>>~6c&*zqN ze16si_9M^dmGdpFW_>q0i2Q7U^3g&UIv069q?~JQX`AT=_e7qLCKu#kJr}$W^5S4} zYpttyjvL({d0uSg%_oZ2X$K+CYpxt0sB?dTha!KNeJ0P>s3VX+(qZ@+b~N(G*e>-m z?l|O+w~x^I8+an}C)us|8hHxxr`il(Lr+Kk45w>-j6DnavuzRb7pHZ`xybXG z0rD5p*GTKv=yddA6<>!UHK8@A9X4Vim3cJ@=q97h>MNA=EJ1lQ}-$4pC$$zhN${1 z^3U1rcKa&*0`f1~?RKk5zl{7Vw6K55)#V~Yc}2*-hWzUuP`+N|-$b65WUxW8D$Bov z{JY}ZhrLVgBnvk2_mTfV9GH(-esP5uky zIj`8llGZp;uu1+J`ESIHIK_XO*54ujy*Ts93{CGJk^e~~FBW@XjWquS`CorSoM^id zPwM_V@_*$2wACRZ=W=fA?d@+L2pGHnm;G4(wA8+vkERNLBmYl`Q+Qh{EXaWc0|j0l zX2fR$Wp!5wp%50YcyiroBT*E1VaQtxH5yyyqEzfJnP>uqB%w{pOe2Clb%+EM(hfI^4x;>W?^>15L5j&5Wgr2W96HGj0$Rp zFOI?z^m(D!T5F-L9=U^WJ8wx8mZCvdvhcc#unY>kw_0`)oKdqp3gdsp@k!n_x3+vu zWJMGvh&LFqpYCk=n&8SPOcco`d7DPr+$gMy!fH-EeQTqz1`2D6^quk(0DpOCx87k2 zYooA^Nb*X!Z<b0WKrpg=WtMMCP zp@zaVk#(gY4f;UJo5X$!EY=piT^DzYO>#2)I0qi}?{Q@|gb ztgSDWcN7Xole~YNg4rUEMd3JcCBgx1sVAUtqF61+FsVdwi%_^&+~~8j&v5_{ zn=OS)QMk+n*X1WQg0Dc~NVS@e&FzJ2S=kAW(P}h1UwN+tHu4A*|C*oBEx> z^U1V3r1O7HW>asX@K)h%`3@kPQcqXyHnjGJv|RAl;9V5nqpu^w>I?XWQuqLc4~bP$ zSQ_DD6h0BRRrTEqD_RlfGZa48IZhz70>_sq@GrUz_i|KG-=M%h@7Cnr3sFhmqws@^ zb+~9CJHDP#r~GE(V`N{ zC{`4Lw~;0khl%l{6I3B1P#h_QD4R7ZVKj;hDFkmTV^CZ~yLau=%2*V|@60J1J}SNh zisOGA+}p-dC@w8-OKZ3)Vp$Y9^+s9SGEy1iQCvY~c$=Ak;!66BYoCTDqR3mqC3WLT zC9HI%Wz%$g|jHgVNOP=&06BJUZO)XgiEus(_#CoLi%) zY=EiwrYKHzaBmx%qsZwrDmt!;*b2q1?OT7kjfV2JC~oH>c^lgS#T}jd*o}wu&M5BU z2x~B`cSCV^7s=b=9w@eWZh-r=*oI=ea~Ioxh)+YYL+5zg>qODXsnK|-ccIvA-ym){ z+erws5^uO*tNQgQ-avC8 z6mKT9prcmhTT#4CJPe&fK3e@dP~zee#JVVrM|euv`s!Z`mP{Sn2V#5=ZckN$$qfm zlpwVB?eJ0trEDojZChPxp+h@{?RV#g>I7tL zz^=0^NaVL?qEl}FBw3VrntgZWcsOM-|)HWz>tL|Ud ztvy`(inB@D9;F?`WqCKrISyFb38kIo6=nIjcU`77IlH2?TWNPXOs5}6;d@)Yr~HR} zJgl?_N-d>Ub1CbU-EB4Cv(q$XXj?!2ZMLISD^0VHP*IyoYm0x6^XoxhLDNy{EX}ab z@iH;n96$wzunl-X0sG27M^aD)rk(kJPq(Zdv~KcIqe% zmS*c)j`GUm5N-UAH$2U@=b|*PG~Z_rQYx_T|HnPZ|El9&DD6#0wZy%cuE7C%cb(Z? zqfDeqn^!RVv~B4)l#X}Tl*c$qC!%x` z9pKFe;qjUxx;>~He1kXb0Y(9UpZh?H>q;xJy=kd)=t5_Tw zDP4dPp96Gc>E=K7RI!I^(^3X-;GL$aoLxL7yUAr@}D^a?NKiMjn{gk~1rEB@y zngsc==G46&r5jjohrHw`X@uQ`(#?Et%91P3q?T?)={7o(T2=w|RBGuCl?o(vzBP@>^u-X_TJfFO{}4l~0kS=TLf{K1B}qpz4>%(u*j)q;9_tG}|5Rxc3#5 zUgaG(x$O3#ypGZvEXQ6w`;gv3>1}!~s#>dAAI^WfD80wq7|MdwhxP$VAM%!fwX*c# ze2mg3d~C^ffzK)E(q|}fQt**B%m1Wx=}VNpqE%p%y+rb9^Ba`DB~r;lk}J3GQTl-h z6%WB~=qHqZw$mzk&|gvFZyfea6({scf1t$QHSCGaXY@*cqx6qf%%}9q2Fd}wn8tiL zgmQmaE9TGTp?C6pAXv$fX`3r5?)LKCtGpG;TZ=aiO|W|0u)HnG+Yx6}-R@fdLxtrXP~MS_UW{G;S87j&wxyc^29i{I3=C%Za;_dvNtq_fl>YCQPbP;S>T`>|G@hH{6v5aL7~ZP<6B zJVP9RQJyNZtwUAiE|k0JP?hbRMhAbZ%DpJ}(frA|nCy;zln2E55e;M&2T`7_TTX}g zM9w)Ao{RE4@uTx9+@Tx4kys!9ePushE4}!4$Q9eL!ZdvOx zZO|Ts^1*Wd%E9FlrhF*Mhw-fbl+zPxDuz%y$xV8bLOH4a$5a zv8;ir{OeKXJBg$8y&9i}ZbE;VFDDN3XUZ0DMVT)uj`nA%P2Yj?o#GUReOSqlb~noR zxM+Ur-G?%N1Q_8%Q^h@q@jv1WncfCqL4& zC_kr>{91egWs!#4LsCV(jPfgvs0KE^hVttg$*;XPQGUy5uaSN4p!|QX*r;t_+xsYg zU=#e>`3U8YW!gZ0Z9hf%Gn?Qi;R}?%6kXdfDJso~QS)|);alLw|&Haw@AL0X<`awY<{Dt!0niM~6{zb*mq_}jc1W^%bwv~^3 zE=mNIs5}_up*T%d;;4Tl#Hjbu6um1cR6y@bW#_}7tHBH^Sz-+HG88#^R0_lz?q#XX zl~5@QH>n>3TrE~nY2t79z9dE3a8yPRag;AnZFdwZqs8}2`!j*7(S=bN!;{F%P~Vf_L}@_MMO&m*+fXoOBeWkVjJ zUWOuPV^k*d2=%g5#Wz7^Q{kiqjL^+c*_=nHFG-QMB`SQ3ev~g!ZFd_~wiVxF8;#KI zQQ1K_enBI2CscoS7G7Q82;CKx-NY(wfg`jTl|AHwu|XuRw4&1HqPR7$p)$?Yn4jv? zQRx)xJugjdaV9EV;@i#w273=Gz2aHqAF(U5Q0dnQZmsL63~J5z={yIOx#Hg1f@Z^f zRQ9BgtY!VnuEN+Gm3?%ETb=z-*`FB0ybMLofv6lrtl@uNmfGAQs2pl9()G5^8>{>#;MdiE7_jDPYv=&YJ z=FS_c4nLyuQ{`vN4ebBbhbFI4pZto-Z)8=@a+Ye@AE^9EmgP0jvhHtG{^6{b1LEU8 zIlpS4$~R_HR-xE)tAoeD5`%k&dz5;RGL6FNu^0E@2?;O)ii%Qa*Abz zEUGykz}64%%;{|B8+FwJszv@OV~J4XHdscL6R4!!8`;$+R5^!==WU&gjMd+Y)hnU8vgla}4)n3O zRZv}36DNMb!$ej`bq%txY=)GYHDcAR+v-}VuFVW5w1|0Jw;1c9x*juR8RIsa7#pBE zsY(gOsdq^&Ck@KbPB8d|M8DZr-57t>$$V+g8e#UvW_1%(Hzg&C7NlrF_-3eXPIyHb zf-cIIsBUG?oVMQXzLqu~*V~}FEqNg2YI1v2cM$1hq&%h0PN?oIwn|%_JT&$o+7;E^ z2pysR(hGMD{lNJ1((y!q5 za3sofR6BKwXJ*etwToMEzUOG6q6gJp^=poUOEqVq+RvXm{RmP>9o0cT^r?Lkvele} z>ReTa0hguoQQcF1$79IJsGh=go%8sr zMyH{AI=j(+B@ECY0s+ZX!s0O z#0liVKKt~6YEx4RO?((W>wK8E)N0D0iGR>1r_{5-JemsJv;%6DOK2)9f;F3}Xlhaf z>oyHX(+EYd$EHze;yvV?{WVf9N(o#TO}u?v&_G+MMbR|Y1*^_j98J7mT-0H^`jTkk zjpDL~E9>E=Wzc`LtaUib%aBSgk0#zFu6RgxODm#j0?m2naFOtXO;{OC6KP#krK)^z zz;kB$|Iv0H@KF^1```4045262@90SY5yS?HqF6vc1w;iE0z`;F0!ipL>USEH6?94vz&wQru&d&G_5WWM| zfkpb>)U_wRKEij9TufOKKYq%xXv%!=>gy|fhsafKfp{GIlBsyKe!_Q{Y=!dU`}4_* z{e|xc-;wCj^gQnoq1qlIsP59t>2v6J-%GBfcF628H5uGY-7FMf{< zJ68CPQ+t0AT8|#Z^`XKyOpX8r$53LZsv1-(~!Xx+b0p>L9Ja-MIB@Kwu}@Bg%;b^k;Uq1S(8%k)5Qs_;$Ii!bC^d}>{eb@2{j z)Cpg`-cBtMqe=zL5Wbmuaf%E`ET&1`Ia~PV$cHI~i3s|}GllOgz4McKJ+ZVVdG9&G zcdn!sS>x#2&lA4$wQRhj)z>c+zKireYw_#yDGdTH5xz@h!vI26uuQYFRQ9u9dWnt zt<-D3;t{msy~4Lj9|2lb?dF90g>SWbpca1**S9?&d~3DqtE!0u9umHF+V#mO`sNM7 z*B~D-wUL*n%RQV@?|nr09`!w@w%m)yh;OU!=}ZYoJRy8fN>?>aN|?TSTKJxkcwZvK z#ro%jZ=I!Lzqi=s-_;yIy)|TVzZ1;XBd>^SE z%pM`Rjt_A@5x!6Lc4YCQsTQ^)WT)_bE~{@cM6C}*$d|&mOMTy93(-##5&X6AeWQ2v zN@QVN^E=`DUVWgDQiN#cke82d9mG3)PJT=C5`=r6s=R-j3 z5x(Djf2eJ);)wWD)eNKD^^vpt6JKckC47GuJS(fLUCVTv-w^%`b7wkB@iaZ>&l3J@ z>GL*b88ANzF#jcE*jxse>5=28BN)1LJ3b zs_JQt5E1^Uj1WIFS=K^pcw6CbC&P=A;kFS9qI3}cjyg&r15<76Ec~T1ir?mn)L7-h z-$mzi;;7wfd6;>fa(Fl4-%Ec!g>7jI)x#VF?=Ad2^gf@-Zn#b!GK8>wguj~#IGJ??+fA;N#Gq_<89 zPwH6ie48BbG=Sxo}n*ddRQ(Seq@LzwS{hf#vFB(?~|JC+> zz*>tJ3I8?bSp~^n#9ECP3;%Vxp4uXqDZD}Wm!#fqtEe{#|I*akbxoC_%Y^?H{iV94 z37jycvRW72TZR8NU8*g?(^SwM!hfgKwRGyb4yHKfF5$mBW$+L$;P(jsy}FUG1tm-P zeZqggTy`HxMqqzMb&c>pkdhE3xWF9(0|SoXZ!Cj4*ebtU$mG+EfT z3;)}?vf5+V`i*ym|2>I|*dw`>ydA>-fph#7FMJ;f|HrZw3^+pLPdZe7eJcE)nIG%B zMN@`7w|0rGklzUZw@y!4OY`@_|AYG6GSNlVRw@_Bz}>?C zlm3(?c`kpqsUw4b5&mCwO>hL81H?VT|GT~4(T`{1p8Hey|I!MHeyPUJ_(uc`86)5t zBR+@>WQstRp1-?A)7AuXL?Bl_DDo$I8OO6C#L5?e0-a6P;i8I}h*Ky6LMnx9eCzX3~x)U!em zEg%9xwG_k>ZTeXJmVsdri0F}AvW0?q)OBdM-yv0jhMWCBhD@m#NR*~)^u(xzn*dE8lS3N~wA7?WH^Tt=z zjjMmHtXGlt6@mTq@FXRY{3@lQRz^8M1P*kz)atw0N@Y?X5je;dWOaRC5je!|`gkNu zg$eW%fy3;h$0?Py6I4)t5ja8@AzP3>~!Z3w$Yw7RlN1k~4wQTyn{)ti$=V2WPP>J~TY&>9h#su!2Cc&2|( zYehg!0^H$tw@w#<8M^C88Qqwkoh1UZ?V~g`=7>9Yt_Yl|I|N5?(!Xbmz&Ym9m&ABn zuc9%hRDpRSaGs1|8`LIdT!9Nj;6fQ}r=)0HECQF& zwCBg=B5;L_7EDBo?+a;=QUCX$|FzwkU0&jn6t1UxEhtzfvcw6@@ES4$vt_ZxRSMb>ej}E~dBJhF! zik`@RiJY`&`SlbbccO-^!@= zPQtx}elG$)*arr-geO~z-6HUl-BepdYpQ+`0d>$(+s31s3ELwAze|4$SZuq!e~Q3g z&VJghX#XREhCL5#G2_KMm??r;_F;-Mo-E?Q91&EXT_)c%j#JP4gZUz;KD11}m{fCt zV4(;K^(lkpRgJ!*NCcZ{sbsgQZfPNcE!6@O`)dk)S8EYeUryRzzv&xGL{NP&S(5y) zI`LjYwsy+agu-C2qMckVG)d2<5X8Vbz&meHYJWjr@aVvu*R9-qSHwPJEz2P z=#+_Ixh+n;Q>Uv4c1wxl(CIFMdt2j7cCn|Y2=0>-$Dy;Y2<~T#<6_SNB6wg*9EVOH z5j;qL>t}u-?ojC~f``~*I5hf+;9-2 zSOkYyVz_wZI1xPF7Q>-2OazA~W4Ptc2oXHd7Q>-&vIvf}#Bj0W6cIet7Q>-2S_H@F zjY}+DOT}2#0E`vEar)`0m9~&P{Hg;kfZE5j;D&^@epl6avo`!Fe*Ul`SxN^Z6opfqboCeX}TMzZ1+Hy+{Nv zmf_7U;q@~sW=xQQmx|zJGBD+}qxJp;B6xXE)>B< zDK8T&q1TGwV&^jpON8r1@CNlEUGl}*q^hZttLhSq0fIM*;7!4$@}m)Jh>^C?sC4iUUFxWaZ9{*0@1-Rbk+oFF$q z?nDRB-6DUuGI)=5MDHMa`ZmmUr#tAc62bfQ_aJfEWEa0$1l1RitrKCBDreVOBCHj` z2ZIk;=QtHpr|Jg@@zsqUw*&RG?<0uoMR0@ubkjyu<=k9OiC7Pd;3L6D<6k_TcRX9) zAOG80Q8Q+!QBkW_%-V_wY86$pL>0BE+9O5mi&DErQLB{Nqh@GqN>N+Ws8OR*D>Z*U z-{0@?`}2Lz$;~^@c&i!jvAkFDWK*Jj&G1F49T z{QLtR%|<;|B3gh$#9AgKDZlp2_#}O}c>7IMnSYfGyvP(HVR6am8a5qP#(2qSrIhnG z71YU*rg+Kc_p4D(>(A)c3#HYrIrH?7MUGbg3f7#A|N4f(x?m>wkE#KQmW4TlKpdsQBs^um9ap=Uy{f$GPmY~Ep)b$)M zRC-YDJFMU{nbwzbrZ1C07al6h^&%n$q?bYws5zBHAJ7@Edh|v6x4JsW^+G-HQ0men zs(nWKVe&1|D7esiE}r#H^Rxcx5b)ivf7kG|C%}BDHa*toBPjcu zjBBNX&dwq9Wn>tiXX1~XAGc7N8~oWno?1P!%JF0=bO`$CoS2$sE~dUl*)XWoY##g> zw8Ue=^od-Nu~8kpn>yy|A^*~XlUJPN>YtS3zEzfO$OCSxBT;#UrqGuK%ecqU-?PiA z4896;s#j`0PqYz4Mt=ybXH!#+r1{8PNHGnmwDBwx)A)7h3vE#GRt`gj+^fD9`?dF@ z?WYEwK}W2}>*V;a_Cd-9MbhSUPY{3rd_%`4O5=gzvj<9|>f`2PWD=r=Mu7%s*$3$i z%}qm0L278(IbGmT+8I78qAtFfZu>Y@c}y7Ept+;;qhHL9#mc!{Cld7kD2Pe&TrUKOUo zritO_i7=jVw8~j=czJp+p@6rYx_Poi4UqbAeiUj2jOJTv3%dbA7hS**?%7CfX7QSJ2cweBi z2W72Bz6&l~nI4^vQ+)IJ1bSu&KGFSXpdW4Jd8vh_IegB;#^IUQn+?q^X`xKOm(kva zX`!c|H$}<7yj?p%tmPjQ^(=e>?OPtAqulnatf~bJIq##PU=RLQ`)BV+|4*Da4DXEjFeGebK zjrj##)FhwXo>E(a2Z-A@jJR`C z3g&U&=Dc(8pZnm)in*sh2^{OBw>VX3xvdiDy2;DjfOHkxL!EXYs<9J zi#G%f;&%Rgci55m9L$C6_>j}OCjnI&@H73w3B~kV);z9k=}-8iuq%zrzS)QsRhpm=d)m-5VZz0u5>A3N{sRS|v>SB!gBekM$bj zEmirbRs=A|Tbg!+s+Wo+*TCOn_ef6i`a52wDjs~;hoQsCnopFcIcAnOR z(4yS$0-;BrK&nr}AgR<%N7=Z3I1%N&&zv^*z7@#oHH_agSyL3RkE)-^a)J{re6<;~<^#f>fNTt>fev{$b8eR0Fa zXrW$J23+z^z}7>lvkDNZ)JdBVZuc~v?ZO(}^{KTMV=3hqw`aCiy)0DdsP+$m?wZz> zdjn<&oj-=2MdlCnY55Q0N$K0I(5SjNs|8Xv94q)@+S+gzK(c?*LZi%1^=I*S+=wRV z%NOlGrGuMEH@LwP(gR?W5SKuz5Y*x%6yPDEg9TdDgm5k$WB3$ll@L46Qc@x#66hKiTb^fRX%Q(p zc^z!@wwSmbLq5x92aYReuBlE*eJTNVu4KRWJ%Gg}7`*xJoRbda!-0=A&x60OUw))i z+weumlpp#_C?z-AmpR2Fh|x>yPQoL9@Z7>(vW2{qp!flmtFrb`&1b5@<4aT&u>;{j z;_f~Yu~HAX!SVwvUj}~*LtS)qbX=Gc^i;v}B0~6_>I>)#v}pXBmuayad3RdNoZrQA z6u%`iv!_THpszI5z?#!P)7_O3+)PqM4Tlg3$-InM|1n5&3-H)@R)&>Tl zlE!0MRQT&_G-a^^6))5mA3bT-i{UNSdVU9 zggJfjsANnD`gg5H^RMi$ANh4%u_N>;*(nxd4=b#H2Qj=qbyJqqg0Fp`HKnvezaIEf z4_|e&(k?1gG=r}V=39Nn=Ke*Dv8GV1rZqeK{NRhZ)v65_dmL%IvpRoQnwe0BP0`ha zD?3b8&F4Hr4cq`5B}3k3@dTwpT8-h=#=+79!-Kp>^mPy6ER9Jq<^`0R)yyehbn5YD zHLNMOrli#cq`V`zB0QK<-mX#x@g2QeB?QL$)W?>0lqL9bWCq$lYmHs}V56}ixNGut zU6?XlA@e(~>ZJRcu;fPU9Eq+1>+itCp`a>gWfWco%H+`QIi(_4=!n>8nxo z=bNe8=q1!ubG2txM&>x7iZSId!}WugbnHOypsULmYv3a|SG~0fA)h`);LZ1j;d~Zw z4H!hX&w(*2<2JqqwSLlo0fD zu0$2PZNk7kmvRU!z8-KwM4Hi** zJfR9-H9S|4n6nn(_e$x~T;*oVu`O_`DQ1J_RD7svd!F}MvtCnLi_ZLw%S^VFv>|-| z5b;~VYH{6tf*)#GZYKEVdC&}t``seVAmv83np%0QhSu1o*L(bjagJ6t9(+X~4>8yP z6i!dcFPSCbc^uz}r9yESn5MkgVrvxp?g5I2gC_2|x#2tGg>TOv!R-mn2;X#}U-I(? z@P#ctUjo0lyk@)~(}cl``1eox`L!pE!J=<`iz;Mtp8A6)swMwn7>c%+bm5sRmlfN@8(D3l|dph(9uadlR= zoh~vWpgi{ITa>VT*C*NDiC)cyt}v3Hu}H`D6lhSID{#_+y$0sYvL1HcBq@r7zx4VW z5_F4b4ptVEFRN`lpD2VXi13MAS5$**337i3jAHgnjm@vR7jJ;>^JM2MD!a2Tf%5D5 z27lS`n|8;CqVh#lY?7&ze5RmxHUVn6DOpfk&mX%1KkO5c=lrB4rvVozfq$|ujeXu| z>66RO!y{n|FSFqLAZ!Bhg<2Lc^o(Wk6iI!gc2aOm*x;DH)faPd^g~MXK*Z|PlS>Y; zvY9eV1BHNxsv&&baC!IBr8>A{0L9{F)&+-)>wi#mFAy)HI$)%WSu%^=NRPYy`S&!m z?Q4iZs>`?xG{_w~5cb^{8q`7HBnKTf{+)imODNWbA0U?0r?B5i`WB{3ph5M&Yew#6 zJ1$tdvh-QOU$%PirQ3w+PsT665B!#XTSkoB4JnJQ{wi92GvN>Nz3St{Wt3=<@S#sW zy!;o{^hO7?Z3yb-I`)TkV%nu9n3Kix6BqqNW6%n(ulxmPf{PJ1!-Vg=)eLO9)PsJ4 zd`Z6i-Lv(**jN=8ou)>g0Bd-`rvVGuyjT^!BEv0#QpeY=<(5mwRk12%1vYaxrW3~# zHmFWob7^(A4WB7&Yl4@mR!~!xn2%z?7I52IqGCyZkSW~uTSwx}#sk@!gpFG#kzRQ* zjm&>ZZ&No;*_FiZmBw~XuaeBMRD#CDlZ!nQHWY(o;zgsU+m7J}p&j?NHNDSgHg+TPWGVFH6@MHKgu&!JlL)6Av7uK5aru;D79N#j0Cz7wyGDoOARqA&gp3AymR zz|)Iog%5Pt=msIrw8t`rKW9*JS`bi zi+oaN-PhJa&0aOX1a}iZET7(KH5|2c3k)JmAWW>v0# z4gueK#toZojESAC9sF$Ku4>a4J+JOQ->bPzdg|3v9aRWsoD80j?BzTsn4sU7US=3=wB#$-u=ZtaI3Z8`DJz7vaHckv4Z#JE84ysYO?b+> z{zVL2t80(SEGD+`Mdu- z_n-Qm_uZ9~ncNUtd?@6*bC)i`lze zw_Jq@in{J^@-1X+Fv4ZsU$SM0hO}7m#umPN)o*PrtQ6UNS*CB(srFYq`ZW}j#|#?9 z@PQujl1Malt0D}m%DGf6W)ffXiGs>?NE1~$*qeSmHXB1*+6RaeRl8Z>PU4}c@%Ot zE$8=195F?zzV1cpnPRPD8}&ebQD?_cbtOlPYBoN2;PO?5g*a;ZI8CVfwV~o(aoEw6 zP~8v5>G2Plop1T@1FFg;YJWe!p|0Q&28K7iV^Ha>%-!v5b#epl(UK1l`z~c>!{G@s zCNaNtLsxms2SVk)48j!JwiJids>24apH89buQnZ{=LrIl83Mhr^r`Z{TSU%G*R2b? zD^T`&f`+0--w*z9$c%++rz?%ZllTwEFkXd9@#0$U!hD>fhS10f#)*gx-M?jljqfa3 zicy0@IcG$J2yIo4Co*cgsd*Lx=eA`^!l<8J#3y%z)s{9Y*1)`L;J{+M(0%<3{TE}@ zc_Zy?-i?dIWVcW&@}Xea4{CJhT5EM&13i*~t1bBspUTzE88?vt)j#JS8eQ@s`{ziV9Z|&M~@NI zgVm1*&SH-Grp$LeOI^%Xi(_+WteduTOzDhxxlcY^ZLLl&fgP)^NlV053EkCj>iI&H zvbuC_y7Tc>E=77#_dm?h)$Tq%Hi!2Q{UnV6m+brJY5r|o;Q?j{p{fvrffvu{OZe1R*P3v zHQoj_A0cHXiEDl?C2kMve=$CtTbt6R8=O=vEIaU^VK-1_dA;*~1dy|7443rPHdRTL z=&b8>$yI<$cwD7iMak-@DrdI7%Xl*^>*x3LdoHntL&nwkcrfVWP>GTd+{S1<4uyH= z{id=sX{K}7Y(nNfU5i7CmW0{46XU*7_>j>f2ypTK@LQ!s_k{S(*I?$l`QK7Ie}DfZ zdp~HN_2#*!-<(KByrx9qu|xbXsvbO>X{lA7Lh)&E$KBqlpMN^6_pmdh zuVy$^VZ``y#AvgJk4d{eW9^2qOjyR5k%aE~fRtxCbl{!|e8&G=YTSCR+JHIz57X~Q zg!1pMOTPO8%DKF6)BYPcAMEmHG%iy(7aqY!jSqR7i){R+>bf7#Jg(r$mXAS^`5XUo ztCz$Yewb=B52I7H43o*L`6h~TG<-~>&a&I1x+*YRCnvla;oT_X>$|b_{>>JD_U^+K ziJ`W#oH_n-PN|>6XsT6%DgybFbltv6BV}X9Mvlq>w_)Q^jhQKS(`J`veCeoXo<^cp zx@TtRj~kmUZ8CdOtyOF5xE#b#c=*|$J7<5Moq4|hch~rrchcE(?^z}LVgTQmDoC@d z?L((H07;zW{t=0!7KxcQ1Ky(TirLqGHKx}jva`wbQue}bvzZ0HKk;bklP6u&T~3&k zC7llQDw#jIHadOnC1az@Yq3iA{WSdJ6M1pYwf2`S`^Ko^k13wd*rQWiQKV1z?Wq7@ z_7~C2v1)RUEh@U((>Cn#jCXZqjrVPGD(Y8{B=OekeVV>5^)Fp@gTKggDf56?)0Roj z%c1U-+`oqiEIacrm#7rhw_jL(cByN{ipD>Q>>@)@6_*6=OTcv4r?;>3iho5)k4lrf z!z_I*@?Hx`)=?K2Cy3UZHs77-vx2Iz=N3DHO4Xp+A>e zD$NVJNnr(DObXNNPx8?(_Gc46aRz$M=TjmSi#rlbhHe4orQY=PsGeXG`m$akB`mCH zREWJWug;upWpKmoCU=CKq(F`fjyBsvCHpB;Lxn8-ExYcFjEn;n@PhyG@4JsFYJ+0+ z{h7D0S1KodG)C=mqA(Q%3 z_3|gAjR}k{WR5crP>ttt^PO<_>r-Me^UT#Q9dYy5;qKt6>hSr-Y8MK|Misa_<&+0{ zUccHUhN1DQru>vg)V%wZ#n>1I-w`WcqG?R8cF|&Jynye7m4A$$XE$rSUe&_+%W`o> z%}u#ab~b)NzjXGt{U;&6h?I}>H%*T}quGJ*Igb~~MS-Y5>d|3*##%|XkN`^5lqU1c zSIYAGTsucUSi>4@NJ5~dA7|*3qX8&bO4LlWBYPKfg+|u%> z4l&D{XoM20rXl?-3lV5-JJN4C5`EXaU>*GS_t~lVw zH&)KB(4Y3xe~H%LuAW_bP^BVK_4|W5y+#RRuepgZZ-r^D`zq@?BnvSZL3elR^F($6V>7zgMYq5u6ql00&Fqotpf+}Rzv8Yu{EHm3lu#qa5rx- zZZ$?-v}wuQjdHXZOjRA18&3=`{4S3Mlk?s{q)D=r!NjD+UWh(f|9njSg%gPQnKaOA zAXK8u8mk*O{{{Y$YN}2B80`v}{7QRZo)>kFET|K3qLn|`NK+<){p$?Itf zOm>I&y84TC(`x^tFL^OP#x%Uw8?jF_si|+1pjcC=x04lF5@*UHgJ<@0)$C$Wd=;Yf{r}c;`P$f=`)NQ42 z{OvgatPj2`6K zI?bdXeu!qu;S;9<%78LafP)Gj=VpH!;!rVTONXUFiV(WZ%OK+uOzU!+RFGkJ zfF@31<;U~SHt&E$w6_36xVvRo%D$eEI%pn?V*cTIUqT%xJLmo)q?HECj~Wr)zrMd- zwl;FN*q0EB&>@`1%T5hs`uB6mI)~5lt|4XUgC9+-iqEM#RoEt1NYtGj%7y(Zw>9kk z+=_6OiRk1CBEz!$j?9ds<3iJMMbOR6h3q}UP#DUGd`g$J;RCd~1DJq*rDKhS=iCGZ zJ7k6_VDXqxpMM&=gI&0T;`B`I^k9UDN7T+?0~C4!umq9c%J|UC6RYLco`9IC6|7(E3Zpq=_oPAJ)mz5++Xsz6!?UNYz}Wk$5p|U@gvwa$FML8=UEQ5V z)c28%p>|^fK$QYpK!sl~Aw2M3OZT`sAQWUvjnj3*h%2;DzOiV(2kzv+nB6B1NwfSJ z7Fmt~*^=N~dD>_B+vn^E*GGPy$L=N4cT!?>znL$_ScKdLcQRv|)rd#ZD!aoXDzTsy z8eBSkr$FMD^QJMz#;?!wxPq((0gdx6O2ZF^2YAr>BDYd3`>QW zNwU9aG2+&5w}Ua`WwilbSo%pf4vn0|%&%_kfFqvSs=iie!mX-V`quAJeJsK4Zn}5X z>7x&;zOdzM_P5+~j7yE#db1;=87MkPC_1PpIx?|p0>%`1_c;#0z$FBWQbz&)3eWFI zUEFzk#tOU8g>(rg63UG6T3~!vBw?kO$nA#p^yni>j1a%Y61uvHwsvQp&H#7+T@y0! z1r-LRK`fAd@@uo9lH<=Vvu%^n#;`5*pnE}2lqfP)e9DcvK+SY-m4jCne=iVDW+kgTD;}6QmFk%^-+GWTl#t;{MQ^y zuvCeJ?S_zjO;NSd&1xm~sq0?9?zjBSy1cq{m{yxmF4NzWgSQ)fXf8!PLw#8wc@&gU zo1lZu2LR4EfHNJ%Z}0h@Etq6*Rzmv`nWSIUI?yp^f?b9`k-uJ@3vyw$4kWjhA6y$6 zz3c~`>iM1{b(iqJaT|1YEnnEskQ4+ zqy5*l>w#ml=_AC?u>{s$qAv2R#91NPv}(WQY6xG)38Q#IOmoz_T^tElOYAK{;?aA) z<F$A~qUm&xk!^&`K`$r|-y5inu*@`l~~O{omKNgj=-dgKE%w%JiN0MqmFlawPP^ z18C6PulDApSyX#O!T^xxD=!i>w}I6AfE-$yf;$?$0uRmd;ZFjG9-A#cm`dMCD#ZD) z-J)4nP)7aZuj9dIb2!--%irn=SbmNR?rAdkEwKc0)OH}CaAN7Cz(f&_`|7*<* zgd?N=%Kn{Dao*6HR~=t`PHbGRjL8GLw)KVRgN}cyC7x9JE5mm}|3E|kgr9e=AGnVO zEIrec`MY;1X!!SIa79S+;%kCS{)D1gDePYQK`m-x@i=Z`=(vI}>Wg+^*s%@3RBf_( z_p#8(m4=b6i)}9yh#26`lNQFC~%cYVGL7 zTM#!1PK}-`7a^A*O_j|C4-iDhs09Szck~^_7{~ZAS=Ub_NDh)8@LG4H_ha`UAhY`c zZg?7t(gC*|`Wc#6HqSEW&{LO`^!Xs%2PW>CdQkCHR85(_PP^>4^9jL*l-+q^D) z1lJiIre?%d^0d=q64*V_k_!?z2)L6AbMJnD4m&PMuSFSbLyoh$-L91ACA9A?01Xj9 zUlF`oI{SMRWhNMBO5aI`K^>QYmlG)c`7m_qL>^F$uF2gX7;YC%1cOv>;`*-$oj`ef z2V9OlaI5EeLfDNB0fHJ%&C7 z+?r^A4Wa<(G8Yj*&&Z{XM#b!L(_cvGk1A$_gyzZ5hDzw)?tLDi^3M5of@KxUw`a5t zn0_!W1jKs3<*L_=l3H09=CwDYEG|zc8hL!onx!`FfT$)e)5D+ z?H9lNxAl119!15NNwzpRvMVP&z5vYdy_#>PE9VQ5LlC z8?%+R$G{(=4DP&z5x&Y_V#lFM+TX2c-#l?)I*<|EpgT)w+G2V9)svqrRC%)Y`sQ=( zZ+(kcj)q*h4R4U@b)3LAxeWvU5JhkpE#?-_SqMAsbN1d%=otgrHhNFk8U4orBOJH4 zMIT0jS$MuVgE^MMnZk*jpe`!h@gzv~b?eOJ1HR??;&jWM3kR1UybUO0?&9>5J`LfL zPNPxl{@-Vj@5fNr@m*-b=gF7MG{MdfbY2VExb8NA&UU*0c7c;4So+8yNj>pssH8 zJ%;~j0K3lJhg6=9D9qc~Pu!U6Ac}7TV^wG81gSIF zHG3q-c`xo|5v;Bj^7asSVPSuycf%6cyAmN?;=l?W_KzV;SJ(#Zg46NL@9CKu>;ef{ zxtB=zBZc#i+r!cC(&2a~K`8Bxy2t>B+wCu?+a(9;%}^?KSQH#k<-*cM5qc*fU2iB+ z571XCa*&?uYDDSIoQ3W#pOI;41W==eC#ie799jNASqf-zS5(U?bqUkjC)`R+HhG;q zJQZ|R;`I}YNGCN((!U8-{wp%)zK2pC=u1pP$9#W@to=5 z_1zvzFnZ{tZC~y2gSxU1v*XIP>PlT?`6%Xm)Q)XHeh1$e)H5#96Uyny!@2M+KxGI$ zX!Y~QDgE+w9Ni?Se$=u4Y2SW;f9Onf_zg24qyh`B4$R)JHXdA=5B+$B(FO@n1^HjS##$wc?K~ag0g#(x8lh6QoxV$yf<|tUVGM? zX}hzNNJ$Q60_meZu=B|PxS^kIcNvdHutgP` z07YLbo>`t{7x&wFPS+1u9ey>3sM2DS4eif_^aAdHt0VT<=<~0z{c;9k5>TB|BO584 zg2@}6Uu_t4A5cKatZd{7>??~i!=|5ua~vCJr!D_>+`;8Ctez^Q|KS@r_8s!&ySw5u zC7%7K6+tDnvX2~)%TWIt_3}Btu^g39ZXSQs0oA6+)rAeW)l>O_V;|-9U}mZO5FXAp zdaNxeUfjU`>>0ma=WANgS9`zcJE4hQG>1b>Khrh$hGbBCLydjHTbwo(?(J^+B@V8X zLo4E6_$8a*5d0BjMT8G$aLC@DR`?b?5E)$ctTiT5j z*Gv?bqdEU{C;49%d-s{Tb=6i0YxA7ZNA2-4VUl%7oR+BcSTULn?`-uU1(5_Yh;5Ju zob}sFYYoUs1c4K>vH-co2(WT)zB_eyN;z-RP(?)&s32XbFWp|kJf40WWtf~li-Mc!i=3!pnKt7JZMdJoMPS21%zc;Q@B`Rbk)LQ zSrd*W8q_SE6J<45+C&KbZQ19Ct-e>*R8To@mp8wh*EmULwoE3q$-K)w8WY<6FP!Ri z8On*9&r4BM%K7kL$jpbTQ)_SSC1p}pGBI*%s|X*%JnTnY#pi+_3fI50wM?Q?+9(2l zbKP$7=-wf-KE5&!m3-;I*5W^o$UId4GQF>zQXVmB4*zj-&7aGB=ZG;Z`}|YEMy$W6vS&{%1QArVf+D(ZiUo!mjMBi5R>lm zqmkJMY|kzUUYw9aq~7t!EaE?Fj{~+A;a%#4^&1L!16vFC=7OvTJGSeh*gP4rd`Rn? zSciNzMM1nWriB5h>~5Kt!t)LhU%^-+y*VM@gB?R2uyHeDjbR?-_SsI@^)v#T-6Ada zDhlXqzx@E#`2yx=gk?p0(?O0SYKNrow}y!EFs^I%q7b?u#}Grd6$S(egf5a0>xA_f zB8J2AN%2Ck{G$;fDoQd83as}8TnF^?*@6Y}W|#mnKor^jJDVVIEB(>{@oNEg7sXio zw|Np6x*U|H{)^cZmplrjvoAQ7IGR&K_}TXV6whrcqiw9K7Zg*B{GoDv*W`x^Z;K~; zPc7X}{b0-y?uplenb+HM!F&C^`P(=0lax}ExL+r6rz9<*o(;@qEs*xh@U*PFS|C~c zL;5{yA*WWxd`@2{?xJ51_~Cyias>F85b-E(%tME5bcrp+8uqt)KmahMMZDeqN!r`w z?(Qdi%;xl72%?FUE(UyAq7TvwN{i9&i)A40-GWEkmGrK5btGsoDK9Bv*7Z*oX9)na zYal6BhH#>^6=W45JLNS`(MIG5dB_uxePXW}r%c|wnc!#;G&^-AF%4sGZ{WRQAf_Uv|Y3#q+A#oTry*X;Qr^=^P^;(NUI(1szz zDcoBYvL4__{SGJw;cvjiNbyjN*NMx+BV_Mf#!JkG-EC*xwaD6Qz_1BqOJsAPp%KN` zZ-k}Cn1irTST$h;f?(@s{4cJ09go1wZXTJA}coo<#g?;0?f?Q5hTp0sa16f64-?8pJXg&ndfFwr{Aduu>$4ACkIZOaK z;M5Z^wm<6xb;vdNFXYJvpfZ(?jot`Gx;>*0yb5z7+jm=&Ka>K4=vq#oxhJ5%_pSVB z7Gl_g#xCRD;+#AW#Vf#jjzXj_g!z*IEGAiX?hR7tq z!fxQ5U||HMOSuHe0q|UkYB!M)=u#S=9xK5w)h{g^3C{04&oDwUjUFkPDHfF4=Lahk zks+n87k{m<5i2^x-@rVlMNq*kgFI@)N`M5)Vp3{uNSH$M0|$|JooxUNiiG#X2If~j z(P7JEL}^P|YqtTz%?PUYD zW(F(>W*Z|4llJ= zwzH=Gk4wK>^Hm?P(J^9~k=B%0(|k6=hgf^GwaVoJRd&d|@LDF|t#W4N zx?p7PSFR2kV42vCI~~i!fX5Y+mBp_W;G#KAID@P zCMl(6z7-?#Iag?gJrnjt&%pi&F-3B~`>(`xgb6HOso6~RTixfkFw5`>c0e|N>z`+u znn6Y~SvM#G{MUN?@*SXzo?rp|kPXMVNnJvCLyRCQpG|J zObl2FB=rsZPgj-8dOdqMutHbn--Sliq^ zON(8wDG*qrE($cb>WSYg!gUCDP^egrkBELhGBs(udzKQrp8riEZLQxMO^|`Cydr%3 zzHTNj@DK~b%+g>Dk!Rb7|4hep(j+2aVH9{e*u}xgvb+=1PO*WXQ^S{Ycd5jpCJUSO zNcl1&tPnbd4sji#uOxL>5M?iICrwf;4-su2llQ@Xt5eK?#rFta?_Kw;&X5Y1yi3VT zjUWZe*IVb=(j-z~3a=)>fWcK$q9pmj2v%5I#KfqNLa8xA#_oXBo*NbvnC~-Vgq6m~ z(F4oK1A@|euG+ANvK_}wgeq)1##>sJJ6E4giV`mfOCq;_<%Gg!r%A-XqF;H7K>DwK zo3Fv<1jbS#fopj9xcgvWnzxu;?hR}OGIuT8o5vy75Q6W9&>>3JkA5>)`iVmUsqQRN z?6dL15ETdO2as>w`x1`z+qS_U9kN!6+4jiiSFFpaFbj=w$*d=|1Nv#X-8CxOsh zk!Ml2K=k9w0#rjN2O!WLFuA{9c`9VjY==^!z#?Gz$0Gr+Bp)+kb&>7VSmFGF6lM6n zz35=__nrU}z&(FIgv6nW7x3>6Uuco0n%dur2K4V^_rITz|R@Th8x9=>q@A+QoKwmt?GYK z+5B$={?X)nAYO8W6>L6mY`<9uFN)cqMhHP1?r@F;U2q*vE23*zAxk~83;XpYbkFm< z4F87M!j4GnQ3}y0-O>GIX9blzn{pr^vS(vUp0i-$jEIKOQWUE~v;x8qNB@fkha)*i zqR&H8vH2;XnryZVSOSuo%s%U?sVkEzzg;nMl)#%F$Yv||S-4~;FED|;LJdX=FEB(* zff-QP-+(YGA2)VQ){c+A57WC|%nq=R<11H$@Thy3ateC|h?J7lMG>G1vKNCmMR;d? zm$0r@+sAvRa<7Mbt3X%-M)wy*umhvF0o|S!YT#c!TWea1KEy2CTLwbakx{vLV}^fi z4UF|gT3<~I+nn}T_skzH^4}TvB)4aSGzaXA`)sN(wmvI}^Yef8-<+^gSuvk0qt75p zg>h$>%$^x?9C%e{;UPj8V@`#QL@KTNQfF=zci!a(VtN8d0WIazyW0DUhJVklbTc`g zZ9I^xa1)gBvi%zN3NQz`NlntKMd(^G;A*;d)FPG7i3z%t}C6reZiu}(w5dKJp^S3gWB|)wQ4=Y;?NUZ z04?(6!H8UrWYQhr1+4AW#PmL77m~wGq8)Z{tylnZdL`d@(j;PGwAb+WVL`!;9ENQD z3|JoIe|#DL6#^u7V% zz50Sbn&(F)K>;J=e}u_D-Iqx7X14>#>^UHKz5;>_AHQkZ1q#BN+|2w>l0 z`Ma_L{h#RVX~A5HPleHah1B(g?iO;uRT-6xbDVfNa(mPK1~w77xGK--;~X}^5Bx$d z-o(1+_j@^+V6)Nx>D|cM$$f|imqV@wq{z`PEf3fwJYZLp=l2Ek+l zHYlby$yzfXVl~nKY2Qc!d?+hiYHeN2OX%|p>lYQLV;MUIWO#X)Y!KwM9Ca?@Q}cea zCHK9(6hu6nQ0HVT`mF5fs*NVZswaRGxTn+*m*Xw!AOihQ4pRXB%2nrIfvv=29jm&m z)&46*OiHe();FKAan_PjiYLGNSoIKZQ2Ry1elxpQ|4sRYClv7PA<_bWln=ObYI7ws zz}Ru**^TIRM)(WQvQAW6I_%;qMgqGy`oy9o_4px{a~GhsK-k5&6_;xyt)H3eu=#@# zjIf(M^!dZPcP;$}**G{YUrjIokFRW(oTO82g%BjM2NZBLZE0COLyuqrAP{%u%q8D6 z!fm^kH;SboC0tmQoQeCPjrp*)@c&SBRjMU~x5I3Zp|G9E?R7irqW>!_Cn$i(Zn@cB zOPSGtoQx#_ojGM{pton^j~#W{@UD+E=lJWF|IbxFnx<;7cE1DQyXClmLN2UVPHncN zEEpSy%q7JR{$~?z9!~3`z1bnfJrIpaoXF>ziI;9X|0!e&`-m9tBFA>Mew2z8rTu?? z`=^4NKRf*%N-Y-w?r0+lgfisYl{8*11a{C86hJF7cQc!y;?S-O+3%LS(#e#)bNpf2 zY>FT}15AtzFF9`i+fWeC`~SUndjW@#2mgs=T40N^ce7G_bMc4IB>z=aM_9&}_A#2y zQs4>NTM-4h;!&9s)<2CvWA~p*Mpi+A(X05Gv}&ioKf*PLYfr#epL1fiq#xt|ci}zL z2vm0eiDabGPAlz&+QN}CnxF&`e^onp^}2cv5#PXUuG>>VYJxcbtT}v@=v94h?M{N% zhb{kASRNgA+#DFbvl&1K9QVwkaMNaifmPfi!#sdtH<1Y#Z%^{y&v}SYvD?0Z7lw5n zDVPnrJ_t3{hN!+G@IpR!{8w!9e~9`HpeDNaYw4j^A=J=8YC>;<3WN>T`7Vf zAOcHoE+9xpK&fJ(iBd!e#ZZ*qI~b6T6sc0a#rOB0ZzhwOTXr{_-93ArbDn!Inh|?U zevU``FA*O^^U1Ksb}T-vzvI`A>7B+T9UTkj;1}j&Kmqk5IblQqA zEFn$ZXC6mlTHkL5BkzO(edM5RkAtE`GrNeVzwHH1oGxo3%YeD?E}m-PGl z*g#F(`SyWBVX5yn!aYghI-%!B|Fihyt7yIm7UInS627;i!IAN9VcjI~lQfow#7+tR z?=04h20SldK~g)G|Lej11F!xh5Oz+XF{3?a&i19LzM>9)guocgjS$aBC;VJ;U&1+m zrh@pF$7c&2Gc*91lz2m=;}h;@zi3}AtcW%%QG*|wl-j(`P|-zpyjb9zLSwAvAJ=F3 zN;uF6gNGQ23j({x^c(M94_dS_;;$iDLpe@d}Gq~}_isu)_e zUL9P)1>QA>d#k4_#_l0RnDJD|4Pt_Ok6rG7vx+ev_!n1$0EYy*oyDEU#(3z{jfCa~}P_pQ~upM%Aoz5mFG#bIPiu@dvcCS;&6FfV4{~CJN5rg7QHJzH=gJ7{JfwH-V z75s*=S{$?J0nEt9obm>YFcJ_l_0ZJyXz`qv-7x3sV$M$3hHRqFUdB=t#ISKSBVIxE z&=NcmiEdceZW;1mQ-6TUjuuWITrnJ0Hhc;1l3WpiR0!_7fN#lR{};Xc5rZO4ew~^@ z&iK2@6>&&~&~u#fYp3t>i~6OkoRtp@e8s817w6gt`Qt2lWlxNX1@I`cl}-uD<1`$e;@Z zoo0`!}8;Q&~~Yd01zAEXu#9wJXs zu_~N7fuB^pKHTLdB~a|Ej4HQ@uDzs2=R_Swm4-F;dLPf{#CH>e5RN@DZsX}ZNck7` z)ATF?^Cx;c$G-b&zqu|5z|L>FjKwpkzjpt>*dICtu7=JY`zJXMpQ}kj@js39BJf77 z2k5~rxA*WbFVR7Gc7C4A?Zu!~^C&%d@(=p9)f%5KJP9J|*n!A7HJ&dyF=_EoTaG)l z;GCWZdlop^e0ud{8k|4;Cj%g{N;~!Pt35k+nf^}*s1a-omltBKo`!8ONXITMk-8#z^3O6%W%cu3ZT_1=eGg-Uk1Dk(w)ez)(KCvHfDAj z^uNT-XGpFd`|ZE>^XZ`7=5NDeH(_?#LkdTZu;8Vn*xL?r%K^E4RUg$)^KZ}C@@J+u zvomZM#A!ss&v-!qhA-Q34bbRR3P0FJxEDMmE<5A%i zlptHvs3AO_!tSuG)?N-yd#I_4Zj1$kXxYEY8=>j*@dy(TpvFIp+Isj@A&At0M&z8! zLy~0poS#7&P-zfHP9lG#)qFq$W@7@3;qk@a4vVkjb(;@3z=yblVOcxxQ}_#0?B{Yx z9E?8sJkovzJ?apKv5PqWCQ}J;CyBYlAt%;p$U)E9PG~BZbd|?Y69% z2Q(TB7pgw#o4vWK8KfQGr^R=OYTmxRpMOpR@2 zt}kl3+sQm{ow~jNZj;#ZoPJI$S-1MtbH6<|(dkdBF5v#)kt(m9Du<+js%6rI@Z5?5 zRmSU}z_Oy7+i8aG@qIrGOT%-=-~n_IzC`unvs12{U1vH6%JmCM&sdgoMEn0qbRo=S*9C;4j&tdS)L5|0Yt)VH85OS@}u-?|o>N@))* z>P+PIO+vCvBC1t{BDwGVWJ8U=269$``%OZ zgJ#}JV*cK5-5FgF^ZDDfVMe2*10E{mk`NY~4`ki&K-ptBV1Q?62|UndRY>j*+gfb$ z``eapz>F`erfFn-GdJRPSp7xm4YSz(qo1z~a5XI8V1f?enaaqUYwnMGsnR0yF|X`r zuEH%sJukvb5DEQc<%i;N)z$$QgUi|-84AxiFb%ZF4zjfF*DGRaWJHxhuI-Ic$kb3z zSvc?=)}mZ}$EcXjUN*WPl8s5u`)Vjai#-@b?Vi^`?;SSqCZt&osVD$XpWle3xPECk z&rHqv9g6|?PBr-oZzYM=eG(9W<0l&7M(S=e>mI%N8Ai-_mq@t=b4~TJ3weL^;Abo# zFz#3{Rc0j7Yyy|Gu4i&?2S7hy;R&qq!km!;);jq8y(gKqfA#o}sluzT9Nf&>d`9Q1 z(H5S|*F3>{EF3C}s?bqkPEMta0T)2lm@o;Fw(8{cg6WwCY23*xPT4sg zavtNKtKH<5de?7}qXEeBg3|iVgOLhF_+{J@^ycMu2+%wipfA8F{2h;V*=Ly1Hb^=m z0%VBhUb0ifauJ(waT_ifhGu8rq zmE7T26Mhi`h4wF<&9U2`{7$xR^T6AQF6AjKA&Ri zbPPr@gO=ggY_9w0f%gYLx)nrz_kVi*syFbLnNKQTXSYITO19>&d4v#8;9Av>jv=n1 zSGC{2qYvdiynYqkD|IDFN-IfE7X@XvN1Rl^oq5i$ zJM-Zh(ii1toJ~LDoUMx*XVzTiJMS{TVG=ad_$VF|=&FAHO`P!SjZN-Pi_*U4m)na? z&uue-4|=DPTDEL_6(i4ERi<@W4?Z4cfXc57o;};O`{?r8Wr9SqqdRJ7a`LLzzFQf97vAn0ilpc z99s{=J0kCG|5!S=FbVQVXad_hC$x0uk{*1b$&VBCRg>K-1_LPxBuI5qfnC^t9 zOh$o7mC!y)userc#1s!}UZO%PBKNj`z_r<-Ku8_)huF@h2OMZO07K0u5f@YT6*80e zQJJZT!2_s@N>~lZgzblIVj0xc;x_#Vs=jj-S_jTB`ryqgS(`H72U5xO{jRME39P@X z2-V+v@c#I=z?Wksd)!uJS-=}c354TQ`Ogx+c85lZ4Fp+s)+|ncYrjKL?t6Gomsu z!UBI{Q1*r`l5F61$y>e*4aN+ch#wmHTTspJS_Jm$hrhaCxy(l%8Cri|Hy=UYgR}my z$D4@YdxE!QvB&S_Zrai@=V*ubgl>*8sEfpHTCN${H(BkoYb!ezEu?3pPB;~PXS(NE zA0wfZ#tr}qs33LF<^n+)%GfzH^y6W?2b$5>8sE06;egR zLix4ddXruCPvF&OCR#Qt6!a(D zYKdg0FG=sk;${RkWfVh1DsBW^B`&)*I|Qr88;KQ_&sbgV&_P~#6V04)OV63a)U4O`|r9OuQylK zLm6X%|0++VTz}+~AHvY*8$tW^e+ifR?sS)F%n`plkZbwa<9!4m(~0)TT%>osbYqE`rrF%ePwo5WVCRxONQd7W5kE9* z5ox&;C`n;qzIhQha$$yH^9t)M`JK+yK?7wPcB&RhZ2ETU<~7!+)UH3hm5J~gA)50# zHk1{;q(*;`D<8Q#Ws8Ra{FedE$o(^B`Oi!w)!|sE7d3-I&}+O8U^|ol6-*5 z`S&8%$N+2Y5i}WQX-7|M;LHcR-O1I%tb)(m^ikmDl>uc5t8Kbx&%LoiEGAJiO1X5! zig;eH&f*pdHDKW3!$>8w*_zkU<+G8t2%{^OdWc(e6f@hgoUwmM50s5GYCrCA##UF} z|GR4QWUf+OvzmUOc#xvQL&vVh4msJm9yRTzO;9aNg%C|)1yBYFPpfEBMU}|}MWQ}p!^ICD*E5DT_{QlEC z^Dw?E<3xr!Adz$<8kfyb^DzqtRNyRhXXzPhps}tV%m?Ju0db@o&u}LUHH}%gYRlOy z!A%S)Pbf}vinO7Pc!n=ThksL)lxJOdQ?t??zteD3mr>rs;KxOrPz=qfC7T0$#3ks? zN;3j}OvJ!~@TP3fB9mpp??b`j8%;hHwtMYdCoVrymXr8gBW+*%9bK;I@N}&>*_99s ze0{L?+?V=W@%J=I>5q!3gKV)+8?M_VAoggD*}OdK(u3tA$dD|Zik%X{vtq5pk# z>+(!*OSAZ++qc1%=IW)lk3?SkR-YEjB3R{^fXjxBLik5;4czUk;Ij<+flRIffB7-p z-BNAI_nMOLd+Pk1>+7XoO{ zeuW)pW#Lp5;yDm9@f4`|C}ez8hf=pEyN=DR1dhw7(_l|xyxyF@+>2s%4gvOljl@@8 zfNt;M`&>t735lH`!5s^R12N*W1>v2L_b?LOXAk){-AEefPVKp}5MIUCR8_dEb zFO8Z*LkHx(jedAoQ(Zv2pGY%z=aGVE1K?wy^3v&r)ArTNEiO8lOx`Mq3D?3og~~jb zT|aJmiy6^V&*wADJ;9PT!}ue=n<3)Hb@>Soak`L8@Q#42mA-wTuqXVWBN z(IE=2%b@O)@DQZ5VhS(64#|Si-oCih3M2!PDYZsYZC*ZI6H;|bH$K} zoh&}1yFRikr^-};#KtzvXK7G{h&qwVb4nyTGlohSH@KgE0nw{GmGNUaBOMs{*gG`V z>~*B6&{3D9r+^?-T_9BTb_uR_5c`URr15T=k)BQ)&8kayNHh5f{d)_z6Yo2P{7u4f zGWZD)KYYaOcb!#8H8^$c7D!M?UNbo}@1UC#`pbA}EL(KUT6Apcw`pa|{f?yEjh6k_ z_WSwoD8dbV1XZg*-l$Xo0A8FAFSc{1lgus0nF z3qAG6L3(ONl@3*CDp7u#-=4SAb)Y-Y_ZX(pA>NFz{scp?vg)g5qmLYOw@v0U4_C4R z(WEWy6atOS>FdWCV(XZjI6a`TEO(bshEVhcXN^d`O_dK8>aw+uffPj?3C z^s`1vMdTYW5(Ct)*X~109Y(r3FhB`#mhgpW&nXAzTm3=LKhW^!VYFJJ`S9XtLGNEb zG`W8(@pTFKS`XKIgHQ9tw+ZviT{$;i>H;<8H1|Ij2UyWzt&DGEH(ax0l7r|km8Q&vu)jljNnojq+j^LXY zS)}U)ac2>74V)Zjd>k{`a;KRFgt2=R9F-$iwGeU*(i}5AM*mmQssmGlheXv-1_Xaa zy&2PS9Bpgw)U|hD>F7-P@sQ>L-F-TPgVeT{;|dPgPh(a2;lR!a`ld)J?BkL zjwXOmblXIz`tRw~0j~UPm1`=yWGcHtD)KSL^FOjxu6~a>c1ECR@gvBhfmR2p;(_Bq z?<8+~x_Dq__CPU>=d9nv$im9l2p}+Ey8v^jBdvCs- z7S#C#ukV_6DeoOQx5{)V+Sb~~A6%^n5S{`mZ+}#cUt?WdVSIM1hKxEMxmzpedIl(8 zbCpgyYIvG>!z-e}s-#w{zn=X5y=QV|<|ZG91Wx1xygKD<2>Jdg9$8IpL}_TW{0VU% zrfa!*YX0jNWebIYZLkRBx zx4>B4gg=q7YIDljm3}gQ?|Idf*0?*LTlI{9+e7EH_Smp!ilu%{?`1~i=WgwjLeh0V zuV~)l(ozfC;=)s71t>0?`8f#Oe;QWx70@0(ee7G{5x6?>?1Sbe|0;vNpKd0TvQREl zZDm9I=C*x^*9+V|*jgM;9eVeCyt>){hW;9*O~<=%)BaRs;#CjJ?8QPmuij@8dZLUM z1f;<$wl(ix?&KLT)wd^wGw~tcBdK7Vjt}55rYvX_{9DXirAp8DYqT1+$-$;fXyB6V zniq=rumE;Fmqn=4U|L8_w~h%~Cef^Xf%=~P;k6k3H&eF<-Ct&nf2zbC>dk7A8ef}z z>rTv;_ag5CdpHL?JQE&%V@}UBna&$)I~Zn)K$Fac(iWmowsH}DG-xlZKqv>c)tMw; z67*?)k;fvh&yX(*N+H!5a#$S30PX~f`!XW_xFyPbh_opLZN0q`_o#J=-tGbz(u`*L zFcm9kp^2plLs@yhj1|AQYG4o6kQZ;4hAO)j*V%eNg|~;B zhr3jZ$uq^ENbrX6kI|@+Z*Pogx0_;^b}&DpDy}G5$d@Eu1Ak*ALMnh8N*13=67|80 z$Xm^~gXLg}^Q?rT$uQ1v6eM zgp>1$CUM!XL1%q%2D27cVKeHi9mm?LL_>gq`OWCN52}RmdhlY*OI8Jy>-pTM?v|Ph zguL>;3=Zy?EjG{v36xTET9@=izd72oKnyl=j-th;kABypYYh*h z*GNHCTiei@BX*LmB15tB%ry;_35TL8Jct)TEa9dwG&aNq@l*rfYZWJq76p;;IpRh7 zFI(){h}I+#TJw`r2wile^SjJ-jM50h(vNUIZIf5`RH8g$dFG4rXuf9j%+Aa`8d6> z`V`eigw~lG&o*)Km0H%ZfKOopM6JF&b1r3N$X5i_kw;V`8@_|L4Z*8O^-$F98lT4E zPhY~pHW(by0>5PSMWc7z8hx~N39LY>GXtelH{~qEqfv}_He>@!>C~qxABz`OMiJ+r z*Zk>A$nb_rf5I5@7w!OEw^#h0yXh|czy)J_%5jd0nwxbx+UUa3#ZCZwc zaq*R2ZX<#>wkSbo(l}tXE`mqF+px!cR$rn@JfFjzFfSvviapkO@;^O=&O`{FhP7fW zono%?Nq7-78SKf7mz*2FY~=Mg3BHe23*Ne3;{&bM{5TSBf`u^0>L6!_I2*Cp?pGhV zMUKBacj%e1N67Qn&|i2C)ayUd9XC^sSZuTL{!zxDNzy_cS-p9Akyho`NHjKhj=Duu zjpCs>K^P^0B*x5N%n93H;;PSA|5do%0t>-HW%^~mNs$vM)kYMwZT8xHnE6hpH9FXo z7_B#_d;kt_Fxw`Fnew2?pb~v{SWkyvEA9=cz%4(zhN2TcK<~(u49yP;Laox=JBqEk zA*Li~qdw)O?CiMOYAvu1xzhATT7}}Pmze+sDih~Sm7lT1^{2b#*DGHsnO`5URUv)1 zyy^U(R%~tV37#yGo`XxCSMOZ|uLUD;0|_C^C1`6}*C4-D-O{5b2w8%cjyDx54(HYl zj!*z8{yMxxYcZ-?qbnr?o{s?|w_-fje-%bXzzG;IY74rw&L-U2C1J>m}g zFcnaM7{LArMw!?6Q1@F|#-P~nYVe&1mujf(nxMr@^8p>6X>MH7*ri%@xs4uq3wIm3 z@#f?#Ubo(+u)7RGV0@Kb{l((yCU0mFvfANMD)0m##kEwdUQmp-c@ zL40G9#rq;(ZG5Aa7v;BZUAD+5v(QzI7do{)D&4Bwt6-c2hJImpSa1jW)j!X>P&Zz7R_EB4B25M?djEFeLQH2 zIc25r_%@va1Om52m7lfA#bxXzpA7$s`4ia(==jma+ker2nsD8Q-ol^v95k5H!?yjE zew&O2txe|-jtr;r(AklK31q)s)qfs-DzV-M?@vG>)gw^1Fm&U8Q8^zz?4Cl?VPFiy zw<2&{Rh-OYM_RvoVo+rG8}I?rU$3Upwc@0sQPg->xYxg8^DwmVp*B8%2#f%btTCm< zd#9Q46o*LdJWWmzflok>@3qW#hpnSzc8cKT=1+em(Pa3@E z+_<%|OWK;P>5&{Liv+qMwA9ZOuY9Jx{0u48R0E-|i}QMtk%YcYlqU)K-<&9y_0r-` z2A@ks1L^UBaC!*Mn7f9^ZPh}ySn#rQ<3{=9W8d=rh{MaU^$;exRrvrn5D7Bvk2AQE zK7&yZG8($@5qI$nHh%b^Sk|?swV;$Id{priI`A$S689Es1i-yp# zKOq3Q-GZ@M_u$?kk+b+4Z3;&-!nGmbWRMRMK`VhUxDfOn5&baLVz1WOEJ~4I4{dqX zWgot*BL^j4r9h1=T|<<%g19%t0;V-SJ^c_kKDx<`rUE&dKRwME-pDOLJjM)0n3@1J zKGJzihw0r3QTA%+W;mH$)#kCE{@*Rd zn!b6yAS8erB7Z=57SG`joyc~MLfCwM`A+5*s{9LJX!DLh zCP!kcD0#jTcztdwx)4o+(mx-6Q01|Hs|d}70>p4{U;<{Nx&>%rlr6TkDVi+@(J`pY zk7fcP+=*xth~OBCHf27Co#szj`f(hsZ|L)hz{qAa_k%%xv@E;}Tg8xr*ex+lgS%m? z!usyjlyaEn6QSyG2N%#5bEt>@^=6xJ2*Ip zM8g)}a?6i15SZb1m;f=WFWe=4Iq=+;^b2+nTa4hyjz+QLS>Waoi#m!A0|dy4Rew(}u#l$ru+ zJYFTJD7XsTA5K13cjrpnlh)0!Ir=mS0`04{{c?HIECW>648X3Cvpnx%-5yT@QkHk(@{xf5~5QGe)X}VS} zz7+C7!e|OOH`be}^xf3ps2=E!gn+@irgYEDjvjS{TcXa--Aw;ojDOgA0K;S8n&E8( zUU@nOf*o7{3o>;NF+Skp$KM9vxlM2pwO?%|p2=_<+yN6_a4zU&0UptsPJWIE5sS0z z4_@-)xy}(m+{$9{jc4jP{ful<*ZX1XvCFJ${Zgv#O z?^;J`pt%+0=7J^*@Q-a>qqby0oAA{YI(c_SJ9^LtyLM3l*f1wZp@O138Ss2_Fx{J_*dLg_lya!ue7Fq+=Dp1H)jYXfcPWV}De60eTyxL&gHcyhp;mf4Y z0aAScYQ*16KoM1s@oU*+nlHV>9!7>Qe` z!UB0)AOGkYL^7Q-PGl@~LT$tcih(5h@MLMCd_kH8iffg(M~Z0eR}-p;T1Dxhe8t$j z)uyV$(Q$e=29#J+bOfVF9gpF6b%s1400Fy{D|)|EL{EKTDu7q(ZZw(H72=UAvzf4$ zE0C6|QaAsOcVU%Jd^a(Lyg8p!Unec#VnKj8ybE)Fg7H!(V$rGRHJs;9KQqsind@%h z=kTLDh1=O!?~vEWV$oi^g+tKYD+r5+OM0-=^{x%5Lso$OF)grZ7-ppdkoQ4 ztONs(7jSfwLGn;c_wZjde8caD%K*wmsP+z#oe+4l+3sFKyz+VLzkpa&?HBEG`iRKM z0VDnvd?LK9o|1b9U4T%Hmv}{eFD;`0TCw zeBKI5>g_3Bdx%+)?dI3pvpj;E8n9!g5Sv=c$uzQ!4?H!*r@K^Rg1J;llAc%K^rIUR1fT*BRzsgWet z$eU>c>yln8I?S!apbFQ^RKW)0X@%G?CrBUh-O+PHlbt4k2H(sDm{EbY8T4vjv428dAE@cHGdpSII3g7~ z$gPWB34Lb~qY2$&1e=H>PZIkoC--H*C*3r54TG9*iSqq^1%bg^D4N6`FW02D0J5&3 zM@jEYuwcYi2F`EP>r*C&c+9`BdUR3wR~>wHG}YivrQz#lh!kT2B(Hzj+j{k#1*o#m zxEAqWeEkaH6DDQeo8&-sk+u0Yspi2B*Z2o-x}rqogUg@;GC6m#CimMV=W`^slLzII z!&IEAZ?=fmFn9dn7_E=&v;p^b2COC!M!(9)^X?g1#U)%I; zw8z-6F_C$I=w*6PTg)=>>SwF>%tEX8bA{6j_m5F>r%D`WQ68c3*9i=$Zk!S|!30ZC zl8TsgYo5JSHK`eyoeqBbmj{@<=&$Xq7l;%4^}Jrp zUw1rKxg)qX;JVe*IM#1BZJjZGO`EJzu~~yP#xx`}HgGhSa1P%s!~z%4_pk(Y#Oarn z78_LKyfsRz|7KM~+os0PNs{J^L>4So75lR}9vi4Req720i|xxbi{7}LBqH%BBJl(w z^PnNk6E@qwK=4=l;%v5+;_O&dQjx7tN3reutbuOM@dJy3t((0ET5{@oRpZ`Fh=gi; zH8UiSJoGvH>$mi%Txz*8QEEs#ZRNGWu3p;S7w=0Dwnz7oq9JSyr!{#nFN}79yJ4z? zBEPe>J)R!yWyog+yODJ;`o?$;_0}c2dmN=i7!xfZR5WOOHl2~*J#DY49! z?_VGp4WrK1$k5Dx{;jV)@8?s*Z}-giML+1Jysvr}Y$qjhP@L<9F<2k=l4IptB|J2t zK)-iWfxrt7r?l zl~QCardO97DRmMp<#utytXA#v&^si*kwxUKIccQND=Od9C^0q3eKEU>w+6LU*7(e% z4k<`AqPS-hi^OvcV!Q7TcsUO5|GcuBW&hs!4AgyjGUL4xWIQE3AE~+j@u;J2Jr~GM zef%|_Te&YjUE&dgwwDJ?SqbFg^2`e3w4CRa>cK=!8Fa>-=_XmK`?1ouXB53lz8l-^ z(BkEQH+fZHtlx0a!~xf3Jju0<^Q>2hQcFgVjGwAV`dTdFyogNNsS=70lxG)1Yz}fa z1+8yVsNd)egLVd}@H`hcvJgsO0kS9Xi`_qLwENGJ3@?^Bz=Hsh--t)eO@E=alj<9X zY<{_&L5WSAT(li=kvB#Pl{mID=3~xu&4MSN!=6PcTU^P8(kkK8l0|HO|sV+a?_|eYa^j?kYZ`ypd)6iY@)h8AifJOt^RQOeuuJ{$|Ur zGwqr9+^oPM+R=P)bMowV3lKMzVyt;fC9zh}&fdL4S|%aS``4*Pvhha=bUr0#oGwC- zvm}KkvF>cyV_3#SM_#qp5t>qj@-zEqLFmYSy^*VC z$|+>yCJt_6B@&gv1ql+-`l4FK4$F19=KC)a9M*0OTaJ9|i?4_u!vKjBj6AM;^{FbY;$Vn-A!JDV^ zkutqQZFW?pTDK;wXj#QLIGRWdJDG*6esbnwhuboGTc(SDu}*P7pG%8;AO6@Q|; zJC4|WUvs6v`*Sz6=LGXT-d>^-nW|Pgp@|TvZVjBH=?@f4{Ju`Kk~Wc8lH_YI$u;gG zE>%sEoi=fmkC{7dLc~g{I?C~#WQjV}Fzv0zHqe##iME2)QOXR^s5kP5@66thMa{Hf zlIOL7jVwW>wPlGxF{+PPb5e%DpvwJ1e)I`=)TZ1j%~wRfrS&9QXI0&F72z&|PCEUh zc{bj%@oHK_M?rS)p+pzoA)UcI1+uPrN%&>UR$Y%!3I*4p=gcv?5mvfGq*9UYb07=7 z(y52~Z2O{8Ec^p-XwBmhz*ji4cM0LSBK$_;fAv^J^{nt6!&C zxhvE$>|yUhT3L7?6F(%T^Z6u2V<&;WuB4x27jGgQhX}(1vG|0Wa?|R(9Bs%^4vlOF z2M$U#q7V`OO}1DZnN_9CGqRkk#3ol~OJHh7jH4?|2b@6W#+cyL$LAYky4Bk)imL+y z+?8!YQ#+P~#U#A+6#`q{*0V{uAV#-i;{Jm|=i`0nW0^TTP<;0%vWPE|^^9AvZ0V!l z?MIf|x8)pv%T3vSU|F}zvQ^Lcdb1|eT9Qm_yfMJsrr|EElGXeDI&~#$5<+?ORBWv# zp0<*;$)*;VZ;bsZ{kPGS2Dm@p=sL6(_j0s2kN!>#$YYb5B;l&Xs=!Cx`Ea5BueROC z?^_NL?u9MsEA7`_x$S!P{Y-tCI>~DC%p%iW*{E6JB_)s~kvJhM$k%&Et+jzc`MR-= z!eQC9_`k7Nl)04`8eNy$CC?lTqKc2xB)RV;DQhwf1HFRp`SnI41lQ0^doU5~eRulpusJo!L8r1Ds){Qqva!8!c&fyPL|vn%@oEzW))3bk$#cDzlq}dn&717|9ye4 z1Bg&Ym_&WI-0kqtJI;51mmC!440L0R5#4fAtb56P+j6D+-Lw6_T=AS*BKLig94YSq z6~D&Q4*cQNn)n#8USB=o{7^ctI<0r&`|rL9Zp+<0r}2r^rFGgrd%w;GC#K#z`y}Pn zM&;EeOsijKF``V%8~aZDn=d4nchj6Ss0e1&FSHp{^2&d9rqUpVK?yl<=Y6{c?3g2D zrdK9cibB1e7;&ARE5*8B3oDwhwse1l=ODUDO9=3omYd?+y`lAlznnbeD@%w$hi2AR zK#h=+~FlZ|UAU|Kdr}wocKsPAMjXY?F7Z z5}P)H9&*HOydFY|ArC7q`Ggr(kdl^$;$qy3My>A@&I^c|4x#EU!L7fwJ?3gdO&mUs zH%L*(=u|zm=NP$4Sk2qobtbIqRJB!Y0rYwV&ipN-UcUvl$HX_K>DJ-^ecJ7X7jOP) zfcfrkCadc)`F}ys9dhTHnFhzYmKyTnL~>PQju_&8$K&^}BdlGN)9{T$C*l<|J~khp z4!&tX9_dBCIh|K%tS8Jx=&>$L1h_=}Xk1_U`0;dEsK2pkX@+4mwrBOWxC%f$3*r6p zKXc3mKa`JR2?tYT`iq5yf0RQc{?isPT zVco+g){$+-{-1RsbJh|WcV+#zsd3!y{>^*sy)Q1y{>91(taicn#w)b4ty=gN3~z@Oi2Z;Zu()x?&AXxuLK7$Rjd1p5SfnqD_c?eS zIjek~u{ApuU(OfWU3QD}H2$rhkt?=J7+c{9e1CMAG;{7^wn0C7kyTXY5a79HqwO_1 zR^pq0xb}?IWWd5P0g?ArDAyU`t#6=madqv6)vq@Cqqj%)mrl0AxRZf6dU3}+-2stb zNn)eAUfqUHqt5vS&lL0;`W(LzqWmcCf4=22S(E;OGCnHW@i4xlW$OT22No~6=&n#7 z{23bjou0R&KiwCC3!9umbpS7a#_QQU``TVuR&vU3QFW2z_63sL*D)6s*lPbgE-}r5 z#;mhMF^aj$y+U8MO%6AuLf^;cS2VJ)Df z?X{=jtCXc|HPhkWfuCN%M@?djVo%8_61|2l*n9BGyg68l--#~uLY z&%agxTJeQD?d-o{@r62`5|@koehZvPdW8{c<5t3aPHcx0A_@@2y$J(LZS0CC*C)!G zgRb*(-qNzUGG?VUX2oBuoc8t3?t_`3a?bfL9DV09?Cay8_??IVOLGqKrDcEROJ`q@ z8%@^(G#01sT2i&#JN+ky0xf>TgpwnJS4|1T3LS`d-iH3-$E*I7_AGmQX(X8VL| z#0LH6%gr2{?-b9oS9;3qsPv#AYDp%BjQ$rYG#aN3I8A(jl4wdzLQCHPY!3h1;?SX0 z0d}?N{?W{+S86&W-|9!EKZ=zvU5@X_Tsn3T1XvqEt{)0$eu^WK6}B#vX_BvDRl&0u zQ?8`}wr=<}x=5}htC1JR$@G78uEi_YBqjxVg(@I8`L;1Bu4(c3S`Qujfa9 zRelRUrMmptnjh^8zl{0Aq8@b5j!nvgDcfzMHW;4Jm}t@A0*1fDMa0`w z^?>WP%}s8dXyW*khR=;uDy)L6&n*@flFr1|Za=?$ zX)@)aOrn$8?@W)g1Rt<4$#cXUwRU~_G@eJKjI@+vkfjT06WCmIm*Pfz#L?@`>cNgL z5}WwQR+(7NHtNkT!_-JZoa!i#L&<{B#6XYs>=T&UjM1!x#HNPeW;N`Xn^@YD`9M-^ zLLTBKCoW6}6r}e;aN-w3Mj{O@$QA7EBu~>w??vHO8T~YeZ(=ujLukkJX5~mv8AGb; zC|_ogb?g00&1LW_=HDbr!*QfMw%mR_{9Nbc(D=taE^?p+>ydjjH<|fz?z%XjF@rjI z{#`nZt@c(*O2DEM{lLNW*Iy4!>;sk?ied|)iJWL2 zY(88*mI1Q7SR;)`Vfkp!|M~8mLN{2IJHN4%Hndlmy(%bS5j?y>RrF0z`jK36QJl0M zhs_1ZcE+T;%Vblbb z;9E#BYR;4rMxAs23-a9+m~N)tz=>u$>RxYjd6!I;&kByWdW^Y^KL6paPouY@D3tQg zf@eexJ2YHE6_gvqJXlF%O3AeQ`3cwRlCisx$(N$gKz=_!Rj%PO$4rRa^n#A2Cby51 z^BZmGeT4Cj=!=6(xjd%by}9?k;w;DIjRCqYZQi=1y5L>%mURb6e_1N3Kw6-YCuuqD znx;U{%wP@fm7FF?GcBniY*Hr{A^c9ccAz_IIZIQsqwF++{Z?)VOaQ$=c%0bQ>lnR8+N5~&B*l~in7*{q0a_hlmtZ0+42Sz4%fkQg?UeVsmPQ(DM=swW{GTyjj>_VYje$HjVu358=>~Ditx$@s2FQT5 zBa;8cn2!Yck+D>q&u%KrC6`(B(@+nUA?#X&eviWR*xvcA_MIzS>t#+-BMAmeH&3fq z(l8YceT9#f%$|fujY&5xWm1w@$})1&3XlV6p}DFLukerlXV#D2Hi}DWeM2WehNi{Z zam%;ssN1goH)`SaULyUMtLoc~6L2&$+$e(fQ$hgrzE4aT{m-sn=I zk$t@RV6-UcDfi#k1u^SVhpl_>QLiC#pn=N|A zo95p%ohXd*a6z4>cD++oL7f?|v5sX|@76zcJ>ZY@fXTZ55D%;3HIoY;+!^{4pN4W> zJf>Kur5wd0LWqib!{__GbPcQehwa$8LnuVL_2f2+Xh4|s?-H4Z4W#Eh@UKvBa(!|m zM3;b0Y25b&e}tZR!1sjKjbFQT;Af%3pUC4X<{EAf_(b$M1lN)Kt3sphpFx%6jcQoMAF41h_Nd73VbdFwh#hCQ|QlsxNIXuUVlNg76>m8l>CkL>906G30uTI(t7$dwb-tY3JC}*BRt@nIejQz1y4Xp^YIhK= zc~$f}#Orv5u_I{IJ5opB_oou3CT)d7(a4bdv!0u#KM={WBK%rHZ6n<$G{M#0@@ICm zgtRvIb!qahQB2p7$yYSN7Zdqq6R+|1(W1ZJS=cZ^qc%jNuBYbav-OG2i!eY=Uot zO^TFUUWEK&e&6op!}P0AjKzE}=EbarwS{7I=6Y!6dSK@ImYGF&MN6*2+$|hQ5?|~( zTs`00{Br2TPv+)vB#|n>947^W8TSGgJxXRyZ5p$*t#rmSyGzVF(jnEyA@#Gjw6RU< z=|->U%0%K#~|Vh{hH71jr6Q7Yq;bdI2ygTdXT;)^tGtpwbhd+PFIY4 z$e1Fp-TKfnW~9NWNo&1Io^?Gn%8CDx4rT15M4~Kq(}*q~YuroVh2P5;VJ}Z+RQQJ9 z_-e|}CEzsT`RX*_>ZROPW%Ctf+=XGzfT9|yBh22~$TRXPM2Y;dNX|J&tZibTNE4y% z;;%T=&eKKL%)N%``%Sp`Qz4i$!7b;cCq5}Hy}EOGth=O`55rnIrZ8<~DKt)Mo*BrK zy5jk&vFuV&zj!SV%ujwOZu)Ig(sahZjgD^cbWZ91m&UWcS_~ywiP*5WIG%LAb_fMo zbN8uDdG<5?=QC2zXT0VY&2)aA@Ppxd_MTe*Nxm&86rj(ok3ls*T{OttD^plZLD1&9 z511-7Ne!3DEmSJZ?2WVOdlJ2q8XSHvHOR|4RKYgeRHgJ47-_hZA-5lP9AC9ZJ&&=2 zrhRoe{9XDrhvmXytXktYl~dqpxFw@yBLnqL6zWx{8={zHpAO8BI0T&hi)aWI}q;(spMfNs$nPHVJGo- zf`X&Ez)-J#X}NT^{#m>e7oL6?EYUci;Xqs%MVc)H$AoAFL{ba?6t~LwI8#&vO{o?+kLDvVud4Exjm-xpf6v7}ui~)~? zKES1!edh03&C~?eK#iOz`$jyide{IM!wtekzTLrW#mk72gJQKpn5{kK1S}|v4Ej+3 zfe9;I9i4b{i?V7~(*#!#1v*@y#C*NSA{aiG!~YQ*z8x4YCU=FkNld8WWk$;2u3uUe zv;Si@Qi}+OU&z5_p%kqr+G08>1?4gShz_YMn+2|W78y-`E&l=GNILM3XoUaKw2#B-O2k&9S$+M)PXIH8bmu)w7 zOUPn{b(seS26VX3H#AGTuD)(H}sU@YQ{ zq#yr@Ysa-aeeCBcFwl$cCGgqckNJut6bgOL9|Ah4{XC-Qz5{t+6N~_}K7; z(H)Y9GY>zZq>S$bsuRE*=JllVP*48KCb+;sE^784U4pE0mx(ZM1F2>TSgL*LYxPA2 zV^*ZRpSqTq&L5gj*l;)?hC7+ZM8xVs3GNQvXtiKW=E=ss2M5MO2kzWZWU`K?Jt`5Y z{|P1P2A{DI3qELFLtn(0*E@aI8h#T61`H^P>9|`(Z*g-U2MeO19?k1f6&NwzAk2mY zlzj;d!pdzB!W)Pz!13-QLckaVn8o3^$U3|%*lT0Y+a^MAE@WM|T7;qTKOh9q8z|v} zGqojQn>>WyM%HD$dIjnFNs-X(Uyg~=nE$i(&D-#99>d~*az!y6r?>bl;}co??l(Bu zojxsGs{ryvImjy`Yx2Ik)5}PCm%7i57${XpLx7{KYaKLJpP&00%Y*@b3GTZ=57Na? znLykshQ9dOzI2VB5(ZR!mt6))=5JzrsXX=H17kMdsh>*1@uB>9t6|&kj944=o?qdk zgdwAWjtTM+n8s7S4wNXVc|A5wmQYBP(FNgRsC}u%XY~lkb&DJBVgfiQP=7KlAI(}8 zU>z&M)L>t_@hqF-p9Vrq=MSj&@&+!O*Avcy0T{+0!~AWRvQJCX>OMP+106?_srf=l@jxS5gnj9RdN!dT7(8KQ7lUVDO987$k$ubx=Y$O0oS-hG z%a#Hc453=(Nx=7`7kob|<>iCa31QCQdpXSue`@f?BAg&DczS}oq zY{koZ6a9b^h_hE;V!V%9s-UXVOlS})WXClf%*z{^Y z)qw?j6wut|YB5L4Fvm>06nb!$OElQa2Y=%j9x&RuK=Wp=WLJLR?*eXd)-rDT*cwIE z`IrgS2%EP4mR-MjzNsj>;ggRLEJza+j=UUGiAZbv(t_g?qk~}ZC@2qxoEinRe8FSr zI?`MeHNN9}qrsZ@rp-a!GJe{^c`G{y*ma}LL^1s*kdN2weC6-bEb{9#QBTjT>` zSW}Dc4U5U%h`9}i?`(I7TcxtW^uY!T!<5?{vfd;Qe-I(HlI0(2B`cnB_s%SS1_J#P zImf6CX?$#E!BK?S9(R{9$D8td6=Sk)Ikp;$4+QI5*KTD4`MdJdnJ7MEkYZ*)p@FDi zK1$!1z*q1N3OesCnT5hIhWiPEyczQH6OB2f3q_>`GR(w_jswm%s6R}g0<_6bP}fO6 zWsgnxHHpasI2F_k4<0=2_9Q~54TPBK;ip-3LJGrfN^mkvc&MdXQ z4lAsn#6Fv~|1_H~)-TaKzb&t`g7Ni&JHD$^2IDsIElGmiPO!7jxQsMWGN&8*oPtmO z)lfkX5mvv^Z;nt>h2Li&Ch;cTxxJWdf4ck!Rc=LKESB1z-u(o_5v2d- zMzCl%uXi^OCS%;_bECRK)^WoknA=Wt_7&S^L&w4EEG%MS17^$*sWVz4-Ilw#ApXtO zAQ*DT%_~&cMw$)dEc}duWSWw));ie7IprdR+Hh{VF}yJP4D7tN6y?^)mK4Nm;l#;~ z2Fa-i3#+GOH@q^$Xd`GrJ$L#qwfv2fFdN>IG#SxdRk|RruN6Rw%c2M>J_=$U{ma^n z@?WlngnBx$mUG|es{+nr9!FTU$p?bI_crt1ImuSy1e4$UYf7Rv8`1-?^FLZG#b*K5 z=Ca{(D-L#O*_m(TtAIyrUYglIi8|ickS~lKwoQn%HRYysO%Pr4UYf3{?4OpG7Nj3+ z2Uu68aV$;5+wz~X)BvesZ*T>n%&E805}cxXOW z*fJat`J6>agTXMTo;kc*pjfP#t>hhWWThIB*S2>1M!JPA9WoZ7o%fT-$fU8LD%oJh<*+;eT@H?h}y zuq^Xr;^Tw_b(Wh4$Cson&9qzZ(XC$*B~N^*btMZ{x(a22H42EnPSNV!B6Xw=9ON6 z#Dvsit;0hDEez00&)wP6S>gUG5ltVREToaQ&<#&1_QkieFswVi6ZOsO*^EP|L z&yIIq^ubnKMTD9wV@}g{gqB^KzQ@m=@@sn6&A*eZn}4n0lRZCU;RY~h8pyQ%sYQ*rl0!xG>1GNsT^=J72E|%7;SG5T=ba|Qho&aF21xy@D;LGyd~tF3xWWRcWak{1IM~)bxjK6C$;Q0x z{!qx2h7B_tB8adkj~%QlhPv6Boe{FF@7o5Mc<;Jy(dNgR%cb=r|II`p~Qpp-MmoN47r#e zCTnvJvJZ!1c$3;YpBFoof?!K6{(X(t|T z*PpUdf%?G|0R*9>5{=Fl+v!drZ8(aX#lOh0ND5?gBER2a)@$M5XBI1;U|M=OJif0m=lm?8wi zP?S#=!+F4$#8hR;GM?X4_1Y_=B8Lp;#&Kexxbr;zW6c+0y_C-Sn4JAi#oKRknYo-2 z!38xH#W^v>&mS+E44jCGKB-UJ6tn;)@|rpfHJH&knC!KvU(A^FSNZ?!{*j|?#mFNZ zlknVk-L5QQ`U20A<73_->rT#DEPsLTLeJ0M_h#Q0ic<5w<~fyOUD>_rsE*{{>SDU} zDy7RR?78rh!en##grDO~B_>5;YD2fQKc35**1+aOaHf8$n9^sN>`GAit3v$y0Ej>T zhRIxgL)tp$>~x<~(q&J~FeoqTiXPV7d&DtKIyK#QfPG#v<^=C)^jSBOBf!U zk4m+&;GOqK$VQO2LC{S&;YLW5u2m{KiW8D;!d2?K6KdR6i@N{?P+r+_WK#y?u+)8+7@9wPk^=cFa{MAAx&V!d0K{UCkSBzwhw~G;G!99fFj|FR zL)svRr(>V~4LJ-`0~{2Gp+ga3%5PXAb3j_46~SoTA0gIrGc1B$`8lZkncW3$Tx$dd z2s-~ij53rA+N=F@thflV*w-y5*eE3=Ab{YrPOP=?DR{N}0B`yu@-S4;T2C#x; zrNQUDe5cQQ;|_bv#-pY$l2taa4+t8BPT0y^SMpLbdy!& zL=OgYVM&1Zy>EKYE>m!|loV#Pl$7cVP46_<=R{e4m{o>Snp|=|K2s;X40$S@HFe-$ zx&nxxtif5*mMQJLup?&<8ljEFY)^ z+ivtrkm-PP86C%@F007GKY~d)1cQ@s@Ws;qDCt)ModnhN>b$Jabk zBR<41I9HtTXV=|cO(wOyix`>vNx~n#14({W8E2rRfud1Ir94BW-2L6UOvA9^!fQ`M z=0<~l9ndm4jk(>4Ud!R@3fAmwF=rOp?I|e`IRw=zvdGhX| z6PI-T9p+S^Mxa121`=ol#wO3jY~tQeu*Xydve=NyzY0B;pS(Yj%ax<_uXZzE)%yuG z+7=Q-ijf^_KVhb6!Y)V#T7SoI)`yKrCQ4-p|4;`Wrs)0AS)$j)X8cH|d}c!b&vj~z z+vE35koQk%sc&lc`f-FE5ITT&!-+rD8Ba+Z5HwIkHU6iz#Ixe%Km|j=Fa?ys7Zu1* zh_N0A4iLitP{Aq}A>0NbFu{RmBI_nVWT6d$YjOt;hTs#ABUIXMQgo0-FbJ*v4vpIq zifsdf3tjVWZb@bWv zUW30?x#qk4YobML2oD$v|Jz^`35vPDg0Za&m05*8Y@g!hQg;)l|DAqCg#syUoYgSf zL?iY|Q`T#|8$tK~HYY}kVJ-q+{EXAJA(b2{OEk&Lv zovaVuwbElo@j<{#9qB_rFB_%xkBa)I^O6kSLq|!2@mh*;Qdb_N%g*S6$FfKPS*;}6 z4vkY0EL@InECfr-uZ-T5^8t|`ZNrS%Q;eVg4w}b!!Xqi2{%le3uc{J#l)zDTllDv2aZ55yq{3osK zlqDoKZbOFnlM1Br{Luyckygq^ZF$c)0k_gJf~2~OwKew(K5(xWjdUY?RIPbfrRlJ} zIA1UrV)zi^jtS%UC;GeNiC~P;8sfK;$z*;_yy$TngTEP@FdmyQ8k@jR%m}3RZo5gA zLG%N^3q(`j`cHDXoESwd^Pl9hu0n%F`X5bXUy7%mjRpul^cBQH<%40JVg$17MnMH3 zmsPvxojJ@2gZ~AIQj2h`0!U5R;kr;W{HXU_R`HA|PYAvtFPQ(*wTfp)kwKJ#i#V;Gv!bvdG)C5BrPGSTA?!DrDZ>lasVFzAHZl_qxIWYcKMIh$ z>n&8Etj2zBFEkz%*X4UGrmwwh$b35rO%iW+%p;Y*$PxO{FCQ%(%WXwUHBor|OK!AL zgO5=|h*1Np9`zsZlDE*(Rs@qC_2FmrV2G;`SOhk3qyB4LLU>aJM%Gz9j)1j+>9M=; zQE&i8TpKXwi}R66C17Gh987nGO^2RWKWip0OUDL_!4YfIO$ImKB|$`BIap?{w8z%z z6HLMw%##Hhk$P=xjo$c|kb;yC{31(@@1kBK8($Fb8z(__$Xc9p^Y$=kUjiC~K$$^_ z7^Sc~3E1tc0@{rm_1?hhfE~21w15bL?jt_bmm%r^6$~BDjWoF;6~-d_C&TRU<-5}<7A7vFD$RKk~N=w=g@o2`~JIA)GwDcBnuw;y-z&V1{f2)qnELjtd&A zp8rz)k}JOp1QY+rGr`PJl0X&;-I&+EoEAk4o*%@!_{C#*FSMow zkSC{)`cp~(6-xw*l;E{ZHsWsE7{;Ow#3Qi7lTTQie9;wxZA42(|C>-lJXoFTI(&=3 zaMFOW*G^xgfIXnU2kFpNdBzaydPrU|7Xh>mk*Ykd>SdjPk!|s2U4~k$KF_|CKjPe- z%xaR8Is6`*cXl^*t(2SMT`2+Rza6bPlijkz;qG6VFf}*z)Yy)xy!Nht?Vv8>sGhC; zjYXm{XedGw^o}8ITy-%ZygZ!E0$ZW~9_yMo*#T0;&)ak|{A7zg0`NyQ%PwAPsYO?V zjpVmvFOE*P5{G{(V&|T2X&LaOEik>$Ujl19b)akU5UD>#`DLXN)6NIrLHFC-OQH%r zx@SMM!V+^7_C9!Ocup;Cgv_eT&A}|5MIN;H&Rcp1OFpkzliy2d)PTo|w8t}PJypGR-rNxPUThP^b#(N37T0(wm=yiVo>p@4 z4E>>m(z!!2*eVmu>cbC!>{=!1z9H`mg&S7^!+0>a#x@a!-v*irNW$@umk7mkhmR0J zDEGH#-U%y@C@vA(iQe$;gTklw$+HHV+RV9l@TXnTu{my9%$E_b;~XVu;`B_9yq=$R zRzh1Ja(mZ0vWi)^KaBse>O3#pFcZ_ zb)GcvTIxuqI?6m~NR%bo?x!7=CE8%ZKD^GSl|1ms`QQ)rAle?Hy)Q$Q%#7W8M_g>N z=bLUvZ>m9O#=1C;_-c=gKq9T=p2vno2ZSrCk#MoWCCL$MN%6Nws@#_R&zJiumMkAN zH$Bj`YOhnS%jp16*D;czd1YWz$xr$6fcg7|8|v1<_)B>-@wbTMx96G53-$ZDq;tdJBcj_Yt>gigUzDtXG`1eS2i1RMY zh~7SK;#$NkRo)D`aWU}qn7uP~o~KME;`tf8$pN3v&4`-Tf63%Xl)QTRuInE5;sqh< zJwKiKX>7-ACqMBe;YMOG7h+!J8=+ly?b4K!;P2(kW`?(oq4&M1{@~BwR2Kg*T5g2s zWwOAWGYDy&VoRXcw!>YU4h%i^`lanutM_N&zsC6x=_=ptrNGSQws++I=&N&yNOJen zWRlU!D<+LkPc*FwC_k)ZsM(kx;xqcgx7ON!P`PJ1zkDfPT0(hS*S(lks)58!6n)1b zE}i*cTK@X+k~<*1?}&DKs_*bspeivCZ~)##{}xardM7s!WwO@cAc|dQPazhM`7olz zoaCf9rG-s*g++cvfO(e5DlH)?H`JCf^p(X-xhf8tNZ%7Us*O zf04QyQ`~-6KK!pLU?s0z(CO#Xg1%&(kaKE>Sx&QFmDS?9Wea=Sh*t`Hwh`8`KpxDc zD<4KA>OgKW?uMs;+C%E}&Jb$fa(8>C4s?5k-@6aIuMycX_>tqFQ3o$2cOw(_3z!hYFD zQv*#41B`)D#slG#>w>cCN^3c8z((#?RW{>KWC-VcDM_t3S7O z;n}y753g>rD*y0!YB1y#N~K)Hh|u;awcagX9%lQTlvZWOvzih>^RU+DZJXkZ@B*uT zgj+io*QEywmfYz$J&dq(7pL31+qS)qB0vdU=dPZRIL6h+5_O%u&ANS+Hb57d-1(Bb zLi>BKy_2Du$mL{#!R5&3VDVQBjy1k5snrIT&UrAoe_m$q0@tmaa$%IlRlWlhFp2$u zBcJerH0tS)0V)_Jgn^{hRFnJq_3)YuoF3|qTw}97$c5P%AN(uT5q^S68xsTy5}@qo z>(4@{F+v5Yfg73`hvrFvU=n1}$dky#&weZN6AJpTSckWmH-uO=hG(HV+LCVF+=3wM zsGmd({8z6-nGc`DLuS9dKsPA>O&U}q9NJ#|m2Nxk;#(;*qW;$DM4GZtiEaO6+pDL~ zt(4hOL=Xw1O)}8`YJE5f_D{8qC^b_z!4f3;Q=t2@M<{GYzQ_vKgsOt(CpXn{)O!e} zq28U+BH7^=kKoOQdj1ajV<(Z+;h_%LD1FE=Xd2*Q#mj^;fq;N9s6Cf{W|`pZa3^|5@*kZw{;Cy&@DbUKtq=qkG^uhe@LzKOl`7f`0L^FqRmokkd1k_0 z`DTak+P-H(1d-Qe=V-C zoL~E8_x|-gE9tKzz-HLXji8rj&-R91oe3xOIjAHU-3_~zon{-M_Z3rfAI6v3h@d}I zKUmAFlv@v(!0@bJ4Y+1Il=BzH&QkL4XRF{S?ar0~7fO#iX06ymSPVURt^1`oF1pgm zg*(8GR;U-gmbRkX&lV{J*}*m^i}=2+rPBzth=#T#bQ5j>Ziz&(Sb^LZFQn3_hg7U; zGJ>NK&JZW`+DGVhh|uc;dee(kmvyf7K@F#M4=2ly_Mu;MQ255he&t}P&uEcQ_%*2s z3tR;%68@oFHVgI2*xG-O9KMysX4dtMKuN@S6Kvv#qBml>Q3wA89Knh0anyC84tG$3 z0HnLbX=EpBE9l1fL5y&b0A88pY&xLc8vGyUxSJaU8jKiC`8a@fTQ{~3H|`=(dYsXO zn|pqcW9NdKBVmlf=plP}sJ9TifVYX;JVs3CiaBP9jT(;f6VHi#Clbm$`J4=J@yB(T zN63S)f)dy6HU@&zfSY+6Mi9djykq}=o1L|SB|H+aq^N^@e3T&H`-glKlGfXv;QhCY z>KgzuzF~F7h1yk*puQ|1aFZv7nh5k|#~qO1R?>CXx8o}DK8=2({WeWLETU-!A9_XP*|U9y)@1j%?Py z=&5vrO(?sbvpv_G6~YVK5D0oJC_$;#JZ%}urblP*{B6YXdx`V9{#|!9vw~t5wGR`J zkul7XB!}#2xE6< z)^lmZreDK(o(`qFPAn;|8rGKf%{>Yjz=zo#k|+J@R#d_`8miAtw{pi~l){KfmwB_N z@9s`Lgdo&fB$Ayn3X#ww1&+&=rp%ngQa+>T0ukAy$KmFu{E`IR#QJnTxk~~ zUE_j9?%VQ=APg9{6GJ4rRHlw}`M#A`nJU?96RPr)X-OxB#^f)m2xS*?l7_E%&$a|^vkc$<2Tj`$%JFI-6WBHZr2btn_4EebT zoJL$<(FV&sk^~(;5{O({RHr(2ZD|3*8Qg#U0|VUH=4aWG8wBPN42smv_z|-as2zu) zlNjD<7WuhL0LK%}7jTW+R4GCaxo*X7I^t?T-AiHa0`C6DSub{0Z z&60atS#uUgt^CG0ek9^0;$BIh#L!E6dN5b$7>B{u%Xn(7@E=Soc7N>Emnd3f>(5dl{@mwFTAo zDK7z@M{aq5lKC04@tjCCg{|gWE?do#@yeuirSakONCH(O0##CizUyk2nLYJ8*Vh@3 z-i?9S75c}>iOtoyl~DqP%J=ppxW72-t_dw5>W9k7(GHuP=+J)4`#rv7=gNv4-9%z79|VJ5xrjK97o zwJU|#)8UK;+Dl=COJ{Rk1_U(RLQa#++p|@#{OKFj(xBc@`b35x#CH>)n}d9bPLz;p|5m5szPhNM&v;7)Cpucu?{2nuO3d! zXlGI!uy-pVGX(^UkOR2-a@;)R_i5U{NsS zO;5;>ZP$`)*OG3B4o*)9nq80@Uo=3yx#1aRh8M@YQyrmTBbfBt^W#|a4`s98`8@?I z8$t}~y7oU>f~A{*Vcji9A*h6u%EX9qRS}zoj*`|^;Tua-gMRNo@ll$og4h#dpqjS) zrSFT9=WLm9c3kP-<1OL~9WPJR38a5gon`97E)o{KnGgcLlbBO08gt&}Mh)`FBVl9> zozY|_UP?2&HL!nR!0f&0%iuBJ@sLIOPU=Kdv)H!KH#+ofsJ$FPYo7kAs|*E?tE~+v0&d50PaYh)@*BqH7lwtI=$J&jB`!S-1U17E`_xFRcW)$`KXOdta*C!lDHs~f_QIc@&2!XUgw}EvBp~B z%Zb00{n1EQYXnG+rio@&YV3Hg#@{OjbbW6!9%}Z@lJOa;_wgucU^ISk0dOx!AWCB# z(x68BFU)VgQo(27_dDr{wB|mppX~@6Jd$sr?!kN|$W6Wt9>`O=F5)kH96tLy|TuH&Vqb>?_&rEKw z7`7HHF037pi(=~8D}>GtnvHnjg}5e}I8%hA;n%f?4!GmD6(}&Xj_@Ki`3i3@#Ilv( z9G{QPwP6<0!M?s>JeV4$ z;Aq8XY!_;aH=^=$q=az#L4Qfn;Nj?+_NRIg{b{+(R}A%p&mG1}21=ef?+lIDpik%Z z+rT#Yx?bHa^k^>KUhKEQoz`xfA)DUFaaAcUoNdUf@!usUu`S!s7j}hm{2UagdPG{9 z*(@a{Ob2#L>jQF--A8k6!DHP93m9h@bHkFP$;nZDvX|}a)22(u+jM9gKS#!2Erz++ zfK8=QafVJz1ifCX`M6U*ZMqeHk|RJTDoe;?Svr(cfd-7J6O( zXkw7P?A%J)nb|r6bCQF`X=F>cYBI(`EpYcfj+$tQ3w5{)HrbXgNjl-YIMzVlrvaB} ziyv}Tl#CPjx!GwYjvEmkZXXJ+VIt1BC_*Jc+ZTD%qElb{Cp!v6L*EbQ(k=|*A*#su zOJZFLSiS>t54+?9_sfY+U#P8)lzQG#Uz8wS6#aJ63-!j=ogJl~4b%qAr#EJaCS6;O z(y%bXN{i1jm`9qikseHqKaP!`7!y;++p=;7lf<{;bd#=slKd_-5%=c60|KCG4H19ob;#VHY&u|Nj z`R?PXz4R4<$AjIWyH#lQ&#GXg^nJYag?0`vIRjc5X;lODDWcv`L@`oyJQAZoIym+1 zRJaiUm2P*+#Ym9~BqB7t?2UZ^9b`tzV}np5r6NO;u)Si_$RWFrmI+LHw~<-}Uy4kd z+54 z6GW~IrI#DD(h3OnZtsR3!nakAv7ptttzuHf`ctp><5N8(03&L z1DX2k;Cn~|s%vb8=MDvJ~jUk(n;mZ#}mb%mu10Cm$nv^DdMa9B7 z6;J`C)<#|%A+G=g_gg7)es<&#qa+>j9zlTU;Ad+_^^Xysdt{!k#D2EWQ5LB*+hen& zz&8ZjWi@xseXIY|7)*(&kpKx~Kyd8L=dZ#7JlFzsWZbG{5UzsZt|Z~3GHy}`e=n)H??#5o@Y~BL+;{VnU6vqAs3duaJ^vd^UA!0IeW<|OgflR%JPmDxTYia+arNg zgQ{A&*iQue%gu|VV29i6ru*5vCaf{wdKJ(^8FtSS=F^7_>jOMF86a$@m3;8X56s;I zifs>Gde|8qyt$GF4C8ZLANXicDl9pn$$6Yi+-k}rGXNTE`D2luXVj0qdIQRIcZFY7 z>kl;#H^I)TSW+j{(Ig%qBUKBNJo>b1h_9kt+P*Y#b1BxAZTK~9a2;r=#kp2(gGxV3}Do40-<^jpO}eF)C(u@jqAAW1e++}o=wuw{+J)wlccBf()v}v7Hy$Moo%!F zm7cEqD2TPPEUif)^uDP8lPN}YMdG1S$IO^^#ZYbNx%kJq@#6Tonc}51As(u6R^0*L3=P4sV-?aa2(7QfVOI6U}^||Bnv)oA6mm?;&Lkot& z_h&UZ!n1x*sFt%~;l?vHt?TM(IZ$yv&qcoTct2NgvYk}6YOk?*plZzT zsMsd1>Tx)I z5S2GG;;IRR2_HIzhp4JiIIL^$Y>6-QGG>}~?BYWR>c5bopV{q(< zwY(%~Ok2+SZFFYqJ3z(yyq|hq7DDW+P6K}skSSinQy^d}DF=!2Q)hr<4HDGjGly>a z$=iW{Gtf@o>LXHW6k7M18lgJw#6)-gY+&>NmXiSsV*C%!6nJ}mHu~%$M zX(*U{-saSwrtjavoi;xRzTS4BOFeinLRVBYiCzCg=J>r(31_*hBm)+lMPFUoN%nH! z?$3G4-y++Ahu9Hub+XfUS?=YrzVMMD>7*bzFuG`LfoUa6N_KN!t(u#Sm3RM-)t zzBJfVG`YLB0CmS#C3`yzQBs6LZcFbHVjWZTF2b@!ML-s6zE113T6l7NKn%h@fitEe z?up`WEZ^tr5Q}K7>#w{^G$T)3Y0bTDZ<%@3r^*!Zv8TNKCf6})lbZ*XUUt1+&t-s_NcffSsgLk{CCggk`I=MR zs8!5Vn(kA?F~7mp>Qy>nYc17rmwZaCCGGaM9+y4MduCCRsj?P*%xzJxRIm7`r?x8y z0o-jNz+T7aJlt)yNXvTh+tg$GQQvcH1P$!l@Hd;)882CT*QYOnNMfkGF;|Pi$J-qw z4jia%wcG}I9{Z+=3;M`O75n)XSu{$8o1u5)q>{ZuOFKs5qxvMChxXXw+i2fD`c|SP z>V;jM;dIb3Bk)?LvGruhlnrL+RuS2lI(GqtRg0E@Y=gu%hgs4o{}w4sJ(~(bWTI=n z_%`b|DfFrAmJtqoifpgBzW&f<;xqE^aCYYV*##k;&zjqt&eLHHh7OSp2jmU~Yv_yQKufejJpSCSzjV2O+wVIjKR&`*gQ1E3U82~ws2>knDT_Uj zrs&(y;{cH8QO>2KZ(C|aHU(|zyx%S*(NmjCzqPHqkXEKqhjIYOr+&8_-rl~wFpa~2 zppi@(#kEDV7r;0UQ{Q&7uSK|u;@WcBxBAdr&H7tX(7L9~!7xOz5apPwi=?*vN)Bey zel)~Wm~%6{V9Q$TNb94~3>I@`m>eK}n=W^wiF%(*^&?A)KNm|h^iR*r;~XlZc+$rZ z$8R@H)!AmC2uMsksVXGAY*7%=EGkgUl5|Gp$`+y zk~mp>!A9JBw;`Lc$>P*OABD(pO?V)aEzb-z99_NS9AkWScgTn+{q+E3OgTP$+VG2# zRh9ReK62hTT1iZZ$Y+laf}MNW-w@E+&X{Qbh8AN{3^J>5p6QAk94^B@-zi3jA~w9> z1e>q1(eh)}1+XkiLZtoo!mAkE6YUX@C9+8P>^B4^ied17doA_b69r!obqRwr=OPml zfs1N31g2t-7LB?;7yanuWqEw>dsv7vU@5(!iDC&LC4k{TG6%iyXTh-oNN>aLLj=J= zE*ur0PESA%2?YoFaI*lT+bp*UQmPpExUz2>Jx5>khH@*N4+IIlB!v+|t^CxLCZaev zv-ymMZ)NjC4s$N$bKzi)4hFv#_LhLH_!hRK^frj1QE4UQn|9NjNl>lCPiK{PR%|#p<evLgwd!6!{i|ZpY_6CFbGgbksx0Xpva&f$WXk5i(1_fRmk^mFK(d}N1oqrxp$Xv z7z&GXeAL5o_~TZWUbrzgOt2(-OHmxV?Sh(|{z*V{z%DzEod}7yKW?*XKy%Qp3(n4` zqz7XoCGwmgfTIF5Z@2ss%;*V0$~{LWFShh(Chf8^UjR}8YL8BGWb(xl zaGRe5{CIT2fs-M;W^5KxZ#!>xV!rC0;0S1xzfaC^L$4p%9{I}XcMrI0^szK944F!8 zD}1Z^xVLi3%4=FeIBmA?g-z&H=yF)^y>VD?kF@Ob6;slb_wBy|o&3DuTOotWWSb^? zN~gxCtK{Blse9k9>U)9HH09yxt&b~p2SHrFtuO7A@0EQ^_{A)w=~cfa_5*#BhArGp zF)I5EH7u$2++{I&;o9L!XTCJm^BK(CTxZ4R>2@T}ce3=(c>#p_x0S#ZS=;gf=1y|) z)nMb$Qj^%;-~LX|D=%b~wZ%y@mLJr1I^#I_b@*bQyS?fPHkPvi*cig-D(jjbRH*Gf z{jDE4CclD)|1 zP<+jAyd%&17oWvX0!%xr>)gMsL`|Y~$RCXrK1gZ7`-xdm%*@Rr+h#W2c*M=&R$8dM zyQ!sWKRY;gu{>2>%&IY7U2IG6wxH~7NLdoUnNfXGZaV*m7bMFwgKJyA+<#+bR-Wg$ zMV~($g?Tvbhmdvt7>nJ$I?j5kdd~ulH;E-%BJ*n8oBb_&#JoI>xFJsc9CT zhUM>FzgUngRk5$VemnT|@rNg@W_5YhX?noyz2z#mnMmC`4c(m0eGMh$oD^p~&E77q zxfILq`p}kj3@-4V{#dFI#;Ku)0!8LU5>cVILccgOR10GRH7m%Uk_jb_k~JTOW834D z!Z{Kt)cE;a;>g5T%P`pz`>sc+bgD~&yBOy`T`@8hJ;OA=JFh;f>l$qjR~?R8QyZ?V z&obW#`Z<)wi$(iWdAQkJg0!bYVP_N{K4W;Get2L;+;>L4Z!KgQ`=tX!4%L$3oH9A1w`2!aUgf^Y(joYK^8YQRoi+h|XekYHT4as?_|P?;n~cf+;a zT~zqTAi+I>asiy4=5;TbXkjYGmF*?og%#M*RkHy3#(K z5ikjqcqDAR9vDd@oEGm-Q*z>{cP>+(ZgzHFed2n{iL%g1_;@?n?%DLO`ugz92F!XT zLMJ=*>6H5V3>jB(C!Ld@)i{M7uXHGLZ-V({4mJL>pzFAD4E>oTwB(JLXY9>y1&$RizC=Osq&)I{XlDeN8a zCI6b{72GuAQ@Rs6V%fHV-KKcCJ=Wo6^1*FegV$kQQtyn4|55`lQJGg5msPl#ML02< z8t{MnhR^J!PAIFk4rx&{DbKrzVpV9vI^3ln-$DL zlg)P&KFj|q^z$yR@Rzl42?^;WN+>Prp2}5h%jHDeAxtz@oYxTkkj#Bn(8VwCxI%?l zQeuEn_`rt*U!0M3GVDbzqqfL;y?Zp3K{x<0z(vgxFY?ep41zi4nPLN|ZA z?m|n7>RGj&Ns8)2w4~PS3xDXl2Ox&g_=N+MBETbnjP^S}`6Cl~6~~;sKpCs#!FnrY z;}NWKtMC`qaiv8oJtt;uC-)&cK6~p}sM;k33z^txf7T^t-1oWik7-`&l*kw30i;FD zZH1Li`cmKYt(5dO@Dl64d#pr=7|2D*ZsoWqbje2Z)K)@eimphKAP!2W%_l3 z`%PCg`Arwgd~of;}So0f&6UWU3?u8c}6y6(f zCjCXp;X*6lf<47UJ4SX$hj6+ygrA&x;r89kwHWFAh1SpOu(uYX-g>zl+`t|YA@1tN z;;c6x*?)){(V!W%c=Y2})ut5=*L8T8T;0k;`~T=YSdoZo zP!5SW=sL>e+#*)$wj8=BEn5AnygD%HmJ8#n#{7GO7yZuNKlxX3Zz5K9oESVXcYcWV zS75(a( zBfYD<^Alpjl8HyGYSW){hzo!D=cU~D^Y0YSEB5+(q@{kF?#$RJu5Bx!BRjP8nCBUn zj7~O6R=-JyV#!9EsqedV)1yec3w_T}E0y!1Ss0IE&(W1@7wj>#0Ni$=>!zZ+rXxQ!83KM(!lSJvw$84YnE)HX0FKhdP}HPZM2+4L{n&Z}s~(W8ZvA z%lrb&<;J~eC)mJO+|`{MG+wIo{E7nK1eEiV_q@wi&W#T^Tyw>H&ke3SQ!(8O5$)0@#WRu<2_e*)UF$?$CPyZs(SOQ=gBWb?Yj5C zMrQcZ+`fkRi`Cx`d9D%$bY00xQ+4sOah(3L)=8TKPo62|C40vR3^(F3H!3%6mL-MU z@l3bH!R}L>>0Mdzp>vpkMcbD%v1Q-aKPG_Pd_e(YO@flIruV0PeA|$)zW+@+=do!` zEyuS0J@>vXz2o_eyYwf5hizP2O}|*)LVJcI?8T~kO6;vP|Ay~%-&qGeqy~Qt{z}=c za6EvWDl&4F>#M9>%1Zm2@suayysaB(k(cCizn0H`cj3s*waL{>?hs9RfEQ6t>M%E- zsyijLaL}b_zg4EMcBU_Drth`NXr7aW*R6gx?+rimS^jAuZbJMKzZIV(b=tvl@vJO0 zEx_c5V9}pWNY4`bgQW*0&s7Gz**|^K*H8G8c*N{JXpCn(%Jf~^%je5sPnN;9Z?GJm z>`Pj!d9&=1K9@#X^TgLY=7_B19Va)s_H_kfW!wc0N4Bt!v*2YNxxOUYdk)+P4xQM9%z^<%oC8+Dont@YnW5UoIs&yf|8u=X#qRcdGOX=~9c2!Y+;WnZTp9^x ze~v!azUZ5N-;s3M5$};LR09}ZM;yvb9YhjmQ_u;WVhVH5KOQ+g*N#qLq2=~5haB}k z&M%A3+I6UjgL2W%6MpLB6CzQ!9D-`31S=x5swQn4_+|NIUDBUg>o*;w9H^kUHCHx1 zjl`5ITU4uc^&|$%Q0gmcZ;`7UEUK^KI8n}GS31*z5tIXVp3ZWWwHI9H*H?I-jmY*o zJ-A$@BRzN3*=J{0zkIoZ=TD|`S^P^=owIJxv9kJCgZ!6V+pX1E#HZdvy0Xb(r2?M! z<7Wo>zd_c)^M`I<6%}Kh$I=dht>uH4F>k$T4H>g&6mRM*A?4mYDw`Z~5Ib(0K6m0t zG*?&o=cf7zHveB2*5o`NA?VQr8T6UY-+oTe{XGIh5A{WPy(q}icCLi{QR!_Qd5`yVXbiV&G} zCHA{d=_k+UZwd2ql4*orDIrWy&^19}dC5{jPI3qrG~NeEbWalTH(ECb2Kpc+YVQTY zi=+?{sPvkkoBX&u*yFZ2ARyHGIA1ZzjFkQj$o)YdBK;`rsthsF7oHbd(T!jl3S6rYeIomL-7w1NpzaguEY_MA`Jg}r zy0j>CfvQqWC}AxZz&Bs>+LxvJUJ?>$jmAI;eRW08L{8Kn9#3G+juR7F5=&tp(vew1 zU_^Kr7<7W;qS%RYjJs(mb>XlBT|%KoT%l&VrKvy0F2SOdnuQv-B)n%H511m~oU|(% zeM*_*!OtYC6c9e2xU(wny+;ySYK<0!j`lfr*G!tqIEPQfr{Cz+(aHXN>)tX||B=SP zNzLQ3HJ_UbSe8_Rvyxm4gCE9!czY*pOvsL2dIf^ZA?J#rw9oz*Cl)Q5&ZEdYj0Uul z2Ks#`MH9`)MsHwg7r{)K8iTByG3$)p5TXrpQyS}x`u46Uro@ctNApsa>^$Ffe~3J` z;gL75mp-pYnb)&;z}e%TGU4X0?Vq+0dgOf+VFOIFCJW6R;~8$JHD9ExnrzLqvN7Jj zq%2_>9%82vv=$+h=sz^}^jT5#295@EQ*sH6L&Rk=`Y{`0nvG2B_#Lm;WilAA7t?4X z)@T&|UiePD`^@9g3-{uFtRB{FGnpHk%Kf;oZgeC;8*@QaU)N%GU#6brFzxXAy|bbU zh70XPVnS26i&p#m&y<9cc`u@A!fn*cT(!>E+9%hnpDYvcr7Yt;|I`;A^;%P=hLjNe zNds*a`uL&Vw?^IMCVhNCTLrVRV?N9Gg=H*RKi^z#{?wIf5q-CVre7=nIS_w0?m+Vr za$YrJiua@4!KR-C*I45Iea`aZoSy2;3)x;EUU$v5-=w z?d=WiJSAhM16h4vYsmcG2~mXD#9n(^?mkY*^Qz1o<-GWpNpp{gx~>qR8zl~HkRGwn zne6CAVF#+V1}Ib7@XU0ZjMGhc74U(rA7G4kZe891 z-Ri3=b2dHF#fSaYpDU z6@PRJZdrKeS#xxiWo?vnN-0AAVpF)NYb6R+IQ-B-Y++x@zTEg88>U>&N^;7vL+3e9 za)u=>8QgW^Jvx7i?UeZHWUE=uDY*({q+9fD-E;H~6ZW^VT@QhOqRK8Oq2y1<(RK*k zd@HZ+VR59?hc@v(Be_FtWH*iN#>*oQU+&ANnlPhlYnb_KrBS$ba!8?|)g}+>+U)r+ax|#sBOH^yHq~t#ONCLvz1 zfMa~8By~QCa-3SNf61s)&Yz#jBt{)7bG&i?{lPc(8QBlkJnlXI=)-l!$m(LZB2;-j z^m^;@X>;*1gIcwnZA)db8I#HHC8}E^u4hjtGUi1bVx9)*eR`Mnqx|kO#X#6TL3@;E zXK$cyif1RuDFk`=X>&R`b2=?^I>;uZ{roIiLI+Jt5z`saUv|7R6eL{TGUP#Erqvim zOYu25tyYx}o*_@0&R-&P$B>0%L`{U6eA-(U_wg5~NGSxhEjN0u5mPE^z0kKO@RZ~z zaUDL|>x$ZW<_@!5gW7yAH0OI02On{Tdg%uT-&J@@95n4-;rAnlF3b{3b7fbU`*HC} zUozZ7I|J?}+wbi@dZRYTzUti1$Ci7KKsI{~DjdF)$L^j#eeq;*x59$3-Gx$vXl;r! z-r+M>QHq}wd#NP*sl1fq>$^|z>efFNjWL;glonFL>{Z-ll_WoaqQjH<8Zj+tbHN|K z?VTls6*Hf+n-`&PkZZq}*pqIDO?HO!&&?<F%^w z-(+i*F5e1W`04zKlP5U@1+`0A5Ai+EmGcq@hw9LmNSAC>_+#-|>X0;bPQ`N#MHeI_ zNYwRJlM)Pl!QS$q)g5?&)@4T;uXE7DORBokkY4LD4thrJgB+=K$%GAd`aVLnxti_` zsGkzD0~#icPDWO17|TL6fe2aDwk} z9X~`SGtu?r9u^Ee$c>zwa81owY>mcqExK5Xy4fhk1Z=lcEY9`8%y&<_%Lu)UG+d$>WdRPVLQ zYi+xY_||A1=*zVZixxXJZR8a%GQpkME0H3qM4zFCo_<+SSKgOMjk&1SoaM8NP6*q7dg)O+2-mOafgc}?@WTwskn|g;* zw-xPWxGX2^ljS5632&3?L?G@vd{nGi6f1m1k%qP-%+yDrEBF;?r5hxX19QG z@PWi(juEBgg}PnZ(nZFEd}1(JRH8`~-J7DT=kh^4+9hEKUQ%*j_+G>#`WIpeP$IYoh)HiurrdoFq=O(#QtOl}WSl z76Vq4KS{IPs4;c)?nqi`@ftDwhUy>X1K#$PedJybGw=0Yj~n`!xALaM zNY0HJz(4uQ*vYabFCr6trC5TY5aW1rRQ}>TllL1bD4Kw6m8*IADsb@d&7Rfk?2D_{ zt@tT>1wHHYYkv;}oVUw;;E?ujw8y}AtV^`u|qBmc23Wbz=|VPFrW*D5|J0Nwq`_${~d_m)l5)DxFDDwc{9< zCzP<2-}+|!ifYkqDhv6xM)O1No44T56EEt?rY}~L=a})zX73zzy(h5rXQW5Wbp5Gc zy&0;UC@(y|y$vt!_OMvK{49ZCf=2S(weZ_)wsb{G9XC|dx_oTE z(;;~;g6B83@m+*prX43)ytyQypf)WOU3}_Db{XW%u{mp+G}jz{n{G!xL0d*ZqHS7| z!nZ=Gb3$OdD_xmHc0HTZ&oU(Y*kI*}IcW_+FYVi*9%N6yNC9)De~{xv;bXcNRAsPW zs&s^T{N7#B89VyUcs7yTE2$e2Wwn>U^7N;ohEdlKI+Cxu;Ux??4;e*!;*0&PZG47i z=I*y~t=~8Byo*wVFnOtUmD1OaNrxdD7hfEuh4ze)G_w22t5QxfPZTh9W_@G9*U#nh z4pctbjlH$=N%xr}gWOKipVb(=8MEu?YA%KX8!hYnEVG0wj@BTymY6hqTxJb}souee zMJEjCM+@TI4Jo?}n=q7JAQ;gpdg8Pm@e#24Zx^cO>a(F|hd(tKeQG%L>7ap++>Bpg z!@E~s-Hq^M9ztJR=UMk>@;-=_ODu8%i0(s)^W4mLlQ?Q5X-4QDTnt%mO3PK--^s*l zyUO~6ZKuSA3-+o%yof5-#Df5pL$LC@v&y&VrRez+S+0jyKD=6&BF#9JPcbm1k)%A+ z4X}}FjAG)lBPy3ND~Dt>TP*LA0B7BI7%X!m8D!*X;mFdB{r-&MXjRK6=ltyC-+J=) za;_Bq6QywH0QX?ARmsPq1GRQJXD&sm(H}Hkzv#+4T$%CdBQn#Tr@m(@wVr6f@W*&) znRqr}l3uh-dtRWrxU5mhQLmft2HY79naR``3>?0$n8lEZJ9;s!J@)x1_q6=j9HLc4 zmFYY=m!PbFUf^rm(fc7!8nli$sWE9CUTV31+B(=g(S>tFHNQXKd;LV5Hun$qAEWZg zE{GAc4^H4zoK>xcrc$jRCdrCyfx^Ml=1B)$hWK&>;({+G4R5`SDZP@JSM!q??j=TE z&iE!JeA$N_-W^1pQ}q1C>IEKhISz$g2Cj(BtV*#lbEs&#%Y zuCwFt#5mP93c@D#w?!yE($z8=(5x0?uHAstdit_EPtTjR1%ius22QbZ|2@4)sLug z1A+*1`Mqy0dtD^Fsj`qsYxGVsv~nltl0Sd9sRSfLQfDm(2Q16FaC%GOjLiwhl6sF7 z*(SX$$bRD(w;A~qMs*cz>G7024r6}&U|)kvs%q!xE+bY_I7|6C_457RXCG>2K1iI~ ziMKZIsO0y4BLEo#&gy6Eb`KkHtEvU-MpkEn;5M7lYE!2L zYQc$NNvdrw;Y_j$7sS{MkwP}~a*B!&q(XuU+-w_rw7N!h&;1b%CWI^O@k_DwtczT z3XfKU$~c{kKRqpq9bMPF?yhJ#`fk|0GdBlYI=oVKmpeVz-*xD*Rew>~YB-Y)bxpV2MCf0F$S61wtC9!?^dRfHj9eI3znkEIu z>>efSr9ExL+JAJ(idkM5U)DJ8b=sv)fGm<3B&+m9Pkf_|TpIOprbK8EH|6f{kvw2M zw>C8SJL1X&JbGd5n8f70$=xSBK7WaFI}(&-Gp0A!NJZ4GtF4AgPj6gzw@o#uGNQz@ zZro>{#8e~}AljCr41PHx+H6yo!y@!+ZwhR<;?Qek8*_Hl_57z_Y)lbMKQFK{*_b0) zb~2$*C?;iJSa*P#CoQp^86+e~EFiIh#0C;ONGOmvK;i^x2S{8Xaf7s3h8H9>NSMaN zcC7489%bJK*XBM02@O6brUiSr!5?Q2&xYVwb{~JDDHR~V#KeA#iAjy=e}DerKUZ5I za_*Ic0PGfkOlViCZW|8<1K|C+)?b_3#4a8Mvl0V#SN0bdHlStCPkAmAT?I1A+C3Iu#G2xo~z zS0do-AeyKm+&*Mt+ctU;iql4p(6*2~JR16MJ%_?TVXY?! zm=uOHM#elvz@s0T!9s&D(C!y>1iTss+AY$FfGxv;@{leBEI!GMgC{@#wH6J(4hIUF zySMmKn+9=hx>f|q^&A))fwM=R=t02GzcNewPvg2GK$-d%2w317v*h1K2u1=H;uQkc zhy-5YeT{&VHi@hKTLc~!TVUpZzefVAD&Hbto}bJzuznOkXL*?6fG8XhSvbWE-;Kg4 zBbxy6ISRBE`H&Zuh{mZPWdV^jfZhckE(F$9rvhJQN8@;q&jG(A8mEc;1&D!Y+(D$w zBVM>R28V|UF*sG^&6aHxAA=(xA9imc3uMiUZMNb!GzTme3#`}x2Xt+fi=9Pt!Ivnw z-7q=<)R6iX)DVl)McxC%SS-#Aneu6i5Q2^4aO%jJ)BzHOr~aX1a6?JO@W zb{eOHOaz2MJdPiZI1S7=zOjuSp9TtA5$Mf4L6|2Vkl1JRU%FZZYG2FOCQ`qQZP><(3fkng^nP{%(mIBiJ*wG)ix4J0?kXaMZF1TX{#2)*f4g6dark6qFv{M%~Fk!IC!`My7y^ChG$ln*uJHOA5GX zrG8t;6d4}9&7Lj5aKh^;pcdoP+bly0P#2oGjm}blx`7ll+(iLSVx|DSsW^S)CqNjd z;tY{zO3`puD$W3@Uyp`+doeipV=B-V{1@S2*)srL`xp720Zt6KyCo?HKikY}ZUC-( zjS+_h(*TO4Z6QI}BMn&b`{g#OP6JkSeL%yW8yEq2V^ebdFOr0<(gBj3+{zPz3(`UF ze)tvCkPae`?RPXBk_jBCp8yhjYwyRv zdAG4U;kQ{hC1l{gXcvS#fGpA9%EQAU5U}C(zsTAh%L%t`vMw5I3kY}s4Zw9c9U$=exI@TY+*p{b09+fJ5Au=1SolUhFzS>X7M{xo4lPy0 z!pi4xwn){zSUBYzC=siKg*~a@_BL`3l&JiR#9?I%9OvIV6Ojt6uh!U-azv`?Z4tZS zek!o=vi^4AT?HVZ<{17(g~!3|C}xwBLHrMA7yP3DR1jmlU1HV?w-sI$kbb6EII<9Q f&;mgG_Qr|8uL^-=q&XH|FT|;_m0DrJjrRWl%5v}> diff --git a/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsBigintSet.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsBigintSet.java new file mode 100644 index 0000000..e8b2db4 --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsBigintSet.java @@ -0,0 +1,130 @@ +package org.mobilitydb.kafka.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 long 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, long arg1, long arg2, boolean arg3, boolean arg4) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bigintset_shift_scale requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bigintset_shift_scale(arg0, arg1, arg2, arg3, arg4); + } + + /** + * MEOS {@code bigintset_start_value} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static long bigintset_start_value(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 Pointer bigintset_value_n(Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bigintset_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bigintset_value_n(arg0, arg1); + } + + /** + * MEOS {@code bigintset_values} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static 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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsBigintSpan.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsBigintSpan.java new file mode 100644 index 0000000..14be5e0 --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsBigintSpan.java @@ -0,0 +1,144 @@ +package org.mobilitydb.kafka.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(long arg0, long arg1, boolean arg2, boolean arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bigintspan_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bigintspan_make(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code bigintspan_bins} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static long bigintspan_width(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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsBigintSpanSet.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsBigintSpanSet.java new file mode 100644 index 0000000..0d43365 --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsBigintSpanSet.java @@ -0,0 +1,116 @@ +package org.mobilitydb.kafka.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, long arg1, long 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 long 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, long arg1, long arg2, boolean arg3, boolean arg4) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bigintspanset_shift_scale requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bigintspanset_shift_scale(arg0, arg1, arg2, arg3, arg4); + } + + /** + * MEOS {@code bigintspanset_upper} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static 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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsCbufferSet.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsCbufferSet.java new file mode 100644 index 0000000..15eb8c9 --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsCbufferSet.java @@ -0,0 +1,116 @@ +package org.mobilitydb.kafka.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 Pointer cbufferset_value_n(Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbufferset_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbufferset_value_n(arg0, arg1); + } + + /** + * MEOS {@code cbufferset_values} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static 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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsDateSet.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsDateSet.java new file mode 100644 index 0000000..0a93f5e --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsDateSet.java @@ -0,0 +1,144 @@ +package org.mobilitydb.kafka.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, boolean arg3, boolean arg4) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "dateset_shift_scale requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.dateset_shift_scale(arg0, arg1, arg2, arg3, arg4); + } + + /** + * MEOS {@code dateset_start_value} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static 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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsDateSpan.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsDateSpan.java new file mode 100644 index 0000000..d9be508 --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsDateSpan.java @@ -0,0 +1,144 @@ +package org.mobilitydb.kafka.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, boolean arg2, boolean arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "datespan_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.datespan_make(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code datespan_to_tstzspan} — tier stateless. + *

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

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static int datespan_upper(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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsDateSpanSet.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsDateSpanSet.java new file mode 100644 index 0000000..0e4e9af --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsDateSpanSet.java @@ -0,0 +1,172 @@ +package org.mobilitydb.kafka.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 Pointer datespanset_date_n(Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "datespanset_date_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.datespanset_date_n(arg0, arg1); + } + + /** + * MEOS {@code datespanset_dates} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static int datespanset_start_date(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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFloatSet.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFloatSet.java new file mode 100644 index 0000000..d59a046 --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFloatSet.java @@ -0,0 +1,200 @@ +package org.mobilitydb.kafka.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, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatset_degrees requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatset_degrees(arg0, arg1); + } + + /** + * MEOS {@code floatset_end_value} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static double floatset_start_value(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 Pointer floatset_value_n(Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatset_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatset_value_n(arg0, arg1); + } + + /** + * MEOS {@code floatset_values} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static 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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFloatSpan.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFloatSpan.java new file mode 100644 index 0000000..719e463 --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFloatSpan.java @@ -0,0 +1,228 @@ +package org.mobilitydb.kafka.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, boolean arg2, boolean arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatspan_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatspan_make(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code floatspan_to_intspan} — tier stateless. + *

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

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static double floatspan_upper(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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFloatSpanSet.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFloatSpanSet.java new file mode 100644 index 0000000..eae183a --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFloatSpanSet.java @@ -0,0 +1,200 @@ +package org.mobilitydb.kafka.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, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatspanset_degrees requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatspanset_degrees(arg0, arg1); + } + + /** + * MEOS {@code floatspanset_floor} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static double floatspanset_upper(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, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "floatspanset_width requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.floatspanset_width(arg0, arg1); + } + + /** + * MEOS {@code floatspanset_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static 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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFreeCatalog.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFreeCatalog.java new file mode 100644 index 0000000..ba4630b --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFreeCatalog.java @@ -0,0 +1,605 @@ +package org.mobilitydb.kafka.meos; + +/* AUTO-GENERATED by codegen_flink_free.py — do not edit by hand. + * Source header: meos_catalog.h + * Methods emitted: 45 (stateless=23 · io-meta=22) + * 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 MeosOpsFreeCatalog { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsFreeCatalog() { /* utility */ } + + /** + * MEOS {@code alphanum_basetype} — tier stateless. + *

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

+ */ + public static boolean geo_basetype(int arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_basetype requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_basetype(arg0); + } + + /** + * MEOS {@code interptype_name} — 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 String interptype_name(int arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "interptype_name requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.interptype_name(arg0); + } + + /** + * MEOS {@code meosoper_name} — 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 String meosoper_name(int arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "meosoper_name requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.meosoper_name(arg0); + } + + /** + * MEOS {@code numset_type} — tier stateless. + *

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

+ */ + public static boolean tempsubtype_from_string(String arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tempsubtype_from_string requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tempsubtype_from_string(arg0, arg1); + } + + /** + * MEOS {@code tempsubtype_name} — 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 String tempsubtype_name(int arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tempsubtype_name requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tempsubtype_name(arg0); + } + + /** + * MEOS {@code tgeodetic_type} — tier stateless. + *

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

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

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

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

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

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

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

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

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

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

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

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

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

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

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

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

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

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

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

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

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

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

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

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

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

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

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

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

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

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

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

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

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

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

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

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

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

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

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

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

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

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

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

+ */ + public static boolean temptype_subtype_all(int arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temptype_subtype_all requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temptype_subtype_all(arg0); + } + +} diff --git a/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFreeCbuffer.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFreeCbuffer.java new file mode 100644 index 0000000..9ba2e74 --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFreeCbuffer.java @@ -0,0 +1,1958 @@ +package org.mobilitydb.kafka.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 java.time.OffsetDateTime; +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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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, OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbuffer_timestamptz_to_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbuffer_timestamptz_to_stbox(arg0, arg1); + } + + /** + * MEOS {@code cbuffer_to_geom} — tier stateless. + *

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

+ *

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

+ */ + public static 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, boolean arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "cbuffer_transform_pipeline requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.cbuffer_transform_pipeline(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code cbuffer_tstzspan_to_stbox} — tier stateless. + *

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

+ *

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

+ */ + public static 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 boolean 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 boolean 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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFreeCore.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFreeCore.java new file mode 100644 index 0000000..ec9cb5b --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFreeCore.java @@ -0,0 +1,9721 @@ +package org.mobilitydb.kafka.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 java.time.LocalDateTime; +import java.time.OffsetDateTime; +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 OffsetDateTime add_timestamptz_interval(OffsetDateTime 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 boolean adjacent_span_bigint(Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "adjacent_span_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.adjacent_span_bigint(arg0, arg1); + } + + /** + * MEOS {@code adjacent_span_date} — tier stateless. + *

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

+ */ + public static boolean adjacent_span_span(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 boolean 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 boolean adjacent_span_timestamptz(Pointer arg0, OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "adjacent_span_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.adjacent_span_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code adjacent_spanset_bigint} — tier stateless. + *

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

+ */ + public static boolean adjacent_spanset_span(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 boolean 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 boolean adjacent_spanset_timestamptz(Pointer arg0, OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "adjacent_spanset_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.adjacent_spanset_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code adjacent_tbox_tbox} — tier stateless. + *

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

+ *

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

+ */ + public static boolean adjacent_tbox_tbox(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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean after_set_timestamptz(Pointer arg0, OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "after_set_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.after_set_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code after_span_date} — tier stateless. + *

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

+ */ + public static boolean after_tbox_tbox(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 boolean 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 boolean after_timestamptz_set(OffsetDateTime 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 boolean after_timestamptz_span(OffsetDateTime 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 boolean after_timestamptz_spanset(OffsetDateTime 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean before_set_timestamptz(Pointer arg0, OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "before_set_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.before_set_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code before_span_date} — tier stateless. + *

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

+ */ + public static boolean before_tbox_tbox(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 boolean 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 boolean before_timestamptz_set(OffsetDateTime 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 boolean before_timestamptz_span(OffsetDateTime 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 boolean before_timestamptz_spanset(OffsetDateTime 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, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bigint_extent_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bigint_extent_transfn(arg0, arg1); + } + + /** + * MEOS {@code bigint_get_bin} — tier stateless. + *

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

+ */ + public static boolean contained_set_set(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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean contained_timestamptz_set(OffsetDateTime 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 boolean contained_timestamptz_span(OffsetDateTime 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 boolean contained_timestamptz_spanset(OffsetDateTime 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 boolean contains_set_bigint(Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_set_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_set_bigint(arg0, arg1); + } + + /** + * MEOS {@code contains_set_date} — tier stateless. + *

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

+ */ + public static boolean contains_set_set(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 boolean 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 boolean contains_set_timestamptz(Pointer arg0, OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_set_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_set_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code contains_span_bigint} — tier stateless. + *

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

+ */ + public static boolean contains_span_span(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 boolean 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 boolean contains_span_timestamptz(Pointer arg0, OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_span_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_span_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code contains_spanset_bigint} — tier stateless. + *

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

+ */ + public static boolean contains_spanset_span(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 boolean 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 boolean contains_spanset_timestamptz(Pointer arg0, OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "contains_spanset_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.contains_spanset_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code contains_tbox_tbox} — tier stateless. + *

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

+ *

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

+ */ + public static boolean contains_tbox_tbox(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 boolean 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 LocalDateTime date_to_timestamp(int arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "date_to_timestamp requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.date_to_timestamp(arg0); + } + + /** + * MEOS {@code date_to_timestamptz} — tier stateless. + *

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

+ *

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

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

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

+ *

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

+ */ + public static 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, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "float_degrees requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.float_degrees(arg0, arg1); + } + + /** + * MEOS {@code float_exp} — tier stateless. + *

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

+ *

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

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

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

+ *

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

+ */ + public static 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, OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "float_timestamptz_to_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.float_timestamptz_to_tbox(arg0, arg1); + } + + /** + * MEOS {@code float_to_set} — tier stateless. + *

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

+ *

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

+ */ + public static 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(long arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "int64_cmp requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.int64_cmp(arg0, arg1); + } + + /** + * MEOS {@code int_extent_transfn} — tier stateless. + *

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

+ *

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

+ */ + public static 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, OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "int_timestamptz_to_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.int_timestamptz_to_tbox(arg0, arg1); + } + + /** + * MEOS {@code int_to_set} — tier stateless. + *

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

+ *

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

+ */ + public static 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(long 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, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intersection_set_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intersection_set_bigint(arg0, arg1); + } + + /** + * MEOS {@code intersection_set_date} — tier stateless. + *

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

+ *

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

+ */ + public static 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, OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intersection_set_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intersection_set_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code intersection_span_bigint} — tier stateless. + *

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

+ *

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

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

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

+ *

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

+ */ + public static 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, OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intersection_span_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intersection_span_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code intersection_spanset_bigint} — tier stateless. + *

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

+ *

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

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

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

+ *

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

+ */ + public static 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, OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intersection_spanset_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intersection_spanset_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code intersection_tbox_tbox} — tier stateless. + *

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

+ *

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

+ */ + public static 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(OffsetDateTime 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 boolean left_bigint_set(long 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 boolean left_bigint_span(long 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 boolean left_bigint_spanset(long 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean left_set_bigint(Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "left_set_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.left_set_bigint(arg0, arg1); + } + + /** + * MEOS {@code left_set_float} — tier stateless. + *

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

+ *

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

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

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

+ *

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

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

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

+ *

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

+ */ + public static boolean left_set_set(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 boolean 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 boolean left_span_bigint(Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "left_span_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.left_span_bigint(arg0, arg1); + } + + /** + * MEOS {@code left_span_float} — tier stateless. + *

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

+ *

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

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

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

+ *

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

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

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

+ *

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

+ */ + public static boolean left_span_span(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 boolean 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 boolean left_spanset_bigint(Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "left_spanset_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.left_spanset_bigint(arg0, arg1); + } + + /** + * MEOS {@code left_spanset_float} — tier stateless. + *

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

+ *

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

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

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

+ *

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

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

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

+ *

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

+ */ + public static boolean left_spanset_span(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 boolean 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 boolean 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 boolean 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 boolean 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, OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "numspan_timestamptz_to_tbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.numspan_timestamptz_to_tbox(arg0, arg1); + } + + /** + * MEOS {@code numspan_tstzspan_to_tbox} — tier stateless. + *

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

+ *

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

+ */ + public static 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean overafter_set_timestamptz(Pointer arg0, OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overafter_set_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overafter_set_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code overafter_span_date} — tier stateless. + *

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

+ */ + public static boolean overafter_tbox_tbox(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 boolean 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 boolean overafter_timestamptz_set(OffsetDateTime 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 boolean overafter_timestamptz_span(OffsetDateTime 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 boolean overafter_timestamptz_spanset(OffsetDateTime 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean overbefore_set_timestamptz(Pointer arg0, OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overbefore_set_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overbefore_set_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code overbefore_span_date} — tier stateless. + *

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

+ */ + public static boolean overbefore_tbox_tbox(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 boolean 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 boolean overbefore_timestamptz_set(OffsetDateTime 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 boolean overbefore_timestamptz_span(OffsetDateTime 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 boolean overbefore_timestamptz_spanset(OffsetDateTime 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean overleft_bigint_set(long 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 boolean overleft_bigint_span(long 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 boolean overleft_bigint_spanset(long 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean overleft_set_bigint(Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overleft_set_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overleft_set_bigint(arg0, arg1); + } + + /** + * MEOS {@code overleft_set_float} — tier stateless. + *

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

+ *

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

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

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

+ *

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

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

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

+ *

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

+ */ + public static boolean overleft_set_set(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 boolean 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 boolean overleft_span_bigint(Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overleft_span_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overleft_span_bigint(arg0, arg1); + } + + /** + * MEOS {@code overleft_span_float} — tier stateless. + *

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

+ *

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

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

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

+ *

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

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

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

+ *

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

+ */ + public static boolean overleft_span_span(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 boolean 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 boolean overleft_spanset_bigint(Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overleft_spanset_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overleft_spanset_bigint(arg0, arg1); + } + + /** + * MEOS {@code overleft_spanset_float} — tier stateless. + *

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

+ *

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

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

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

+ *

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

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

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

+ *

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

+ */ + public static boolean overleft_spanset_span(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 boolean 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 boolean 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 boolean 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 boolean 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 boolean overright_bigint_set(long 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 boolean overright_bigint_span(long 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 boolean overright_bigint_spanset(long 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean overright_set_bigint(Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overright_set_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overright_set_bigint(arg0, arg1); + } + + /** + * MEOS {@code overright_set_float} — tier stateless. + *

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

+ *

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

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

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

+ *

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

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

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

+ *

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

+ */ + public static boolean overright_set_set(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 boolean 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 boolean overright_span_bigint(Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overright_span_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overright_span_bigint(arg0, arg1); + } + + /** + * MEOS {@code overright_span_float} — tier stateless. + *

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

+ *

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

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

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

+ *

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

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

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

+ *

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

+ */ + public static boolean overright_span_span(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 boolean 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 boolean overright_spanset_bigint(Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "overright_spanset_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.overright_spanset_bigint(arg0, arg1); + } + + /** + * MEOS {@code overright_spanset_float} — tier stateless. + *

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

+ *

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

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

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

+ *

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

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

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

+ *

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

+ */ + public static boolean overright_spanset_span(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 boolean 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 boolean 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 boolean 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 boolean 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 boolean right_bigint_set(long 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 boolean right_bigint_span(long 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 boolean right_bigint_spanset(long 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean right_set_bigint(Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "right_set_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.right_set_bigint(arg0, arg1); + } + + /** + * MEOS {@code right_set_float} — tier stateless. + *

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

+ *

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

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

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

+ *

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

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

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

+ *

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

+ */ + public static boolean right_set_set(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 boolean 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 boolean right_span_bigint(Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "right_span_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.right_span_bigint(arg0, arg1); + } + + /** + * MEOS {@code right_span_float} — tier stateless. + *

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

+ *

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

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

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

+ *

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

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

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

+ *

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

+ */ + public static boolean right_span_span(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 boolean 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 boolean right_spanset_bigint(Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "right_spanset_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.right_spanset_bigint(arg0, arg1); + } + + /** + * MEOS {@code right_spanset_float} — tier stateless. + *

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

+ *

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

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

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

+ *

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

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

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

+ *

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

+ */ + public static boolean right_spanset_span(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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 Pointer tboxfloat_xmax(Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tboxfloat_xmax requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tboxfloat_xmax(arg0); + } + + /** + * MEOS {@code tboxfloat_xmin} — tier stateless. + *

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

+ */ + public static 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(boolean 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, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "teq_tbool_bool requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.teq_tbool_bool(arg0, arg1); + } + + /** + * MEOS {@code teq_temporal_temporal} — tier stateless. + *

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

+ *

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

+ */ + public static 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, boolean arg3, boolean arg4) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloatbox_shift_scale requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloatbox_shift_scale(arg0, arg1, arg2, arg3, arg4); + } + + /** + * MEOS {@code tge_float_tfloat} — tier stateless. + *

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

+ *

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

+ */ + public static 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(LocalDateTime arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "timestamp_to_date requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.timestamp_to_date(arg0); + } + + /** + * MEOS {@code timestamptz_extent_transfn} — tier stateless. + *

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

+ *

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

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

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

+ *

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

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

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

+ *

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

+ */ + public static OffsetDateTime timestamptz_shift(OffsetDateTime 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, OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "timestamptz_tcount_transfn requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.timestamptz_tcount_transfn(arg0, arg1); + } + + /** + * MEOS {@code timestamptz_to_date} — tier stateless. + *

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

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

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

+ *

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

+ */ + public static 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, boolean arg3, boolean arg4) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tintbox_shift_scale requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tintbox_shift_scale(arg0, arg1, arg2, arg3, arg4); + } + + /** + * MEOS {@code tle_float_tfloat} — tier stateless. + *

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

+ *

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

+ */ + public static 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(boolean 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, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tne_tbool_bool requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tne_tbool_bool(arg0, arg1); + } + + /** + * MEOS {@code tne_temporal_temporal} — tier stateless. + *

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

+ *

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

+ */ + public static 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(long 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, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_bigint_span requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_bigint_span(arg0, arg1); + } + + /** + * MEOS {@code union_bigint_spanset} — tier stateless. + *

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

+ *

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

+ */ + public static Pointer union_bigint_spanset(long 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, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_set_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_set_bigint(arg0, arg1); + } + + /** + * MEOS {@code union_set_date} — tier stateless. + *

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

+ *

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

+ */ + public static 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, OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_set_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_set_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code union_span_bigint} — tier stateless. + *

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

+ *

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

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

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

+ *

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

+ */ + public static 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, OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_span_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_span_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code union_spanset_bigint} — tier stateless. + *

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

+ *

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

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

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

+ *

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

+ */ + public static 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, OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_spanset_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_spanset_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code union_tbox_tbox} — tier stateless. + *

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

+ *

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

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

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

+ *

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

+ */ + public static 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(OffsetDateTime 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(OffsetDateTime 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(OffsetDateTime 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 long 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 long 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 long 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 long 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 long distance_set_bigint(Pointer arg0, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_set_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_set_bigint(arg0, arg1); + } + + /** + * MEOS {@code distance_set_date} — tier bounded-state. + *

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

+ *

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

+ */ + public static int distance_set_date(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, OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_set_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_set_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code distance_span_bigint} — tier bounded-state. + *

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

+ *

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

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

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

+ *

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

+ */ + public static int distance_span_date(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, OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_span_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_span_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code distance_spanset_bigint} — tier bounded-state. + *

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

+ *

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

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

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

+ *

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

+ */ + public static int distance_spanset_date(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, OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "distance_spanset_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.distance_spanset_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code distance_tstzset_tstzset} — tier bounded-state. + *

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

+ *

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

+ */ + public static double distance_tstzset_tstzset(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 boolean 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 boolean 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 boolean 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(long 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(long 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(long 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, long arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_set_bigint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_set_bigint(arg0, arg1); + } + + /** + * MEOS {@code minus_set_date} — tier bounded-state. + *

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

+ *

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

+ */ + public static 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, OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_set_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_set_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code minus_span_bigint} — tier bounded-state. + *

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

+ *

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

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

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

+ *

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

+ */ + public static 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, OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_span_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_span_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code minus_spanset_bigint} — tier bounded-state. + *

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

+ *

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

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

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

+ *

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

+ */ + public static 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, OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_spanset_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_spanset_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code minus_text_set} — tier bounded-state. + *

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

+ *

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

+ */ + public static 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 OffsetDateTime minus_timestamptz_interval(OffsetDateTime 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(OffsetDateTime 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(OffsetDateTime 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(OffsetDateTime 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(OffsetDateTime arg0, OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "minus_timestamptz_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.minus_timestamptz_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code nad_tboxfloat_tboxfloat} — tier bounded-state. + *

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

+ *

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

+ */ + public static double nad_tboxfloat_tboxfloat(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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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(boolean 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, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_eq_tbool_bool requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_eq_tbool_bool(arg0, arg1); + } + + /** + * MEOS {@code always_eq_text_ttext} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

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

+ */ + public static int always_eq_text_ttext(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(boolean 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, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ne_tbool_bool requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ne_tbool_bool(arg0, arg1); + } + + /** + * MEOS {@code always_ne_text_ttext} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

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

+ */ + public static int always_ne_text_ttext(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(boolean 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, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_eq_tbool_bool requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_eq_tbool_bool(arg0, arg1); + } + + /** + * MEOS {@code ever_eq_text_ttext} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

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

+ */ + public static int ever_eq_text_ttext(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(boolean 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, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ne_tbool_bool requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ne_tbool_bool(arg0, arg1); + } + + /** + * MEOS {@code ever_ne_text_ttext} — tier windowed. + *

Requires window operator — caller wraps in AggregateFunction.

+ *

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

+ */ + public static int ever_ne_text_ttext(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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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(boolean arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bool_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bool_out(arg0); + } + + /** + * MEOS {@code cstring2text} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: string/CString conversion (low-level)

+ */ + public static 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 boolean 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 boolean 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 LocalDateTime 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(LocalDateTime arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pg_timestamp_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pg_timestamp_out(arg0); + } + + /** + * MEOS {@code pg_timestamptz_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

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

+ */ + public static OffsetDateTime 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(OffsetDateTime arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pg_timestamptz_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pg_timestamptz_out(arg0); + } + + /** + * MEOS {@code rtree_create_bigintspan} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Free function (not class-classified). Classification rule: MEOS infra / catalog / utility

+ */ + public static 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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFreeGeo.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFreeGeo.java new file mode 100644 index 0000000..efc065e --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFreeGeo.java @@ -0,0 +1,3427 @@ +package org.mobilitydb.kafka.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 java.time.OffsetDateTime; +import jnr.ffi.Pointer; + +public final class MeosOpsFreeGeo { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsFreeGeo() { /* utility */ } + + /** + * MEOS {@code above_stbox_stbox} — tier stateless. + *

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

+ *

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

+ */ + public static boolean above_stbox_stbox(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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 Pointer bearing_point_point(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "bearing_point_point requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.bearing_point_point(arg0, arg1); + } + + /** + * MEOS {@code before_stbox_stbox} — tier stateless. + *

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

+ *

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

+ */ + public static boolean before_stbox_stbox(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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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(boolean arg0, double arg1, double arg2, double arg3, double arg4, double arg5, double arg6) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "gbox_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.gbox_make(arg0, arg1, arg2, arg3, arg4, arg5, arg6); + } + + /** + * MEOS {@code gbox_to_stbox} — tier stateless. + *

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

+ *

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

+ */ + public static 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 boolean 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 boolean 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 boolean 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, OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_timestamptz_to_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_timestamptz_to_stbox(arg0, arg1); + } + + /** + * MEOS {@code geo_to_set} — tier stateless. + *

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

+ *

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

+ */ + public static 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, boolean arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_transform_pipeline requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_transform_pipeline(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code geo_tstzspan_to_stbox} — tier stateless. + *

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

+ *

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

+ */ + public static 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, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geog_area requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geog_area(arg0, arg1); + } + + /** + * MEOS {@code geog_centroid} — tier stateless. + *

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

+ *

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

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

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

+ *

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

+ */ + public static double geog_distance(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 boolean geog_dwithin(Pointer arg0, Pointer arg1, double arg2, boolean arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geog_dwithin requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geog_dwithin(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code geog_from_binary} — tier stateless. + *

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

+ *

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

+ */ + public static 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 boolean geog_intersects(Pointer arg0, Pointer arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geog_intersects requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geog_intersects(arg0, arg1, arg2); + } + + /** + * MEOS {@code geog_length} — tier stateless. + *

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

+ *

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

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

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

+ *

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

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

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

+ *

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

+ */ + public static 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 Pointer geom_azimuth(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geom_azimuth requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geom_azimuth(arg0, arg1); + } + + /** + * MEOS {@code geom_boundary} — tier stateless. + *

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

+ *

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

+ */ + public static 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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, OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeoinst_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeoinst_make(arg0, arg1); + } + + /** + * MEOS {@code timestamptz_to_stbox} — tier stateless. + *

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

+ *

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

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

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

+ *

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

+ */ + public static 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, OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpointinst_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpointinst_make(arg0, arg1); + } + + /** + * MEOS {@code union_geo_set} — tier stateless. + *

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

+ *

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

+ */ + public static 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, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "union_stbox_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.union_stbox_stbox(arg0, arg1, arg2); + } + + /** + * MEOS {@code above_tspatial_stbox} — tier bounded-state. + *

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

+ *

Free function (not class-classified). Classification rule: topology/position rel on 1 temporal + scalar

+ */ + public static boolean above_tspatial_stbox(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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFreeNpoint.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFreeNpoint.java new file mode 100644 index 0000000..b6547ea --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFreeNpoint.java @@ -0,0 +1,1087 @@ +package org.mobilitydb.kafka.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 java.time.OffsetDateTime; +import jnr.ffi.Pointer; + +public final class MeosOpsFreeNpoint { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsFreeNpoint() { /* utility */ } + + /** + * MEOS {@code contained_npoint_set} — tier stateless. + *

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

+ *

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

+ */ + public static boolean contained_npoint_set(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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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(long arg0, double arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npoint_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npoint_make(arg0, arg1); + } + + /** + * MEOS {@code npoint_ne} — tier stateless. + *

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

+ *

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

+ */ + public static boolean npoint_ne(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 long 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 boolean 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, OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npoint_timestamptz_to_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npoint_timestamptz_to_stbox(arg0, arg1); + } + + /** + * MEOS {@code npoint_to_geompoint} — tier stateless. + *

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

+ *

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

+ */ + public static 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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(long arg0, double arg1, double arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nsegment_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nsegment_make(arg0, arg1, arg2); + } + + /** + * MEOS {@code nsegment_ne} — tier stateless. + *

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

+ *

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

+ */ + public static boolean nsegment_ne(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 long 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 boolean route_exists(long arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "route_exists requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.route_exists(arg0); + } + + /** + * MEOS {@code teq_tnpoint_npoint} — tier stateless. + *

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

+ *

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

+ */ + public static 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(long arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "route_length requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.route_length(arg0); + } + + /** + * MEOS {@code always_eq_tnpoint_tnpoint} — tier cross-stream. + *

Pairwise across streams — caller wraps in a join.

+ *

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

+ */ + public static int always_eq_tnpoint_tnpoint(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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFreePose.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFreePose.java new file mode 100644 index 0000000..7fab1e6 --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFreePose.java @@ -0,0 +1,1009 @@ +package org.mobilitydb.kafka.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 java.time.OffsetDateTime; +import jnr.ffi.Pointer; + +public final class MeosOpsFreePose { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsFreePose() { /* utility */ } + + /** + * MEOS {@code contained_pose_set} — tier stateless. + *

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

+ *

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

+ */ + public static boolean contained_pose_set(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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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, OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pose_timestamptz_to_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pose_timestamptz_to_stbox(arg0, arg1); + } + + /** + * MEOS {@code pose_to_point} — tier stateless. + *

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

+ *

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

+ */ + public static 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, boolean arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "pose_transform_pipeline requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.pose_transform_pipeline(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code pose_tstzspan_to_stbox} — tier stateless. + *

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

+ *

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

+ */ + public static 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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFreeRgeo.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFreeRgeo.java new file mode 100644 index 0000000..de15478 --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFreeRgeo.java @@ -0,0 +1,423 @@ +package org.mobilitydb.kafka.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_trgeometry} — tier 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_trgeometry(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geo_tpose_to_trgeometry requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geo_tpose_to_trgeometry(arg0, arg1); + } + + /** + * MEOS {@code teq_geo_trgeometry} — 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_trgeometry(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "teq_geo_trgeometry requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.teq_geo_trgeometry(arg0, arg1); + } + + /** + * MEOS {@code teq_trgeometry_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_trgeometry_geo(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "teq_trgeometry_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.teq_trgeometry_geo(arg0, arg1); + } + + /** + * MEOS {@code tne_geo_trgeometry} — 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_trgeometry(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tne_geo_trgeometry requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tne_geo_trgeometry(arg0, arg1); + } + + /** + * MEOS {@code tne_trgeometry_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_trgeometry_geo(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tne_trgeometry_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tne_trgeometry_geo(arg0, arg1); + } + + /** + * MEOS {@code nad_stbox_trgeometry} — 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_trgeometry(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nad_stbox_trgeometry requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nad_stbox_trgeometry(arg0, arg1); + } + + /** + * MEOS {@code nad_trgeometry_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_trgeometry_geo(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nad_trgeometry_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nad_trgeometry_geo(arg0, arg1); + } + + /** + * MEOS {@code nad_trgeometry_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_trgeometry_stbox(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nad_trgeometry_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nad_trgeometry_stbox(arg0, arg1); + } + + /** + * MEOS {@code nai_trgeometry_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_trgeometry_geo(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nai_trgeometry_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nai_trgeometry_geo(arg0, arg1); + } + + /** + * MEOS {@code shortestline_trgeometry_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_trgeometry_geo(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "shortestline_trgeometry_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.shortestline_trgeometry_geo(arg0, arg1); + } + + /** + * MEOS {@code tdistance_trgeometry_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_trgeometry_geo(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tdistance_trgeometry_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tdistance_trgeometry_geo(arg0, arg1); + } + + /** + * MEOS {@code always_eq_geo_trgeometry} — 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_trgeometry(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_eq_geo_trgeometry requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_eq_geo_trgeometry(arg0, arg1); + } + + /** + * MEOS {@code always_eq_trgeometry_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_trgeometry_geo(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_eq_trgeometry_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_eq_trgeometry_geo(arg0, arg1); + } + + /** + * MEOS {@code always_ne_geo_trgeometry} — 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_trgeometry(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ne_geo_trgeometry requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ne_geo_trgeometry(arg0, arg1); + } + + /** + * MEOS {@code always_ne_trgeometry_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_trgeometry_geo(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ne_trgeometry_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ne_trgeometry_geo(arg0, arg1); + } + + /** + * MEOS {@code ever_eq_geo_trgeometry} — 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_trgeometry(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_eq_geo_trgeometry requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_eq_geo_trgeometry(arg0, arg1); + } + + /** + * MEOS {@code ever_eq_trgeometry_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_trgeometry_geo(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_eq_trgeometry_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_eq_trgeometry_geo(arg0, arg1); + } + + /** + * MEOS {@code ever_ne_geo_trgeometry} — 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_trgeometry(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ne_geo_trgeometry requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ne_geo_trgeometry(arg0, arg1); + } + + /** + * MEOS {@code ever_ne_trgeometry_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_trgeometry_geo(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ne_trgeometry_geo requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ne_trgeometry_geo(arg0, arg1); + } + + /** + * MEOS {@code always_eq_trgeometry_trgeometry} — 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_trgeometry_trgeometry(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_eq_trgeometry_trgeometry requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_eq_trgeometry_trgeometry(arg0, arg1); + } + + /** + * MEOS {@code always_ne_trgeometry_trgeometry} — 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_trgeometry_trgeometry(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "always_ne_trgeometry_trgeometry requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.always_ne_trgeometry_trgeometry(arg0, arg1); + } + + /** + * MEOS {@code ever_eq_trgeometry_trgeometry} — 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_trgeometry_trgeometry(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_eq_trgeometry_trgeometry requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_eq_trgeometry_trgeometry(arg0, arg1); + } + + /** + * MEOS {@code ever_ne_trgeometry_trgeometry} — 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_trgeometry_trgeometry(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ever_ne_trgeometry_trgeometry requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ever_ne_trgeometry_trgeometry(arg0, arg1); + } + + /** + * MEOS {@code nad_trgeometry_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_trgeometry_tpoint(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nad_trgeometry_tpoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nad_trgeometry_tpoint(arg0, arg1); + } + + /** + * MEOS {@code nad_trgeometry_trgeometry} — 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_trgeometry_trgeometry(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nad_trgeometry_trgeometry requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nad_trgeometry_trgeometry(arg0, arg1); + } + + /** + * MEOS {@code nai_trgeometry_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_trgeometry_tpoint(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nai_trgeometry_tpoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nai_trgeometry_tpoint(arg0, arg1); + } + + /** + * MEOS {@code nai_trgeometry_trgeometry} — 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_trgeometry_trgeometry(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "nai_trgeometry_trgeometry requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.nai_trgeometry_trgeometry(arg0, arg1); + } + + /** + * MEOS {@code shortestline_trgeometry_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_trgeometry_tpoint(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "shortestline_trgeometry_tpoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.shortestline_trgeometry_tpoint(arg0, arg1); + } + + /** + * MEOS {@code shortestline_trgeometry_trgeometry} — 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_trgeometry_trgeometry(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "shortestline_trgeometry_trgeometry requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.shortestline_trgeometry_trgeometry(arg0, arg1); + } + + /** + * MEOS {@code tdistance_trgeometry_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_trgeometry_tpoint(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tdistance_trgeometry_tpoint requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tdistance_trgeometry_tpoint(arg0, arg1); + } + + /** + * MEOS {@code tdistance_trgeometry_trgeometry} — 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_trgeometry_trgeometry(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tdistance_trgeometry_trgeometry requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tdistance_trgeometry_trgeometry(arg0, arg1); + } + +} diff --git a/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFreeTransform.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFreeTransform.java new file mode 100644 index 0000000..9e54190 --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsFreeTransform.java @@ -0,0 +1,72 @@ +package org.mobilitydb.kafka.meos; + +/* AUTO-GENERATED by codegen_flink_free.py — do not edit by hand. + * Source header: meos_transform.h + * Methods emitted: 4 (stateless=4) + * 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 MeosOpsFreeTransform { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsFreeTransform() { /* utility */ } + + /** + * MEOS {@code lwproj_lookup} — 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 lwproj_lookup(int arg0, int arg1, Pointer arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "lwproj_lookup requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.lwproj_lookup(arg0, arg1, arg2); + } + + /** + * MEOS {@code spheroid_init_from_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 spheroid_init_from_srid(int arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "spheroid_init_from_srid requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.spheroid_init_from_srid(arg0, arg1); + } + + /** + * MEOS {@code srid_check_latlong} — 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 void srid_check_latlong(int arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "srid_check_latlong requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + GeneratedFunctions.srid_check_latlong(arg0); + } + + /** + * MEOS {@code srid_is_latlong} — 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 srid_is_latlong(int arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "srid_is_latlong requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.srid_is_latlong(arg0); + } + +} diff --git a/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsGeogSet.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsGeogSet.java new file mode 100644 index 0000000..2f54c28 --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsGeogSet.java @@ -0,0 +1,32 @@ +package org.mobilitydb.kafka.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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsGeomSet.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsGeomSet.java new file mode 100644 index 0000000..22c8da3 --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsGeomSet.java @@ -0,0 +1,116 @@ +package org.mobilitydb.kafka.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: GeomSet + * Methods emitted: 7 (bounded-state=5 · 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_type} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static boolean geoset_type(int arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geoset_type requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geoset_type(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 Pointer geoset_value_n(Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "geoset_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.geoset_value_n(arg0, arg1); + } + + /** + * MEOS {@code geoset_values} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static 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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsIntSet.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsIntSet.java new file mode 100644 index 0000000..c13907c --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsIntSet.java @@ -0,0 +1,144 @@ +package org.mobilitydb.kafka.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, boolean arg3, boolean arg4) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intset_shift_scale requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intset_shift_scale(arg0, arg1, arg2, arg3, arg4); + } + + /** + * MEOS {@code intset_start_value} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static int intset_start_value(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 Pointer intset_value_n(Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intset_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intset_value_n(arg0, arg1); + } + + /** + * MEOS {@code intset_values} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static 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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsIntSpan.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsIntSpan.java new file mode 100644 index 0000000..3536e0b --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsIntSpan.java @@ -0,0 +1,158 @@ +package org.mobilitydb.kafka.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, boolean arg2, boolean arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intspan_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intspan_make(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code intspan_to_floatspan} — tier stateless. + *

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

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static 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, boolean arg3, boolean arg4) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intspan_shift_scale requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intspan_shift_scale(arg0, arg1, arg2, arg3, arg4); + } + + /** + * MEOS {@code intspan_upper} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static int intspan_upper(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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsIntSpanSet.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsIntSpanSet.java new file mode 100644 index 0000000..d0e4559 --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsIntSpanSet.java @@ -0,0 +1,130 @@ +package org.mobilitydb.kafka.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, boolean arg3, boolean arg4) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intspanset_shift_scale requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intspanset_shift_scale(arg0, arg1, arg2, arg3, arg4); + } + + /** + * MEOS {@code intspanset_upper} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static int intspanset_upper(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, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "intspanset_width requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.intspanset_width(arg0, arg1); + } + + /** + * MEOS {@code intspanset_in} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static 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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsNpointSet.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsNpointSet.java new file mode 100644 index 0000000..16fa980 --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsNpointSet.java @@ -0,0 +1,130 @@ +package org.mobilitydb.kafka.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 Pointer npointset_value_n(Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "npointset_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.npointset_value_n(arg0, arg1); + } + + /** + * MEOS {@code npointset_values} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static 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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsPoseSet.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsPoseSet.java new file mode 100644 index 0000000..5ad9f5a --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsPoseSet.java @@ -0,0 +1,116 @@ +package org.mobilitydb.kafka.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 Pointer poseset_value_n(Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "poseset_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.poseset_value_n(arg0, arg1); + } + + /** + * MEOS {@code poseset_values} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static 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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsRuntime.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsRuntime.java new file mode 100644 index 0000000..cbf8209 --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsRuntime.java @@ -0,0 +1,29 @@ +package org.mobilitydb.kafka.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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsSTBox.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsSTBox.java new file mode 100644 index 0000000..0022a05 --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsSTBox.java @@ -0,0 +1,775 @@ +package org.mobilitydb.kafka.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 java.time.OffsetDateTime; +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(boolean arg0, boolean arg1, boolean 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, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_area requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_area(arg0, arg1); + } + + /** + * MEOS {@code stbox_cmp} — tier bounded-state. + *

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

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 1 temporal

+ */ + public static int stbox_cmp(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 boolean 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 boolean 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, OffsetDateTime arg1, double arg2, double arg3, double arg4, Pointer arg5, Pointer arg6, OffsetDateTime arg7) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_get_space_time_tile requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_get_space_time_tile(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); + } + + /** + * MEOS {@code stbox_get_time_tile} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code predicate}.

+ *

Classification: predicate on 1 temporal

+ */ + public static boolean stbox_gt(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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_perimeter requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_perimeter(arg0, arg1); + } + + /** + * MEOS {@code stbox_quad_split} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static 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, boolean 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, OffsetDateTime arg6, boolean 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, OffsetDateTime arg2, boolean 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 Pointer stbox_tmax(Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_tmax requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_tmax(arg0); + } + + /** + * MEOS {@code stbox_tmax_inc} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static 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, boolean arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_transform_pipeline requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_transform_pipeline(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code stbox_volume} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static double stbox_volume(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 Pointer stbox_xmax(Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "stbox_xmax requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.stbox_xmax(arg0); + } + + /** + * MEOS {@code stbox_xmin} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static 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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsSet.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsSet.java new file mode 100644 index 0000000..6b9d971 --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsSet.java @@ -0,0 +1,410 @@ +package org.mobilitydb.kafka.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: Set + * Methods emitted: 28 (bounded-state=17 · 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_basetype} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static boolean set_basetype(int arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "set_basetype requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.set_basetype(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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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_spantype} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static boolean set_spantype(int arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "set_spantype requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.set_spantype(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_type} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static boolean set_type(int arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "set_type requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.set_type(arg0); + } + + /** + * 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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsSpan.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsSpan.java new file mode 100644 index 0000000..8e050d0 --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsSpan.java @@ -0,0 +1,354 @@ +package org.mobilitydb.kafka.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: Span + * Methods emitted: 24 (bounded-state=15 · 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_basetype} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static boolean span_canon_basetype(int arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "span_canon_basetype requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.span_canon_basetype(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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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_tbox_type} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static boolean span_upper_inc(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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsSpanSet.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsSpanSet.java new file mode 100644 index 0000000..690c4b7 --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsSpanSet.java @@ -0,0 +1,452 @@ +package org.mobilitydb.kafka.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: SpanSet + * Methods emitted: 31 (bounded-state=21 · 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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_type} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static boolean spanset_upper_inc(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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTAlpha.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTAlpha.java new file mode 100644 index 0000000..e4f432c --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTAlpha.java @@ -0,0 +1,31 @@ +package org.mobilitydb.kafka.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: TAlpha + * Methods emitted: 1 (bounded-state=1) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; + +public final class MeosOpsTAlpha { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsTAlpha() { /* utility */ } + + /** + * MEOS {@code talpha_type} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static boolean talpha_type(int arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "talpha_type requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.talpha_type(arg0); + } + +} diff --git a/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTBool.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTBool.java new file mode 100644 index 0000000..7851cad --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTBool.java @@ -0,0 +1,229 @@ +package org.mobilitydb.kafka.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 java.time.OffsetDateTime; +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(boolean 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, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbool_at_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbool_at_value(arg0, arg1); + } + + /** + * MEOS {@code tbool_end_value} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static boolean tbool_end_value(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, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbool_minus_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbool_minus_value(arg0, arg1); + } + + /** + * MEOS {@code tbool_start_value} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static boolean tbool_value_at_timestamptz(Pointer arg0, OffsetDateTime arg1, boolean 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 Pointer tbool_value_n(Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbool_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbool_value_n(arg0, arg1); + } + + /** + * MEOS {@code tbool_values} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static 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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTBoolInst.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTBoolInst.java new file mode 100644 index 0000000..4eb7911 --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTBoolInst.java @@ -0,0 +1,33 @@ +package org.mobilitydb.kafka.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 java.time.OffsetDateTime; +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(boolean arg0, OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tboolinst_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tboolinst_make(arg0, arg1); + } + +} diff --git a/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTBox.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTBox.java new file mode 100644 index 0000000..d87d229 --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTBox.java @@ -0,0 +1,480 @@ +package org.mobilitydb.kafka.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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 Pointer tbox_tmax(Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tbox_tmax requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tbox_tmax(arg0); + } + + /** + * MEOS {@code tbox_tmax_inc} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static 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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTCbuffer.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTCbuffer.java new file mode 100644 index 0000000..21ecd87 --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTCbuffer.java @@ -0,0 +1,228 @@ +package org.mobilitydb.kafka.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, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tcbuffer_at_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tcbuffer_at_stbox(arg0, arg1, arg2); + } + + /** + * MEOS {@code tcbuffer_expand} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static 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, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tcbuffer_minus_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tcbuffer_minus_stbox(arg0, arg1, arg2); + } + + /** + * MEOS {@code tcbuffer_points} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static 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, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tcbuffer_trav_area requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tcbuffer_trav_area(arg0, arg1); + } + + /** + * MEOS {@code tcbuffer_from_mfjson} — tier io-meta. + *

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code constructor}.

+ *

Classification: IO/serialization

+ */ + public static 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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTFloat.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTFloat.java new file mode 100644 index 0000000..594e253 --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTFloat.java @@ -0,0 +1,537 @@ +package org.mobilitydb.kafka.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 java.time.OffsetDateTime; +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, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_degrees requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_degrees(arg0, arg1); + } + + /** + * MEOS {@code tfloat_end_value} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static double tfloat_end_value(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, OffsetDateTime 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 boolean tfloat_value_at_timestamptz(Pointer arg0, OffsetDateTime arg1, boolean 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 Pointer tfloat_value_n(Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloat_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloat_value_n(arg0, arg1); + } + + /** + * MEOS {@code tfloat_value_split} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static 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, OffsetDateTime 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, OffsetDateTime 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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTFloatInst.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTFloatInst.java new file mode 100644 index 0000000..eb08990 --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTFloatInst.java @@ -0,0 +1,33 @@ +package org.mobilitydb.kafka.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 java.time.OffsetDateTime; +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, OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tfloatinst_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tfloatinst_make(arg0, arg1); + } + +} diff --git a/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTGeo.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTGeo.java new file mode 100644 index 0000000..4712205 --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTGeo.java @@ -0,0 +1,383 @@ +package org.mobilitydb.kafka.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: TGeo + * Methods emitted: 26 (bounded-state=25 · stateless=1) + * Source: JMEOS jar (PR #15 / regen-against-meos-1.4) ∩ streaming-relevance baseline v4. + */ + +import functions.GeneratedFunctions; +import java.time.OffsetDateTime; +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, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeo_at_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeo_at_stbox(arg0, arg1, arg2); + } + + /** + * MEOS {@code tgeo_at_value} — tier bounded-state. + *

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

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static 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, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeo_minus_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeo_minus_stbox(arg0, arg1, arg2); + } + + /** + * MEOS {@code tgeo_minus_value} — tier bounded-state. + *

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

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static 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, boolean arg5, boolean 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, boolean arg5, boolean 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, OffsetDateTime arg6, boolean arg7, boolean 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, OffsetDateTime arg6, boolean arg7, boolean 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, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeo_traversed_area requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeo_traversed_area(arg0, arg1); + } + + /** + * MEOS {@code tgeo_type} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static boolean tgeo_value_at_timestamptz(Pointer arg0, OffsetDateTime arg1, boolean 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 Pointer tgeo_value_n(Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeo_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeo_value_n(arg0, arg1); + } + + /** + * MEOS {@code tgeo_values} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static 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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTGeogPoint.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTGeogPoint.java new file mode 100644 index 0000000..f032148 --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTGeogPoint.java @@ -0,0 +1,60 @@ +package org.mobilitydb.kafka.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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTGeography.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTGeography.java new file mode 100644 index 0000000..6b08cdf --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTGeography.java @@ -0,0 +1,74 @@ +package org.mobilitydb.kafka.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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTGeomPoint.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTGeomPoint.java new file mode 100644 index 0000000..2b0bb5f --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTGeomPoint.java @@ -0,0 +1,74 @@ +package org.mobilitydb.kafka.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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTGeometry.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTGeometry.java new file mode 100644 index 0000000..973d278 --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTGeometry.java @@ -0,0 +1,102 @@ +package org.mobilitydb.kafka.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: TGeometry + * Methods emitted: 6 (stateless=3 · io-meta=2 · 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 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_type} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static boolean tgeometry_type(int arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tgeometry_type requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tgeometry_type(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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTInt.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTInt.java new file mode 100644 index 0000000..cdb146b --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTInt.java @@ -0,0 +1,425 @@ +package org.mobilitydb.kafka.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 java.time.OffsetDateTime; +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, OffsetDateTime 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 boolean tint_value_at_timestamptz(Pointer arg0, OffsetDateTime arg1, boolean 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 Pointer tint_value_n(Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tint_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tint_value_n(arg0, arg1); + } + + /** + * MEOS {@code tint_value_split} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static 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, OffsetDateTime 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, OffsetDateTime 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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTIntInst.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTIntInst.java new file mode 100644 index 0000000..1d67190 --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTIntInst.java @@ -0,0 +1,33 @@ +package org.mobilitydb.kafka.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 java.time.OffsetDateTime; +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, OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tintinst_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tintinst_make(arg0, arg1); + } + +} diff --git a/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTNpoint.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTNpoint.java new file mode 100644 index 0000000..4304e90 --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTNpoint.java @@ -0,0 +1,312 @@ +package org.mobilitydb.kafka.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, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnpoint_at_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnpoint_at_stbox(arg0, arg1, arg2); + } + + /** + * MEOS {@code tnpoint_cumulative_length} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static 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, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnpoint_minus_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnpoint_minus_stbox(arg0, arg1, arg2); + } + + /** + * MEOS {@code tnpoint_positions} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static 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 long 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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTNpointInst.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTNpointInst.java new file mode 100644 index 0000000..a35697e --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTNpointInst.java @@ -0,0 +1,33 @@ +package org.mobilitydb.kafka.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 java.time.OffsetDateTime; +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, OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnpointinst_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnpointinst_make(arg0, arg1); + } + +} diff --git a/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTNumber.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTNumber.java new file mode 100644 index 0000000..62199ed --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTNumber.java @@ -0,0 +1,382 @@ +package org.mobilitydb.kafka.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: TNumber + * Methods emitted: 26 (bounded-state=20 · 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_basetype} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static boolean tnumber_basetype(int arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnumber_basetype requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnumber_basetype(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_spantype} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static boolean tnumber_spantype(int arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnumber_spantype requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnumber_spantype(arg0); + } + + /** + * 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_type} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static boolean tnumber_type(int arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tnumber_type requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tnumber_type(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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTPoint.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTPoint.java new file mode 100644 index 0000000..ae5d106 --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTPoint.java @@ -0,0 +1,368 @@ +package org.mobilitydb.kafka.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: TPoint + * Methods emitted: 25 (bounded-state=21 · 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 Pointer tpoint_tfloat_to_geomeas(Pointer arg0, Pointer arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpoint_tfloat_to_geomeas requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpoint_tfloat_to_geomeas(arg0, arg1, arg2); + } + + /** + * MEOS {@code tpoint_angular_difference} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static 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 boolean tpoint_as_mvtgeom(Pointer arg0, Pointer arg1, int arg2, int arg3, boolean 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 Pointer tpoint_direction(Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpoint_direction requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpoint_direction(arg0); + } + + /** + * MEOS {@code tpoint_get_x} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static 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 boolean 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, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpoint_trajectory requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpoint_trajectory(arg0, arg1); + } + + /** + * MEOS {@code tpoint_twcentroid} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static 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_type} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static boolean tpoint_type(int arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpoint_type requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpoint_type(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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTPose.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTPose.java new file mode 100644 index 0000000..0c2ee0b --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTPose.java @@ -0,0 +1,257 @@ +package org.mobilitydb.kafka.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 java.time.OffsetDateTime; +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, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpose_at_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpose_at_stbox(arg0, arg1, arg2); + } + + /** + * MEOS {@code tpose_end_value} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static 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, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpose_minus_stbox requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpose_minus_stbox(arg0, arg1, arg2); + } + + /** + * MEOS {@code tpose_points} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static 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 boolean tpose_value_at_timestamptz(Pointer arg0, OffsetDateTime arg1, boolean 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 Pointer tpose_value_n(Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tpose_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tpose_value_n(arg0, arg1); + } + + /** + * MEOS {@code tpose_values} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static 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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTRGeometry.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTRGeometry.java new file mode 100644 index 0000000..32261f5 --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTRGeometry.java @@ -0,0 +1,523 @@ +package org.mobilitydb.kafka.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 java.time.OffsetDateTime; +import jnr.ffi.Pointer; + +public final class MeosOpsTRGeometry { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsTRGeometry() { /* utility */ } + + /** + * MEOS {@code trgeometry_to_tinstant} — tier stateless. + *

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

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

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

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

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

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

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

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static Pointer trgeometry_to_tpose(Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeometry_to_tpose requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeometry_to_tpose(arg0); + } + + /** + * MEOS {@code trgeometry_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 trgeometry_after_timestamptz(Pointer arg0, OffsetDateTime arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeometry_after_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeometry_after_timestamptz(arg0, arg1, arg2); + } + + /** + * MEOS {@code trgeometry_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 trgeometry_append_tinstant(Pointer arg0, Pointer arg1, int arg2, double arg3, Pointer arg4, boolean arg5) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeometry_append_tinstant requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeometry_append_tinstant(arg0, arg1, arg2, arg3, arg4, arg5); + } + + /** + * MEOS {@code trgeometry_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 trgeometry_append_tsequence(Pointer arg0, Pointer arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeometry_append_tsequence requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeometry_append_tsequence(arg0, arg1, arg2); + } + + /** + * MEOS {@code trgeometry_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 trgeometry_before_timestamptz(Pointer arg0, OffsetDateTime arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeometry_before_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeometry_before_timestamptz(arg0, arg1, arg2); + } + + /** + * MEOS {@code trgeometry_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 trgeometry_delete_timestamptz(Pointer arg0, OffsetDateTime arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeometry_delete_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeometry_delete_timestamptz(arg0, arg1, arg2); + } + + /** + * MEOS {@code trgeometry_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 trgeometry_delete_tstzset(Pointer arg0, Pointer arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeometry_delete_tstzset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeometry_delete_tstzset(arg0, arg1, arg2); + } + + /** + * MEOS {@code trgeometry_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 trgeometry_delete_tstzspan(Pointer arg0, Pointer arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeometry_delete_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeometry_delete_tstzspan(arg0, arg1, arg2); + } + + /** + * MEOS {@code trgeometry_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 trgeometry_delete_tstzspanset(Pointer arg0, Pointer arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeometry_delete_tstzspanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeometry_delete_tstzspanset(arg0, arg1, arg2); + } + + /** + * MEOS {@code trgeometry_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 trgeometry_end_instant(Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeometry_end_instant requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeometry_end_instant(arg0); + } + + /** + * MEOS {@code trgeometry_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 trgeometry_end_sequence(Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeometry_end_sequence requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeometry_end_sequence(arg0); + } + + /** + * MEOS {@code trgeometry_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 trgeometry_end_value(Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeometry_end_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeometry_end_value(arg0); + } + + /** + * MEOS {@code trgeometry_geom} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static Pointer trgeometry_geom(Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeometry_geom requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeometry_geom(arg0); + } + + /** + * MEOS {@code trgeometry_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 trgeometry_instant_n(Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeometry_instant_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeometry_instant_n(arg0, arg1); + } + + /** + * MEOS {@code trgeometry_instants} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static Pointer trgeometry_points(Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeometry_points requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeometry_points(arg0); + } + + /** + * MEOS {@code trgeometry_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 trgeometry_restrict_timestamptz(Pointer arg0, OffsetDateTime arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeometry_restrict_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeometry_restrict_timestamptz(arg0, arg1, arg2); + } + + /** + * MEOS {@code trgeometry_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 trgeometry_restrict_tstzset(Pointer arg0, Pointer arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeometry_restrict_tstzset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeometry_restrict_tstzset(arg0, arg1, arg2); + } + + /** + * MEOS {@code trgeometry_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 trgeometry_restrict_tstzspan(Pointer arg0, Pointer arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeometry_restrict_tstzspan requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeometry_restrict_tstzspan(arg0, arg1, arg2); + } + + /** + * MEOS {@code trgeometry_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 trgeometry_restrict_tstzspanset(Pointer arg0, Pointer arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeometry_restrict_tstzspanset requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeometry_restrict_tstzspanset(arg0, arg1, arg2); + } + + /** + * MEOS {@code trgeometry_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 trgeometry_restrict_value(Pointer arg0, Pointer arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeometry_restrict_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeometry_restrict_value(arg0, arg1, arg2); + } + + /** + * MEOS {@code trgeometry_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 trgeometry_restrict_values(Pointer arg0, Pointer arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeometry_restrict_values requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeometry_restrict_values(arg0, arg1, arg2); + } + + /** + * MEOS {@code trgeometry_rotation} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static Pointer trgeometry_segments(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeometry_segments requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeometry_segments(arg0, arg1); + } + + /** + * MEOS {@code trgeometry_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 trgeometry_sequence_n(Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeometry_sequence_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeometry_sequence_n(arg0, arg1); + } + + /** + * MEOS {@code trgeometry_sequences} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static Pointer trgeometry_sequences(Pointer arg0, Pointer arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeometry_sequences requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeometry_sequences(arg0, arg1); + } + + /** + * MEOS {@code trgeometry_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 trgeometry_set_interp(Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeometry_set_interp requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeometry_set_interp(arg0, arg1); + } + + /** + * MEOS {@code trgeometry_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 trgeometry_start_instant(Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeometry_start_instant requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeometry_start_instant(arg0); + } + + /** + * MEOS {@code trgeometry_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 trgeometry_start_sequence(Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeometry_start_sequence requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeometry_start_sequence(arg0); + } + + /** + * MEOS {@code trgeometry_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 trgeometry_start_value(Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeometry_start_value requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeometry_start_value(arg0); + } + + /** + * MEOS {@code trgeometry_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 trgeometry_traversed_area(Pointer arg0, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeometry_traversed_area requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeometry_traversed_area(arg0, arg1); + } + + /** + * MEOS {@code trgeometry_value_n} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

I/O / catalog / lifecycle helper.

+ *

Object-model role: {@code output}.

+ *

Classification: IO/serialization

+ */ + public static String trgeometry_out(Pointer arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeometry_out requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeometry_out(arg0); + } + +} diff --git a/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTRGeometryInst.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTRGeometryInst.java new file mode 100644 index 0000000..835148b --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTRGeometryInst.java @@ -0,0 +1,33 @@ +package org.mobilitydb.kafka.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 java.time.OffsetDateTime; +import jnr.ffi.Pointer; + +public final class MeosOpsTRGeometryInst { + + public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE; + + private MeosOpsTRGeometryInst() { /* utility */ } + + /** + * MEOS {@code trgeometryinst_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 trgeometryinst_make(Pointer arg0, Pointer arg1, OffsetDateTime arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "trgeometryinst_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.trgeometryinst_make(arg0, arg1, arg2); + } + +} diff --git a/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTSequenceSet.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTSequenceSet.java new file mode 100644 index 0000000..6686a13 --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTSequenceSet.java @@ -0,0 +1,32 @@ +package org.mobilitydb.kafka.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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTSpatial.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTSpatial.java new file mode 100644 index 0000000..0335f8d --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTSpatial.java @@ -0,0 +1,158 @@ +package org.mobilitydb.kafka.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: TSpatial + * Methods emitted: 10 (bounded-state=5 · 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, boolean arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tspatial_transform_pipeline requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tspatial_transform_pipeline(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code tspatial_type} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static boolean tspatial_type(int arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tspatial_type requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tspatial_type(arg0); + } + + /** + * 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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTText.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTText.java new file mode 100644 index 0000000..09405f5 --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTText.java @@ -0,0 +1,271 @@ +package org.mobilitydb.kafka.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 java.time.OffsetDateTime; +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 boolean ttext_value_at_timestamptz(Pointer arg0, OffsetDateTime arg1, boolean 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 Pointer ttext_value_n(Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ttext_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ttext_value_n(arg0, arg1); + } + + /** + * MEOS {@code ttext_values} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static 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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTTextInst.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTTextInst.java new file mode 100644 index 0000000..b141995 --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTTextInst.java @@ -0,0 +1,33 @@ +package org.mobilitydb.kafka.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 java.time.OffsetDateTime; +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, OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "ttextinst_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.ttextinst_make(arg0, arg1); + } + +} diff --git a/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTemporal.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTemporal.java new file mode 100644 index 0000000..26b7b12 --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTemporal.java @@ -0,0 +1,1405 @@ +package org.mobilitydb.kafka.meos; + +/* AUTO-GENERATED by codegen_flink_v3.py — do not edit by hand. + * MEOS object-model class: Temporal + * Methods emitted: 99 (bounded-state=77 · 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 java.time.OffsetDateTime; +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, OffsetDateTime arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_after_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_after_timestamptz(arg0, arg1, arg2); + } + + /** + * MEOS {@code temporal_append_tinstant} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static 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, OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_at_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_at_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code temporal_at_tstzset} — tier bounded-state. + *

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

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static 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_basetype} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static boolean temporal_basetype(int arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_basetype requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_basetype(arg0); + } + + /** + * 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, OffsetDateTime arg1, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_before_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_before_timestamptz(arg0, arg1, arg2); + } + + /** + * MEOS {@code temporal_delete_timestamptz} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static 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, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_duration requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_duration(arg0, arg1); + } + + /** + * MEOS {@code temporal_dyntimewarp_distance} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static double temporal_dyntimewarp_distance(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 OffsetDateTime 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, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_insert requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_insert(arg0, arg1, arg2); + } + + /** + * MEOS {@code temporal_instant_n} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static 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 boolean 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, OffsetDateTime arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_minus_timestamptz requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_minus_timestamptz(arg0, arg1); + } + + /** + * MEOS {@code temporal_minus_tstzset} — tier bounded-state. + *

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

+ *

Object-model role: {@code restriction}.

+ *

Classification: role=restriction

+ */ + public static 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, boolean arg2, boolean arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_segm_duration requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_segm_duration(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code temporal_segments} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static 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, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_simplify_dp requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_simplify_dp(arg0, arg1, arg2); + } + + /** + * MEOS {@code temporal_simplify_max_dist} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static 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 OffsetDateTime 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, OffsetDateTime 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, OffsetDateTime 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 Pointer temporal_timestamptz_n(Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_timestamptz_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_timestamptz_n(arg0, arg1); + } + + /** + * MEOS {@code temporal_tprecision} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static boolean temporal_type(int arg0) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_type requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_type(arg0); + } + + /** + * 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, boolean arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "temporal_update requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.temporal_update(arg0, arg1, arg2); + } + + /** + * MEOS {@code temporal_upper_inc} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static boolean temporal_upper_inc(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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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 boolean 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, boolean 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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTextSet.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTextSet.java new file mode 100644 index 0000000..f9ad5c1 --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTextSet.java @@ -0,0 +1,158 @@ +package org.mobilitydb.kafka.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 Pointer textset_value_n(Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "textset_value_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.textset_value_n(arg0, arg1); + } + + /** + * MEOS {@code textset_values} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static 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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTstzSet.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTstzSet.java new file mode 100644 index 0000000..967cfcc --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTstzSet.java @@ -0,0 +1,187 @@ +package org.mobilitydb.kafka.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 java.time.OffsetDateTime; +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 OffsetDateTime 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 OffsetDateTime 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, OffsetDateTime arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzset_tprecision requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzset_tprecision(arg0, arg1, arg2); + } + + /** + * MEOS {@code tstzset_value_n} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static 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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTstzSpan.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTstzSpan.java new file mode 100644 index 0000000..01b253a --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTstzSpan.java @@ -0,0 +1,201 @@ +package org.mobilitydb.kafka.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 java.time.OffsetDateTime; +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(OffsetDateTime arg0, OffsetDateTime arg1, boolean arg2, boolean arg3) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzspan_make requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzspan_make(arg0, arg1, arg2, arg3); + } + + /** + * MEOS {@code tstzspan_to_datespan} — tier stateless. + *

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

+ *

Object-model role: {@code conversion}.

+ *

Classification: role=conversion

+ */ + public static 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, OffsetDateTime 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 OffsetDateTime 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, OffsetDateTime arg2) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzspan_tprecision requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzspan_tprecision(arg0, arg1, arg2); + } + + /** + * MEOS {@code tstzspan_upper} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static OffsetDateTime 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/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTstzSpanSet.java b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTstzSpanSet.java new file mode 100644 index 0000000..34386bd --- /dev/null +++ b/kafka-streams-app/src/main/java/org/mobilitydb/kafka/meos/MeosOpsTstzSpanSet.java @@ -0,0 +1,243 @@ +package org.mobilitydb.kafka.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 java.time.OffsetDateTime; +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, OffsetDateTime 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, boolean arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzspanset_duration requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzspanset_duration(arg0, arg1); + } + + /** + * MEOS {@code tstzspanset_end_timestamptz} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static OffsetDateTime 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 OffsetDateTime 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 OffsetDateTime 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 Pointer tstzspanset_timestamptz_n(Pointer arg0, int arg1) { + if (!MEOS_AVAILABLE) { + throw new UnsupportedOperationException( + "tstzspanset_timestamptz_n requires libmeos — set -Dmobilityflink.meos.enabled=true"); + } + return GeneratedFunctions.tstzspanset_timestamptz_n(arg0, arg1); + } + + /** + * MEOS {@code tstzspanset_tprecision} — tier bounded-state. + *

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

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

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

+ *

Object-model role: {@code accessor}.

+ *

Classification: role=accessor

+ */ + public static OffsetDateTime 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/kafka-streams-app/tools/codegen/README.md b/kafka-streams-app/tools/codegen/README.md new file mode 100644 index 0000000..bfd3823 --- /dev/null +++ b/kafka-streams-app/tools/codegen/README.md @@ -0,0 +1,21 @@ +# MEOS-API → MobilityKafka codegen + +`org.mobilitydb.kafka.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) +- `MeosOpsFree
` — one per public MEOS header for free fns (6 headers, 1,346 methods) + +Mirrors the same generator pair used on MobilityFlink (`codegen/flink-meos-ops`); +differs only in package path (`org.mobilitydb.kafka.meos`) and module +layout (`kafka-streams-app/` vs `flink-processor/`). + +Each emitted method forwards to `functions.GeneratedFunctions.(...)` +after probing the shared `MeosOpsRuntime.MEOS_AVAILABLE` flag. Method +Javadocs carry a tier marker — see the MobilityFlink companion for +the full tier vocabulary and Kafka Streams wiring shape per tier. + +## Regeneration + +Same recipe as MobilityFlink's `tools/codegen/README.md`; only the +output directory differs. diff --git a/kafka-streams-app/tools/codegen/codegen-free.py b/kafka-streams-app/tools/codegen/codegen-free.py new file mode 100644 index 0000000..d40a61d --- /dev/null +++ b/kafka-streams-app/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/kafka-streams-app/tools/codegen/codegen-oo.py b/kafka-streams-app/tools/codegen/codegen-oo.py new file mode 100644 index 0000000..6cea150 --- /dev/null +++ b/kafka-streams-app/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/kafka-streams-app/tools/codegen/meos-ops-free-manifest.json b/kafka-streams-app/tools/codegen/meos-ops-free-manifest.json new file mode 100644 index 0000000..0780313 --- /dev/null +++ b/kafka-streams-app/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/kafka-streams-app/tools/codegen/meos-ops-manifest.json b/kafka-streams-app/tools/codegen/meos-ops-manifest.json new file mode 100644 index 0000000..e1a306b --- /dev/null +++ b/kafka-streams-app/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