Struct omnitigs::unitigs::NodeUnitigs

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

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>, Global> 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<<NodeUnitigs<Graph> as IntoIterator>::Item, Global>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<Graph: GraphBase> Sequence<NodeUnitig<Graph>, [NodeUnitig<Graph>]> for NodeUnitigs<Graph>

type Iterator<'a> = Iter<'a, NodeUnitig<Graph>> where Self: 'a

The iterator type of the sequence.

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

Returns an iterator over the sequence.

fn len(&self) -> usize

Returns the length of the sequence.

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

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

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

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

fn is_empty(&self) -> bool

Returns true if the sequence is empty.

fn first(&self) -> Option<&Item>

Returns the first item of the sequence.

fn last(&self) -> Option<&Item>

Returns the last item of the sequence.

fn is_proper_subsequence_of(&self, other: &Self) -> boolwhere Item: Eq,

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

fn contains(&self, item: &Item) -> boolwhere Item: Eq,

Returns true if this sequence contains the given item.

fn forward_merge_iter_assume_mergeable<'a>( &'a self, suffix: &'a Self ) -> Chain<Self::Iterator<'a>, Skip<Self::Iterator<'a>>>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.

fn backward_merge_iter_assume_mergeable<'a>( &'a self, suffix: &'a Self ) -> Chain<Self::Iterator<'a>, Skip<Self::Iterator<'a>>>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.

fn to_debug_string(&self) -> Stringwhere Item: Debug,

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