Enum StepStatus 

pub enum StepStatus {
    Success,
    ReadError,
    ProcessorError,
    WriteError,
    Starting,
    Failed,
    Started,
}

Represents the current status of a step execution.

This enum indicates the current state of a step execution, including both success and various failure states. It helps track the step’s progress and identify the cause of any failures.

Examples

use spring_batch_rs::core::step::{StepExecution, StepStatus};

let mut step_execution = StepExecution::new("my-step");
assert_eq!(step_execution.status, StepStatus::Starting);

// After successful execution
step_execution.status = StepStatus::Success;
match step_execution.status {
    StepStatus::Success => println!("Step completed successfully"),
    StepStatus::ReadError => println!("Failed during reading"),
    StepStatus::ProcessorError => println!("Failed during processing"),
    StepStatus::WriteError => println!("Failed during writing"),
    StepStatus::Starting => println!("Step is starting"),
    StepStatus::Failed => println!("Step has failed"),
    StepStatus::Started => println!("Step has started"),
}

Variants

Success

The step executed successfully.

All items were read, processed, and written without errors exceeding configured skip limits. This is the desired end state for a step execution.

ReadError

An error occurred during the read operation.

This indicates that an error occurred while reading items from the source, and the error count exceeded the configured skip limit. The step was terminated due to too many read failures.

ProcessorError

An error occurred during the processing operation.

This indicates that an error occurred while processing items, and the error count exceeded the configured skip limit. The step was terminated due to too many processing failures.

WriteError

An error occurred during the write operation.

This indicates that an error occurred while writing items to the destination, and the error count exceeded the configured skip limit. The step was terminated due to too many write failures.

Starting

The step is starting.

This is the initial state of a step before execution begins. All steps start in this state when first created.

Failed

The step is failed.

This is the final state of a step after execution has failed.

Started

The step is started.

This is the state of a step after execution has started.

Trait Implementations

impl Clone for StepStatus

fn clone(&self) -> StepStatus

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for StepStatus

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for StepStatus

fn eq(&self, other: &StepStatus) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for StepStatus

impl StructuralPartialEq for StepStatus