Struct Transition 

pub struct Transition { /* private fields */ }

Describes how task execution should continue after a node completes.

Most transitions are created either through NodeId::transitions_with for the linear case or Transition::fan_out plus FanOutTransition::join_with for branching. Use Transition::pause and Transition::error when a transition closure needs to control task execution directly.

Examples

use swiftide_tasks::{NodeError, Task, TaskRunOutcome, Transition};

let mut task = Task::<i32, i32>::new();

let start = task.register_node_fn(|input: &i32| -> Result<i32, NodeError> { Ok(*input) });
let left = task.register_node_fn(|input: &i32| -> Result<i32, NodeError> { Ok(*input + 1) });
let right = task.register_node_fn(|input: &i32| -> Result<i32, NodeError> { Ok(*input + 2) });
let join = task.register_node_fn(
    |input: &swiftide_tasks::JoinInput<i32>| -> Result<i32, NodeError> {
        Ok(input.iter().copied().sum())
    },
);

task.starts_with(start);
task.register_transition(start, move |value| {
    Transition::fan_out(&left, value)
        .and(&right, value)
        .join_with(join.join())
        .concurrency_model(swiftide_tasks::ConcurrencyModel::Parallel)
})?;
task.register_transition(left, join.join())?;
task.register_transition(right, join.join())?;
task.register_transition(join, task.transitions_to_finish())?;

assert_eq!(task.run(1).await?, TaskRunOutcome::Completed(5));

Implementations

impl Transition

pub fn next<T: TaskNode + ?Sized>( node_id: &NodeId<T>, context: T::Input, ) -> MarkedTransition<T>

Continues execution at node_id with the provided input.

Examples

use swiftide_tasks::{NodeError, Task, Transition};

let mut task = Task::<i32, i32>::new();
let start = task.register_node_fn(|input: &i32| -> Result<i32, NodeError> { Ok(*input + 1) });
let finish = task.register_node_fn(|input: &i32| -> Result<i32, NodeError> { Ok(*input * 2) });

task.starts_with(start);
task.register_transition(start, move |value| Transition::next(&finish, value))?;

pub fn fan_out<T, Input>( node_id: &NodeId<T>, context: Input, ) -> FanOutTransition

where T: TaskNode + ?Sized, Input: Into<T::Input>,

Builds a fan-out that schedules one or more branches from the current node output.

The returned FanOutTransition must attach an explicit join with FanOutTransition::join_with before it can be returned from a task transition. Branches in that fan-out are joined branches, not independent task endings. To express multiple logical endings, transition each branch to a join node and finish the task from the join node.

Examples

use swiftide_tasks::{NodeError, Task, Transition};

let mut task = Task::<i32, i32>::new();
let start = task.register_node_fn(|input: &i32| -> Result<i32, NodeError> { Ok(*input) });
let left = task.register_node_fn(|input: &i32| -> Result<i32, NodeError> { Ok(*input + 1) });
let right = task.register_node_fn(|input: &i32| -> Result<i32, NodeError> { Ok(*input + 2) });

task.starts_with(start);
let join = task.register_node_fn(
    |input: &swiftide_tasks::JoinInput<i32>| -> Result<i32, NodeError> {
        Ok(input.iter().copied().sum())
    },
);

task.register_transition(start, move |value| {
    Transition::fan_out(&left, value)
        .and(&right, value)
        .join_with(join.join())
})?;

pub fn pause() -> Self

Pauses the current branch.

Examples

use swiftide_tasks::{NodeError, Task, TaskRunOutcome, Transition};

let mut task = Task::<i32, ()>::new();
let start = task.register_node_fn(|input: &i32| -> Result<i32, NodeError> { Ok(*input) });

task.starts_with(start);
task.register_transition(start, |_value| Transition::pause())?;

assert_eq!(task.run(1).await?, TaskRunOutcome::Paused);

pub fn error(error: impl Into<Box<dyn Error + Send + Sync>>) -> Self

Fails the current branch with the provided error.

Examples

use std::io::Error;

use swiftide_tasks::{NodeError, Task, Transition};

let mut task = Task::<i32, i32>::new();
let start = task.register_node_fn(|input: &i32| -> Result<i32, NodeError> { Ok(*input) });

task.starts_with(start);
task.register_transition(start, |_value| Transition::error(Error::other("boom")))?;

assert!(task.run(1).await.is_err());

pub fn concurrency_model(self, concurrency_model: ConcurrencyModel) -> Self

Overrides the concurrency model for work scheduled by this transition.

Trait Implementations

impl Debug for Transition

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

Formats the value using the given formatter.

impl<To: TaskNode + ?Sized> From<MarkedTransition<To>> for Transition

fn from(marked_transition: MarkedTransition<To>) -> Self

Converts to this type from the input type.