Struct TaskDAG 

pub struct TaskDAG { /* private fields */ }

Available on native and crate feature tasks only.

Directed Acyclic Graph for task dependencies

Manages complex task dependencies and provides topological sorting for execution order.

Examples

use reinhardt_tasks::{TaskDAG, TaskId};

let mut dag = TaskDAG::new();
let task_a = TaskId::new();
let task_b = TaskId::new();

dag.add_task(task_a).unwrap();
dag.add_task(task_b).unwrap();
dag.add_dependency(task_b, task_a).unwrap();

let order = dag.topological_sort().unwrap();
assert_eq!(order.len(), 2);

Implementations

impl TaskDAG

pub fn new() -> TaskDAG

Create a new empty task DAG

Examples

use reinhardt_tasks::TaskDAG;

let dag = TaskDAG::new();
assert_eq!(dag.task_count(), 0);

pub fn add_task(&mut self, task_id: TaskId) -> Result<(), TaskError>

Add a task to the DAG

Examples

use reinhardt_tasks::{TaskDAG, TaskId};

let mut dag = TaskDAG::new();
let task_id = TaskId::new();
dag.add_task(task_id).unwrap();
assert_eq!(dag.task_count(), 1);

Errors

Returns an error if the task already exists in the DAG.

pub fn add_dependency( &mut self, task_id: TaskId, depends_on: TaskId, ) -> Result<(), TaskError>

Add a dependency between tasks

task_id depends on depends_on, meaning depends_on must complete before task_id.

Examples

use reinhardt_tasks::{TaskDAG, TaskId};

let mut dag = TaskDAG::new();
let task_a = TaskId::new();
let task_b = TaskId::new();

dag.add_task(task_a).unwrap();
dag.add_task(task_b).unwrap();
dag.add_dependency(task_b, task_a).unwrap();

Errors

Returns an error if:

• Either task doesn’t exist in the DAG
• The dependency would create a cycle

pub fn task_count(&self) -> usize

Get the number of tasks in the DAG

Examples

use reinhardt_tasks::{TaskDAG, TaskId};

let mut dag = TaskDAG::new();
dag.add_task(TaskId::new()).unwrap();
dag.add_task(TaskId::new()).unwrap();
assert_eq!(dag.task_count(), 2);

pub fn get_task(&self, task_id: TaskId) -> Option<&TaskNode>

Get a task node by ID

Examples

use reinhardt_tasks::{TaskDAG, TaskId};

let mut dag = TaskDAG::new();
let task_id = TaskId::new();
dag.add_task(task_id).unwrap();

let node = dag.get_task(task_id);
assert!(node.is_some());

pub fn get_ready_tasks(&self) -> Vec<TaskId>

Get tasks that are ready to execute (all dependencies satisfied)

Examples

use reinhardt_tasks::{TaskDAG, TaskId, TaskNodeStatus};

let mut dag = TaskDAG::new();
let task_a = TaskId::new();
let task_b = TaskId::new();

dag.add_task(task_a).unwrap();
dag.add_task(task_b).unwrap();
dag.add_dependency(task_b, task_a).unwrap();

let ready = dag.get_ready_tasks();
assert_eq!(ready.len(), 1); // Only task_a has no dependencies

pub fn mark_completed(&mut self, task_id: TaskId) -> Result<(), TaskError>

Mark a task as completed

Examples

use reinhardt_tasks::{TaskDAG, TaskId, TaskNodeStatus};

let mut dag = TaskDAG::new();
let task_id = TaskId::new();
dag.add_task(task_id).unwrap();

dag.mark_completed(task_id).unwrap();
assert_eq!(dag.get_task(task_id).unwrap().status(), TaskNodeStatus::Completed);

Errors

Returns an error if the task doesn’t exist in the DAG.

pub fn mark_failed(&mut self, task_id: TaskId) -> Result<(), TaskError>

Mark a task as failed

Examples

use reinhardt_tasks::{TaskDAG, TaskId, TaskNodeStatus};

let mut dag = TaskDAG::new();
let task_id = TaskId::new();
dag.add_task(task_id).unwrap();

dag.mark_failed(task_id).unwrap();
assert_eq!(dag.get_task(task_id).unwrap().status(), TaskNodeStatus::Failed);

Errors

Returns an error if the task doesn’t exist in the DAG.

pub fn mark_running(&mut self, task_id: TaskId) -> Result<(), TaskError>

Mark a task as running

Examples

use reinhardt_tasks::{TaskDAG, TaskId, TaskNodeStatus};

let mut dag = TaskDAG::new();
let task_id = TaskId::new();
dag.add_task(task_id).unwrap();

dag.mark_running(task_id).unwrap();
assert_eq!(dag.get_task(task_id).unwrap().status(), TaskNodeStatus::Running);

Errors

Returns an error if the task doesn’t exist in the DAG.

pub fn topological_sort(&self) -> Result<Vec<TaskId>, TaskError>

Perform topological sort using Kahn’s algorithm

Returns an execution order that respects all dependencies.

Examples

use reinhardt_tasks::{TaskDAG, TaskId};

let mut dag = TaskDAG::new();
let task_a = TaskId::new();
let task_b = TaskId::new();
let task_c = TaskId::new();

dag.add_task(task_a).unwrap();
dag.add_task(task_b).unwrap();
dag.add_task(task_c).unwrap();
dag.add_dependency(task_b, task_a).unwrap();
dag.add_dependency(task_c, task_b).unwrap();

let order = dag.topological_sort().unwrap();
assert_eq!(order.len(), 3);
// task_a must come before task_b, task_b must come before task_c
let a_pos = order.iter().position(|&id| id == task_a).unwrap();
let b_pos = order.iter().position(|&id| id == task_b).unwrap();
let c_pos = order.iter().position(|&id| id == task_c).unwrap();
assert!(a_pos < b_pos);
assert!(b_pos < c_pos);

Errors

Returns an error if the graph contains a cycle.

Trait Implementations

impl Clone for TaskDAG

fn clone(&self) -> TaskDAG

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TaskDAG

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

Formats the value using the given formatter.

impl Default for TaskDAG

fn default() -> TaskDAG

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for TaskDAG

fn deserialize<__D>( __deserializer: __D, ) -> Result<TaskDAG, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for TaskDAG

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

where __S: Serializer,

Serialize this value into the given Serde serializer.