cel_cxx_ffi/
extensions.rs

1use crate::absl::Status;
2use crate::compiler::CompilerLibrary;
3use crate::runtime::{FunctionRegistry, RuntimeBuilder, RuntimeOptions};
4
5#[cxx::bridge]
6mod ffi {
7    #[namespace = "absl"]
8    unsafe extern "C++" {
9        type Status = super::Status;
10    }
11
12    #[namespace = "cel"]
13    unsafe extern "C++" {
14        type FunctionRegistry<'f> = super::FunctionRegistry<'f>;
15        type RuntimeBuilder<'a, 'f> = super::RuntimeBuilder<'a, 'f>;
16        type RuntimeOptions = super::RuntimeOptions;
17        type CompilerLibrary = super::CompilerLibrary;
18    }
19
20    #[namespace = "cel::extensions"]
21    unsafe extern "C++" {
22        include!(<extensions/comprehensions_v2.h>);
23        #[rust_name = "register_comprehensions_v2_functions"]
24        fn RegisterComprehensionsV2Functions<'f>(
25            function_registry: Pin<&mut FunctionRegistry<'f>>,
26            runtime_options: &RuntimeOptions,
27        ) -> Status;
28
29        include!(<extensions/encoders.h>);
30        #[rust_name = "register_encoders_functions"]
31        fn RegisterEncodersFunctions<'f>(
32            function_registry: Pin<&mut FunctionRegistry<'f>>,
33            runtime_options: &RuntimeOptions,
34        ) -> Status;
35
36        include!(<extensions/lists_functions.h>);
37        #[rust_name = "register_lists_functions"]
38        fn RegisterListsFunctions<'f>(
39            function_registry: Pin<&mut FunctionRegistry<'f>>,
40            runtime_options: &RuntimeOptions,
41        ) -> Status;
42
43        include!(<extensions/math_ext.h>);
44        #[rust_name = "register_math_functions"]
45        fn RegisterMathExtensionFunctions<'f>(
46            function_registry: Pin<&mut FunctionRegistry<'f>>,
47            runtime_options: &RuntimeOptions,
48        ) -> Status;
49
50        include!(<extensions/regex_ext.h>);
51        #[rust_name = "register_regex_extension_functions"]
52        fn RegisterRegexExtensionFunctions<'a, 'f>(
53            runtime_builder: Pin<&mut RuntimeBuilder<'a, 'f>>,
54        ) -> Status;
55
56        include!(<extensions/regex_functions.h>);
57        #[rust_name = "register_regex_functions"]
58        fn RegisterRegexFunctions<'f>(
59            function_registry: Pin<&mut FunctionRegistry<'f>>,
60            runtime_options: &RuntimeOptions,
61        ) -> Status;
62
63        include!(<extensions/select_optimization.h>);
64        type SelectOptimizationOptions;
65        #[rust_name = "enable_select_optimization"]
66        fn EnableSelectOptimization<'a, 'f>(
67            builder: Pin<&mut RuntimeBuilder<'a, 'f>>,
68            options: &SelectOptimizationOptions,
69        ) -> Status;
70
71        include!(<extensions/sets_functions.h>);
72        #[rust_name = "register_sets_functions"]
73        fn RegisterSetsFunctions<'f>(
74            function_registry: Pin<&mut FunctionRegistry<'f>>,
75            runtime_options: &RuntimeOptions,
76        ) -> Status;
77
78        include!(<extensions/strings.h>);
79        #[rust_name = "register_strings_functions"]
80        fn RegisterStringsFunctions<'f>(
81            function_registry: Pin<&mut FunctionRegistry<'f>>,
82            runtime_options: &RuntimeOptions,
83        ) -> Status;
84    }
85
86    #[namespace = "rust::cel_cxx"]
87    unsafe extern "C++" {
88        include!(<cel-cxx-ffi/include/absl.h>);
89        include!(<cel-cxx-ffi/include/extensions.h>);
90
91        // bindings_ext.h
92        #[rust_name = "bindings_compiler_library"]
93        fn BindingsCompilerLibrary() -> UniquePtr<CompilerLibrary>;
94
95        // comprehensions_v2.h
96        #[rust_name = "comprehensions_v2_compiler_library"]
97        fn ComprehensionsV2CompilerLibrary() -> UniquePtr<CompilerLibrary>;
98
99        // encoders.h
100        #[rust_name = "encoders_compiler_library"]
101        fn EncodersCompilerLibrary() -> UniquePtr<CompilerLibrary>;
102
103        // lists_functions.h
104        #[rust_name = "lists_compiler_library"]
105        fn ListsCompilerLibrary() -> UniquePtr<CompilerLibrary>;
106
107        // math_ext_decls.h
108        #[rust_name = "math_compiler_library"]
109        fn MathCompilerLibrary() -> UniquePtr<CompilerLibrary>;
110
111        // proto_ext.h
112        #[rust_name = "proto_ext_compiler_library"]
113        fn ProtoExtCompilerLibrary() -> UniquePtr<CompilerLibrary>;
114
115        // regex_ext.h
116        #[rust_name = "regex_extension_compiler_library"]
117        fn RegexExtensionCompilerLibrary() -> UniquePtr<CompilerLibrary>;
118
119        // regex_functions.h
120        #[rust_name = "regex_compiler_library"]
121        fn RegexCompilerLibrary() -> UniquePtr<CompilerLibrary>;
122
123        // SelectOptimizationOptions
124        fn SelectOptimizationOptions_new() -> UniquePtr<SelectOptimizationOptions>;
125
126        // SelectOptimizationOptions getters and setters
127        fn SelectOptimizationOptions_force_fallback_implementation(options: &SelectOptimizationOptions) -> bool;
128        fn SelectOptimizationOptions_force_fallback_implementation_mut(options: Pin<&mut SelectOptimizationOptions>) -> &mut bool;
129
130        // sets_functions.h
131        #[rust_name = "sets_compiler_library"]
132        fn SetsCompilerLibrary() -> UniquePtr<CompilerLibrary>;
133
134        // strings.h
135        #[rust_name = "strings_compiler_library"]
136        fn StringsCompilerLibrary() -> UniquePtr<CompilerLibrary>;
137    }
138}
139
140
141// bindings_ext.h
142pub mod bindings {
143    pub use super::ffi::bindings_compiler_library as compiler_library;
144}
145
146// encoders.h
147pub mod encoders {
148    pub use super::ffi::encoders_compiler_library as compiler_library;
149
150    pub fn register_functions<'f>(
151        function_registry: std::pin::Pin<&mut super::FunctionRegistry<'f>>,
152        runtime_options: &super::RuntimeOptions,
153    ) -> Result<(), super::Status> {
154        let status = super::ffi::register_encoders_functions(function_registry, runtime_options);
155        if status.is_ok() {
156            Ok(())
157        } else {
158            Err(status)
159        }
160    }
161}
162
163// comprehensions_v2.h
164pub mod comprehensions {
165    pub use super::ffi::comprehensions_v2_compiler_library as compiler_library;
166
167    pub fn register_functions<'f>(
168        function_registry: std::pin::Pin<&mut super::FunctionRegistry<'f>>,
169        runtime_options: &super::RuntimeOptions,
170    ) -> Result<(), super::Status> {
171        let status = super::ffi::register_comprehensions_v2_functions(function_registry, runtime_options);
172        if status.is_ok() {
173            Ok(())
174        } else {
175            Err(status)
176        }
177    }
178}
179
180// lists_functions.h
181pub mod lists {
182    pub use super::ffi::lists_compiler_library as compiler_library;
183
184    pub fn register_functions<'f>(
185        function_registry: std::pin::Pin<&mut super::FunctionRegistry<'f>>,
186        runtime_options: &super::RuntimeOptions,
187    ) -> Result<(), super::Status> {
188        let status = super::ffi::register_lists_functions(function_registry, runtime_options);
189        if status.is_ok() {
190            Ok(())
191        } else {
192            Err(status)
193        }
194    }
195}
196
197// math_ext.h
198pub mod math {
199    pub use super::ffi::math_compiler_library as compiler_library;
200
201    pub fn register_functions<'f>(
202        function_registry: std::pin::Pin<&mut super::FunctionRegistry<'f>>,
203        runtime_options: &super::RuntimeOptions,
204    ) -> Result<(), super::Status> {
205        let status = super::ffi::register_math_functions(function_registry, runtime_options);
206        if status.is_ok() {
207            Ok(())
208        } else {
209            Err(status)
210        }
211    }
212}
213
214// proto_ext.h
215pub mod proto {
216    pub use super::ffi::proto_ext_compiler_library as compiler_library;
217}
218
219// regex_functions.h
220pub mod re {
221    pub use super::ffi::regex_compiler_library as compiler_library;
222
223    pub fn register_functions<'f>(
224        function_registry: std::pin::Pin<&mut super::FunctionRegistry<'f>>,
225        runtime_options: &super::RuntimeOptions,
226    ) -> Result<(), super::Status> {
227        let status = super::ffi::register_regex_functions(function_registry, runtime_options);
228        if status.is_ok() {
229            Ok(())
230        } else {
231            Err(status)
232        }
233    }
234}
235
236// regex_ext.h
237pub mod regex {
238    pub use super::ffi::regex_extension_compiler_library as compiler_library;
239
240    pub fn register_functions<'a, 'f>(
241        runtime_builder: std::pin::Pin<&mut super::RuntimeBuilder<'a, 'f>>,
242    ) -> Result<(), super::Status> {
243        let status = super::ffi::register_regex_extension_functions(runtime_builder);
244        if status.is_ok() {
245            Ok(())
246        } else {
247            Err(status)
248        }
249    }
250}
251
252// select_optimization.h
253pub mod select_optimization {
254    use std::pin::Pin;
255
256    pub use super::ffi::SelectOptimizationOptions as Options;
257    unsafe impl Send for Options {}
258    unsafe impl Sync for Options {}
259
260    impl Options {
261        pub fn new() -> cxx::UniquePtr<Self> {
262            super::ffi::SelectOptimizationOptions_new()
263        }
264
265        pub fn force_fallback_implementation(&self) -> bool {
266            super::ffi::SelectOptimizationOptions_force_fallback_implementation(self)
267        }
268
269        pub fn force_fallback_implementation_mut<'a>(self: Pin<&'a mut Self>) -> &'a mut bool {
270            super::ffi::SelectOptimizationOptions_force_fallback_implementation_mut(self)
271        }
272    }
273
274    pub fn enable<'a, 'f>(
275        builder: std::pin::Pin<&mut super::RuntimeBuilder<'a, 'f>>,
276        options: &Options,
277    ) -> Result<(), super::Status> {
278        let status = super::ffi::enable_select_optimization(builder, options);
279        if status.is_ok() {
280            Ok(())
281        } else {
282            Err(status)
283        }
284    }
285}
286
287// sets_functions.h
288pub mod sets {
289    pub use super::ffi::sets_compiler_library as compiler_library;
290
291    pub fn register_functions<'f>(
292        function_registry: std::pin::Pin<&mut super::FunctionRegistry<'f>>,
293        runtime_options: &super::RuntimeOptions,
294    ) -> Result<(), super::Status> {
295        let status = super::ffi::register_sets_functions(function_registry, runtime_options);
296        if status.is_ok() {
297            Ok(())
298        } else {
299            Err(status)
300        }
301    }
302}
303
304// strings.h
305pub mod strings {
306    pub use super::ffi::strings_compiler_library as compiler_library;
307
308    pub fn register_functions<'f>(
309        function_registry: std::pin::Pin<&mut super::FunctionRegistry<'f>>,
310        runtime_options: &super::RuntimeOptions,
311    ) -> Result<(), super::Status> {
312        let status = super::ffi::register_strings_functions(function_registry, runtime_options);
313        if status.is_ok() {
314            Ok(())
315        } else {
316            Err(status)
317        }
318    }
319}
cel_cxx_ffi/extensions.rs

cel_cxx_ffi/
extensions.rs
