Struct omnitigs::unitigs::NodeUnitig

pub struct NodeUnitig<Graph: GraphBase> { /* fields omitted */ }

A unitig stored as sequence of nodes.

Implementations

impl<Graph: GraphBase> NodeUnitig<Graph>

pub fn new(
    walk: VecNodeWalk<Graph>,
    single_edge: Option<Graph::EdgeIndex>
) -> Self

Creates a new unitig from the given walk. Panics if the walk has length two nodes but no single edge is given, or if a single edge is given but the walk has a length other than two nodes.

pub fn single_edge(&self) -> &Option<Graph::EdgeIndex>

Returns the single edge field of this unitig. The field is Some if this unitig has exactly two nodes. In this case, the two nodes might be connected by multiple edges, so then this field serves as disambiguation between the edges.

pub fn into_node_walk(self) -> VecNodeWalk<Graph>

Extracts the node walk from this unitig, consuming the unitig. Note that the information for unitigs of length two with a multiedge is lost.

Trait Implementations

impl<Graph: Clone + GraphBase> Clone for NodeUnitig<Graph> where
    Graph::EdgeIndex: Clone, 

fn clone(&self) -> NodeUnitig<Graph>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Graph: GraphBase> Debug for NodeUnitig<Graph> where
    Graph::NodeIndex: Debug, 

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

Formats the value using the given formatter.

impl<Graph: GraphBase> Eq for NodeUnitig<Graph> where
    Graph::NodeIndex: Eq,
    Graph::EdgeIndex: Eq, 

impl<Graph: GraphBase, IndexType> Index<IndexType> for NodeUnitig<Graph> where
    VecNodeWalk<Graph>: Index<IndexType>, 

type Output = <VecNodeWalk<Graph> as Index<IndexType>>::Output

The returned type after indexing.

fn index(&self, index: IndexType) -> &Self::Output

Performs the indexing (container[index]) operation.

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

pub 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.

pub 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.

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

Returns true if this walk is non-trivial.

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

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.

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

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.

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

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.

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

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.

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

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.

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

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

impl<Graph: GraphBase> PartialEq<NodeUnitig<Graph>> for NodeUnitig<Graph> where
    Graph::NodeIndex: PartialEq,
    Graph::EdgeIndex: PartialEq, 

fn eq(&self, rhs: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]

pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, Graph: GraphBase> Sequence<'a, <Graph as GraphBase>::NodeIndex, [<Graph as GraphBase>::NodeIndex]> for NodeUnitig<Graph> where
    Graph::NodeIndex: 'a, 

type Iterator = Iter<'a, Graph::NodeIndex>

The iterator type of the sequence.

fn iter(&'a self) -> Self::Iterator

Returns an iterator over the sequence.

fn len(&self) -> usize

Returns the length of the sequence.

pub fn prefix(&'a self, len: usize) -> &'a Subsequence

Returns a prefix with length len of this sequence. Panics if len >= self.len().

pub fn suffix(&'a self, len: usize) -> &'a Subsequence

Returns a suffix with length len of this sequence. Panics if len >= self.len().

pub fn is_empty(&self) -> bool

Returns true if the sequence is empty.

pub fn first(&'a self) -> Option<&'a Item>

Returns the first item of the sequence.

pub fn last(&'a self) -> Option<&'a Item>

Returns the last item of the sequence.

pub fn is_proper_subsequence_of(&'a self, other: &Self) -> bool where
    Item: Eq, 

Returns true if this is a proper subsequence of the given sequence. Proper means that the sequences are not equal.

pub fn contains(&'a self, item: &Item) -> bool where
    Item: Eq, 

Returns true if this sequence contains the given item.

pub fn forward_merge_iter_assume_mergeable(
    &'a self,
    suffix: &'a Self
) -> Chain<Self::Iterator, Skip<Self::Iterator>> where
    Item: Eq, 

Returns an iterator over this sequence merged before the given other sequence under the assumption that the sequences can be merged this way. A merge is possible if a non-empty suffix of this sequence equals a non-empty prefix of the other sequence.

pub fn backward_merge_iter_assume_mergeable(
    &'a self,
    suffix: &'a Self
) -> Chain<Self::Iterator, Skip<Self::Iterator>> where
    Item: Eq, 

Returns an iterator over this sequence merged after the given other sequence under the assumption that the sequences can be merged this way. A merge is possible if a non-empty prefix of this sequence equals a non-empty suffix of the other sequence.

pub fn to_debug_string(&'a self) -> String where
    Item: Debug, 

Converts the sequence to a string using the debug formatting of the items.

impl<'a, Graph: 'a + GraphBase> Sequence<'a, NodeUnitig<Graph>, [NodeUnitig<Graph>]> for NodeUnitigs<Graph> where
    Graph::NodeIndex: 'a, 

type Iterator = Iter<'a, NodeUnitig<Graph>>

The iterator type of the sequence.

fn iter(&'a self) -> Self::Iterator

Returns an iterator over the sequence.

fn len(&self) -> usize

Returns the length of the sequence.

pub fn prefix(&'a self, len: usize) -> &'a Subsequence

Returns a prefix with length len of this sequence. Panics if len >= self.len().

pub fn suffix(&'a self, len: usize) -> &'a Subsequence

Returns a suffix with length len of this sequence. Panics if len >= self.len().

pub fn is_empty(&self) -> bool

Returns true if the sequence is empty.

pub fn first(&'a self) -> Option<&'a Item>

Returns the first item of the sequence.

pub fn last(&'a self) -> Option<&'a Item>

Returns the last item of the sequence.

pub fn is_proper_subsequence_of(&'a self, other: &Self) -> bool where
    Item: Eq, 

Returns true if this is a proper subsequence of the given sequence. Proper means that the sequences are not equal.

pub fn contains(&'a self, item: &Item) -> bool where
    Item: Eq, 

Returns true if this sequence contains the given item.

pub fn forward_merge_iter_assume_mergeable(
    &'a self,
    suffix: &'a Self
) -> Chain<Self::Iterator, Skip<Self::Iterator>> where
    Item: Eq, 

Returns an iterator over this sequence merged before the given other sequence under the assumption that the sequences can be merged this way. A merge is possible if a non-empty suffix of this sequence equals a non-empty prefix of the other sequence.

pub fn backward_merge_iter_assume_mergeable(
    &'a self,
    suffix: &'a Self
) -> Chain<Self::Iterator, Skip<Self::Iterator>> where
    Item: Eq, 

Returns an iterator over this sequence merged after the given other sequence under the assumption that the sequences can be merged this way. A merge is possible if a non-empty prefix of this sequence equals a non-empty suffix of the other sequence.

pub fn to_debug_string(&'a self) -> String where
    Item: Debug, 

Converts the sequence to a string using the debug formatting of the items.