Struct Task

pub struct Task<Input: NodeArg, Output: NodeArg> { /* private fields */ }

Implementations

impl<Input: NodeArg + Clone, Output: NodeArg + Clone> Task<Input, Output>

pub fn new() -> Self

pub fn done(&self) -> NodeId<NoopNode<Output>>

pub fn transitions_to_done( &self, ) -> impl Fn(Output) -> MarkedTransitionPayload<NoopNode<Output>> + Send + Sync + 'static

Creates a transition to the done node

pub fn starts_with<T: TaskNode<Input = Input> + Clone + 'static>( &mut self, node_id: NodeId<T>, )

Defines the start node of the task

pub fn validate_transitions(&self) -> Result<(), TaskError>

Validates that all nodes have transitions set

Errors

Errors if a node is missing a transition

pub async fn run( &mut self, input: impl Into<Input>, ) -> Result<Option<Output>, TaskError>

Runs the task with the given input

Errors

Errors if the task fails

pub fn reset(&mut self)

Resets the task to the start node

WARN: This will lead to a type mismatch if the previous context is not the same as the input of the start node

pub async fn resume(&mut self) -> Result<Option<Output>, TaskError>

Resumes the task from the current node

Errors

Errors if the task fails

pub fn current_node<T: TaskNode + 'static>(&self) -> Option<&T>

Gets the current node of the task

pub fn node_at<T: TaskNode + 'static>(&self, node_id: NodeId<T>) -> Option<&T>

Gets the node at the given NodeId

pub fn node_at_index<T: TaskNode + 'static>(&self, index: usize) -> Option<&T>

Gets the node at the given index

pub fn register_node<T>(&mut self, node: T) -> NodeId<T>

where T: TaskNode + 'static + Clone, <T as TaskNode>::Input: Clone, <T as TaskNode>::Output: Clone,

Registers a new node in the task

pub fn register_transition<'a, From, To, F>( &mut self, from: NodeId<From>, transition: F, ) -> Result<(), TaskError>

where From: TaskNode + 'static + ?Sized, To: TaskNode<Input = From::Output> + 'a + ?Sized, F: Fn(To::Input) -> MarkedTransitionPayload<To> + Send + Sync + 'static,

Registers a transition from one node to another

Note that there are various helpers and conversions for the MarkedTransitionPayload

Errors

Errors if the node does not exist

pub fn register_transition_async<'a, From, To, F>( &mut self, from: NodeId<From>, transition: F, ) -> Result<(), TaskError>

where From: TaskNode + 'static + ?Sized, To: TaskNode<Input = From::Output> + 'a + ?Sized, F: Fn(To::Input) -> Pin<Box<dyn Future<Output = MarkedTransitionPayload<To>> + Send>> + Send + Sync + 'static,

Registers a transition from one node to another asynchronously

Note that there are various helpers and conversions for the MarkedTransitionPayload

Errors

Errors if the node does not exist

NOTE: AsyncFn traits’ returned future are not ‘Send’ and the inner type is unstable. When they are, we can update Fn to AsyncFn

Trait Implementations

impl<Input: NodeArg, Output: NodeArg> Clone for Task<Input, Output>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Input: Debug + NodeArg, Output: Debug + NodeArg> Debug for Task<Input, Output>

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

Formats the value using the given formatter.

impl<Input: NodeArg + Clone, Output: NodeArg + Clone> Default for Task<Input, Output>

fn default() -> Self

Returns the “default value” for a type.