Struct Edge 

pub struct Edge<W = ()> {
    pub source: NodeId,
    pub target: NodeId,
    pub weight: W,
}

A directed edge from source to target carrying a weight of type W.

For unweighted graphs use W = () (the default). For weighted graphs use any numeric type, most commonly f64.

Examples

use graph_core::{Edge, NodeId};

let u = NodeId::new(0);
let v = NodeId::new(1);

// Weighted edge
let weighted = Edge::new(u, v, 3.5_f64);
assert_eq!(weighted.weight, 3.5);

// Unweighted edge (weight = ())
let unweighted: Edge<()> = Edge::new(u, v, ());
assert_eq!(unweighted.source, u);
assert_eq!(unweighted.target, v);

Fields

source: NodeId

The node this edge originates from.

target: NodeId

The node this edge points to.

weight: W

The edge weight. Use () for unweighted graphs.

Implementations

impl<W> Edge<W>

pub fn new(source: NodeId, target: NodeId, weight: W) -> Edge<W>

Creates a new directed edge.

Examples

use graph_core::{Edge, NodeId};

let e = Edge::new(NodeId::new(0), NodeId::new(1), 2.0_f64);
assert_eq!(e.weight, 2.0);

pub fn is_self_loop(&self) -> bool

Returns true if this is a self-loop (source == target).

Examples

use graph_core::{Edge, NodeId};

let looped = Edge::new(NodeId::new(3), NodeId::new(3), ());
assert!(looped.is_self_loop());

let normal = Edge::new(NodeId::new(0), NodeId::new(1), ());
assert!(!normal.is_self_loop());

pub fn reversed(self) -> Edge<W>

where W: Clone,

Returns the reversed edge (source and target swapped, weight unchanged).

Examples

use graph_core::{Edge, NodeId};

let e = Edge::new(NodeId::new(0), NodeId::new(1), 5u32);
let r = e.reversed();
assert_eq!(r.source, NodeId::new(1));
assert_eq!(r.target, NodeId::new(0));
assert_eq!(r.weight, 5);

Trait Implementations

impl<W> Clone for Edge<W>

where W: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<W> Debug for Edge<W>

where W: Debug,

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

Formats the value using the given formatter.

impl<W> PartialEq for Edge<W>

where W: PartialEq,

fn eq(&self, other: &Edge<W>) -> 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<W> StructuralPartialEq for Edge<W>