Enum NodeOutput 

pub enum NodeOutput<T> {
    SoftFail,
    Ok(T),
}

Represents the outcome of a node execution, with support for soft failures.

Examples

use node_flow::node::NodeOutput;

let success: NodeOutput<i32> = NodeOutput::Ok(42);
let failure: NodeOutput<i32> = NodeOutput::SoftFail;

assert_eq!(success.ok(), Some(42));
assert_eq!(failure.ok(), None);

Variants

SoftFail

Indicates that the node failed in a non-critical way and produced no output.

This is distinct from a hard failure (error) and may simply mean that input conditions were not met.

Ok(T)

Indicates that the node successfully produced a value of type T.

Implementations

impl<T> NodeOutput<T>

pub fn ok(self) -> Option<T>

Converts NodeOutput<T> into an Option<T>.

• Returns Some(T) if the output is NodeOutput::Ok.
• Returns None if the output is NodeOutput::SoftFail.

Examples

use node_flow::node::NodeOutput;

let output = NodeOutput::Ok(5);
assert_eq!(output.ok(), Some(5));

let failed = NodeOutput::<i32>::SoftFail;
assert_eq!(failed.ok(), None);

pub fn ok_or<E>(self, err: E) -> Result<T, E>

Converts NodeOutput<T> into a Result<T, E>, using a provided error value if soft-failed.

• Returns Ok(T) if the output is NodeOutput::Ok.
• Returns Err(err) if the output is NodeOutput::SoftFail.

Errors

Returns the provided err value if the node soft-failed.

Examples

use node_flow::node::NodeOutput;

let ok: Result<i32, &str> = NodeOutput::Ok(42).ok_or("no value");
assert_eq!(ok, Ok(42));

let soft_fail: Result<i32, &str> = NodeOutput::SoftFail.ok_or("no value");
assert_eq!(soft_fail, Err("no value"));

pub fn ok_or_else<E>(self, err: impl Fn() -> E) -> Result<T, E>

Converts NodeOutput<T> into a Result<T, E>, lazily computing the error value if soft-failed.

• Returns Ok(T) if the output is NodeOutput::Ok.
• Calls err() and returns Err(err()) if the output is NodeOutput::SoftFail.

This is the lazy variant of NodeOutput::ok_or, avoiding unnecessary error construction when the node succeeds.

Errors

Calls the provided closure to produce an error if the node soft-failed.

Examples

use node_flow::node::NodeOutput;

let ok: Result<i32, String> = NodeOutput::Ok(10).ok_or_else(|| "soft fail".to_string());
assert_eq!(ok, Ok(10));

let soft_fail: Result<i32, String> = NodeOutput::SoftFail.ok_or_else(|| "soft fail".to_string());
assert_eq!(soft_fail, Err("soft fail".to_string()));

Trait Implementations

impl<T: Debug> Debug for NodeOutput<T>

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

Formats the value using the given formatter.

impl<Input, Error, Context, NodeType, NodeOutput, NodeError> Node<Input, NodeOutput<Input>, Error, Context> for Detached<Input, Error, Context, NodeType, NodeOutput, NodeError>

where NodeType: Node<Input, NodeOutput, NodeError, Context> + Clone + Send + 'static, Context: SpawnAsync + Fork + Send + 'static, Input: Clone + Send + 'static,

fn run( &mut self, input: Input, context: &mut Context, ) -> impl Future<Output = Result<NodeOutput<Input>, Error>> + Send

Runs the node.

fn describe(&self) -> Description

Describes this node, its type signature and other specifics.

impl<Input, Output, Error, Context, InnerData, R> Node<Input, NodeOutput<Output>, Error, Context> for FnFlow<Input, Output, Error, Context, InnerData, R>

where InnerData: Clone, for<'a> R: Runner<'a, Input, Output, Error, Context, InnerData>,

fn run( &mut self, input: Input, context: &mut Context, ) -> impl Future<Output = Result<NodeOutput<Output>, Error>> + Send

Runs the node.

fn describe(&self) -> Description

Describes this node, its type signature and other specifics.

impl<Input, Output, Error, Context, NodeTypes, NodeIOETypes> Node<Input, NodeOutput<Output>, Error, Context> for OneOfParallelFlow<Input, Output, Error, Context, NodeTypes, NodeIOETypes>

where NodeTypes: ChainRun<Input, Result<NodeOutput<Output>, Error>, Context, NodeIOETypes> + ChainDescribe<Context, NodeIOETypes>,

fn run( &mut self, input: Input, context: &mut Context, ) -> impl Future<Output = Result<NodeOutput<Output>, Error>> + Send

Runs the node.

fn describe(&self) -> Description

Describes this node, its type signature and other specifics.

impl<Input, Output, Error, Context, NodeTypes, NodeIOETypes> Node<Input, NodeOutput<Output>, Error, Context> for OneOfSequentialFlow<Input, Output, Error, Context, NodeTypes, NodeIOETypes>

where NodeTypes: ChainRun<Input, Result<NodeOutput<Output>, Error>, Context, NodeIOETypes> + ChainDescribe<Context, NodeIOETypes>,

fn run( &mut self, input: Input, context: &mut Context, ) -> impl Future<Output = Result<NodeOutput<Output>, Error>> + Send

Runs the node.

fn describe(&self) -> Description

Describes this node, its type signature and other specifics.

impl<Input, Output, Error, Context, ChainRunOutput, J, NodeTypes, NodeIOETypes> Node<Input, NodeOutput<Output>, Error, Context> for ParallelFlow<Input, Output, Error, Context, ChainRunOutput, J, NodeTypes, NodeIOETypes>

where Input: Send, Context: Send, for<'a> J: Joiner<'a, ChainRunOutput, Output, Error, Context>, NodeTypes: ChainRun<Input, Result<ChainRunOutput, Error>, Context, NodeIOETypes> + ChainDescribe<Context, NodeIOETypes> + Send + Sync,

fn run( &mut self, input: Input, context: &mut Context, ) -> impl Future<Output = Result<NodeOutput<Output>, Error>> + Send

Runs the node.

fn describe(&self) -> Description

Describes this node, its type signature and other specifics.

impl<Input, Output, Error, Context, NodeTypes, NodeIOETypes> Node<Input, NodeOutput<Output>, Error, Context> for SequentialFlow<Input, Output, Error, Context, NodeTypes, NodeIOETypes>

where NodeTypes: ChainRun<Input, Result<NodeOutput<Output>, Error>, Context, NodeIOETypes> + ChainDescribe<Context, NodeIOETypes>,

fn run( &mut self, input: Input, context: &mut Context, ) -> impl Future<Output = Result<NodeOutput<Output>, Error>> + Send

Runs the node.

fn describe(&self) -> Description

Describes this node, its type signature and other specifics.

impl<T: PartialEq> PartialEq for NodeOutput<T>

fn eq(&self, other: &NodeOutput<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Eq> Eq for NodeOutput<T>

impl<T> StructuralPartialEq for NodeOutput<T>