Trait traitgraph::walks::NodeWalk[−][src]

pub trait NodeWalk<'a, Graph: GraphBase, NodeSubwalk: NodeWalk<'a, Graph, NodeSubwalk> + ?Sized>: Sequence<'a, Graph::NodeIndex, NodeSubwalk> where
    Graph::NodeIndex: 'a, {
    fn compute_trivial_heart(&'a self, graph: &Graph) -> Option<(usize, usize)>
    where
        Graph: StaticGraph,
    { ... }

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

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

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

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

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

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

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

    fn is_proper_subwalk_of(&'a self, other: &Self) -> bool
    where
        Graph::NodeIndex: Eq,
    { ... }
}
Expand description

A sequence of nodes in a graph, where each consecutive pair of nodes is connected by an edge.

Provided methods

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.

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.

Returns true if this walk is non-trivial.

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.

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.

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.

Additionally to the univocal extension, this function returns the offset of the original walk in the univocal extension as usize.

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.

Additionally to the univocal extension, this function returns the offset of the original walk in the univocal extension as usize.

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.

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

Implementations on Foreign Types

Implementors