Struct Edge 

pub struct Edge<E> {
    pub source: Uuid,
    pub target: Uuid,
    pub edge_type: E,
    pub direction: EdgeDirection,
    pub weight: Option<f32>,
    pub created_at: DateTime<Utc>,
    pub archived_at: Option<DateTime<Utc>>,
}

A weighted, typed edge between two nodes

Generic over edge type E to support different relationship types (e.g., CardEdgeType::Blocks, CardEdgeType::RelatesTo, etc.)

Fields

source: Uuid

Source node identifier

target: Uuid

Target node identifier

edge_type: E

Type of relationship (e.g., Blocks, RelatesTo)

direction: EdgeDirection

Direction of the edge

weight: Option<f32>

Optional weight for weighted graph algorithms

created_at: DateTime<Utc>

When this edge was created

archived_at: Option<DateTime<Utc>>

When this edge was archived (None = active)

Implementations

impl<E> Edge<E>

pub fn new( source: Uuid, target: Uuid, edge_type: E, direction: EdgeDirection, ) -> Self

Create a new edge

pub fn is_archived(&self) -> bool

Check if this edge is archived

pub fn is_active(&self) -> bool

Check if this edge is active (not archived)

pub fn archive(&mut self)

Archive this edge

pub fn unarchive(&mut self)

Unarchive this edge

pub fn involves(&self, node_id: Uuid) -> bool

Check if this edge involves a given node (source or target)

pub fn connects(&self, node_a: Uuid, node_b: Uuid) -> bool

Check if this edge connects two specific nodes (in either direction for bidirectional)

Trait Implementations

impl<E: Clone> Clone for Edge<E>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E: Debug> Debug for Edge<E>

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

Formats the value using the given formatter.

impl<'de, E> Deserialize<'de> for Edge<E>

where E: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<E> Serialize for Edge<E>

where E: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.