Enum Edge 

pub enum Edge<S: State> {
    Fixed {
        from: String,
        to: String,
    },
    Conditional {
        from: String,
        router: Arc<dyn Router<S>>,
        path_map: PathMap,
    },
}

Edge in a Juncture graph

Edges define the flow of execution between nodes. Fixed edges always route to the same target, while conditional edges use a router function to determine the target based on the current state.

Examples

use juncture_core::{edge::Edge, State, Node};
use std::sync::Arc;

struct MyState;
impl State for MyState {
    type Update = MyStateUpdate;
}

struct MyStateUpdate;

// Fixed edge: routes from "node_a" to "node_b"
let fixed = Edge::<MyState>::Fixed {
    from: "node_a".to_string(),
    to: "node_b".to_string(),
};

// Conditional edge: routes based on state
let conditional = Edge::<MyState>::Conditional {
    from: "router".to_string(),
    router: Arc::new(|state: &MyState| {
        Box::pin(async move {
            Ok(juncture_core::edge::RouteResult::One("target".to_string()))
        })
    }),
    path_map: PathMap::new(),
};

Variants

Fixed

Fixed edge that always routes to the same target

Fields

from: String

Source node name

to: String

Target node name

Conditional

Conditional edge that routes based on state

Fields

from: String

Source node name

router: Arc<dyn Router<S>>

Router function to determine target

path_map: PathMap

Mapping of router return values to target node names

Trait Implementations

impl<S: Clone + State> Clone for Edge<S>

fn clone(&self) -> Edge<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: State> Debug for Edge<S>

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

Formats the value using the given formatter.