Enum ExecutionResult

Source

pub enum ExecutionResult<T, E> {
    Success(T),
    ConditionNotMet,
    Failed(ExecutorError<E>),
}

Expand description

Task execution result

Represents the result of executing a task using an enum to clearly distinguish between success, unmet conditions, and failure.

§Type Parameters

T - The type of the return value when execution succeeds
E - The type of the error when execution fails

§Examples

use qubit_dcl::double_checked::{ExecutionResult, ExecutorError};

let success: ExecutionResult<i32, String> = ExecutionResult::success(42);
if let ExecutionResult::Success(val) = success {
    println!("Value: {}", val);
}

let unmet: ExecutionResult<i32, String> = ExecutionResult::unmet();

let failed: ExecutionResult<i32, String> =
    ExecutionResult::task_failed("Task failed".to_string());

Variants§

§

Success(T)

Execution succeeded with a value

§

ConditionNotMet

Double-checked locking condition was not met

§

Failed(ExecutorError<E>)

Execution failed with an error

Implementations§

Source §

impl<T, E> ExecutionResult<T, E>

Source

pub fn success(value: T) -> Self

Builds ExecutionResult::Success with value.

§Parameters

value - Successful task value.

§Returns

A success result containing value.

Source

pub fn unmet() -> Self

Builds ExecutionResult::ConditionNotMet.

§Returns

A result representing a failed double-check condition.

Source

pub fn task_failed(err: E) -> Self

Builds a failed result with ExecutorError::TaskFailed.

§Parameters

err - Error returned by the executed task.

§Returns

A failed result wrapping the task error.

Source

pub fn prepare_failed(msg: impl Display) -> Self

Builds a failed result with ExecutorError::PrepareFailed.

Accepts any std::fmt::Display value (including std::error::Error and String); the message is stored in a CallbackError wrapper.

§Parameters

msg - Prepare error message or displayable error value.

§Returns

A failed result containing the prepare failure message.

Source

pub fn prepare_commit_failed(msg: impl Display) -> Self

Builds a failed result with ExecutorError::PrepareCommitFailed.

§Parameters

msg - Commit error message or displayable error value.

§Returns

A failed result containing the prepare-commit failure message.

Source

pub fn prepare_commit_failed_with_callback_type( callback_type: &'static str, msg: impl Display, ) -> Self

Builds a failed result with ExecutorError::PrepareCommitFailed and explicit callback type metadata.

The callback type can later be read from ExecutorError::callback_type.

§Parameters

callback_type - Callback type tag, e.g. "prepare_commit".
msg - Commit error message or displayable error value.

§Returns

A failed result containing the typed prepare-commit failure message.

Source

pub fn prepare_failed_with_callback_type( callback_type: &'static str, msg: impl Display, ) -> Self

Builds a failed result with ExecutorError::PrepareFailed and explicit callback type metadata.

The callback type can later be read from ExecutorError::callback_type.

§Parameters

callback_type - Callback type tag, e.g. "prepare".
msg - Failure message.

§Returns

A failed result containing the typed prepare failure message.

Source

pub fn prepare_rollback_failed( original: impl Display, rollback: impl Display, ) -> Self

Builds a failed result with ExecutorError::PrepareRollbackFailed.

§Parameters

original - Original failure that triggered prepare rollback.
rollback - Failure produced by the rollback action.

§Returns

A failed result containing both original and rollback messages.

Source

pub fn prepare_rollback_failed_with_callback_type( rollback_callback_type: &'static str, original: impl Display, rollback: impl Display, ) -> Self

Builds a failed result with ExecutorError::PrepareRollbackFailed and explicit callback type metadata for the rollback action.

The rollback callback type can later be read from ExecutorError::callback_type.

§Parameters

rollback_callback_type - Callback type tag, e.g. "prepare_rollback".
original - Original failure that triggered prepare rollback.
rollback - Failure produced by the rollback action.

§Returns

A failed result containing both original and typed rollback messages.

Source

pub fn from_executor_error(err: ExecutorError<E>) -> Self

Wraps an arbitrary ExecutorError as ExecutionResult::Failed.

§Parameters

err - Executor error to store in the failed result.

§Returns

A failed result containing err.

Source

pub fn is_success(&self) -> bool

Checks if the execution was successful.

§Returns

true if this result is ExecutionResult::Success.

Examples found in repository ?

examples/double_checked_lock_executor_demo.rs (line 56)

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

Source

pub fn is_unmet(&self) -> bool

Checks if the condition was not met.

§Returns

true if this result is ExecutionResult::ConditionNotMet.

Source

pub fn is_failed(&self) -> bool

Checks if the execution failed.

§Returns

true if this result is ExecutionResult::Failed.

Source

pub fn into_result(self) -> Result<Option<T>, ExecutorError<E>>

Converts the result to a standard Result

§Returns

Ok(Some(T)) - If execution was successful
Ok(None) - If condition was not met
Err(ExecutorError<E>) - If execution failed

§Errors

Returns the stored ExecutorError when this value is ExecutionResult::Failed.

Source §

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

Source

pub fn unwrap(self) -> T

Unwraps the success value, panicking if not successful

§Returns

The success value stored in ExecutionResult::Success.

§Panics

Panics if this result is ExecutionResult::ConditionNotMet or ExecutionResult::Failed.

Examples found in repository ?

examples/double_checked_lock_executor_demo.rs (line 57)

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