Struct DagGraph 

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

Directed acyclic graph generic over any E: Edge.

Rejects self-references and any edge whose insertion would create a cycle in the active-edge subgraph. Wraps an EdgeStore<E> to inherit archive / unarchive semantics for soft-delete cascades.

Deserialize runs the DAG invariants against the active subset of loaded edges; a corrupted file with a cycle or self-reference fails to load up front rather than silently rehydrating into an invariant-violating state.

The graph machinery is fully generic: external code can instantiate DagGraph<MyEdge> for any MyEdge: Edge without needing to modify this crate. The kanban-domain DependencyGraph uses three concrete instantiations (DagGraph<SpawnsEdge> / DagGraph<BlocksEdge> / etc.) but the machinery itself is open for extension.

Implementations

impl<E: Edge> DagGraph<E>

pub fn new() -> Self

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

Borrow the raw underlying edge list (active + archived). Persistence layers use this to serialise; size and membership queries go through the EdgeSet trait surface.

pub fn add_edge_with_metadata(&mut self, edge: E) -> Result<(), GraphError>

Push an edge while preserving caller-supplied metadata.

Runs the same self-reference, duplicate, and cycle invariants as the trait’s Graph::add_edge:

• self-references are rejected always;
• active duplicates (an existing active source -> target) are rejected always; the duplicate check ignores archived edges so re-adding after archive succeeds;
• cycles are rejected when the edge is active, ignored when it is archived (archived edges are not part of the active DAG and don’t constrain new mutations).

Load paths use this to rehydrate stored edges and surface corrupt-DAG state as a hard load failure.

pub fn descendants(&self, node: E::NodeId) -> Vec<E::NodeId>

Transitive successors of node (descendants).

pub fn ancestors(&self, node: E::NodeId) -> Vec<E::NodeId>

Transitive predecessors of node (ancestors).

Trait Implementations

impl<E: Edge> Cascadable for DagGraph<E>

fn archive_node(&mut self, node: E::NodeId)

Archive every edge involving node (soft delete).

fn unarchive_node(&mut self, node: E::NodeId)

Unarchive every edge involving node.

fn remove_node(&mut self, node: E::NodeId)

Remove every edge involving node (hard delete).

impl<E: Clone> Clone for DagGraph<E>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E: Debug> Debug for DagGraph<E>

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

Formats the value using the given formatter.

impl<E> Default for DagGraph<E>

fn default() -> Self

Returns the “default value” for a type.

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

where E: Edge + Clone + Deserialize<'de>,

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl<E: Edge> Directed for DagGraph<E>

fn outgoing(&self, node: E::NodeId) -> Vec<E::NodeId>

fn incoming(&self, node: E::NodeId) -> Vec<E::NodeId>

impl<E: Edge> EdgeSet for DagGraph<E>

fn contains(&self, a: E::NodeId, b: E::NodeId) -> bool

Directed active-only membership: source-to-target ordering matters. Aligned with Graph::contains_edge.

fn contains_archived(&self, a: E::NodeId, b: E::NodeId) -> bool

Directed any-state membership including archived edges.

fn len(&self) -> usize

Total edge count (active + archived).

fn active_len(&self) -> usize

Active edge count only.

fn is_empty(&self) -> bool

True iff this set has no active edges. Archived edges, if any, are not counted: a graph whose entire active set has been archived reports is_empty() == true, matching what callers asking “anything here right now?” expect.

impl<E: Edge> Graph for DagGraph<E>

type NodeId = <E as Edge>::NodeId

fn add_edge(&mut self, from: E::NodeId, to: E::NodeId) -> Result<(), GraphError>

Add an edge from -> to. Returns GraphError::Cycle / GraphError::SelfReference when the implementation rejects.

fn remove_edge( &mut self, from: E::NodeId, to: E::NodeId, ) -> Result<(), GraphError>

Remove the edge from -> to. Returns GraphError::EdgeNotFound if no such edge exists.

fn contains_edge(&self, from: E::NodeId, to: E::NodeId) -> bool

True iff an edge from -> to is present.

impl<E: PartialEq> PartialEq for DagGraph<E>

fn eq(&self, other: &DagGraph<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 DagGraph<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 DagGraph<E>