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
131
132
133
134
135
136
137
138
139
140

#include <cel-cxx-ffi/include/type_provider.h>
#include <cel-cxx-ffi/src/common/type_provider.rs.h>

namespace rust::cel_cxx {

using Type = cel::Type;
using StructTypeField = cel::StructTypeField;
using EnumConstant = cel::TypeIntrospector::EnumConstant;
using ValueBuilder = cel::ValueBuilder;
using MessageFactory = google::protobuf::MessageFactory;
using Arena = google::protobuf::Arena;

// TypeIntrospector
class AnyFfiTypeIntrospectorWrapper: public cel::TypeIntrospector {
public:
    AnyFfiTypeIntrospectorWrapper(Box<AnyFfiTypeIntrospector> ffi): ffi_(std::move(ffi)) {}

    virtual absl::StatusOr<absl::optional<Type>> FindTypeImpl(absl::string_view name) const override {
        bool found = false;
        Type result;
        auto status = ffi_->FindTypeImpl(name, found, result);
        if (!status.ok()) {
            return absl::Status(status.code(), status.message());
        }
        if (!found) {
            return absl::nullopt;
        }
        return result;
    }

    virtual absl::StatusOr<absl::optional<EnumConstant>> FindEnumConstantImpl(
        absl::string_view type_name,
        absl::string_view value_name
    ) const override {
        bool found = false;
        EnumConstant result;
        auto status = ffi_->FindEnumConstantImpl(type_name, value_name, found, result);
        if (!status.ok()) {
            return absl::Status(status.code(), status.message());
        }
        if (!found) {
            return absl::nullopt;
        }
        return result;
    }

    virtual absl::StatusOr<absl::optional<StructTypeField>> FindStructTypeFieldByNameImpl(
        absl::string_view type_name,
        absl::string_view field_name
    ) const override {
        bool found = false;
        StructTypeField result(cel::common_internal::BasicStructTypeField("", 0, Type()));
        auto status = ffi_->FindStructTypeFieldByNameImpl(type_name, field_name, found, result);
        if (!status.ok()) {
            return absl::Status(status.code(), status.message());
        }
        if (!found) {
            return absl::nullopt;
        }
        return result;
    }
private:
    Box<AnyFfiTypeIntrospector> ffi_;
};

std::unique_ptr<TypeIntrospector> TypeIntrospector_new(Box<AnyFfiTypeIntrospector> ffi) {
    return std::make_unique<AnyFfiTypeIntrospectorWrapper>(std::move(ffi));
}

// TypeReflector
class AnyFfiTypeReflectorWrapper: public cel::TypeReflector {
public:
    AnyFfiTypeReflectorWrapper(Box<AnyFfiTypeReflector> ffi): ffi_(std::move(ffi)) {}

    virtual absl::StatusOr<std::unique_ptr<ValueBuilder>> NewValueBuilder(
        absl::string_view name,
        google::protobuf::MessageFactory* message_factory,
        google::protobuf::Arena* arena
    ) const override {
        std::unique_ptr<ValueBuilder> result;
        auto status = ffi_->NewValueBuilder(name, *message_factory, *arena, result);
        if (!status.ok()) {
            return status;
        }
        return result;
    }

    virtual absl::StatusOr<absl::optional<Type>> FindTypeImpl(absl::string_view name) const override {
        bool found = false;
        Type result;
        auto status = ffi_->FindTypeImpl(name, found, result);
        if (!status.ok()) {
            return absl::Status(status.code(), status.message());
        }
        if (!found) {
            return absl::nullopt;
        }
        return result;
    }

    virtual absl::StatusOr<absl::optional<EnumConstant>> FindEnumConstantImpl(
        absl::string_view type_name,
        absl::string_view value_name
    ) const override {
        bool found = false;
        EnumConstant result;
        auto status = ffi_->FindEnumConstantImpl(type_name, value_name, found, result);
        if (!status.ok()) {
            return absl::Status(status.code(), status.message());
        }
        if (!found) {
            return absl::nullopt;
        }
        return result;
    }

    virtual absl::StatusOr<absl::optional<StructTypeField>> FindStructTypeFieldByNameImpl(
        absl::string_view type_name,
        absl::string_view field_name
    ) const override {
        bool found = false;
        StructTypeField result(cel::common_internal::BasicStructTypeField("", 0, Type()));
        auto status = ffi_->FindStructTypeFieldByNameImpl(type_name, field_name, found, result);
        if (!status.ok()) {
            return absl::Status(status.code(), status.message());
        }
        if (!found) {
            return absl::nullopt;
        }
        return result;
    }
private:
    Box<AnyFfiTypeReflector> ffi_;
};

std::unique_ptr<TypeReflector> TypeReflector_new(Box<AnyFfiTypeReflector> ffi) {
    return std::make_unique<AnyFfiTypeReflectorWrapper>(std::move(ffi));
}

} // namespace rust::cel_cxx