Struct EdgeNode 

pub struct EdgeNode {
    pub type_: EdgeNodeKind,
    pub sources: MolIds,
    pub targets: MolIds,
    pub label: Option<Label>,
    pub edge_routing: Option<EdgeRouting>,
    pub role: Option<String>,
    pub arrow: EdgeArrow,
    pub color: Option<String>,
    pub stroke_width: Option<f64>,
    pub dashed: bool,
}

Edge node — a reaction / network link between mol ids.

Self::sources / Self::targets are one or many mol ids (A+B → C+D). Label chrome refs sibling text/mol nodes via Self::label.

Fields

type_: EdgeNodeKind

Wire discriminant — required so untagged Node does not absorb edges as mols.

sources: MolIds

Reactant mol id(s) — "a" or ["a","b"] (alias: source).

targets: MolIds

Product mol id(s) — "c" or ["c","d"] (alias: target).

label: Option<Label>

Label chrome: id / list / {id, pos?} / {above,below,left,right}.

Hosts should measure each placement’s text (or mol viewport) and pass those boxes to the layout engine with the placement pos (edge side).

edge_routing: Option<EdgeRouting>

Per-edge override of scheme LayoutOpts::edge_routing.

role: Option<String>

Optional semantic role (e.g. enzyme) — not drawn by default.

arrow: EdgeArrow

color: Option<String>

stroke_width: Option<f64>

dashed: bool

Implementations

impl EdgeNode

pub fn edge_routing_or(&self, scheme: &LayoutOpts) -> EdgeRouting

Effective shaft routing: edge override, else scheme layout default.

Trait Implementations

impl Clone for EdgeNode

fn clone(&self) -> EdgeNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EdgeNode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EdgeNode

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for EdgeNode

fn eq(&self, other: &EdgeNode) -> 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 Serialize for EdgeNode

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for EdgeNode