Struct ExecutionContext 

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

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

Implementations

impl<T, E> ExecutionContext<T, E>

where E: Display,

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 54)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create shared state
    let running = Arc::new(AtomicBool::new(false));
    let data = ArcMutex::new(42);

    println!(
        "Initial state: running = {}",
        running.load(Ordering::Acquire)
    );
    println!("Initial data: {}", data.read(|d| *d));

    let executor = DoubleCheckedLockExecutor::builder()
        .on(data.clone())
        .when({
            let running = running.clone();
            move || running.load(Ordering::Acquire)
        })
        .build();

    // Try to execute when service is not running (should fail)
    let result = executor
        .call_with(|value: &mut i32| {
            *value += 1;
            Ok::<_, std::io::Error>(*value)
        })
        .get_result();

    if result.is_success() {
        println!("Unexpected success: {}", result.unwrap());
    } else {
        println!("Expected failure: Condition not met.");
    }

    // Start the service
    running.store(true, Ordering::Release);
    println!(
        "Service started: running = {}",
        running.load(Ordering::Acquire)
    );

    // Now execute should succeed
    let result = executor
        .call_with(|value: &mut i32| {
            *value += 1;
            Ok::<_, std::io::Error>(*value)
        })
        .get_result();

    if result.is_success() {
        println!("Success: new value = {}", result.unwrap());
    } else {
        println!("Unexpected failure: {:?}", result);
    }

    // Verify the data was updated
    println!("Final data: {}", data.read(|d| *d));

    // Stop the service
    running.store(false, Ordering::Release);
    println!(
        "Service stopped: running = {}",
        running.load(Ordering::Acquire)
    );

    // Try to execute when service is stopped (should fail)
    let result = executor
        .call_with(|value: &mut i32| {
            *value += 1;
            Ok::<_, std::io::Error>(*value)
        })
        .get_result();

    if result.is_success() {
        println!("Unexpected success: {}", result.unwrap());
    } else {
        println!("Expected failure: Condition not met.");
    }

    Ok(())
}

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

Checks the execution result (does not consume the context)

Returns

A shared reference to the stored ExecutionResult.

pub fn is_success(&self) -> bool

Checks if execution was successful

Returns

true if the stored result is ExecutionResult::Success.

impl<E> ExecutionContext<(), E>

where E: Display,

pub fn finish(self) -> bool

Completes execution (for operations without return values)

Returns whether the execution was successful. This convenience method intentionally collapses both unmet conditions and execution failures to false; use Self::try_finish when the failure details must be preserved.

Returns

true if the stored result is ExecutionResult::Success containing ().

pub fn try_finish(self) -> Result<bool, ExecutorError<E>>

Completes execution while preserving failure details.

Returns

• Ok(true) - Execution succeeded with ().
• Ok(false) - The double-checked condition was not met.
• Err(ExecutorError<E>) - Execution failed, preserving the original executor error.

Errors

Returns the stored ExecutorError when the underlying result is ExecutionResult::Failed.