Enum StepId 

pub enum StepId {
    WithFlow {
        flow: Arc<Flow>,
        index: usize,
    },
    Standalone {
        name: String,
        index: usize,
    },
}

A step identifier that provides access to both the step index and name.

This type has two variants:

• WithFlow: Used during execution when you have access to the flow. More efficient as it doesn’t allocate for the name string.
• Standalone: Used in storage/serialization contexts where the flow isn’t available.

Choosing a Constructor

When you have access to Arc<Flow>, prefer StepId::for_step() as it avoids allocating a string for the step name. Use StepId::new() only when the flow reference is not available (e.g., deserializing from storage).

Note on Flow Lifetime

The WithFlow variant keeps the Arc<Flow> alive. If you need to store a StepId without keeping the flow alive, use StepId::into_standalone() or StepId::to_standalone().

Variants

WithFlow

Step with flow reference - borrows name from flow, no allocation.

Fields

flow: Arc<Flow>

Reference to the flow containing this step.

index: usize

The step index in the workflow.

Standalone

Standalone step - owns the name string.

Fields

name: String

The step name/ID.

index: usize

The step index in the workflow.

Implementations

impl StepId

pub fn for_step(flow: Arc<Flow>, index: usize) -> Self

Create a StepId from a flow reference.

This is the preferred constructor when you have access to Arc<Flow> as it avoids allocating a string for the step name.

pub fn new(name: String, index: usize) -> Self

Create a standalone StepId without a flow reference.

Use this only when the flow reference is not available, such as when deserializing from storage. If you have access to Arc<Flow>, prefer StepId::for_step() instead to avoid the string allocation.

pub fn index(&self) -> usize

Get the step index.

pub fn name(&self) -> &str

Get the step name.

pub fn to_standalone(&self) -> Self

Convert to a standalone StepId, cloning if necessary.

This releases the flow reference if held. Useful when you need to store the StepId without keeping the flow alive, or when serializing.

pub fn into_standalone(self) -> Self

Convert into a standalone StepId, consuming self.

This releases the flow reference if held. More efficient than to_standalone() when you don’t need the original.

pub fn has_flow(&self) -> bool

Returns true if this StepId holds a flow reference.

pub fn flow(&self) -> Option<&Arc<Flow>>

Get the flow reference if this is a WithFlow variant.

Trait Implementations

impl Clone for StepId

fn clone(&self) -> StepId

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StepId

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

Formats the value using the given formatter.

impl Display for StepId

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

Formats the value using the given formatter.

impl Hash for StepId

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for StepId

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for StepId

fn eq(&self, other: &Self) -> 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 PartialOrd for StepId

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for StepId

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 StepId