cel-cxx 0.2.5

A high-performance, type-safe Rust interface for Common Expression Language (CEL), build on top of cel-cpp with zero-cost FFI bindings via cxx
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
141
142
143
144
145

//! Asynchronous runtime support for CEL.
//!
//! This module provides support for asynchronous evaluation of CEL expressions
//! using the [async-std](https://github.com/async-rs/async-std) or
//! [tokio](https://github.com/tokio-rs/tokio) runtimes.
//!
//! # Features
//! - `async-std`: Enables asynchronous evaluation of CEL expressions using
//!   [async-std](https://github.com/async-rs/async-std).
//! - `tokio`: Enables asynchronous evaluation of CEL expressions using
//!   [tokio](https://github.com/tokio-rs/tokio).
//!

use async_scoped::spawner::{Blocker, FuncSpawner, Spawner};
use futures::Future;

pub(crate) mod abort;

/// Runtime trait for CEL asynchronous runtime.
pub trait Runtime: 'static {
    /// Scoped spawner for CEL asynchronous runtime.
    type ScopedSpawner: Spawner<()>
        + FuncSpawner<(), SpawnHandle = <Self::ScopedSpawner as Spawner<()>>::SpawnHandle>
        + Blocker
        + Default
        + Send
        + Sync
        + 'static;

    /// Blocking runner for CEL asynchronous runtime.
    type BlockingRunner: BlockingRunner;
}

/// Blocking runner trait for CEL asynchronous runtime.
pub trait BlockingRunner: 'static {
    /// Block on a future.
    fn block_on<F: Future>(fut: F) -> F::Output;
}

/// Tokio runtime for CEL asynchronous runtime.
#[cfg(feature = "tokio")]
#[cfg_attr(docsrs, doc(cfg(feature = "tokio")))]
#[allow(missing_debug_implementations)]
pub enum Tokio {}

/// Tokio runtime implementation.
#[cfg(feature = "tokio")]
#[cfg_attr(docsrs, doc(cfg(feature = "tokio")))]
pub mod tokio {
    #![allow(missing_debug_implementations)]
    use super::*;

    impl Runtime for Tokio {
        type ScopedSpawner = async_scoped::spawner::use_tokio::Tokio;
        type BlockingRunner = TokioBlockingRunner;
    }

    /// Tokio blocking runner for CEL asynchronous runtime.
    pub struct TokioBlockingRunner;
    impl BlockingRunner for TokioBlockingRunner {
        fn block_on<F: Future>(fut: F) -> F::Output {
            ::tokio::runtime::Handle::current().block_on(fut)
        }
    }
}

/// Async-std runtime for CEL asynchronous runtime.
#[cfg(feature = "async-std")]
#[cfg_attr(docsrs, doc(cfg(feature = "async-std")))]
#[allow(missing_debug_implementations)]
pub enum AsyncStd {}

/// Async-std runtime implementation.
#[cfg(feature = "async-std")]
#[cfg_attr(docsrs, doc(cfg(feature = "async-std")))]
pub mod async_std {
    #![allow(missing_debug_implementations)]
    use super::*;

    impl Runtime for AsyncStd {
        type ScopedSpawner = async_scoped::spawner::use_async_std::AsyncStd;
        type BlockingRunner = AsyncStdBlockingRunner;
    }

    /// Async-std blocking runner for CEL asynchronous runtime.
    pub struct AsyncStdBlockingRunner;
    impl BlockingRunner for AsyncStdBlockingRunner {
        fn block_on<F: Future>(fut: F) -> F::Output {
            ::async_std::task::block_on(fut)
        }
    }
}

/// Smol runtime for CEL asynchronous runtime.
#[cfg(feature = "smol")]
#[cfg_attr(docsrs, doc(cfg(feature = "smol")))]
#[allow(missing_debug_implementations)]
pub enum Smol {}

/// Smol runtime for CEL asynchronous runtime.
#[cfg(feature = "smol")]
#[cfg_attr(docsrs, doc(cfg(feature = "smol")))]
pub mod smol {
    #![allow(missing_debug_implementations)]
    use super::*;

    impl Runtime for Smol {
        type ScopedSpawner = SmolScopedSpawner;
        type BlockingRunner = SmolBlockingRunner;
    }

    /// Smol scoped spawner for CEL asynchronous runtime.
    #[derive(Default)]
    #[allow(missing_debug_implementations)]
    pub struct SmolScopedSpawner;
    unsafe impl<T: Send + 'static> Spawner<T> for SmolScopedSpawner {
        type FutureOutput = T;
        type SpawnHandle = ::smol::Task<T>;

        fn spawn<F: Future<Output = T> + Send + 'static>(&self, f: F) -> Self::SpawnHandle {
            ::smol::spawn(f)
        }
    }
    unsafe impl<T: Send + 'static> FuncSpawner<T> for SmolScopedSpawner {
        type FutureOutput = T;
        type SpawnHandle = ::smol::Task<T>;

        fn spawn_func<F: FnOnce() -> T + Send + 'static>(&self, f: F) -> Self::SpawnHandle {
            ::smol::unblock(f)
        }
    }
    unsafe impl Blocker for SmolScopedSpawner {
        fn block_on<T, F: Future<Output = T>>(&self, f: F) -> T {
            ::smol::block_on(f)
        }
    }

    /// Smol blocking runner for CEL asynchronous runtime.
    pub struct SmolBlockingRunner;
    impl BlockingRunner for SmolBlockingRunner {
        fn block_on<F: Future>(fut: F) -> F::Output {
            ::smol::block_on(fut)
        }
    }
}