Struct Dbg 

pub struct Dbg<'a, SS: SubsetSeq + Send + Sync> { /* private fields */ }

A struct supporting de Bruijn graph operations on the spectrum of k-mers encoded in an SbwtIndex. The graph is node-centric, meaning that the nodes are the distinct k-mers in the index (not including the dummy k-mers) and there is an edge from x to y iff x[1..k) = y[0..k-1). Edge (x,y) is labeled with the last character of y. Reverse complements are not modeled. The struct takes 2n bits of extra space on top of the SBWT, where n is the number of sets in the SBWT.

Implementations

impl<'a, SS: SubsetSeq + Send + Sync> Dbg<'a, SS>

pub fn node_iterator(&'a self) -> NodeIterator<'a>

Returns an iterator over all nodes of the de Bruijn graph.

pub fn new( sbwt: &'a SbwtIndex<SS>, lcs: Option<&LcsArray>, n_threads: usize, ) -> Self

where SS: Sync,

Initializes supports for de Bruijn graph operation based on the given SbwtIndex. If the Lcs array of the SBWT is available, it can be given to significantly speed up construction. IMPORTANT: select support must be built before calling this function.

pub fn push_node_kmer(&self, node: Node, buf: &mut Vec<u8>)

Push the k-mer string of the node to the given buffer.

pub fn get_kmer(&self, node: Node) -> Vec<u8>

Get the k-mer string label of a node. To avoid memory allocation, check Dbg::push_node_kmer.

pub fn get_node(&self, kmer: &[u8]) -> Option<Node>

Get a handle to the node corresponding to the given k-mer, if exists in the graph.

pub fn outdegree(&self, node: Node) -> usize

Returns the number of outgoing edges from the given node.

pub fn indegree(&self, node: Node) -> usize

Returns the number of incoming edges to the given node.

pub fn push_out_neighbors(&self, node: Node, output: &mut Vec<(Node, u8)>)

For each outgoing edge from the given node, pushes to the output vector a pair (v, c), where v is the target node and c is the edge label.

pub fn push_in_neighbors(&self, node: Node, output: &mut Vec<(Node, u8)>)

For each incoming edge to the given node, pushes to the output vector a pair (v, c), where v is the source node and c is the edge label. The edge label will be the same for all in-neighbors because it has to be equal to the last character of the destination k-mer.

pub fn get_last_character(&self, node: Node) -> u8

Gets the last character of the k-mer string of the given node.

pub fn has_outlabel(&self, node: Node, edge_label: u8) -> bool

Returns whether the given node has an outgoing edge labeled with edge_label.

pub fn push_outlabels(&self, node: Node, output: &mut Vec<u8>)

Pushes the labels of all outgoing edges from the given node to the output vector.

pub fn follow_outedge(&self, node: Node, edge_label: u8) -> Option<Node>

Follows the outgoing edge labeled with edge_label from the given node. Returns None if the edge does not exist.

pub fn follow_inedge(&self, node: Node, i: usize) -> Option<Node>

Follows backward the incoming edge that comes from the i-th smallest k-mer (i ∈ [0, indegree(node)) in colexicographic order that has an outgoing edge to node. Returns None if i ≥ indegree(node).

pub fn iter_unitigs_with_callback<F: Fn(&[Node]) + Send + Sync>( &self, callback: F, n_threads: usize, )

pub fn parallel_export_unitigs<W: Write + Send + Sync>( &self, fasta_out: W, n_threads: usize, )

Writes the unitigs of the graph to the given writer in FASTA format. Uses as many threads as are available with the Rayon initialization.

pub fn is_first_kmer_of_unitig(&self, v: Node) -> bool

pub fn push_unitig_string(&self, unitig_nodes: &[Node], out: &mut Vec<u8>)

Computes the unitig string for a unitig represented as a sequence of Nodes. You can get this sequence of nodes by calling Dbg::walk_unitig_from with a node for which Dbg::is_first_kmer_of_unitig is true. If the node sequence is not a unitig, then the computed string will be the first k-mer, plus the last character of every following k-mer.

pub fn walk_unitig_from( &self, v: Node, out_labels_buf: &mut Vec<u8>, ) -> Vec<Node>

Returns the sequence of nodes and the label of the unitig The out_labels_buf is working space for the function. Don’t assume anything about its contents when the function returns. If you also want the string label of the unitig, call Dbg::push_unitig_string with the returned Node vector.

pub fn is_dummy_colex_position(&self, pos: usize) -> bool

Trait Implementations

impl<'a, SS: Clone + SubsetSeq + Send + Sync> Clone for Dbg<'a, SS>

fn clone(&self) -> Dbg<'a, SS>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a, SS: Debug + SubsetSeq + Send + Sync> Debug for Dbg<'a, SS>

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

Formats the value using the given formatter.

impl<'a, SS: PartialEq + SubsetSeq + Send + Sync> PartialEq for Dbg<'a, SS>

fn eq(&self, other: &Dbg<'a, SS>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, SS: Eq + SubsetSeq + Send + Sync> Eq for Dbg<'a, SS>

impl<'a, SS: SubsetSeq + Send + Sync> StructuralPartialEq for Dbg<'a, SS>