Struct handlegraph::hashgraph::HashGraph

pub struct HashGraph {
    pub max_id: NodeId,
    pub min_id: NodeId,
    pub graph: FnvHashMap<NodeId, Node>,
    pub path_id: FnvHashMap<Vec<u8>, PathId>,
    pub paths: FnvHashMap<PathId, Path>,
}

A handlegraph implementation using HashMap to represent the graph topology and nodes, and each path as a Vec of nodes.

Fields

max_id: NodeId

min_id: NodeId

graph: FnvHashMap<NodeId, Node>

path_id: FnvHashMap<Vec<u8>, PathId>

paths: FnvHashMap<PathId, Path>

Implementations

impl HashGraph

pub fn new() -> HashGraph

pub fn from_gfa<T: OptFields>(gfa: &GFA<usize, T>) -> HashGraph

pub fn print_path(&self, path_id: &PathId)

pub fn print_occurrences(&self)

pub fn get_node(&self, node_id: &NodeId) -> Option<&Node>

pub fn get_node_unchecked(&self, node_id: &NodeId) -> &Node

pub fn get_node_mut(&mut self, node_id: &NodeId) -> Option<&mut Node>

pub fn get_path(&self, path_id: &PathId) -> Option<&Path>

pub fn get_path_unchecked(&self, path_id: &PathId) -> &Path

Trait Implementations

impl AdditiveHandleGraph for HashGraph

pub fn append_handle(&mut self, sequence: &[u8]) -> Handle

Add a node with the provided sequence to the graph, letting the graph pick the node ID.

pub fn create_handle<T: Into<NodeId>>(
    &mut self,
    seq: &[u8],
    node_id: T
) -> Handle

Add a node with the provided sequence and ID to the graph.

pub fn create_edge(&mut self, Edge: Edge)

Insert an edge into the graph. Implementations may panic if both handles of the edge do not already exist.

impl Debug for HashGraph

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

Formats the value using the given formatter.

impl Default for HashGraph

pub fn default() -> HashGraph

Returns the "default value" for a type.

impl<'a> GraphPathNames for &'a HashGraph

type PathName = Copied<Iter<'a, u8>>

The iterator on the name of a path.

pub fn get_path_id(self, name: &[u8]) -> Option<PathId>

Returns the PathId that the provided name points to, if there exists a path with that name.

pub fn get_path_name(self, id: PathId) -> Option<Self::PathName>

Returns an iterator that produced the name of the path id, if that path exists in the graph.

pub fn get_path_name_vec(self, id: PathId) -> Option<Vec<u8>>

Convenience method for retrieving a path name as a Vec<u8>.

pub fn has_path(self, name: &[u8]) -> bool

Convenience method for checking whether a path exists by name.

impl GraphPaths for HashGraph

type StepIx = StepIx

pub fn path_count(&self) -> usize

Return the number of paths in this graph.

pub fn path_len(&self, id: PathId) -> Option<usize>

Return the number of steps of the path id, if it exists.

pub fn path_circular(&self, id: PathId) -> Option<bool>

Return the circularity of the path id, if it exists.

pub fn path_handle_at_step(
    &self,
    id: PathId,
    index: Self::StepIx
) -> Option<Handle>

Find the handle at step index in path id, if both the path exists, and the step in the path.

pub fn path_first_step(&self, id: PathId) -> Option<Self::StepIx>

Return the index to the first step of path id, if the path exists and is not empty.

pub fn path_last_step(&self, id: PathId) -> Option<Self::StepIx>

Return the index to the last step of path id, if the path exists and is not empty.

pub fn path_next_step(
    &self,
    id: PathId,
    step: Self::StepIx
) -> Option<Self::StepIx>

Return the index to the step after index on path id, if the path exists and index both exists on the path, and is not the last step of the path.

pub fn path_prev_step(
    &self,
    id: PathId,
    step: Self::StepIx
) -> Option<Self::StepIx>

Return the index to the step before index on path id, if the path exists and index both exists on the path, and is not the first step of the path.

impl<'a> GraphPathsRef for &'a HashGraph

type PathRef = &'a Path

pub fn get_path_ref(self, id: PathId) -> Option<&'a Path>

impl HandleGraph for HashGraph

pub fn min_node_id(&self) -> NodeId

Return the minimum NodeId that exists in the graph.

pub fn max_node_id(&self) -> NodeId

Return the maximum NodeId that exists in the graph.

pub fn node_count(&self) -> usize

Return the number of nodes in the graph.

pub fn edge_count(&self) -> usize

Return the number of edges in the graph.

pub fn total_length(&self) -> usize

Returns the sum of the sequence lengths of all nodes in the graph.

impl<'a> IntoEdges for &'a HashGraph

type Edges = EdgesIter<&'a HashGraph>

The iterator through all the edges in the graph.

pub fn edges(self) -> Self::Edges

Return an iterator that produces each of the edges in the graph.

impl<'a> IntoHandles for &'a HashGraph

type Handles = NodeIdRefHandles<'a, Keys<'a, NodeId, Node>>

The iterator through all of the graph's handles.

pub fn handles(self) -> Self::Handles

Return an iterator on all the handles in the graph.

pub fn has_node<I: Into<NodeId>>(self, n_id: I) -> bool

Returns true if the node node_id exists in the graph. The default implementation uses any on the iterator from Self::handles.

impl<'a> IntoHandlesPar for &'a HashGraph

type HandlesPar = IterBridge<NodeIdRefHandles<'a, Keys<'a, NodeId, Node>>>

The Rayon ParallelIterator through all the handles in the graph.

pub fn handles_par(self) -> Self::HandlesPar

Return a parallel iterator on all the handles in the graph.

