Struct GraphFlowContext 

pub struct GraphFlowContext {
    pub prev_node: Option<NodeIndex>,
    pub current_node: NodeIndex,
    pub completed_nodes: HashSet<NodeIndex>,
    pub node_task_ids: HashMap<NodeIndex, TaskId>,
    pub current_position: usize,
    pub is_initial: bool,
    pub root_task_id: Option<TaskId>,
}

Metadata stored in each node’s task for workflow processing

Fields

prev_node: Option<NodeIndex>

Previous node executed in the Graph This is the source node that led to the current node’s execution

current_node: NodeIndex

The current node being executed in the Graph

completed_nodes: HashSet<NodeIndex>

All nodes that have been completed in this execution

node_task_ids: HashMap<NodeIndex, TaskId>

Map of node indices to their task IDs for result lookup

current_position: usize

Current position in the topological order

is_initial: bool

Whether this is the initial execution

root_task_id: Option<TaskId>

The original task ID that started this Graph execution

Implementations

impl GraphFlowContext

pub fn new(root_task_id: Option<TaskId>) -> Self

Create initial context for Graph execution

pub fn get_dependency_task_ids( &self, dependencies: &[NodeIndex], ) -> HashMap<NodeIndex, TaskId>

Get task IDs for dependencies of a given node

Trait Implementations

impl Clone for GraphFlowContext

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GraphFlowContext

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

Formats the value using the given formatter.

impl Default for GraphFlowContext

fn default() -> GraphFlowContext

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for GraphFlowContext

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Metadata for GraphFlowContext

type Error = GraphFlowContextError

The error produced when extracting the Metadata

fn extract(map: &MetadataStore) -> Result<Self, Self::Error>

Extract Metadata from the store

fn inject(&self, map: &mut MetadataStore) -> Result<(), GraphFlowContextError>

Inject Self into the store

impl Serialize for GraphFlowContext

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

where __S: Serializer,

Serialize this value into the given Serde serializer.