Struct omnitigs::unitigs::EdgeUnitigs

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

A structure storing a vector of edge-centric unitigs.

Implementations

impl<Graph: StaticGraph> EdgeUnitigs<Graph>

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

Computes the maximal unitigs of a graph.

The unitigs are computed edge-centric.

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

pub fn sort_by_len_descending(&mut self)

Sorts the unitigs by length descending.

impl<Graph: StaticEdgeCentricBigraph> EdgeUnitigs<Graph> where
    Graph::EdgeData: BidirectedData + Eq, 

pub fn remove_reverse_complements(&mut self, graph: &Graph)

Retains only one direction of each pair of reverse-complemental unitigs.

Trait Implementations

impl<Graph: GraphBase> Debug for EdgeUnitigs<Graph> where
    Graph::EdgeIndex: Debug, 

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

Formats the value using the given formatter.

impl<Graph: GraphBase, IndexType> Index<IndexType> for EdgeUnitigs<Graph> where
    Vec<EdgeUnitig<Graph>>: Index<IndexType>, 

type Output = <Vec<EdgeUnitig<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 EdgeUnitigs<Graph>

type Item = EdgeUnitig<Graph>

The type of the elements being iterated over.

type IntoIter = IntoIter<EdgeUnitig<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, EdgeUnitig<Graph>, [EdgeUnitig<Graph>]> for EdgeUnitigs<Graph> where
    Graph::EdgeIndex: 'a, 

type Iterator = Iter<'a, EdgeUnitig<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.