impl<'a> IntoNeighbors for &'a HashGraph

type Neighbors = NeighborIter<'a, Iter<'a, Handle>>

pub fn neighbors(self, handle: Handle, dir: Direction) -> Self::Neighbors

Return an iterator of the Handles adjacent to the given handle, in the provided Direction. Implementations should take the orientation of handle into account.

pub fn degree(self, handle: Handle, dir: Direction) -> usize

Return the number of neighbors of handle in the given direction. The default implementation uses count on Self::neighbors.

pub fn has_edge(self, left: Handle, right: Handle) -> bool

Returns true if the left handle has a connection on its right-hand side to the right handle. The default implementation uses any on Self::neighbors.

impl<'a> IntoNodeOccurrences for &'a HashGraph

type Occurrences = OccurIter<'a>

An iterator through the steps on a path, by PathId and StepIx.

pub fn steps_on_handle(self, handle: Handle) -> Option<Self::Occurrences>

impl<'a> IntoPathIds for &'a HashGraph

type PathIds = Copied<Keys<'a, PathId, Path>>

pub fn path_ids(self) -> Self::PathIds

impl<'a> IntoSequences for &'a HashGraph

type Sequence = SequenceIter<Copied<Iter<'a, u8>>>

pub fn sequence(self, handle: Handle) -> Self::Sequence

Return an iterator on the bases of the sequence of handle. Implementations should take the orientation of handle into account, and produce the reverse complement of the sequence when appropriate.

pub fn sequence_vec(self, handle: Handle) -> Vec<u8>

Returns the sequence of the provided handle as an owned Vec<u8>. This is a convenience method that calls collect on Self::sequence, so the default implementation should be fine for all use cases.

pub fn node_len(self, handle: Handle) -> usize

Returns the sequence length of the node at handle. The default implementation uses count on Self::sequence, implementors may wish to change that.

pub fn subsequence(self, handle: Handle, start: usize, len: usize) -> Vec<u8>

Returns the subsequence of the provided handle, with the given offset start and length len, as an owned Vec<u8>. This is a convenience method that uses Self::sequence, skip, take, and collect.

pub fn base(self, handle: Handle, index: usize) -> Option<u8>

Returns the base at position index of the sequence of the provided handle, if it exists. This is a convenience method that uses Self::sequence and nth.

impl MutableGraphPaths for HashGraph

pub fn create_path(&mut self, name: &[u8], circular: bool) -> Option<PathId>

Create a new path with the given name and return its PathId. Returns None if the path already exists in the graph.

pub fn destroy_path(&mut self, id: PathId) -> bool

Destroy the path with the given id. Returns true if the path was destroyed, false if the path did not exist or couldn't be destroyed.

pub fn path_append_step(
    &mut self,
    id: PathId,
    handle: Handle
) -> Option<Self::StepIx>

Append a step on the given handle to the end of path id, if the path exists. Returns the index of the new step.

pub fn path_prepend_step(
    &mut self,
    id: PathId,
    handle: Handle
) -> Option<Self::StepIx>

Prepend a step on the given handle to the beginning of path id, if the path exists. Returns the index of the new step.

pub fn path_insert_step_after(
    &mut self,
    id: PathId,
    index: Self::StepIx,
    handle: Handle
) -> Option<Self::StepIx>

Insert a step on the given handle into path id, after the step at index. Returns the index of the new step if it was successfully inserted, or None if either the path or the step does not exist.

pub fn path_remove_step(
    &mut self,
    id: PathId,
    index: Self::StepIx
) -> Option<Self::StepIx>

Remove the step at index from path id. Returns the index of the removed step if it existed and was removed.

pub fn path_flip_step(
    &mut self,
    id: PathId,
    index: Self::StepIx
) -> Option<Self::StepIx>

Flip the orientation of the handle on step at index on path id, if it exists.

pub fn path_rewrite_segment(
    &mut self,
    id: PathId,
    from: Self::StepIx,
    to: Self::StepIx,
    new_segment: &[Handle]
) -> Option<(Self::StepIx, Self::StepIx)>

Remove all steps between the indices from and to (inclusive) on path, and insert new steps on the Handles in new_segment. Returns a pair with the new step indices of the first and last new handles.

pub fn path_set_circularity(&mut self, id: PathId, circular: bool) -> Option<()>

Set the circularity of path id.

impl MutableHandles for HashGraph

pub fn divide_handle(
    &mut self,
    handle: Handle,
    offsets: Vec<usize>
) -> Vec<Handle>

Divide the given handle at the provided offsets, in terms of the node's sequence. Creates offsets.len() - 1 new handles, and updates the edges accordingly.

pub fn apply_orientation(&mut self, handle: Handle) -> Handle

Transform the node that handle corresponds to so that the orientation of handle becomes the node's forward orientation. I.e. if handle is reverse, the node will be reversed. Returns the new handle.

pub fn split_handle(
    &mut self,
    handle: Handle,
    offset: usize
) -> (Handle, Handle)

Divide the given handle at the provided offset, creating one new handle. Default implementation uses divide_handle(), and there's probably no need to provide another implementation.

impl PathSequences for HashGraph

pub fn path_bases_len(&self, id: PathId) -> Option<usize>

Return the length of path id in nucleotides, if it exists.

pub fn path_step_at_base(&self, id: PathId, pos: usize) -> Option<Self::StepIx>

Return the index of the step at sequence position pos along path id, or None if either the path doesn't exist, or if the path is shorter than pos bases.

pub fn path_step_base_offset(
    &self,
    id: PathId,
    index: Self::StepIx
) -> Option<usize>

Return the sequence offset of the step at index in path id, if it exists.