featureflag 0.0.3

Runtime feature flagging for Rust
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
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166

use std::{
    borrow::Cow,
    cell::{OnceCell, RefCell},
    fmt,
    panic::{AssertUnwindSafe, catch_unwind, resume_unwind},
    sync::OnceLock,
};

use crate::evaluator::{Evaluator, EvaluatorRef};

static GLOBAL_EVALUATOR: OnceLock<EvaluatorRef> = OnceLock::new();

thread_local! {
    static THREAD_EVALUATOR: OnceCell<EvaluatorRef> = const { OnceCell::new() };

    static TASK_EVALUATOR: RefCell<Option<EvaluatorRef>> = const { RefCell::new(None) };
}

/// Set the global evaluator.
///
/// # Panics
///
/// Panics if the global evaluator is already set.
/// For a non-panicking version, use [`try_set_global_default`].
pub fn set_global_default<E: Evaluator + Send + Sync + 'static>(evaluator: E) {
    try_set_global_default(evaluator).expect("failed to set global default");
}

/// Set the global evaluator.
///
/// # Errors
///
/// Returns an error if the global evaluator is already set.
pub fn try_set_global_default<E: Evaluator + Send + Sync + 'static>(
    evaluator: E,
) -> Result<(), SetGlobalDefaultError> {
    let mut initialized = false;

    GLOBAL_EVALUATOR.get_or_init(|| {
        initialized = true;
        evaluator.into_ref()
    });

    if initialized {
        Ok(())
    } else {
        Err(SetGlobalDefaultError { _private: () })
    }
}

/// Set the thread evaluator.
///
/// This function overrides the global evaluator set by [`set_global_default`].
///
/// # Panics
///
/// Panics if the thread evaluator is already set.
/// For a non-panicking version, use [`try_set_thread_default`].
pub fn set_thread_default<E: Evaluator + Send + Sync + 'static>(evaluator: E) {
    try_set_thread_default(evaluator).expect("failed to set thread default");
}

/// Set the thread evaluator.
///
/// This function overrides the global evaluator set by [`set_global_default`].
///
/// # Errors
///
/// Returns an error if the thread evaluator is already set.
pub fn try_set_thread_default<E: Evaluator + Send + Sync + 'static>(
    evaluator: E,
) -> Result<(), SetThreadDefaultError> {
    THREAD_EVALUATOR.with(|cell| {
        let mut initialized = false;

        cell.get_or_init(|| {
            initialized = true;
            evaluator.into_ref()
        });

        if initialized {
            Ok(())
        } else {
            Err(SetThreadDefaultError { _private: () })
        }
    })
}

/// Set the evaluator inside the given closure.
///
/// This function overrides the thread evaluator set by [`set_global_default`]
/// and [`set_thread_default`].
pub fn with_default<E: Evaluator + Send + Sync + 'static, F: FnOnce() -> R, R>(
    evaluator: E,
    f: F,
) -> R {
    evaluator.on_registration();
    with_default_no_registration(evaluator.into_ref(), f)
}

/// Set the evaluator inside the given closure, without calling
/// [`Evaluator::on_registration`].
pub(crate) fn with_default_no_registration<F: FnOnce() -> R, R>(
    evaluator: EvaluatorRef,
    f: F,
) -> R {
    let old_thread_evaluator = TASK_EVALUATOR.replace(Some(evaluator));

    let result = catch_unwind(AssertUnwindSafe(f));

    TASK_EVALUATOR.set(old_thread_evaluator);

    match result {
        Ok(result) => result,
        Err(payload) => resume_unwind(payload),
    }
}

/// Get the default evaluator currently in scope.
///
/// This function will use the first of the following:
/// 1. The evaluator set by [`with_default`].
/// 2. The evaluator set by [`set_thread_default`].
/// 3. The evaluator set by [`set_global_default`].
pub fn get_default<F: FnOnce(Option<&EvaluatorRef>) -> R, R>(f: F) -> R {
    let evaluator = TASK_EVALUATOR
        .with_borrow(|evaluator| evaluator.clone().map(Cow::Owned))
        .or_else(|| THREAD_EVALUATOR.with(|cell| cell.get().cloned().map(Cow::Owned)))
        .or_else(|| GLOBAL_EVALUATOR.get().map(Cow::Borrowed));

    f(evaluator.as_deref())
}

/// Error returned when trying to set the global evaluator
/// when one is already set.
///
/// This error is returned by [`try_set_global_default`].
#[derive(Debug)]
pub struct SetGlobalDefaultError {
    _private: (),
}

impl fmt::Display for SetGlobalDefaultError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str("global evaluator already set")
    }
}

impl std::error::Error for SetGlobalDefaultError {}

/// Error returned when trying to set the thread evaluator
/// when one is already set.
///
/// This error is returned by [`try_set_thread_default`].
#[derive(Debug)]
pub struct SetThreadDefaultError {
    _private: (),
}

impl fmt::Display for SetThreadDefaultError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str("thread evaluator already set")
    }
}

impl std::error::Error for SetThreadDefaultError {}