Type Definition traitgraph::walks::VecNodeWalk

pub type VecNodeWalk<Graph> = Vec<<Graph as GraphBase>::NodeIndex>;

A node walk that is represented as a vector of node indices.

Trait Implementations

impl<'a, Graph: GraphBase> NodeWalk<'a, Graph, [<Graph as GraphBase>::NodeIndex]> for VecNodeWalk<Graph> where
    Graph::NodeIndex: 'a, 

fn compute_trivial_heart(&'a self, graph: &Graph) -> Option<(usize, usize)> where
    Graph: StaticGraph, 

Computes the trivial heart of the walk, or returns None if the walk is non-trivial. The heart is returned as the index of the last split node and the index of the first join node of the walk. These are not part of the heart.

fn compute_trivial_heart_node_len(&'a self, graph: &Graph) -> Option<usize> where
    Graph: StaticGraph, 

Compute the amount of nodes in the trivial heart, or returns None if the walk is non-trivial. Recall that a heart is a walk from arc to arc.

fn is_non_trivial(&'a self, graph: &Graph) -> bool where
    Graph: StaticGraph, 

Returns true if this walk is non-trivial.

fn compute_univocal_extension<ResultWalk: From<Vec<Graph::NodeIndex>>>(
    &'a self,
    graph: &Graph
) -> ResultWalk where
    Graph: StaticGraph, 

Computes the univocal extension of this walk. That is the concatenation LWR, where W is the walk, L the longest R-univocal walk to the first node of W and R the longest univocal walk from the last node of W.

fn compute_univocal_extension_non_scc<ResultWalk: From<Vec<Graph::NodeIndex>>>(
    &'a self,
    graph: &Graph
) -> ResultWalk where
    Graph: StaticGraph, 

Computes the univocal extension of this walk. That is the concatenation LWR, where W is the walk, L the longest R-univocal walk to the first node of W and R the longest univocal walk from the last node of W. This method handles not strongly connected graphs by disallowing L and R to repeat nodes.

fn compute_univocal_extension_with_original_offset<ResultWalk: From<Vec<Graph::NodeIndex>>>(
    &'a self,
    graph: &Graph
) -> (usize, ResultWalk) where
    Graph: StaticGraph, 

Computes the univocal extension of this walk. That is the concatenation LWR, where W is the walk, L the longest R-univocal walk to the first node of W and R the longest univocal walk from the last node of W.

fn compute_univocal_extension_with_original_offset_non_scc<ResultWalk: From<Vec<Graph::NodeIndex>>>(
    &'a self,
    graph: &Graph
) -> (usize, ResultWalk) where
    Graph: StaticGraph, 

Computes the univocal extension of this walk. That is the concatenation LWR, where W is the walk, L the longest R-univocal walk to the first node of W and R the longest univocal walk from the last node of W. This method handles not strongly connected graphs by disallowing L and R to repeat nodes.

fn clone_as_edge_walk<ResultWalk: From<Vec<Graph::EdgeIndex>>>(
    &'a self,
    graph: &Graph
) -> Option<ResultWalk> where
    Graph: StaticGraph, 

Returns the edge walk represented by this node walk. If there is a consecutive pair of nodes with a multiedge, then None is returned. If this walk contains less than two nodes, then None is returned. If there is a consecutive pair of node not connected by an edge, then this method panics.

fn is_proper_subwalk_of(&'a self, other: &Self) -> bool where
    Graph::NodeIndex: Eq, 

Returns true if this is a proper subwalk of the given walk. Proper means that the walks are not equal.