Struct omnitigs::unitigs::NodeUnitigs

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

A structure storing a vector of node-centric unitigs.

Implementations

impl<Graph: StaticGraph> NodeUnitigs<Graph>

pub fn compute(graph: &Graph) -> Self

Computes the maximal unitigs of a graph.

The unitigs are computed both node- and edge-centric. That means that parallel edges are counted as separate unitig each, and bivalent nodes are counted as unitigs as well.

If the graph is a cycle, it outputs an arbitrary subwalk.

Trait Implementations

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

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

Formats the value using the given formatter.

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

type Output = <Vec<NodeUnitig<Graph>> as Index<IndexType>>::Output

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<Graph: GraphBase> IntoIterator for NodeUnitigs<Graph>

type Item = NodeUnitig<Graph>

The type of the elements being iterated over.

type IntoIter = IntoIter<NodeUnitig<Graph>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

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.