Struct EdgeStore 

pub struct EdgeStore<E> { /* private fields */ }

Generic edge-list container over any E: Edge.

Stores edges as a flat list for efficient serialization. Exposes only kind-agnostic operations: anything that depends on direction or per-kind matching semantics (e.g. “is this an undirected edge between a and b in either order?”) lives on the sub-graph type that wraps EdgeStore.

E: Edge lets node-level cascade ops (archive_node, unarchive_node, remove_node) and traversal queries (outgoing, incoming, adjacency_list) work without knowing E’s concrete metadata. The graph machinery is reusable across any kanban-domain or external kind that satisfies the trait.

Implementations

impl<E> EdgeStore<E>

pub fn new() -> Self

Create an empty edge store.

pub fn retain<F: FnMut(&E) -> bool>(&mut self, f: F)

Retain only edges matching f. The kind-aware remove_directed_edge / remove_undirected_edge helpers below build on this; sub-graphs that need other matching semantics can call retain directly.

pub fn edges(&self) -> &[E]

Borrow every edge (active + archived).

pub fn edge_count(&self) -> usize

Total edge count (active + archived).

impl<E: Edge> EdgeStore<E>

pub fn remove_node(&mut self, node_id: E::NodeId)

Remove every edge involving node (hard-delete cascade).

pub fn archive_node(&mut self, node_id: E::NodeId)

Archive every edge involving node (soft-delete cascade).

pub fn unarchive_node(&mut self, node_id: E::NodeId)

Unarchive every edge involving node.

pub fn remove_directed_edge( &mut self, source: E::NodeId, target: E::NodeId, ) -> bool

Remove the single active edge whose source == source and target == target exactly (directed-graph semantics). Archived edges with the same endpoints are preserved — they’re history, not part of the current view, and a remove of the current edge must not silently destroy the history record. Returns true iff an active edge was removed.

pub fn remove_undirected_edge(&mut self, a: E::NodeId, b: E::NodeId) -> bool

Remove any active edge whose endpoints are {a, b} regardless of ordering (undirected-graph semantics). Archived edges are preserved. Returns true iff at least one active edge was removed.

pub fn outgoing(&self, node_id: E::NodeId) -> impl Iterator<Item = &E>

Iterate every outgoing edge from node (source == node).

pub fn incoming(&self, node_id: E::NodeId) -> impl Iterator<Item = &E>

Iterate every incoming edge to node (target == node).

pub fn outgoing_active(&self, node_id: E::NodeId) -> impl Iterator<Item = &E>

Iterate active outgoing edges from node.

pub fn incoming_active(&self, node_id: E::NodeId) -> impl Iterator<Item = &E>

Iterate active incoming edges to node.

pub fn active_edges(&self) -> impl Iterator<Item = &E>

Iterate every active edge.

pub fn adjacency_list(&self) -> HashMap<E::NodeId, Vec<E::NodeId>>

Active-edge directed adjacency list: source -> [target]. Sub-graphs that need a different view (e.g. undirected neighbours) build their own from active_edges.

pub fn active_edge_count(&self) -> usize

Active-edge count.

pub fn would_create_cycle(&self, source: E::NodeId, target: E::NodeId) -> bool

Would adding source -> target create a cycle in the active directed adjacency?

pub fn has_cycle(&self) -> bool

Does the active directed adjacency contain any cycle?

pub fn reachable_from(&self, start: E::NodeId) -> HashSet<E::NodeId>

Set of nodes reachable from start via the active directed adjacency.

Trait Implementations

impl<E: Clone> Clone for EdgeStore<E>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E: Debug> Debug for EdgeStore<E>

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

Formats the value using the given formatter.

impl<E> Default for EdgeStore<E>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, E> Deserialize<'de> for EdgeStore<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: PartialEq> PartialEq for EdgeStore<E>

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

impl<E> StructuralPartialEq for EdgeStore<E>