qubit_dcl::double_checked::execution_context

Struct ExecutionContext

pub struct ExecutionContext<T, E>where
    E: Display,
{ /* private fields */ }

Expand description

Execution context (state after task execution)

This type provides result retrieval functionality after task execution.

Prepare lifecycle callbacks are configured on super::DoubleCheckedLockExecutor and are already applied before an ExecutionContext is returned. Task closures are responsible for their own rollback, cleanup, and commit logic.

§Type Parameters

T - The type of the task return value
E - The type of the task error

§Author

Haixing Hu

Implementations§

Source §

impl<T, E> ExecutionContext<T, E>
where E: Display,

Source

pub fn get_result(self) -> ExecutionResult<T, E>

Gets the execution result (consumes the context)

Prepare commit or rollback callbacks have already been executed by the builder before this context was created. This method does not trigger additional side effects.

§Returns

The owned ExecutionResult stored in this context.

Examples found in repository ?

examples/double_checked_lock_executor_demo.rs (line 63)

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}