cel-cxx-ffi 0.2.5

FFI bindings for the cel-cxx crate
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

#[cxx::bridge]
mod ffi {
    #[namespace = "google::protobuf"]
    unsafe extern "C++" {
        include!(<google/protobuf/arena.h>);
        type Arena;
        #[rust_name = "space_allocated"]
        fn SpaceAllocated(self: &Arena) -> u64;
        #[rust_name = "space_used"]
        fn SpaceUsed(self: &Arena) -> u64;

        include!(<google/protobuf/descriptor.h>);
        type DescriptorPool;

        include!(<google/protobuf/message.h>);
        type MessageFactory;
    }

    #[namespace = "rust::cel_cxx"]
    unsafe extern "C++" {
        include!(<cel-cxx-ffi/include/protobuf.h>);
        fn NewArena() -> SharedPtr<Arena>;

        fn generated_pool() -> SharedPtr<DescriptorPool>;
        fn NewDescriptorPool(file_descriptor_set: &[u8]) -> SharedPtr<DescriptorPool>;

        fn generated_factory() -> SharedPtr<MessageFactory>;
        fn NewMessageFactory() -> SharedPtr<MessageFactory>;
    }
}

// Arena
pub use ffi::Arena;
unsafe impl Send for Arena {}
unsafe impl Sync for Arena {}
impl Arena {
    pub fn new() -> cxx::SharedPtr<Self> {
        ffi::NewArena()
    }
}

impl std::fmt::Debug for Arena {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "Arena {{ space_allocated: {}, space_used: {} }}",
            self.space_allocated(),
            self.space_used(),
        )
    }
}

// DescriptorPool
pub use ffi::DescriptorPool;
unsafe impl Send for DescriptorPool {}
unsafe impl Sync for DescriptorPool {}

impl DescriptorPool {
    pub fn generated() -> cxx::SharedPtr<Self> {
        ffi::generated_pool()
    }

    /// Build a `DescriptorPool` from a serialized `FileDescriptorSet`.
    ///
    /// Returns `Err` if the bytes are malformed or a file descriptor fails to build.
    /// The C++ side returns a null `shared_ptr` on any of these failures without
    /// further detail, so the error message is generic.
    pub fn new(file_descriptor_set: &[u8]) -> Result<cxx::SharedPtr<Self>, &'static str> {
        let pool = ffi::NewDescriptorPool(file_descriptor_set);
        if pool.is_null() {
            return Err("failed to build DescriptorPool from FileDescriptorSet");
        }
        Ok(pool)
    }
}

impl std::fmt::Debug for DescriptorPool {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let ptr = self as *const DescriptorPool;
        let is_generated = {
            let generated_ptr = Self::generated()
                .as_ref()
                .expect("generated_pool is not initialized")
                as *const ffi::DescriptorPool;
            ptr == generated_ptr
        };
        write!(
            f,
            "DescriptorPool {{ ptr: {ptr:p}, is_generated: {is_generated} }}",
        )
    }
}

// MessageFactory
pub use ffi::MessageFactory;
// SAFETY: The generated MessageFactory (singleton) is truly thread-safe.
// DynamicMessageFactory::GetPrototype() mutates internal caches without synchronization,
// so it is NOT safe for concurrent shared access. However, the Ctx architecture ensures
// DynamicMessageFactory is never shared: Ctx::clone_with_new_arena() creates a fresh
// instance per evaluation context, so each thread gets exclusive access. This invariant
// is critical — do NOT share a DynamicMessageFactory across threads.
unsafe impl Send for MessageFactory {}
unsafe impl Sync for MessageFactory {}

impl MessageFactory {
    pub fn generated() -> cxx::SharedPtr<Self> {
        ffi::generated_factory()
    }

    pub fn new() -> cxx::SharedPtr<Self> {
        ffi::NewMessageFactory()
    }
}

impl std::fmt::Debug for MessageFactory {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let ptr = self as *const MessageFactory;
        let is_generated = {
            let generated_ptr = Self::generated()
                .as_ref()
                .expect("generated_factory is not initialized")
                as *const ffi::MessageFactory;
            ptr == generated_ptr
        };
        write!(
            f,
            "MessageFactory {{ ptr: {ptr:p}, is_generated: {is_generated} }}",
        )
    }
}