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

use crate::absl::Status;
use crate::common::{Type, Constant};

#[cxx::bridge]
mod ffi {
    #[namespace = "absl"]
    unsafe extern "C++" {
        include!(<absl/status/status.h>);
        type Status = super::Status;
    }

    #[namespace = "cel"]
    unsafe extern "C++" {
        include!(<common/type.h>);
        type Type<'a> = super::Type<'a>;

        include!(<common/decl.h>);
        type VariableDecl<'a>;
        type OverloadDecl<'a>;
        type FunctionDecl<'a>;
        #[rust_name = "add_overload"]
        fn AddOverload<'a>(self: Pin<&mut FunctionDecl<'a>>, overload: &OverloadDecl<'a>)
            -> Status;

        type Constant = super::Constant;
    }

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

        // VariableDecl
        fn VariableDecl_new<'a>(name: &str, ty: &Type<'a>) -> UniquePtr<VariableDecl<'a>>;
        fn VariableDecl_new_constant<'a>(
            name: &str,
            value: &Constant,
        ) -> UniquePtr<VariableDecl<'a>>;

        // FunctionDecl
        fn FunctionDecl_new<'a>(name: &str) -> UniquePtr<FunctionDecl<'a>>;

        // OverloadDecl
        fn OverloadDecl_new<'a>(
            id: &str,
            member: bool,
            result: &Type<'a>,
            args: &[Type<'a>],
        ) -> UniquePtr<OverloadDecl<'a>>;
    }
}

pub use ffi::VariableDecl;
unsafe impl Send for VariableDecl<'_> {}
unsafe impl Sync for VariableDecl<'_> {}

impl<'a> VariableDecl<'a> {
    pub fn new(name: &str, ty: &Type<'a>) -> cxx::UniquePtr<Self> {
        ffi::VariableDecl_new(name, ty)
    }

    pub fn new_constant(name: &str, value: &Constant) -> cxx::UniquePtr<Self> {
        ffi::VariableDecl_new_constant(name, value)
    }
}

pub use ffi::FunctionDecl;
unsafe impl Send for FunctionDecl<'_> {}
unsafe impl Sync for FunctionDecl<'_> {}

impl<'a> FunctionDecl<'a> {
    pub fn new(name: &str) -> cxx::UniquePtr<Self> {
        ffi::FunctionDecl_new(name)
    }
}

pub use ffi::OverloadDecl;
unsafe impl Send for OverloadDecl<'_> {}
unsafe impl Sync for OverloadDecl<'_> {}

impl<'a> OverloadDecl<'a> {
    pub fn new(
        id: &str,
        member: bool,
        result: &Type<'a>,
        arguments: &[Type<'a>],
    ) -> cxx::UniquePtr<Self> {
        ffi::OverloadDecl_new(id, member, result, arguments)
    }
}