cel_cxx_ffi/common/
values.rs

1use crate::absl::{Duration, SpanElement, Status, StringView, Timestamp};
2use crate::common::{MessageType, OpaqueType, Type, ValueKind};
3use crate::protobuf::{Arena, DescriptorPool, MessageFactory};
4use std::pin::Pin;
5
6#[cxx::bridge]
7mod ffi {
8    #[namespace = "absl"]
9    unsafe extern "C++" {
10        include!(<absl/time/time.h>);
11        type Duration = super::Duration;
12        type Time = super::Timestamp;
13
14        include!(<absl/status/status.h>);
15        type Status = super::Status;
16
17        type string_view<'a> = super::StringView<'a>;
18    }
19
20    #[namespace = "google::protobuf"]
21    unsafe extern "C++" {
22        include!(<google/protobuf/arena.h>);
23        type Arena = super::Arena;
24
25        include!(<google/protobuf/descriptor.h>);
26        type DescriptorPool = super::DescriptorPool;
27        type MessageFactory = super::MessageFactory;
28    }
29
30    #[namespace = "cel"]
31    unsafe extern "C++" {
32        include!(<base/kind.h>);
33        type ValueKind = super::ValueKind;
34
35        include!(<common/type.h>);
36        type Type<'a> = super::Type<'a>;
37        type OpaqueType<'a> = super::OpaqueType<'a>;
38
39        include!(<common/types/message_type.h>);
40        type MessageType<'a> = super::MessageType<'a>;
41
42        include!(<common/value.h>);
43        type Value<'a>;
44        fn kind(self: &Value) -> ValueKind;
45        #[rust_name = "runtime_type"]
46        fn GetRuntimeType<'a>(self: &Value<'a>) -> Type<'a>;
47        #[rust_name = "is_bool"]
48        fn IsBool(self: &Value) -> bool;
49        #[rust_name = "is_true"]
50        fn IsTrue(self: &Value) -> bool;
51        #[rust_name = "is_false"]
52        fn IsFalse(self: &Value) -> bool;
53        #[rust_name = "is_bytes"]
54        fn IsBytes(self: &Value) -> bool;
55        #[rust_name = "is_double"]
56        fn IsDouble(self: &Value) -> bool;
57        #[rust_name = "is_duration"]
58        fn IsDuration(self: &Value) -> bool;
59        #[rust_name = "is_error"]
60        fn IsError(self: &Value) -> bool;
61        #[rust_name = "is_int"]
62        fn IsInt(self: &Value) -> bool;
63        #[rust_name = "is_list"]
64        fn IsList(self: &Value) -> bool;
65        #[rust_name = "is_map"]
66        fn IsMap(self: &Value) -> bool;
67        #[rust_name = "is_message"]
68        fn IsMessage(self: &Value) -> bool;
69        #[rust_name = "is_null"]
70        fn IsNull(self: &Value) -> bool;
71        #[rust_name = "is_opaque"]
72        fn IsOpaque(self: &Value) -> bool;
73        #[rust_name = "is_optional"]
74        fn IsOptional(self: &Value) -> bool;
75        #[rust_name = "is_string"]
76        fn IsString(self: &Value) -> bool;
77        #[rust_name = "is_struct"]
78        fn IsStruct(self: &Value) -> bool;
79        #[rust_name = "is_timestamp"]
80        fn IsTimestamp(self: &Value) -> bool;
81        #[rust_name = "is_type"]
82        fn IsType(self: &Value) -> bool;
83        #[rust_name = "is_uint"]
84        fn IsUint(self: &Value) -> bool;
85        #[rust_name = "is_unknown"]
86        fn IsUnknown(self: &Value) -> bool;
87
88        // BoolValue
89        type BoolValue;
90        #[rust_name = "native_value"]
91        fn NativeValue(self: &BoolValue) -> bool;
92
93        type BytesValue<'a>;
94        #[rust_name = "len"]
95        fn Size(self: &BytesValue) -> usize;
96        #[rust_name = "is_empty"]
97        fn IsEmpty(self: &BytesValue) -> bool;
98
99        type DoubleValue;
100        #[rust_name = "native_value"]
101        fn NativeValue(self: &DoubleValue) -> f64;
102
103        type DurationValue;
104        #[rust_name = "native_value"]
105        fn NativeValue(self: &DurationValue) -> Duration;
106
107        type ErrorValue<'a>;
108
109        type IntValue;
110        #[rust_name = "native_value"]
111        fn NativeValue(self: &IntValue) -> i64;
112
113        type ListValue<'a>;
114        type ListValueBuilder<'a>;
115
116        type MapValue<'a>;
117        type MapValueBuilder<'a>;
118
119        type MessageValue<'a>;
120        #[rust_name = "runtime_type"]
121        fn GetRuntimeType<'a>(self: &MessageValue<'a>) -> MessageType<'a>;
122
123        type NullValue;
124        type OpaqueValue<'a>;
125        #[rust_name = "is_optional"]
126        fn IsOptional(self: &OpaqueValue) -> bool;
127
128        type OptionalValue<'a>;
129        #[rust_name = "has_value"]
130        fn HasValue(self: &OptionalValue) -> bool;
131
132        type StringValue<'a>;
133        #[rust_name = "len"]
134        fn Size(self: &StringValue) -> usize;
135        #[rust_name = "is_empty"]
136        fn IsEmpty(self: &StringValue) -> bool;
137
138        //type StructValue;
139        // todo
140
141        type TimestampValue;
142        #[rust_name = "native_value"]
143        fn NativeValue(self: &TimestampValue) -> Time;
144
145        type TypeValue<'a>;
146        #[rust_name = "native_value"]
147        fn NativeValue<'a>(self: &TypeValue<'a>) -> &Type<'a>;
148
149        type UintValue;
150        #[rust_name = "native_value"]
151        fn NativeValue(self: &UintValue) -> u64;
152
153        //type UnknownValue;
154        // todo
155
156        type ValueIterator<'a>;
157        #[rust_name = "has_next"]
158        fn HasNext(self: Pin<&mut ValueIterator>) -> bool;
159
160        // ValueBuilder
161        type ValueBuilder<'a>;
162    }
163
164    #[namespace = "rust::cel_cxx"]
165    unsafe extern "C++" {
166        include!(<cel-cxx-ffi/include/absl.h>);
167        include!(<cel-cxx-ffi/include/values.h>);
168
169        // Value
170        fn Value_size_of() -> usize;
171        fn Value_swap<'a>(lhs: Pin<&mut Value<'a>>, rhs: Pin<&mut Value<'a>>);
172
173        fn Value_new_bool(bool_value: &BoolValue) -> UniquePtr<Value<'static>>;
174        fn Value_new_bytes<'a>(bytes_value: &BytesValue<'a>) -> UniquePtr<Value<'a>>;
175        fn Value_new_double(double_value: &DoubleValue) -> UniquePtr<Value<'static>>;
176        fn Value_new_duration(duration_value: &DurationValue) -> UniquePtr<Value<'static>>;
177        fn Value_new_error<'a>(error_value: &ErrorValue<'a>) -> UniquePtr<Value<'a>>;
178        fn Value_new_int(int_value: &IntValue) -> UniquePtr<Value<'static>>;
179        fn Value_new_list<'a>(list_value: &ListValue<'a>) -> UniquePtr<Value<'a>>;
180        fn Value_new_map<'a>(map_value: &MapValue<'a>) -> UniquePtr<Value<'a>>;
181        fn Value_new_message<'a>(message_value: &MessageValue<'a>) -> UniquePtr<Value<'a>>;
182        fn Value_new_null() -> UniquePtr<Value<'static>>;
183        fn Value_new_opaque<'a>(opaque_value: &OpaqueValue<'a>) -> UniquePtr<Value<'a>>;
184        fn Value_new_optional<'a>(optional_value: &OptionalValue<'a>) -> UniquePtr<Value<'a>>;
185        fn Value_new_string<'a>(string_value: &StringValue<'a>) -> UniquePtr<Value<'a>>;
186        fn Value_new_timestamp(timestamp_value: &TimestampValue) -> UniquePtr<Value<'static>>;
187        fn Value_new_type<'a>(type_value: &TypeValue<'a>) -> UniquePtr<Value<'a>>;
188        fn Value_new_uint(uint_value: &UintValue) -> UniquePtr<Value<'static>>;
189
190        fn Value_get_bool(value: &Value) -> UniquePtr<BoolValue>;
191        fn Value_get_bytes<'a>(value: &Value<'a>) -> UniquePtr<BytesValue<'a>>;
192        fn Value_get_double(value: &Value) -> UniquePtr<DoubleValue>;
193        fn Value_get_duration(value: &Value) -> UniquePtr<DurationValue>;
194        fn Value_get_error<'a>(value: &Value<'a>) -> UniquePtr<ErrorValue<'a>>;
195        fn Value_get_int(value: &Value) -> UniquePtr<IntValue>;
196        fn Value_get_list<'a>(value: &Value<'a>) -> UniquePtr<ListValue<'a>>;
197        fn Value_get_map<'a>(value: &Value<'a>) -> UniquePtr<MapValue<'a>>;
198        fn Value_get_message<'a>(value: &Value<'a>) -> UniquePtr<MessageValue<'a>>;
199        fn Value_get_null(value: &Value) -> UniquePtr<NullValue>;
200        fn Value_get_opaque<'a>(value: &Value<'a>) -> UniquePtr<OpaqueValue<'a>>;
201        fn Value_get_optional<'a>(value: &Value<'a>) -> UniquePtr<OptionalValue<'a>>;
202        fn Value_get_string<'a>(value: &Value<'a>) -> UniquePtr<StringValue<'a>>;
203        fn Value_get_timestamp(value: &Value) -> UniquePtr<TimestampValue>;
204        fn Value_get_type<'a>(value: &Value<'a>) -> UniquePtr<TypeValue<'a>>;
205        fn Value_get_uint(value: &Value) -> UniquePtr<UintValue>;
206
207        // BoolValue
208        fn BoolValue_new(value: bool) -> UniquePtr<BoolValue>;
209
210        // BytesValue
211        fn BytesValue_new<'a>(arena: &'a Arena, bytes: &[u8]) -> UniquePtr<BytesValue<'a>>;
212        fn BytesValue_native_value(bytes_value: &BytesValue) -> Vec<u8>;
213
214        // DoubleValue
215        fn DoubleValue_new(value: f64) -> UniquePtr<DoubleValue>;
216
217        // DurationValue
218        fn DurationValue_new(value: Duration) -> UniquePtr<DurationValue>;
219
220        // ErrorValue
221        fn ErrorValue_new(status: Status) -> UniquePtr<ErrorValue<'static>>;
222        fn ErrorValue_native_value(error_value: &ErrorValue) -> Status;
223
224        // IntValue
225        fn IntValue_new(value: i64) -> UniquePtr<IntValue>;
226
227        // ListValue
228        fn ListValue_is_empty(list_value: &ListValue) -> bool;
229        fn ListValue_size(list_value: &ListValue) -> usize;
230        fn ListValue_new_iterator<'a, 'this>(
231            list_value: &'this ListValue<'a>,
232            iterator: &mut UniquePtr<ValueIterator<'this>>,
233        ) -> Status;
234
235        // ListValueBuilder
236        fn ListValueBuilder_new<'a>(arena: &'a Arena) -> UniquePtr<ListValueBuilder<'a>>;
237        fn ListValueBuilder_add<'a>(
238            builder: Pin<&mut ListValueBuilder<'a>>,
239            value: &Value<'a>,
240        ) -> Status;
241        fn ListValueBuilder_build<'a>(
242            builder: Pin<&mut ListValueBuilder<'a>>,
243        ) -> UniquePtr<ListValue<'a>>;
244
245        // MapValue
246        fn MapValue_is_empty(map_value: &MapValue) -> bool;
247        fn MapValue_size(map_value: &MapValue) -> usize;
248        fn MapValue_new_iterator<'a, 'this>(
249            map_value: &'this MapValue<'a>,
250            iterator: &mut UniquePtr<ValueIterator<'this>>,
251        ) -> Status;
252
253        // MapValueBuilder
254        fn MapValueBuilder_new<'a>(arena: &'a Arena) -> UniquePtr<MapValueBuilder<'a>>;
255        fn MapValueBuilder_put<'a>(
256            builder: Pin<&mut MapValueBuilder<'a>>,
257            key: &Value<'a>,
258            value: &Value<'a>,
259        ) -> Status;
260        fn MapValueBuilder_build<'a>(
261            builder: Pin<&mut MapValueBuilder<'a>>,
262        ) -> UniquePtr<MapValue<'a>>;
263
264        // MessageValue
265        // todo: implement
266
267        // NullValue
268        fn NullValue_new() -> UniquePtr<NullValue>;
269
270        // OpaqueValue
271        fn OpaqueValue_new<'a>(
272            arena: &'a Arena,
273            descriptor_pool: &'a DescriptorPool,
274            ffi: Box<AnyFfiOpaqueValue<'a>>,
275        ) -> UniquePtr<OpaqueValue<'a>>;
276        fn OpaqueValue_get_optional<'a>(
277            opaque_value: &OpaqueValue<'a>,
278        ) -> UniquePtr<OptionalValue<'a>>;
279        fn OpaqueValue_get_ffi<'a>(opaque_value: &OpaqueValue<'a>) -> Box<AnyFfiOpaqueValue<'a>>;
280
281        // OptionalValue
282        fn OptionalValue_new<'a>(
283            arena: &'a Arena,
284            value: &Value<'a>,
285        ) -> UniquePtr<OptionalValue<'a>>;
286        fn OptionalValue_none() -> UniquePtr<OptionalValue<'static>>;
287        fn OptionalValue_get_value<'a>(optional_value: &OptionalValue<'a>) -> UniquePtr<Value<'a>>;
288
289        // StringValue
290        fn StringValue_new<'a>(arena: &'a Arena, value: &str) -> UniquePtr<StringValue<'a>>;
291        fn StringValue_native_value(string_value: &StringValue) -> String;
292
293        // TimestampValue
294        fn TimestampValue_new(value: Time) -> UniquePtr<TimestampValue>;
295
296        // TypeValue
297        fn TypeValue_new<'a>(value: &Type<'a>) -> UniquePtr<TypeValue<'a>>;
298
299        // UintValue
300        fn UintValue_new(value: u64) -> UniquePtr<UintValue>;
301
302        // ValueIterator
303        fn ValueIterator_next1<'a, 'b>(
304            value_iterator: Pin<&mut ValueIterator<'a>>,
305            descriptor_pool: &DescriptorPool,
306            message_factory: &MessageFactory,
307            arena: &'b Arena,
308            result: &mut UniquePtr<Value<'b>>,
309        ) -> Status;
310        fn ValueIterator_next2<'a, 'b>(
311            value_iterator: Pin<&mut ValueIterator<'a>>,
312            descriptor_pool: &DescriptorPool,
313            message_factory: &MessageFactory,
314            arena: &'b Arena,
315            key: &mut UniquePtr<Value<'b>>,
316            value: &mut UniquePtr<Value<'b>>,
317        ) -> Status;
318
319        // ValueBuilder
320        fn ValueBuilder_new<'a>(ffi: Box<AnyFfiValueBuilder<'a>>) -> UniquePtr<ValueBuilder<'a>>;
321        fn ValueBuilder_new_message<'a>(
322            arena: &'a Arena,
323            descriptor_pool: &'a DescriptorPool,
324            message_factory: &'a MessageFactory,
325            name: string_view<'_>,
326        ) -> UniquePtr<ValueBuilder<'a>>;
327    }
328
329    #[namespace = "rust::cel_cxx"]
330    extern "Rust" {
331        type AnyFfiOpaqueValue<'a>;
332        #[cxx_name = "Clone"]
333        unsafe fn clone<'a>(self: &'a AnyFfiOpaqueValue<'a>) -> Box<AnyFfiOpaqueValue<'a>>;
334        #[cxx_name = "DebugString"]
335        unsafe fn to_string<'a>(self: &AnyFfiOpaqueValue<'a>) -> String;
336        #[cxx_name = "GetTypeName"]
337        unsafe fn type_name<'a>(self: &AnyFfiOpaqueValue<'a>) -> string_view<'a>;
338        #[cxx_name = "GetRuntimeType"]
339        unsafe fn runtime_type<'a>(self: &AnyFfiOpaqueValue<'a>) -> OpaqueType<'a>;
340        #[cxx_name = "Equal"]
341        unsafe fn equal<'a>(self: &AnyFfiOpaqueValue<'a>, other: &AnyFfiOpaqueValue<'a>) -> bool;
342
343        type AnyFfiValueBuilder<'a>;
344        #[cxx_name = "SetFieldByName"]
345        unsafe fn set_field_by_name<'a>(self: &mut AnyFfiValueBuilder<'a>, name: string_view<'a>, value: &Value<'a>) -> Status;
346        #[cxx_name = "SetFieldByNumber"]
347        unsafe fn set_field_by_number<'a>(self: &mut AnyFfiValueBuilder<'a>, number: i64, value: &Value<'a>) -> Status;
348        #[cxx_name = "Build"]
349        unsafe fn build<'a>(self: &mut AnyFfiValueBuilder<'a>, result: &mut UniquePtr<Value<'a>>) -> Status;
350    }
351}
352
353// Value
354pub use ffi::Value;
355unsafe impl<'a> Send for Value<'a> {}
356unsafe impl<'a> Sync for Value<'a> {}
357
358impl<'a> crate::SizedExternType for Value<'a> {
359    fn size_of() -> usize {
360        ffi::Value_size_of()
361    }
362}
363
364impl<'a> SpanElement for Value<'a> {
365    type TypeId = cxx::type_id!("rust::cel_cxx::Span_Value");
366}
367
368impl<'a> Value<'a> {
369    pub fn swap(self: Pin<&mut Self>, other: Pin<&mut Self>) {
370        ffi::Value_swap(self, other);
371    }
372
373    pub fn new_bool(value: &BoolValue) -> cxx::UniquePtr<Self> {
374        ffi::Value_new_bool(value)
375    }
376
377    pub fn new_bytes(bytes: &BytesValue<'a>) -> cxx::UniquePtr<Self> {
378        ffi::Value_new_bytes(bytes)
379    }
380
381    pub fn new_double(value: &DoubleValue) -> cxx::UniquePtr<Self> {
382        ffi::Value_new_double(value)
383    }
384
385    pub fn new_duration(value: &DurationValue) -> cxx::UniquePtr<Self> {
386        ffi::Value_new_duration(value)
387    }
388
389    pub fn new_error(value: &ErrorValue<'a>) -> cxx::UniquePtr<Self> {
390        ffi::Value_new_error(value)
391    }
392
393    pub fn new_int(value: &IntValue) -> cxx::UniquePtr<Self> {
394        ffi::Value_new_int(value)
395    }
396
397    pub fn new_list(list: &ListValue<'a>) -> cxx::UniquePtr<Self> {
398        ffi::Value_new_list(list)
399    }
400
401    pub fn new_map(map: &MapValue<'a>) -> cxx::UniquePtr<Self> {
402        ffi::Value_new_map(map)
403    }
404
405    pub fn new_message(message: &MessageValue<'a>) -> cxx::UniquePtr<Self> {
406        ffi::Value_new_message(message)
407    }
408
409    pub fn new_null() -> cxx::UniquePtr<Self> {
410        ffi::Value_new_null()
411    }
412
413    pub fn new_opaque(opaque: &OpaqueValue<'a>) -> cxx::UniquePtr<Self> {
414        ffi::Value_new_opaque(opaque)
415    }
416
417    pub fn new_optional(optional: &OptionalValue<'a>) -> cxx::UniquePtr<Self> {
418        ffi::Value_new_optional(optional)
419    }
420
421    pub fn new_string(string: &StringValue<'a>) -> cxx::UniquePtr<Self> {
422        ffi::Value_new_string(string)
423    }
424
425    pub fn new_timestamp(timestamp: &TimestampValue) -> cxx::UniquePtr<Self> {
426        ffi::Value_new_timestamp(timestamp)
427    }
428
429    pub fn new_type(type_value: &TypeValue<'a>) -> cxx::UniquePtr<Self> {
430        ffi::Value_new_type(type_value)
431    }
432
433    pub fn new_uint(uint: &UintValue) -> cxx::UniquePtr<Self> {
434        ffi::Value_new_uint(uint)
435    }
436
437    pub fn get_bool(&self) -> cxx::UniquePtr<BoolValue> {
438        ffi::Value_get_bool(self)
439    }
440
441    pub fn get_bytes(&self) -> cxx::UniquePtr<BytesValue<'a>> {
442        ffi::Value_get_bytes(self)
443    }
444
445    pub fn get_double(&self) -> cxx::UniquePtr<DoubleValue> {
446        ffi::Value_get_double(self)
447    }
448
449    pub fn get_duration(&self) -> cxx::UniquePtr<DurationValue> {
450        ffi::Value_get_duration(self)
451    }
452
453    pub fn get_error(&self) -> cxx::UniquePtr<ErrorValue<'a>> {
454        ffi::Value_get_error(self)
455    }
456
457    pub fn get_int(&self) -> cxx::UniquePtr<IntValue> {
458        ffi::Value_get_int(self)
459    }
460
461    pub fn get_list(&self) -> cxx::UniquePtr<ListValue<'a>> {
462        ffi::Value_get_list(self)
463    }
464
465    pub fn get_map(&self) -> cxx::UniquePtr<MapValue<'a>> {
466        ffi::Value_get_map(self)
467    }
468
469    pub fn get_message(&self) -> cxx::UniquePtr<MessageValue<'a>> {
470        ffi::Value_get_message(self)
471    }
472
473    pub fn get_null(&self) -> cxx::UniquePtr<NullValue> {
474        ffi::Value_get_null(self)
475    }
476
477    pub fn get_opaque(&self) -> cxx::UniquePtr<OpaqueValue<'a>> {
478        ffi::Value_get_opaque(self)
479    }
480
481    pub fn get_optional(&self) -> cxx::UniquePtr<OptionalValue<'a>> {
482        ffi::Value_get_optional(self)
483    }
484
485    pub fn get_string(&self) -> cxx::UniquePtr<StringValue<'a>> {
486        ffi::Value_get_string(self)
487    }
488
489    pub fn get_timestamp(&self) -> cxx::UniquePtr<TimestampValue> {
490        ffi::Value_get_timestamp(self)
491    }
492
493    pub fn get_type(&self) -> cxx::UniquePtr<TypeValue<'a>> {
494        ffi::Value_get_type(self)
495    }
496
497    pub fn get_uint(&self) -> cxx::UniquePtr<UintValue> {
498        ffi::Value_get_uint(self)
499    }
500}
501
502// BoolValue
503pub use ffi::BoolValue;
504unsafe impl Send for BoolValue {}
505unsafe impl Sync for BoolValue {}
506
507impl BoolValue {
508    pub fn new(value: bool) -> cxx::UniquePtr<Self> {
509        ffi::BoolValue_new(value)
510    }
511}
512
513// BytesValue
514pub use ffi::BytesValue;
515unsafe impl<'a> Send for BytesValue<'a> {}
516unsafe impl<'a> Sync for BytesValue<'a> {}
517
518impl<'a> BytesValue<'a> {
519    pub fn new(arena: &'a Arena, bytes: &[u8]) -> cxx::UniquePtr<Self> {
520        ffi::BytesValue_new(arena, bytes)
521    }
522
523    pub fn native_value(&self) -> Vec<u8> {
524        ffi::BytesValue_native_value(self)
525    }
526}
527
528// DoubleValue
529pub use ffi::DoubleValue;
530unsafe impl Send for DoubleValue {}
531unsafe impl Sync for DoubleValue {}
532
533impl DoubleValue {
534    pub fn new(value: f64) -> cxx::UniquePtr<Self> {
535        ffi::DoubleValue_new(value)
536    }
537}
538
539// DurationValue
540pub use ffi::DurationValue;
541unsafe impl Send for DurationValue {}
542unsafe impl Sync for DurationValue {}
543
544impl DurationValue {
545    pub fn new(value: Duration) -> cxx::UniquePtr<Self> {
546        ffi::DurationValue_new(value)
547    }
548}
549
550// ErrorValue
551pub use ffi::ErrorValue;
552unsafe impl<'a> Send for ErrorValue<'a> {}
553unsafe impl<'a> Sync for ErrorValue<'a> {}
554
555impl<'a> ErrorValue<'a> {
556    pub fn new(status: Status) -> cxx::UniquePtr<Self> {
557        ffi::ErrorValue_new(status)
558    }
559
560    pub fn native_value(&self) -> Status {
561        ffi::ErrorValue_native_value(self)
562    }
563}
564
565// IntValue
566pub use ffi::IntValue;
567unsafe impl Send for IntValue {}
568unsafe impl Sync for IntValue {}
569
570impl IntValue {
571    pub fn new(value: i64) -> cxx::UniquePtr<Self> {
572        ffi::IntValue_new(value)
573    }
574}
575
576// ListValue
577pub use ffi::ListValue;
578unsafe impl<'a> Send for ListValue<'a> {}
579unsafe impl<'a> Sync for ListValue<'a> {}
580
581impl<'a> ListValue<'a> {
582    pub fn is_empty(&self) -> bool {
583        ffi::ListValue_is_empty(self)
584    }
585
586    pub fn len(&self) -> usize {
587        ffi::ListValue_size(self)
588    }
589
590    pub fn new_iterator<'this>(
591        &'this self,
592    ) -> Result<cxx::UniquePtr<ffi::ValueIterator<'this>>, Status> {
593        let mut result = cxx::UniquePtr::null();
594        let status = ffi::ListValue_new_iterator(self, &mut result);
595        if status.is_ok() {
596            Ok(result)
597        } else {
598            Err(status)
599        }
600    }
601}
602
603// ListValueBuilder
604pub use ffi::ListValueBuilder;
605unsafe impl<'a> Send for ListValueBuilder<'a> {}
606unsafe impl<'a> Sync for ListValueBuilder<'a> {}
607
608impl<'a> ListValueBuilder<'a> {
609    pub fn new(arena: &'a Arena) -> cxx::UniquePtr<Self> {
610        ffi::ListValueBuilder_new(arena)
611    }
612
613    pub fn add(self: Pin<&mut Self>, value: &Value<'a>) -> Status {
614        ffi::ListValueBuilder_add(self, value)
615    }
616
617    pub fn build(self: Pin<&mut Self>) -> cxx::UniquePtr<ListValue<'a>> {
618        ffi::ListValueBuilder_build(self)
619    }
620}
621
622// MapValue
623pub use ffi::MapValue;
624unsafe impl<'a> Send for MapValue<'a> {}
625unsafe impl<'a> Sync for MapValue<'a> {}
626
627impl<'a> MapValue<'a> {
628    pub fn is_empty(&self) -> bool {
629        ffi::MapValue_is_empty(self)
630    }
631
632    pub fn len(&self) -> usize {
633        ffi::MapValue_size(self)
634    }
635
636    pub fn new_iterator<'this>(
637        &'this self,
638    ) -> Result<cxx::UniquePtr<ffi::ValueIterator<'this>>, Status> {
639        let mut result = cxx::UniquePtr::null();
640        let status = ffi::MapValue_new_iterator(self, &mut result);
641        if status.is_ok() {
642            Ok(result)
643        } else {
644            Err(status)
645        }
646    }
647}
648
649// MapValueBuilder
650pub use ffi::MapValueBuilder;
651unsafe impl<'a> Send for MapValueBuilder<'a> {}
652unsafe impl<'a> Sync for MapValueBuilder<'a> {}
653
654impl<'a> MapValueBuilder<'a> {
655    pub fn new(arena: &'a Arena) -> cxx::UniquePtr<Self> {
656        ffi::MapValueBuilder_new(arena)
657    }
658
659    pub fn put(self: Pin<&mut Self>, key: &Value<'a>, value: &Value<'a>) -> Status {
660        ffi::MapValueBuilder_put(self, key, value)
661    }
662
663    pub fn build(self: Pin<&mut Self>) -> cxx::UniquePtr<MapValue<'a>> {
664        ffi::MapValueBuilder_build(self)
665    }
666}
667
668pub use ffi::MessageValue;
669unsafe impl<'a> Send for MessageValue<'a> {}
670unsafe impl<'a> Sync for MessageValue<'a> {}
671
672impl<'a> MessageValue<'a> {}
673
674pub use ffi::NullValue;
675unsafe impl Send for NullValue {}
676unsafe impl Sync for NullValue {}
677
678impl NullValue {
679    pub fn new() -> cxx::UniquePtr<Self> {
680        ffi::NullValue_new()
681    }
682}
683
684pub use ffi::OpaqueValue;
685unsafe impl<'a> Send for OpaqueValue<'a> {}
686unsafe impl<'a> Sync for OpaqueValue<'a> {}
687
688impl<'a> OpaqueValue<'a> {
689    pub fn new<T: FfiOpaqueValue + 'a>(
690        arena: &'a Arena,
691        descriptor_pool: &'a DescriptorPool,
692        ffi: T,
693    ) -> cxx::UniquePtr<Self> {
694        ffi::OpaqueValue_new(
695            arena,
696            descriptor_pool,
697            Box::new(AnyFfiOpaqueValue::new(ffi, arena, descriptor_pool)),
698        )
699    }
700
701    pub fn get_optional(&self) -> cxx::UniquePtr<OptionalValue<'a>> {
702        ffi::OpaqueValue_get_optional(self)
703    }
704
705    pub fn downcast<T: FfiOpaqueValue>(&self) -> Option<Box<T>> {
706        let ffi = ffi::OpaqueValue_get_ffi(self);
707        ffi.downcast::<T>()
708    }
709}
710
711pub trait FfiOpaqueValue:
712    'static + std::fmt::Debug + std::fmt::Display + dyn_clone::DynClone + private::Sealed + Send + Sync
713{
714    fn opaque_type<'a>(
715        &self,
716        arena: &'a Arena,
717        descriptor_pool: &'a DescriptorPool,
718    ) -> OpaqueType<'a>;
719}
720dyn_clone::clone_trait_object!(FfiOpaqueValue);
721
722#[derive(Clone)]
723struct AnyFfiOpaqueValue<'a> {
724    ffi: Box<dyn FfiOpaqueValue>,
725    opaque_type: OpaqueType<'a>,
726}
727
728impl<'a> AnyFfiOpaqueValue<'a> {
729    pub fn new<T: FfiOpaqueValue + 'static>(
730        value: T,
731        arena: &'a Arena,
732        descriptor_pool: &'a DescriptorPool,
733    ) -> Self {
734        let opaque_type = value.opaque_type(arena, descriptor_pool);
735        Self {
736            ffi: Box::new(value),
737            opaque_type,
738        }
739    }
740
741    pub fn clone(&self) -> Box<AnyFfiOpaqueValue<'a>> {
742        Box::new(Clone::clone(self))
743    }
744
745    pub fn type_name(&self) -> StringView<'a> {
746        self.opaque_type.name()
747    }
748
749    pub fn runtime_type(&self) -> OpaqueType<'a> {
750        self.opaque_type
751    }
752
753    pub fn equal<'b>(&self, other: &AnyFfiOpaqueValue<'b>) -> bool {
754        self == other
755    }
756
757    pub fn downcast<T: FfiOpaqueValue>(&self) -> Option<Box<T>> {
758        self.ffi.clone().into_any().downcast::<T>().ok()
759    }
760}
761
762impl<'a> std::fmt::Display for AnyFfiOpaqueValue<'a> {
763    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
764        write!(f, "AnyFfiOpaqueValue")
765    }
766}
767
768impl<'a> PartialEq for AnyFfiOpaqueValue<'a> {
769    fn eq(&self, other: &Self) -> bool {
770        *self.ffi == *other.ffi
771    }
772}
773
774impl<'a> Eq for AnyFfiOpaqueValue<'a> {}
775
776impl<'a> std::fmt::Debug for AnyFfiOpaqueValue<'a> {
777    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
778        write!(f, "AnyFfiOpaqueValue({:?})", self.ffi)
779    }
780}
781
782impl PartialEq for dyn FfiOpaqueValue {
783    fn eq(&self, other: &Self) -> bool {
784        self.dyn_eq(private::Sealed::as_any(other))
785    }
786}
787
788impl Eq for dyn FfiOpaqueValue {}
789
790mod private {
791    use super::FfiOpaqueValue;
792    use std::any::Any;
793
794    pub trait Sealed: Any {
795        fn into_any(self: Box<Self>) -> Box<dyn Any>;
796        fn as_any(&self) -> &dyn Any;
797        fn as_any_mut(&mut self) -> &mut dyn Any;
798
799        fn dyn_eq(&self, other: &dyn Any) -> bool;
800    }
801
802    impl<T: FfiOpaqueValue + PartialEq + Eq> Sealed for T {
803        fn into_any(self: Box<Self>) -> Box<dyn Any> {
804            self
805        }
806        fn as_any(&self) -> &dyn Any {
807            self
808        }
809        fn as_any_mut(&mut self) -> &mut dyn Any {
810            self
811        }
812
813        fn dyn_eq(&self, other: &dyn Any) -> bool {
814            other.downcast_ref::<T>() == Some(self)
815        }
816    }
817}
818
819pub use ffi::OptionalValue;
820unsafe impl<'a> Send for OptionalValue<'a> {}
821unsafe impl<'a> Sync for OptionalValue<'a> {}
822
823impl<'a> OptionalValue<'a> {
824    pub fn new(arena: &'a Arena, value: &Value<'a>) -> cxx::UniquePtr<Self> {
825        ffi::OptionalValue_new(arena, value)
826    }
827
828    pub fn none() -> cxx::UniquePtr<Self> {
829        ffi::OptionalValue_none()
830    }
831
832    pub fn get_value(&self) -> cxx::UniquePtr<Value<'a>> {
833        ffi::OptionalValue_get_value(self)
834    }
835}
836
837pub use ffi::StringValue;
838unsafe impl<'a> Send for StringValue<'a> {}
839unsafe impl<'a> Sync for StringValue<'a> {}
840
841impl<'a> StringValue<'a> {
842    pub fn new(arena: &'a Arena, value: &str) -> cxx::UniquePtr<Self> {
843        ffi::StringValue_new(arena, value)
844    }
845
846    pub fn native_value(&self) -> String {
847        ffi::StringValue_native_value(self)
848    }
849}
850
851pub use ffi::TimestampValue;
852unsafe impl Send for TimestampValue {}
853unsafe impl Sync for TimestampValue {}
854
855impl TimestampValue {
856    pub fn new(value: Timestamp) -> cxx::UniquePtr<Self> {
857        ffi::TimestampValue_new(value)
858    }
859}
860
861pub use ffi::TypeValue;
862unsafe impl<'a> Send for TypeValue<'a> {}
863unsafe impl<'a> Sync for TypeValue<'a> {}
864
865impl<'a> TypeValue<'a> {
866    pub fn new(value: &Type<'a>) -> cxx::UniquePtr<Self> {
867        ffi::TypeValue_new(value)
868    }
869}
870
871pub use ffi::UintValue;
872unsafe impl Send for UintValue {}
873unsafe impl Sync for UintValue {}
874
875impl UintValue {
876    pub fn new(value: u64) -> cxx::UniquePtr<Self> {
877        ffi::UintValue_new(value)
878    }
879}
880
881pub use ffi::ValueIterator;
882unsafe impl<'a> Send for ValueIterator<'a> {}
883unsafe impl<'a> Sync for ValueIterator<'a> {}
884
885impl<'a> ValueIterator<'a> {
886    pub fn next1<'b>(
887        self: Pin<&mut Self>,
888        descriptor_pool: &DescriptorPool,
889        message_factory: &MessageFactory,
890        arena: &'b Arena,
891    ) -> Result<cxx::UniquePtr<Value<'b>>, Status> {
892        let mut result = cxx::UniquePtr::null();
893        let status =
894            ffi::ValueIterator_next1(self, descriptor_pool, message_factory, arena, &mut result);
895        if status.is_ok() {
896            Ok(result)
897        } else {
898            Err(status)
899        }
900    }
901
902    pub fn next2<'b>(
903        self: Pin<&mut Self>,
904        descriptor_pool: &DescriptorPool,
905        message_factory: &MessageFactory,
906        arena: &'b Arena,
907    ) -> Result<(cxx::UniquePtr<Value<'b>>, cxx::UniquePtr<Value<'b>>), Status> {
908        let mut key = cxx::UniquePtr::null();
909        let mut value = cxx::UniquePtr::null();
910        let status = ffi::ValueIterator_next2(
911            self,
912            descriptor_pool,
913            message_factory,
914            arena,
915            &mut key,
916            &mut value,
917        );
918        if status.is_ok() {
919            Ok((key, value))
920        } else {
921            Err(status)
922        }
923    }
924}
925
926// ValueBuilder
927pub trait FfiValueBuilder<'a> {
928    fn set_field_by_name(
929        &mut self,
930        name: StringView<'_>,
931        value: &Value<'a>,
932    ) -> Result<(), Status>;
933    fn set_field_by_number(
934        &mut self,
935        number: i64,
936        value: &Value<'a>,
937    ) -> Result<(), Status>;
938
939    fn build(self: Box<Self>) -> Result<cxx::UniquePtr<Value<'a>>, Status>;
940}
941
942struct AnyFfiValueBuilder<'a>(Option<Box<dyn FfiValueBuilder<'a> + 'a>>);
943
944impl<'a> AnyFfiValueBuilder<'a> {
945    fn new<T: FfiValueBuilder<'a> + 'a>(ffi_value_builder: T) -> Self {
946        Self(Some(Box::new(ffi_value_builder)))
947    }
948
949    fn set_field_by_name(
950        &mut self,
951        name: StringView<'_>,
952        value: &Value<'a>,
953    ) -> Status {
954        let ffi = self.0.as_mut().expect("ffi_value_builder is not set");
955        match ffi.set_field_by_name(name, value) {
956            Ok(_) => {
957                Status::ok()
958            }
959            Err(status) => status,
960        }
961    }
962    fn set_field_by_number(
963        &mut self,
964        number: i64,
965        value: &Value<'a>,
966    ) -> Status {
967        let ffi = self.0.as_mut().expect("ffi_value_builder is not set");
968        match ffi.set_field_by_number(number, value) {
969            Ok(_) => {
970                Status::ok()
971            }
972            Err(status) => status,
973        }
974    }
975
976    fn build(&mut self, result: &mut cxx::UniquePtr<Value<'a>>) -> Status {
977        let ffi = self.0.take().expect("ffi_value_builder is not set");
978        match ffi.build() {
979            Ok(value) => {
980                *result = value;
981                Status::ok()
982            }
983            Err(status) => status,
984        }
985    }
986}
987
988pub use ffi::ValueBuilder;
989unsafe impl<'a> Send for ValueBuilder<'a> {}
990unsafe impl<'a> Sync for ValueBuilder<'a> {}
991
992impl<'a> ValueBuilder<'a> {
993    pub fn new<T: FfiValueBuilder<'a> + 'a>(ffi_value_builder: T) -> cxx::UniquePtr<Self> {
994        ffi::ValueBuilder_new(Box::new(AnyFfiValueBuilder::new(ffi_value_builder)))
995    }
996
997    pub fn new_message(
998        arena: &'a Arena,
999        descriptor_pool: &'a DescriptorPool,
1000        message_factory: &'a MessageFactory,
1001        name: StringView<'_>,
1002    ) -> cxx::UniquePtr<Self> {
1003        ffi::ValueBuilder_new_message(arena, descriptor_pool, message_factory, name)
1004    }
1005}
cel_cxx_ffi/common/values.rs

cel_cxx_ffi/common/
values.rs
