Struct omnitigs::macrotigs::microtigs::Microtigs

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

A structure containing microtigs of a graph.

Since we do not compress our graph, the bivalent edges that cause a microtig to end might be paths. To make connecting microtigs simpler, we therefore define a maximal microtig as ending and starting with the last edge of a bivalent path.

Implementations

impl<Graph: GraphBase> Microtigs<Graph>

pub fn new_with_statistics(macronodes_without_microtig_amount: usize) -> Self

Creates a new empty Microtigs struct.

pub fn from_vec_with_statistics(
    microtigs: Vec<VecEdgeWalk<Graph>>,
    macronodes_without_microtig_amount: usize
) -> Self

Creates a new Microtigs struct with the given vector of microtigs.

pub fn macronodes_without_microtig_amount(&self) -> usize

Returns the amount of macronodes without microtigs that were found while computing this set of microtigs.

Trait Implementations

impl<Graph: Clone + GraphBase> Clone for Microtigs<Graph>

fn clone(&self) -> Microtigs<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 Microtigs<Graph> where
    Graph::NodeIndex: Debug, 

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

Formats the value using the given formatter.

impl<Graph: GraphBase> Eq for Microtigs<Graph> where
    Graph::EdgeIndex: Eq, 

impl<Graph: GraphBase> From<Vec<Vec<<Graph as GraphBase>::EdgeIndex, Global>, Global>> for Microtigs<Graph>

fn from(microtigs: Vec<VecEdgeWalk<Graph>>) -> Self

Performs the conversion.

impl<Graph: GraphBase, IndexType> Index<IndexType> for Microtigs<Graph> where
    Vec<VecEdgeWalk<Graph>>: Index<IndexType>, 

type Output = <Vec<VecEdgeWalk<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> PartialEq<Microtigs<Graph>> for Microtigs<Graph> where
    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: 'a + GraphBase> Sequence<'a, Vec<<Graph as GraphBase>::EdgeIndex, Global>, [Vec<<Graph as GraphBase>::EdgeIndex, Global>]> for Microtigs<Graph>

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