Struct handlegraph::packedgraph::graph::PackedGraph

pub struct PackedGraph { /* fields omitted */ }

Implementations

impl PackedGraph

pub fn new() -> Self

pub fn with_path_mut_ctx<F>(&mut self, path_id: PathId, f: F) where
    F: Fn(&mut PackedPathMut<'b>) -> Vec<StepUpdate>, 

pub fn zip_all_paths_mut_ctx<T, I, F>(&mut self, iter: I, f: F) where
    I: IndexedParallelIterator<Item = T>,
    T: Send + Sync,
    F: Fn(T, PathId, &mut PackedPathMut<'b>) -> Vec<StepUpdate> + Send + Sync, 

pub fn with_all_paths_mut_ctx<F>(&mut self, f: F) where
    F: Fn(PathId, &mut PackedPathMut<'b>) -> Vec<StepUpdate> + Sync + Send, 

pub fn with_all_paths_mut_ctx_chn<F>(&mut self, f: F) where
    F: Fn(PathId, &mut PackedPathMut<'b>) -> Vec<StepUpdate> + Sync, 

Trait Implementations

impl AdditiveHandleGraph for PackedGraph

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,
    sequence: &[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 Clone for PackedGraph

pub fn clone(&self) -> PackedGraph

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PackedGraph

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

Formats the value using the given formatter.

impl Default for PackedGraph

pub fn default() -> Self

Returns the "default value" for a type.

impl<'a> GraphPathNames for &'a PackedGraph

type PathName = IterView<'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 PackedGraph

type StepIx = StepPtr

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,
    ix: 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,
    ix: 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 PackedGraph

type PathRef = PackedPathRef<'a>

pub fn get_path_ref(self, id: PathId) -> Option<Self::PathRef>

impl HandleGraph for PackedGraph

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 PackedGraph

type Edges = EdgesIter<&'a PackedGraph>

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 PackedGraph

type Handles = NodeIdHandles<IndexMapIter<'a>>

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> IntoNeighbors for &'a PackedGraph

type Neighbors = EdgeListHandleIter<'a>

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 PackedGraph

type Occurrences = OccurrencesIter<'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 PackedGraph

type PathIds = Copied<Values<'a, Vec<u8>, PathId>>

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

impl<'a> IntoSequences for &'a PackedGraph

type Sequence = PackedSeqIter<'a>

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 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 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 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 PackedGraph

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,
    step: 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,
    step: 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 PackedGraph

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 PackedGraph

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.

impl SpaceUsage for PackedGraph

pub fn is_stack_only() -> bool

Is the size of this type known statically?

pub fn heap_bytes(&self) -> usize

Calculates the heap portion of the size of an object.

pub fn total_bytes(&self) -> usize

Computes the size of the receiver in bytes.

pub fn stack_bytes() -> usize

Calculates the stack portion of the size of this type.

impl SubtractiveHandleGraph for PackedGraph

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

Remove a handle from the graph, returning true if the handle existed.

pub fn remove_edge(&mut self, edge: Edge) -> bool

Remove an edge from the graph, returning true if the edge existed.

pub fn clear_graph(&mut self)

impl TransformNodeIds for PackedGraph

pub fn transform_node_ids<F>(&mut self, transform: F) where
    F: Fn(NodeId) -> NodeId + Copy + Send + Sync, 

Reassign all node IDs in the graph using the provided transform function. transform is Copy + Send + Sync as some implementations may perform part of the work in parallel.

pub fn apply_ordering(&mut self, order: &[Handle])

Reassign the node IDs using the provided ordering. order must have one element for each node in the graph, and the node IDs will be used to index the slice.