Struct FlowExecutor 

pub struct FlowExecutor<H> {
    pub handler: Arc<H>,
}

Generic executor shell — holds the handler, provides cancel/fail helpers.

Generated files wrap this with a newtype and add the unique execute_step():

pub struct OrderProcessingFlowExecutor<H: OrderProcessingStepHandler>(FlowExecutor<H>);

impl<H: OrderProcessingStepHandler> OrderProcessingFlowExecutor<H> {
    pub fn new(handler: Arc<H>) -> Self { Self(FlowExecutor::new(handler)) }
    pub fn handler(&self) -> &Arc<H> { &self.0.handler }

    pub async fn execute_step(&self, instance: &mut OrderProcessingFlowInstance)
        -> Result<(), FlowError> { /* unique dispatch */ }

    pub async fn start(&self, id: impl Into<String>)
        -> Result<OrderProcessingFlowInstance, FlowError> { self.0.start(id) }

    pub async fn run(&self, instance: &mut OrderProcessingFlowInstance)
        -> Result<(), FlowError> {
        while !instance.is_complete() && instance.status != FlowStatus::Waiting {
            self.execute_step(instance).await?;
        }
        Ok(())
    }

    pub fn cancel(&self, instance: &mut OrderProcessingFlowInstance) {
        self.0.cancel(instance);
    }
    pub fn fail(&self, instance: &mut OrderProcessingFlowInstance, error: impl Into<String>) {
        self.0.fail(instance, error);
    }
}

Fields

handler: Arc<H>

Implementations

impl<H: Send + Sync + 'static> FlowExecutor<H>

pub fn new(handler: Arc<H>) -> Self

pub fn start<S>(&self, id: impl Into<String>, first_step: S) -> FlowInstance<S>

where S: Debug + Clone + Serialize + DeserializeOwned,

Start a new flow instance at a given step.

pub fn cancel<S>(&self, instance: &mut FlowInstance<S>)

where S: Debug + Clone + Serialize + DeserializeOwned,

Cancel the flow instance.

pub fn fail<S>(&self, instance: &mut FlowInstance<S>, error: impl Into<String>)

where S: Debug + Clone + Serialize + DeserializeOwned,

Mark the flow instance as failed with a message.