Struct Executor 

pub struct Executor { /* private fields */ }

Executor for running graph nodes in topological order.

Thread Safety

The Executor is NOT thread-safe for concurrent executions on the same instance. While execute() is async and takes &self (shared reference), the underlying implementation assumes single-threaded access patterns:

• self.nodes is a regular HashMap without synchronization
• Multiple concurrent calls to execute() would have data races when accessing nodes

Safe Usage Patterns

1. Single execution at a time: Only call execute() once at a time per executor instance
2. Clone for parallelism: Create separate executor instances for parallel graph executions
3. Sequential async: Use .await to ensure executions don’t overlap

Future Work

For true concurrent execution support, wrap nodes in Arc<RwLock<HashMap>> or similar.

Implementations

impl Executor

pub fn new() -> Self

pub fn with_cache(cache: CacheManager) -> Self

Create a new executor with caching enabled

pub fn set_cache(&mut self, cache: CacheManager)

Enable caching for this executor

pub fn set_fallback_handler(&mut self, handler: FallbackHandler)

Set a global fallback handler used when node execution fails

pub fn cache(&self) -> Option<&CacheManager>

Get the cache manager (if enabled)

pub fn metrics(&self) -> &ExecutionMetrics

Get execution metrics from last run

pub fn reset_metrics(&mut self)

Reset execution metrics

pub fn from_graph_def(def: &GraphDef) -> Result<Self>

Build executor from graph definition

pub fn register_node(&mut self, node: Box<dyn Node>)

Register a node with the executor

pub async fn execute(&mut self, graph: &mut Graph) -> Result<()>

Execute the graph in topological order

Trait Implementations

impl Default for Executor

fn default() -> Self

Returns the “default value” for a type.