|
vg
tools for working with variation graphs
|
This is the complete list of members for vg::VG, including all inherited members.
| _for_each_kmer(int kmer_size, bool path_only, int edge_max, function< void(string &, list< NodeTraversal >::iterator, int, list< NodeTraversal > &, VG &)> lambda, bool parallel, int stride, bool allow_dups, bool allow_negatives, Node *node=nullptr) | vg::VG | private |
| add_edge(const Edge &edge) | vg::VG | |
| add_edges(const vector< Edge > &edges) | vg::VG | |
| add_edges(const vector< Edge * > &edges) | vg::VG | |
| add_edges(const set< Edge * > &edges) | vg::VG | |
| add_node(const Node &node) | vg::VG | |
| add_nodes(const vector< Node > &nodes) | vg::VG | |
| add_nodes(const set< Node * > &nodes) | vg::VG | |
| add_start_end_markers(int length, char start_char, char end_char, Node *&start_node, Node *&end_node, nid_t &start_id, nid_t &end_id) | vg::VG | |
| adjacent(const Position &pos1, const Position &pos2) | vg::VG | |
| align(const string &sequence, const Aligner *aligner, bool traceback=true, bool acyclic_and_sorted=false, size_t max_query_graph_ratio=0, bool pinned_alignment=false, bool pin_left=false, bool banded_global=false, size_t band_padding_override=0, size_t max_span=0, size_t unroll_length=0, int xdrop_alignment=0) | vg::VG | |
| align(const Alignment &alignment, const Aligner *aligner, const vector< MaximalExactMatch > &mems, bool traceback=true, bool acyclic_and_sorted=false, size_t max_query_graph_ratio=0, bool pinned_alignment=false, bool pin_left=false, bool banded_global=false, size_t band_padding_override=0, size_t max_span=0, size_t unroll_length=0, int xdrop_alignment=0) | vg::VG | |
| align(const Alignment &alignment, const Aligner *aligner, bool traceback=true, bool acyclic_and_sorted=false, size_t max_query_graph_ratio=0, bool pinned_alignment=false, bool pin_left=false, bool banded_global=false, size_t band_padding_override=0, size_t max_span=0, size_t unroll_length=0, int xdrop_alignment=0) | vg::VG | |
| align(const Alignment &alignment, bool traceback=true, bool acyclic_and_sorted=false, size_t max_query_graph_ratio=0, bool pinned_alignment=false, bool pin_left=false, bool banded_global=false, size_t band_padding_override=0, size_t max_span=0, size_t unroll_length=0, int xdrop_alignment=0) | vg::VG | |
| align(const string &sequence, bool traceback=true, bool acyclic_and_sorted=false, size_t max_query_graph_ratio=0, bool pinned_alignment=false, bool pin_left=false, bool banded_global=false, size_t band_padding_override=0, size_t max_span=0, size_t unroll_length=0, int xdrop_alignment=0) | vg::VG | |
| align(const Alignment &alignment, const Aligner *aligner, const QualAdjAligner *qual_adj_aligner, const vector< MaximalExactMatch > &mems, bool traceback=true, bool acyclic_and_sorted=false, size_t max_query_graph_ratio=0, bool pinned_alignment=false, bool pin_left=false, bool banded_global=false, size_t band_padding_override=0, size_t max_span=0, size_t unroll_length=0, int xdrop_alignment=0) | vg::VG | private |
| align_qual_adjusted(const Alignment &alignment, const QualAdjAligner *qual_adj_aligner, const vector< MaximalExactMatch > &mems, bool traceback=true, bool acyclic_and_sorted=false, size_t max_query_graph_ratio=0, bool pinned_alignment=false, bool pin_left=false, bool banded_global=false, size_t band_padding_override=0, size_t max_span=0, size_t unroll_length=0, int xdrop_alignment=0) | vg::VG | |
| align_qual_adjusted(const Alignment &alignment, const QualAdjAligner *qual_adj_aligner, bool traceback=true, bool acyclic_and_sorted=false, size_t max_query_graph_ratio=0, bool pinned_alignment=false, bool pin_left=false, bool banded_global=false, size_t band_padding_override=0, size_t max_span=0, size_t unroll_length=0, int xdrop_alignment=0) | vg::VG | |
| align_qual_adjusted(const string &sequence, const QualAdjAligner *qual_adj_aligner, bool traceback=true, bool acyclic_and_sorted=false, size_t max_query_graph_ratio=0, bool pinned_alignment=false, bool pin_left=false, bool banded_global=false, size_t band_padding_override=0, size_t max_span=0, size_t unroll_length=0, int xdrop_alignment=0) | vg::VG | |
| append(VG &g) | vg::VG | |
| append_step(const path_handle_t &path, const handle_t &to_append) | vg::VG | virtual |
| apply_ordering(const std::vector< handle_t > &order, bool compact_ids=false) | vg::VG | virtual |
| apply_orientation(const handle_t &handle) | vg::VG | virtual |
| ASSEMBLY_OR_NAME_MATCH | handlegraph::PathMetadata | privatestatic |
| break_cycles(void) | vg::VG | |
| build_edge_indexes(void) | vg::VG | |
| build_edge_indexes_no_init_size(void) | vg::VG | |
| build_indexes(void) | vg::VG | |
| build_indexes_no_init_size(void) | vg::VG | |
| build_node_indexes(void) | vg::VG | |
| build_node_indexes_no_init_size(void) | vg::VG | |
| circularize(nid_t head, nid_t tail) | vg::VG | |
| circularize(vector< string > pathnames) | vg::VG | |
| clear() | vg::VG | virtual |
| clear_edge_indexes(void) | vg::VG | |
| clear_edge_indexes_no_resize(void) | vg::VG | |
| clear_indexes(void) | vg::VG | |
| clear_indexes_no_resize(void) | vg::VG | |
| clear_node_indexes(void) | vg::VG | |
| clear_node_indexes_no_resize(void) | vg::VG | |
| clear_paths(void) | vg::VG | |
| collect_subgraph(Node *node, set< Node * > &subgraph) | vg::VG | |
| combine(VG &g) | vg::VG | |
| common_ancestor_next(nid_t id1, nid_t id2, size_t steps=64) | vg::VG | |
| common_ancestor_prev(nid_t id1, nid_t id2, size_t steps=64) | vg::VG | |
| compact_ids(void) | vg::VG | |
| compact_ids(hash_map< nid_t, nid_t > &new_id) | vg::VG | |
| concat_mappings_for_node_pair(nid_t id1, nid_t id2) | vg::VG | |
| connect_node_to_nodes(NodeTraversal node, vector< NodeTraversal > &nodes) | vg::VG | |
| connect_node_to_nodes(Node *node, vector< Node * > &nodes, bool from_start=false) | vg::VG | |
| connect_nodes_to_node(vector< NodeTraversal > &nodes, NodeTraversal node) | vg::VG | |
| connect_nodes_to_node(vector< Node * > &nodes, Node *node, bool to_end=false) | vg::VG | |
| create_edge(const handle_t &left, const handle_t &right) | vg::VG | virtual |
| create_edge(Node *from, Node *to, bool from_start=false, bool to_end=false) | vg::VG | |
| create_edge(nid_t from, nid_t to, bool from_start=false, bool to_end=false) | vg::VG | |
| create_edge(NodeTraversal left, NodeTraversal right) | vg::VG | |
| create_edge(NodeSide side1, NodeSide side2) | vg::VG | |
| handlegraph::MutablePathDeletableHandleGraph::create_edge(const edge_t &edge) | handlegraph::MutableHandleGraph | inline |
| create_handle(const string &sequence) | vg::VG | virtual |
| create_handle(const string &sequence, const nid_t &id) | vg::VG | virtual |
| handlegraph::MutablePathDeletableHandleGraph::create_handle(const std::string &sequence)=0 | handlegraph::MutableHandleGraph | pure virtual |
| handlegraph::MutablePathDeletableHandleGraph::create_handle(const std::string &sequence, const nid_t &id)=0 | handlegraph::MutableHandleGraph | pure virtual |
| create_node(const string &seq) | vg::VG | |
| create_node(const string &seq, nid_t id) | vg::VG | |
| create_path(const list< NodeTraversal > &nodes) | vg::VG | |
| create_path(const vector< NodeTraversal > &nodes) | vg::VG | |
| handlegraph::MutablePathDeletableHandleGraph::create_path(const PathSense &sense, const std::string &sample, const std::string &locus, const size_t &haplotype, const size_t &phase_block, const subrange_t &subrange, bool is_circular=false) | handlegraph::MutablePathMetadata | virtual |
| create_path_handle(const string &name, bool is_circular=false) | vg::VG | virtual |
| handlegraph::MutablePathDeletableHandleGraph::create_path_handle(const std::string &name, bool is_circular=false)=0 | handlegraph::MutablePathHandleGraph | pure virtual |
| create_path_name(const PathSense &sense, const std::string &sample, const std::string &locus, const size_t &haplotype, const size_t &phase_block, const subrange_t &subrange) | handlegraph::PathMetadata | static |
| create_progress(const string &message, long count) | vg::Progressive | |
| create_progress(long count) | vg::Progressive | |
| current_id | vg::VG | |
| dagify(uint32_t expand_scc_steps, unordered_map< nid_t, pair< nid_t, bool > > &node_translation, size_t target_min_walk_length=0, size_t component_length_max=0) | vg::VG | |
| decrement_node_ids(nid_t decrement) | vg::VG | |
| deserialize(istream &in) | vg::VG | virtual |
| destroy_edge(const handle_t &left, const handle_t &right) | vg::VG | virtual |
| destroy_edge(Edge *edge) | vg::VG | |
| destroy_edge(const NodeSide &side1, const NodeSide &side2) | vg::VG | |
| destroy_edge(const pair< NodeSide, NodeSide > &sides) | vg::VG | |
| handlegraph::MutablePathDeletableHandleGraph::destroy_edge(const edge_t &edge) | handlegraph::DeletableHandleGraph | inline |
| destroy_handle(const handle_t &handle) | vg::VG | virtual |
| destroy_node(Node *node) | vg::VG | |
| destroy_node(nid_t id) | vg::VG | |
| destroy_path(const path_handle_t &path) | vg::VG | virtual |
| destroy_paths(const std::vector< path_handle_t > &paths) | handlegraph::MutablePathHandleGraph | virtual |
| destroy_progress(void) | vg::Progressive | |
| dfs(const function< void(NodeTraversal)> &node_begin_fn, const function< void(NodeTraversal)> &node_end_fn, const function< bool(void)> &break_fn, const function< void(Edge *)> &edge_fn, const function< void(Edge *)> &tree_fn, const function< void(Edge *)> &edge_curr_fn, const function< void(Edge *)> &edge_cross_fn, const vector< NodeTraversal > *sources, const unordered_set< NodeTraversal > *sinks) | vg::VG | |
| dfs(const function< void(NodeTraversal)> &node_begin_fn, const function< void(NodeTraversal)> &node_end_fn, const vector< NodeTraversal > *sources=NULL, const unordered_set< NodeTraversal > *sinks=NULL) | vg::VG | |
| dfs(const function< void(NodeTraversal)> &node_begin_fn, const function< void(NodeTraversal)> &node_end_fn, const function< bool(void)> &break_fn) | vg::VG | |
| divide_handle(const handle_t &handle, const vector< size_t > &offsets) | vg::VG | virtual |
| handlegraph::MutablePathDeletableHandleGraph::divide_handle(const handle_t &handle, const std::vector< size_t > &offsets)=0 | handlegraph::MutableHandleGraph | pure virtual |
| handlegraph::MutablePathDeletableHandleGraph::divide_handle(const handle_t &handle, size_t offset) | handlegraph::MutableHandleGraph | inline |
| divide_node(Node *node, int pos, Node *&left, Node *&right) | vg::VG | |
| divide_node(Node *node, vector< int > &positions, vector< Node * > &parts) | vg::VG | |
| divide_path(map< long, nid_t > &path, long pos, Node *&left, Node *&right) | vg::VG | |
| edge_by_sides | vg::VG | |
| edge_count(void) const | vg::VG | |
| edge_handle(const handle_t &left, const handle_t &right) const | handlegraph::HandleGraph | |
| edge_index | vg::VG | |
| edges_end(Node *node) | vg::VG | |
| edges_end(nid_t id) | vg::VG | |
| edges_from(Node *node) | vg::VG | |
| edges_of(Node *node) | vg::VG | |
| edges_of_node(Node *node, vector< Edge * > &edges) | vg::VG | |
| edges_of_nodes(set< Node * > &nodes, set< Edge * > &edges) | vg::VG | |
| edges_on_end | vg::VG | |
| edges_on_start | vg::VG | |
| edges_start(Node *node) | vg::VG | |
| edges_start(nid_t id) | vg::VG | |
| edges_to(Node *node) | vg::VG | |
| edit(vector< Path > &paths_to_add, vector< Translation > *out_translations=nullptr, bool save_paths=false, bool update_paths=false, bool break_at_ends=false) | vg::VG | |
| edit(const string &paths_to_add_path, vector< Translation > *out_translations=nullptr, bool save_paths=false, const string &out_gam_path="", bool break_at_ends=false, bool remove_softclips=false) | vg::VG | |
| edit_fast(const Path &path, set< NodeSide > &dangling, size_t max_node_size=1024) | vg::VG | |
| empty(void) const | vg::VG | |
| empty_edge_ends | vg::VG | private |
| empty_ids | vg::VG | private |
| end_degree(Node *node) | vg::VG | |
| expand_context(VG &g, size_t distance, bool add_paths=true, bool use_steps=true) | vg::VG | |
| expand_context_by_length(VG &g, size_t length, bool add_paths=true, bool reflect=false, const set< NodeSide > &barriers=set< NodeSide >()) | vg::VG | |
| expand_context_by_steps(VG &g, size_t steps, bool add_paths=true) | vg::VG | |
| expand_path(const list< NodeTraversal > &path, vector< NodeTraversal > &expanded) | vg::VG | |
| expand_path(list< NodeTraversal > &path, vector< list< NodeTraversal >::iterator > &expanded) | vg::VG | |
| extend(const VG &g, bool warn_on_duplicates=false) | vg::VG | |
| extend(const Graph &graph, bool warn_on_duplicates=false) | vg::VG | |
| find_node_by_name_or_add_new(string name) | vg::VG | |
| flip(const handle_t &handle) const | vg::VG | virtual |
| flip_doubly_reversed_edges(void) | vg::VG | |
| follow_edges(const handle_t &handle, bool go_left, const Iteratee &iteratee) const | handlegraph::HandleGraph | |
| follow_edges_impl(const handle_t &handle, bool go_left, const function< bool(const handle_t &)> &iteratee) const | vg::VG | virtual |
| handlegraph::MutablePathDeletableHandleGraph::follow_edges_impl(const handle_t &handle, bool go_left, const std::function< bool(const handle_t &)> &iteratee) const =0 | handlegraph::HandleGraph | protectedpure virtual |
| for_each_connected_node(Node *node, function< void(Node *)> lambda) | vg::VG | |
| for_each_edge(function< void(Edge *)> lambda) | vg::VG | |
| for_each_edge(function< void(const Edge *)> lambda) const | vg::VG | |
| handlegraph::MutablePathDeletableHandleGraph::for_each_edge(const Iteratee &iteratee, bool parallel=false) const | handlegraph::HandleGraph | |
| for_each_edge_parallel(function< void(Edge *)> lambda) | vg::VG | |
| for_each_handle(const Iteratee &iteratee, bool parallel=false) const | handlegraph::HandleGraph | |
| for_each_handle_impl(const function< bool(const handle_t &)> &iteratee, bool parallel=false) const | vg::VG | virtual |
| handlegraph::MutablePathDeletableHandleGraph::for_each_handle_impl(const std::function< bool(const handle_t &)> &iteratee, bool parallel=false) const =0 | handlegraph::HandleGraph | protectedpure virtual |
| for_each_node(function< void(Node *)> lambda) | vg::VG | |
| for_each_node(function< void(const Node *)> lambda) const | vg::VG | |
| for_each_node_parallel(function< void(Node *)> lambda) | vg::VG | |
| for_each_path_handle(const Iteratee &iteratee) const | handlegraph::PathHandleGraph | |
| for_each_path_handle_impl(const function< bool(const path_handle_t &)> &iteratee) const | vg::VG | virtual |
| handlegraph::MutablePathDeletableHandleGraph::for_each_path_handle_impl(const std::function< bool(const path_handle_t &)> &iteratee) const =0 | handlegraph::PathHandleGraph | protectedpure virtual |
| for_each_path_matching(const std::unordered_set< PathSense > *senses, const std::unordered_set< std::string > *samples, const std::unordered_set< std::string > *loci, const Iteratee &iteratee) const | handlegraph::PathMetadata | |
| for_each_path_matching(const std::unordered_set< PathSense > &senses, const std::unordered_set< std::string > &samples, const std::unordered_set< std::string > &loci, const Iteratee &iteratee) const | handlegraph::PathMetadata | |
| for_each_path_matching_impl(const std::unordered_set< PathSense > *senses, const std::unordered_set< std::string > *samples, const std::unordered_set< std::string > *loci, const std::function< bool(const path_handle_t &)> &iteratee) const | handlegraph::PathMetadata | protectedvirtual |
| for_each_path_of_sample(const std::string &sample, const Iteratee &iteratee) const | handlegraph::PathMetadata | |
| for_each_path_of_sense(const PathSense &sense, const Iteratee &iteratee) const | handlegraph::PathMetadata | |
| for_each_step_in_path(const path_handle_t &path, const Iteratee &iteratee) const | handlegraph::PathHandleGraph | |
| for_each_step_of_sense(const handle_t &visited, const PathSense &sense, const Iteratee &iteratee) const | handlegraph::PathMetadata | |
| for_each_step_of_sense_impl(const handle_t &visited, const PathSense &sense, const std::function< bool(const step_handle_t &)> &iteratee) const | handlegraph::PathMetadata | protectedvirtual |
| for_each_step_on_handle(const handle_t &handle, const Iteratee &iteratee) const | handlegraph::PathHandleGraph | |
| for_each_step_on_handle_impl(const handle_t &handle, const function< bool(const step_handle_t &)> &iteratee) const | vg::VG | virtual |
| handlegraph::MutablePathDeletableHandleGraph::for_each_step_on_handle_impl(const handle_t &handle, const std::function< bool(const step_handle_t &)> &iteratee) const =0 | handlegraph::PathHandleGraph | protectedpure virtual |
| FORMAT | handlegraph::PathMetadata | privatestatic |
| forward(const handle_t &handle) const | handlegraph::HandleGraph | |
| from_istream(istream &in, bool showp=false, bool warn_on_duplicates=true) | vg::VG | |
| from_turtle(string filename, string baseuri, bool showp=false) | vg::VG | |
| get_base(const handle_t &handle, size_t index) const | vg::VG | virtual |
| get_degree(const handle_t &handle, bool go_left) const | vg::VG | virtual |
| get_edge(const NodeSide &side1, const NodeSide &side2) | vg::VG | |
| get_edge(const pair< NodeSide, NodeSide > &sides) | vg::VG | |
| get_edge(const NodeTraversal &left, const NodeTraversal &right) | vg::VG | |
| get_edge_count() const | vg::VG | virtual |
| get_handle(const nid_t &node_id, bool is_reverse=false) const | vg::VG | virtual |
| get_handle_of_step(const step_handle_t &step_handle) const | vg::VG | virtual |
| get_haplotype(const path_handle_t &handle) const | handlegraph::PathMetadata | virtual |
| get_id(const handle_t &handle) const | vg::VG | virtual |
| get_is_circular(const path_handle_t &path_handle) const | vg::VG | virtual |
| get_is_reverse(const handle_t &handle) const | vg::VG | virtual |
| get_length(const handle_t &handle) const | vg::VG | virtual |
| get_locus_name(const path_handle_t &handle) const | handlegraph::PathMetadata | virtual |
| get_next_step(const step_handle_t &step_handle) const | vg::VG | virtual |
| get_node(nid_t id) | vg::VG | |
| get_node(nid_t id) const | vg::VG | |
| get_node_at_nucleotide(string pathname, int nuc) | vg::VG | |
| get_node_count() const | vg::VG | virtual |
| get_node_nid_to_variant(vcflib::VariantCallFile vfile) | vg::VG | |
| get_path_count() const | vg::VG | virtual |
| get_path_edges(void) | vg::VG | |
| get_path_handle(const string &path_name) const | vg::VG | virtual |
| handlegraph::MutablePathDeletableHandleGraph::get_path_handle(const std::string &path_name) const =0 | handlegraph::PathHandleGraph | pure virtual |
| get_path_handle_of_step(const step_handle_t &step_handle) const | vg::VG | virtual |
| get_path_name(const path_handle_t &path_handle) const | vg::VG | virtual |
| get_phase_block(const path_handle_t &handle) const | handlegraph::PathMetadata | virtual |
| get_previous_step(const step_handle_t &step_handle) const | vg::VG | virtual |
| get_sample_name(const path_handle_t &handle) const | handlegraph::PathMetadata | virtual |
| get_sense(const path_handle_t &handle) const | handlegraph::PathMetadata | virtual |
| get_sequence(const handle_t &handle) const | vg::VG | virtual |
| get_step_count(const path_handle_t &path_handle) const | vg::VG | virtual |
| handlegraph::MutablePathDeletableHandleGraph::get_step_count(const handle_t &handle) const | handlegraph::PathHandleGraph | virtual |
| get_subrange(const path_handle_t &handle) const | handlegraph::PathMetadata | virtual |
| get_subsequence(const handle_t &handle, size_t index, size_t size) const | vg::VG | virtual |
| get_total_length() const | handlegraph::HandleGraph | virtual |
| graph | vg::VG | |
| HAPLOTYPE_MATCH | handlegraph::PathMetadata | privatestatic |
| has_edge(const handle_t &left, const handle_t &right) const | vg::VG | virtual |
| has_edge(const NodeSide &side1, const NodeSide &side2) const | vg::VG | |
| has_edge(const pair< NodeSide, NodeSide > &sides) const | vg::VG | |
| has_edge(Edge *edge) const | vg::VG | |
| has_edge(const Edge &edge) const | vg::VG | |
| handlegraph::MutablePathDeletableHandleGraph::has_edge(const edge_t &edge) const | handlegraph::HandleGraph | inline |
| has_inverting_edge(Node *n) | vg::VG | |
| has_inverting_edge_from(Node *n) | vg::VG | |
| has_inverting_edge_to(Node *n) | vg::VG | |
| has_inverting_edges(void) | vg::VG | |
| has_next_step(const step_handle_t &step_handle) const | vg::VG | virtual |
| has_node(nid_t id) const | vg::VG | virtual |
| has_node(const Node *node) const | vg::VG | |
| has_node(const Node &node) const | vg::VG | |
| has_path(const string &path_name) const | vg::VG | virtual |
| handlegraph::MutablePathDeletableHandleGraph::has_path(const std::string &path_name) const =0 | handlegraph::PathHandleGraph | pure virtual |
| has_previous_step(const step_handle_t &step_handle) const | vg::VG | virtual |
| hash(void) | vg::VG | |
| head_nodes(vector< Node * > &nodes) | vg::VG | |
| head_nodes(void) | vg::VG | |
| id_sort() | vg::VG | |
| identity_translation(unordered_map< nid_t, pair< nid_t, bool >> &node_translation) | vg::VG | |
| include(const Path &path) | vg::VG | |
| increment_node_ids(nid_t increment) | vg::VG | virtual |
| handlegraph::MutablePathDeletableHandleGraph::increment_node_ids(long increment) | handlegraph::MutableHandleGraph | virtual |
| increment_progress() | vg::Progressive | |
| index_edge_by_node_sides(Edge *edge) | vg::VG | |
| init(void) | vg::VG | private |
| is_ancestor_next(nid_t node_id, nid_t candidate_id) | vg::VG | |
| is_ancestor_next(nid_t node_id, nid_t candidate_id, set< nid_t > &seen, size_t steps=64) | vg::VG | |
| is_ancestor_prev(nid_t node_id, nid_t candidate_id) | vg::VG | |
| is_ancestor_prev(nid_t node_id, nid_t candidate_id, set< nid_t > &seen, size_t steps=64) | vg::VG | |
| is_empty(const path_handle_t &path_handle) const | handlegraph::PathHandleGraph | virtual |
| is_head_node(nid_t id) | vg::VG | |
| is_head_node(Node *node) | vg::VG | |
| is_self_looping(Node *node) | vg::VG | private |
| is_tail_node(nid_t id) | vg::VG | |
| is_tail_node(Node *node) | vg::VG | |
| is_valid(bool check_nodes=true, bool check_edges=true, bool check_paths=true, bool check_orphans=true) | vg::VG | |
| join_heads(void) | vg::VG | |
| join_heads(Node *node, bool from_start=false) | vg::VG | |
| join_tails(Node *node, bool to_end=false) | vg::VG | |
| keep_path(const string &path_name) | vg::VG | |
| keep_paths(const set< string > &path_names, set< string > &kept_names) | vg::VG | |
| last_progress | vg::Progressive | private |
| left_degree(NodeTraversal node) | vg::VG | |
| length(void) | vg::VG | |
| likelihoods(vector< Alignment > &alignments, vector< Path > &paths, vector< long double > &likelihoods) | vg::VG | |
| LOCUS_MATCH_ANY | handlegraph::PathMetadata | privatestatic |
| LOCUS_MATCH_NUMERICAL_WITHOUT_HAPLOTYPE | handlegraph::PathMetadata | privatestatic |
| mapping_is_total_match(const Mapping &m) | vg::VG | |
| max_node_id() const | vg::VG | virtual |
| merge(Graph &g) | vg::VG | |
| merge(VG &g) | vg::VG | |
| merge_nodes(const list< Node * > &nodes) | vg::VG | private |
| merge_union(VG &g) | vg::VG | |
| min_node_id() const | vg::VG | virtual |
| name | vg::VG | |
| NO_END_POSITION | handlegraph::PathMetadata | static |
| NO_HAPLOTYPE | handlegraph::PathMetadata | static |
| NO_LOCUS_NAME | handlegraph::PathMetadata | static |
| NO_PHASE_BLOCK | handlegraph::PathMetadata | static |
| NO_SAMPLE_NAME | handlegraph::PathMetadata | static |
| NO_SUBRANGE | handlegraph::PathMetadata | static |
| node_by_id | vg::VG | |
| node_count(void) const | vg::VG | |
| node_count_next(NodeTraversal n) | vg::VG | |
| node_count_prev(NodeTraversal n) | vg::VG | |
| node_index | vg::VG | |
| node_rank(Node *node) | vg::VG | |
| node_rank(nid_t id) | vg::VG | |
| node_starts_in_path(const list< NodeTraversal > &path, map< Node *, int > &node_start) | vg::VG | |
| node_starts_in_path(list< NodeTraversal > &path, map< NodeTraversal *, int > &node_start) | vg::VG | |
| nodes_next(NodeTraversal n, vector< NodeTraversal > &nodes) | vg::VG | |
| nodes_next(NodeTraversal n) | vg::VG | |
| nodes_prev(NodeTraversal n, vector< NodeTraversal > &nodes) | vg::VG | |
| nodes_prev(NodeTraversal n) | vg::VG | |
| nonoverlapping_node_context_without_paths(Node *node, VG &g) | vg::VG | |
| operator=(const VG &other) | vg::VG | |
| operator=(VG &&other) noexcept | vg::VG | |
| optimize(bool allow_id_reassignment=true) | vg::VG | virtual |
| overlay_node_translations(const unordered_map< nid_t, pair< nid_t, bool > > &over, const unordered_map< nid_t, pair< nid_t, bool > > &under) | vg::VG | |
| parse_haplotype(const std::string &path_name) | handlegraph::PathMetadata | static |
| parse_locus_name(const std::string &path_name) | handlegraph::PathMetadata | static |
| parse_path_name(const std::string &path_name, PathSense &sense, std::string &sample, std::string &locus, size_t &haplotype, size_t &phase_block, subrange_t &subrange) | handlegraph::PathMetadata | static |
| parse_phase_block(const std::string &path_name) | handlegraph::PathMetadata | static |
| parse_sample_name(const std::string &path_name) | handlegraph::PathMetadata | static |
| parse_sense(const std::string &path_name) | handlegraph::PathMetadata | static |
| parse_subrange(const std::string &path_name) | handlegraph::PathMetadata | static |
| path_back(const path_handle_t &path_handle) const | vg::VG | virtual |
| path_begin(const path_handle_t &path_handle) const | vg::VG | virtual |
| path_edge_count(list< NodeTraversal > &path, int32_t offset, int path_length) | vg::VG | |
| path_end(const path_handle_t &path_handle) const | vg::VG | virtual |
| path_end_node_offset(list< NodeTraversal > &path, int32_t offset, int path_length) | vg::VG | |
| path_front_end(const path_handle_t &path_handle) const | vg::VG | virtual |
| path_identity(const Path &path1, const Path &path2) | vg::VG | |
| path_sequence(const Path &path) | vg::VG | |
| paths | vg::VG | |
| paths_as_alignments(void) | vg::VG | |
| paths_between(Node *from, Node *to, vector< Path > &paths) | vg::VG | |
| paths_between(nid_t from, nid_t to, vector< Path > &paths) | vg::VG | |
| PHASE_BLOCK_MATCH | handlegraph::PathMetadata | privatestatic |
| pop_back_step(const path_handle_t &path_handle) | handlegraph::MutablePathHandleGraph | virtual |
| pop_front_step(const path_handle_t &path_handle) | handlegraph::MutablePathHandleGraph | virtual |
| preload_progress(const string &message) | vg::Progressive | |
| prepend_step(const path_handle_t &path, const handle_t &to_prepend) | vg::VG | virtual |
| print_edges(void) | vg::VG | |
| progress | vg::Progressive | private |
| progress_count | vg::Progressive | private |
| progress_message | vg::Progressive | private |
| progress_seen | vg::Progressive | private |
| random_read(size_t read_len, mt19937 &rng, nid_t min_id, nid_t max_id, bool either_strand) | vg::VG | |
| RANGE_END_MATCH | handlegraph::PathMetadata | privatestatic |
| RANGE_END_SEPARATOR | handlegraph::PathMetadata | privatestatic |
| RANGE_START_MATCH | handlegraph::PathMetadata | privatestatic |
| RANGE_START_SEPARATOR | handlegraph::PathMetadata | privatestatic |
| RANGE_TERMINATOR | handlegraph::PathMetadata | privatestatic |
| reassign_node_ids(const std::function< nid_t(const nid_t &)> &get_new_id) | vg::VG | virtual |
| rebuild_edge_indexes(void) | vg::VG | |
| rebuild_indexes(void) | vg::VG | |
| remove_duplicated_in(VG &g) | vg::VG | |
| remove_duplicates(void) | vg::VG | |
| remove_inverting_edges(void) | vg::VG | |
| remove_node_forwarding_edges(Node *node) | vg::VG | |
| remove_non_path(void) | vg::VG | |
| remove_null_nodes(void) | vg::VG | |
| remove_null_nodes_forwarding_edges(void) | vg::VG | |
| remove_orphan_edges(void) | vg::VG | |
| remove_path(void) | vg::VG | |
| rename_path(const path_handle_t &path_handle, const std::string &new_name) | handlegraph::MutablePathHandleGraph | virtual |
| resize_indexes(void) | vg::VG | |
| reverse_complement_graph(unordered_map< nid_t, pair< nid_t, bool >> &node_translation) | vg::VG | |
| rewrite_segment(const step_handle_t &segment_begin, const step_handle_t &segment_end, const vector< handle_t > &new_segment) | vg::VG | virtual |
| handlegraph::MutablePathDeletableHandleGraph::rewrite_segment(const step_handle_t &segment_begin, const step_handle_t &segment_end, const std::vector< handle_t > &new_segment)=0 | handlegraph::MutablePathHandleGraph | pure virtual |
| right_degree(NodeTraversal node) | vg::VG | |
| same_context(nid_t id1, nid_t id2) | vg::VG | |
| scan_path(const path_handle_t &path) const | handlegraph::PathHandleGraph | |
| SEPARATOR | handlegraph::PathMetadata | privatestatic |
| serialize(ostream &out) const | vg::VG | virtual |
| serialize_to_emitter(vg::io::ProtobufEmitter< Graph > &emitter, nid_t chunk_size=1000) | vg::VG | |
| serialize_to_file(const string &file_name, nid_t chunk_size=1000) | vg::VG | |
| serialize_to_function(const function< void(Graph &)> &emit, nid_t chunk_size=1000) | vg::VG | |
| serialize_to_ostream(ostream &out, nid_t chunk_size=1000) | vg::VG | |
| set_circularity(const path_handle_t &path, bool circular) | vg::VG | virtual |
| set_edge(Edge *) | vg::VG | |
| set_id_increment(const nid_t &min_id) | vg::VG | virtual |
| show_progress | vg::Progressive | |
| sides_context(nid_t node_id) | vg::VG | |
| sides_from(NodeSide side) | vg::VG | |
| sides_from(nid_t id) | vg::VG | |
| sides_of(NodeSide side) | vg::VG | |
| sides_to(NodeSide side) | vg::VG | |
| sides_to(nid_t id) | vg::VG | |
| size(void) | vg::VG | |
| sort() | vg::VG | |
| start_degree(Node *node) | vg::VG | |
| steps_of_handle(const handle_t &handle, bool match_orientation=false) const | handlegraph::PathHandleGraph | virtual |
| swap_handles(const handle_t &a, const handle_t &b) | vg::VG | virtual |
| swap_node_id(nid_t node_id, nid_t new_id) | vg::VG | |
| swap_node_id(Node *node, nid_t new_id) | vg::VG | |
| swap_nodes(Node *a, Node *b) | vg::VG | |
| sync_paths(void) | vg::VG | |
| tail_nodes(void) | vg::VG | |
| tail_nodes(vector< Node * > &nodes) | vg::VG | |
| to_dot(ostream &out, vector< Alignment > alignments={}, vector< Locus > loci={}, bool show_paths=false, bool walk_paths=false, bool annotate_paths=false, bool show_mappings=false, bool simple_mode=false, bool noseq_mode=false, bool invert_edge_ports=false, bool color_variants=false, bool ultrabubble_labeling=false, bool skip_missing_nodes=false, bool ascii_labels=false, int random_seed=0) | vg::VG | |
| to_turtle(ostream &out, const string &rdf_base_uri, bool precompress) | vg::VG | |
| trav_sequence(const NodeTraversal &trav) | vg::VG | |
| traverse_edge_handle(const edge_t &edge, const handle_t &left) const | handlegraph::HandleGraph | |
| travs_from(NodeTraversal node) | vg::VG | |
| travs_of(NodeTraversal node) | vg::VG | |
| travs_to(NodeTraversal node) | vg::VG | |
| truncate_handle(const handle_t &handle, bool trunc_left, size_t offset) | handlegraph::DeletableHandleGraph | virtual |
| unfold(uint32_t max_length, unordered_map< nid_t, pair< nid_t, bool > > &node_translation) | vg::VG | |
| unindex_edge_by_node_sides(const NodeSide &side1, const NodeSide &side2) | vg::VG | |
| unindex_edge_by_node_sides(Edge *edge) | vg::VG | |
| update_progress(long i) | vg::Progressive | |
| variant_to_traversal | vg::VG | |
| VG(void) | vg::VG | |
| VG(istream &in, bool showp=false, bool warn_on_duplicates=true) | vg::VG | |
| VG(const function< void(const function< void(Graph &)> &)> &send_graphs, bool showp=false, bool warn_on_duplicates=true) | vg::VG | |
| VG(const Graph &from, bool showp=false, bool warn_on_duplicates=true) | vg::VG | |
| VG(set< Node * > &nodes, set< Edge * > &edges) | vg::VG | |
| VG(const VG &other) | vg::VG | |
| VG(VG &&other) noexcept | vg::VG | |
| warned_about_rewrites | vg::VG | private |
| wrap_with_null_nodes(void) | vg::VG | |
| ~DeletableHandleGraph()=default | handlegraph::DeletableHandleGraph | virtual |
| ~HandleGraph()=default | handlegraph::HandleGraph | virtual |
| ~MutableHandleGraph()=default | handlegraph::MutableHandleGraph | virtual |
| ~MutablePathDeletableHandleGraph()=default | handlegraph::MutablePathDeletableHandleGraph | virtual |
| ~MutablePathHandleGraph()=default | handlegraph::MutablePathHandleGraph | virtual |
| ~MutablePathMetadata()=default | handlegraph::MutablePathMetadata | virtual |
| ~MutablePathMutableHandleGraph()=default | handlegraph::MutablePathMutableHandleGraph | virtual |
| ~PathHandleGraph()=default | handlegraph::PathHandleGraph | virtual |
| ~PathMetadata()=default | handlegraph::PathMetadata | virtual |
| ~VG(void) | vg::VG |
1.8.17