Struct NodeId 

pub struct NodeId<T: TaskNode + ?Sized> { /* private fields */ }

A typed handle to a registered node in a Task.

NodeId keeps the node’s type information so transitions can be expressed without manual downcasts. Use NodeId::transitions_with for the common linear case, Transition::fan_out when building static fan-out transitions, and NodeId::join for join nodes.

Implementations

impl<T: TaskNode + ?Sized> NodeId<T>

pub fn id(&self) -> usize

Returns the stable numeric identifier assigned when the node was registered.

pub fn transitions_with(&self, context: T::Input) -> MarkedTransition<T>

Builds a typed transition to this node with the provided input.

This is the most ergonomic way to connect one node to the next in a linear task.

Examples

use swiftide_tasks::{NodeError, Task};

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| finish.transitions_with(value))?;

impl<T, Payload> NodeId<T>

where T: TaskNode<Input = JoinInput<Payload>> + ?Sized, Payload: NodeArg,

pub fn join(&self) -> JoinTarget<T, Payload>

Creates a join target that waits for every branch in the fan-out group.

Fan-out branches cannot be independent task endings. To model branches that are conceptually terminal, transition each branch to a join node and finish the task from that join node.

Examples

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

let mut task = Task::<i32, i32>::new();
let start = task.register_node_fn(|input: &i32| -> Result<i32, NodeError> { Ok(*input) });
let branch = task.register_node_fn(|input: &i32| -> Result<i32, NodeError> { Ok(*input + 1) });
let join = task.register_node_fn(|input: &JoinInput<i32>| -> Result<i32, NodeError> {
    Ok(input.iter().copied().sum())
});

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

impl<T> NodeId<T>

where T: TaskNode<Input = AnyJoinInput> + ?Sized,

pub fn join_any(&self) -> AnyJoinTarget<T>

Creates a join target for branches that intentionally contribute mixed payload types.

Prefer NodeId::join with JoinInput<T> when all branches contribute the same payload type.

impl<T: TaskNode + 'static + ?Sized> NodeId<T>

pub fn new(id: usize, _node: &T) -> Self

Creates a typed node identifier for an already-registered node.

Prefer Task::register_node when building normal task graphs. Constructing an id manually is only correct when id refers to a node managed by the caller’s own task-like runtime.

pub fn as_dyn( self, ) -> NodeId<dyn TaskNode<Input = T::Input, Output = T::Output, Error = T::Error>>

Erases the concrete node type while keeping the node’s typed input and output contracts.

Trait Implementations

impl<T: TaskNode + ?Sized> Clone for NodeId<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: TaskNode + ?Sized> Copy for NodeId<T>

impl<T: TaskNode + ?Sized> Debug for NodeId<T>

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

Formats the value using the given formatter.

impl<T: Eq + TaskNode + ?Sized> Eq for NodeId<T>

impl<T: PartialEq + TaskNode + ?Sized> PartialEq for NodeId<T>

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<T: PartialEq + TaskNode + ?Sized> StructuralPartialEq for NodeId<T>