Enum NextAction 

pub enum NextAction {
    Continue,
    ContinueAndExecute,
    GoTo(String),
    GoBack,
    End,
    WaitForInput,
}

Defines what should happen after a task completes.

This enum controls the flow of execution in your workflow graph. Different variants provide different execution behaviors.

Examples

use graph_flow::{NextAction, TaskResult};

// Step-by-step execution (pause after this task)
let result = TaskResult::new(
    Some("Step 1 complete".to_string()),
    NextAction::Continue
);

// Continuous execution (run next task immediately)
let result = TaskResult::new(
    Some("Processing...".to_string()),
    NextAction::ContinueAndExecute
);

// Wait for user input
let result = TaskResult::new(
    Some("Please provide more information".to_string()),
    NextAction::WaitForInput
);

// Jump to specific task
let result = TaskResult::new(
    Some("Redirecting to error handler".to_string()),
    NextAction::GoTo("error_handler".to_string())
);

// End the workflow
let result = TaskResult::new(
    Some("Workflow completed!".to_string()),
    NextAction::End
);

Variants

Continue

Continue to the next task in the default path (step-by-step execution).

The workflow will pause after this task and wait for the next execution call. This gives you control over when the next task runs.

Best for: Interactive applications, web services, debugging

ContinueAndExecute

Continue to the next task and execute it immediately (continuous execution).

The workflow will automatically proceed to the next task without pausing. This creates a recursive execution until the workflow reaches End, WaitForInput, or an error.

Best for: Batch processing, automated workflows

GoTo(String)

Go to a specific task by ID.

Jump directly to the specified task, skipping the normal edge-based flow. Useful for error handling, loops, or dynamic routing.

Examples

// Jump to error handler
let result = TaskResult::new(
    Some("Error detected, routing to handler".to_string()),
    NextAction::GoTo("error_handler".to_string())
);

// Create a retry loop
let result = TaskResult::new(
    Some("Retrying...".to_string()),
    NextAction::GoTo("validation_task".to_string())
);

GoBack

Go back to the previous task.

Note: This currently stays at the current task. Full back navigation logic may be implemented in future versions.

End

End the graph execution.

Terminates the workflow completely. No further tasks will be executed.

WaitForInput

Wait for user input before continuing.

Pauses the workflow and waits for external input. The workflow will stay at the current task until new data is provided and execution is resumed.

Best for: Human-in-the-loop workflows, interactive applications

Trait Implementations

impl Clone for NextAction

fn clone(&self) -> NextAction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NextAction

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for NextAction

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for NextAction

fn eq(&self, other: &NextAction) -> 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 Serialize for NextAction

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for NextAction

impl StructuralPartialEq for NextAction