qubit_dcl::double_checked::executor_lock_builder

Struct ExecutorLockBuilder

pub struct ExecutorLockBuilder<L, T> { /* private fields */ }

Expand description

Builder state after a lock has been attached.

Call Self::when to configure the required condition tester.

§Type Parameters

L - The lock type implementing Lock<T>.
T - The data type protected by the lock.

§Author

Haixing Hu

Implementations§

Source §

impl<L, T> ExecutorLockBuilder<L, T>
where L: Lock<T>,

Source

pub fn log_unmet_condition( self, level: Level, message: impl Into<String>, ) -> Self

Configures logging when the double-checked condition is not met.

Source

pub fn log_prepare_failure( self, level: Level, message_prefix: impl Into<String>, ) -> Self

Configures logging when the prepare action fails.

Source

pub fn log_prepare_commit_failure( self, level: Level, message_prefix: impl Into<String>, ) -> Self

Configures logging when the prepare commit action fails.

Source

pub fn log_prepare_rollback_failure( self, level: Level, message_prefix: impl Into<String>, ) -> Self

Configures logging when the prepare rollback action fails.

Source

pub fn when<Tst>(self, tester: Tst) -> ExecutorReadyBuilder<L, T>
where Tst: Tester + Send + Sync + 'static,

Configures the required double-checked condition.

The tester is executed outside and inside the lock. State read by the outside check must be safe to access without this executor’s lock.

§Parameters

tester - The reusable condition tester.

§Returns

The builder state that can configure prepare callbacks and build the executor.

Examples found in repository ?

examples/double_checked_lock_executor_demo.rs (lines 51-54)

38fn main() -> Result<(), Box<dyn std::error::Error>> {
39    // Create shared state
40    let running = Arc::new(AtomicBool::new(false));
41    let data = ArcMutex::new(42);
42
43    println!(
44        "Initial state: running = {}",
45        running.load(Ordering::Acquire)
46    );
47    println!("Initial data: {}", data.read(|d| *d));
48
49    let executor = DoubleCheckedLockExecutor::builder()
50        .on(data.clone())
51        .when({
52            let running = running.clone();
53            move || running.load(Ordering::Acquire)
54        })
55        .build();
56
57    // Try to execute when service is not running (should fail)
58    let result = executor
59        .call_with(|value: &mut i32| {
60            *value += 1;
61            Ok::<_, ServiceError>(*value)
62        })
63        .get_result();
64
65    if result.is_success() {
66        println!("Unexpected success: {}", result.unwrap());
67    } else {
68        println!("Expected failure: Condition not met.");
69    }
70
71    // Start the service
72    running.store(true, Ordering::Release);
73    println!(
74        "Service started: running = {}",
75        running.load(Ordering::Acquire)
76    );
77
78    // Now execute should succeed
79    let result = executor
80        .call_with(|value: &mut i32| {
81            *value += 1;
82            Ok::<_, ServiceError>(*value)
83        })
84        .get_result();
85
86    if result.is_success() {
87        println!("Success: new value = {}", result.unwrap());
88    } else {
89        println!("Unexpected failure: {:?}", result);
90    }
91
92    // Verify the data was updated
93    println!("Final data: {}", data.read(|d| *d));
94
95    // Stop the service
96    running.store(false, Ordering::Release);
97    println!(
98        "Service stopped: running = {}",
99        running.load(Ordering::Acquire)
100    );
101
102    // Try to execute when service is stopped (should fail)
103    let result = executor
104        .call_with(|value: &mut i32| {
105            *value += 1;
106            Ok::<_, ServiceError>(*value)
107        })
108        .get_result();
109
110    if result.is_success() {
111        println!("Unexpected success: {}", result.unwrap());
112    } else {
113        println!("Expected failure: Condition not met.");
114    }
115
116    Ok(())
117}