Struct omnitigs::unitigs::EdgeUnitig

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

A unitig stored as sequence of edges.

Implementations

impl<Graph: GraphBase> EdgeUnitig<Graph>

pub fn new(walk: VecEdgeWalk<Graph>) -> Self

Creates a new unitig from the given walk. Panics if the walk is empty.

Trait Implementations

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

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

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

Formats the value using the given formatter.

impl<'a, Graph: GraphBase> EdgeWalk<'a, Graph, [<Graph as GraphBase>::EdgeIndex]> for EdgeUnitig<Graph> where
    Graph::EdgeIndex: '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 arc and the index of the first join arc of the walk.

pub fn compute_trivial_heart_edge_len(&'a self, graph: &Graph) -> Option<usize> where
    Graph: StaticGraph, 

Compute the amount of edges 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>::EdgeIndex, Global>>, 

Compute the univocal extension of a walk. That is the concatenation LWR, where W is the walk, L the longest R-univocal walk to the first edge of W and R the longest univocal walk from the last edge of W.

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

Compute the univocal extension of a walk. That is the concatenation LWR, where W is the walk, L the longest R-univocal walk to the first edge of W and R the longest univocal walk from the last edge of W. This variant handles not strongly connected graphs by forbidding L and R to repeat edges.

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

Compute the univocal extension of a walk. That is the concatenation LWR, where W is the walk, L the longest R-univocal walk to the first edge of W and R the longest univocal walk from the last edge 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>::EdgeIndex, Global>>, 

Compute the univocal extension of a walk. That is the concatenation LWR, where W is the walk, L the longest R-univocal walk to the first edge of W and R the longest univocal walk from the last edge of W. This variant handles not strongly connected graphs by forbidding L and R to repeat edges.

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

Returns the node walk represented by this edge walk. If this walk contains no edge, then None is returned. If there is a consecutive pair of edges not connected by a node, then this method panics.

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

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

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

Returns true if this is a valid circular walk in the given graph.

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

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

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

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

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