add implementations for change seq

Author: jeizenga

bdsg/include/bdsg/hash_graph.hpp

@@ -132,7 +132,12 @@ class HashGraph : public MutablePathDeletableHandleGraph, public SerializableHan
     /// May **NOT** be called during iteration over paths, if it would destroy a path.
     /// May **NOT** be called during iteration along a path, if it would destroy that path.
     void destroy_handle(const handle_t& handle);
-    
+        
+    /// Change the sequence of handle to a new sequence. Returns a (possibly alterered)
+    /// handle to the node with the new sequence. May invalidate the existing handle. Updates
+    /// paths if called through an inheriting MutablePath interface.
+    handle_t change_sequence(const handle_t& handle, const std::string& sequence);
+
     /// Create an edge connecting the given handles in the given order and orientations.
     /// Ignores existing edges.
     void create_edge(const handle_t& left, const handle_t& right);

bdsg/include/bdsg/internal/base_packed_graph.hpp

@@ -180,6 +180,11 @@ class BasePackedGraph {
     /// May **NOT** be called during iteration along a path, if it would destroy that path.
     void destroy_handle(const handle_t& handle);
 
+    /// Change the sequence of handle to a new sequence. Returns a (possibly alterered)
+    /// handle to the node with the new sequence. May invalidate the existing handle. Updates
+    /// paths if called through an inheriting MutablePath interface.
+    handle_t change_sequence(const handle_t& handle, const std::string& sequence);
+    
     /// Shorten a node by truncating either the left or right side of the node, relative to the orientation
     /// of the handle, starting from a given offset along the nodes sequence. Any edges on the truncated
     /// end of the node are deleted. Returns a (possibly altered) handle to the truncated node.
@@ -1752,6 +1757,37 @@ void BasePackedGraph<Backend>::destroy_handle(const handle_t& handle) {
     defragment(get_node_count() == 0);
 }
 
+template<typename Backend>
+handle_t BasePackedGraph<Backend>::change_sequence(const handle_t& handle, const std::string& sequence) {
+
+    size_t g_iv_index = graph_iv_index(handle);
+    size_t seq_start = seq_start_iv.get(graph_index_to_seq_start_index(g_iv_index));
+    size_t seq_len = seq_length_iv.get(graph_index_to_seq_len_index(g_iv_index));
+    if (seq_len >= sequence.size()) {
+        // we can fit the new sequence in the same location
+        for (size_t i = 0; i < sequence.size(); ++i) {
+            seq_iv.set(seq_start + i, encode_nucleotide(sequence[i]));
+        }
+        deleted_bases += (seq_len - sequence.size());
+    }
+    else {
+        // the new sequence doesn't fit, add it at the end
+        seq_start_iv.set(graph_index_to_seq_start_index(g_iv_index), seq_iv.size());
+        for (size_t i = 0; i < sequence.size(); ++i) {
+            seq_iv.append(encode_nucleotide(sequence[i]));
+        }
+        deleted_bases += seq_len;
+    }
+    seq_length_iv.set(graph_index_to_seq_len_index(g_iv_index), sequence.size());
+    
+    // FIXME: disabling since deleting bases can't currently trigger a defrag
+    //if (seq_len != sequence.size()) {
+    //    defragment();
+    //}
+    
+    return handle;
+}
+
 template<typename Backend>
 handle_t BasePackedGraph<Backend>::truncate_handle(const handle_t& handle, bool trunc_left, size_t offset) {
     // TODO: This duplicates the libhandlegraph implementation

bdsg/include/bdsg/internal/graph_proxy_mutable_path_deletable_handle_graph_fragment.classfragment

@@ -202,6 +202,14 @@ public:
         return this->get()->truncate_handle(handle, trunc_left, offset);
     }
 
+        
+    /// Change the sequence of handle's forward orientation to a new sequence. Returns a (possibly
+    /// handle to the node with the new sequence. May invalidate the existing handle. Updates
+    /// alterered) paths if called through a class inheriting a MutablePathHandleGraph interface.
+    virtual handle_t change_sequence(const handle_t& handle, const std::string& sequence) {
+        return this->get()->change_sequence(handle, sequence);
+    }
+    
     /// Remove all nodes and edges. May also remove all paths, if applicable.
     virtual void clear() {
         this->get()->clear();

bdsg/src/hash_graph.cpp

@@ -398,6 +398,13 @@ namespace bdsg {
         // remove this node from the relevant indexes
         graph.erase(get_id(handle));
     }
+
+    handle_t HashGraph::change_sequence(const handle_t& handle, const std::string& sequence) {
+        
+        graph[get_id(handle)].sequence = sequence;
+        
+        return handle;
+    }
 
     void HashGraph::destroy_edge(const handle_t& left, const handle_t& right) {
 

bdsg/src/test_libbdsg.cpp

@@ -1781,6 +1781,13 @@ void test_deletable_handle_graphs() {
             assert(graph.get_degree(h7, false) == 0);
             assert(graph.get_degree(h6, false) == 0);
             assert(graph.get_degree(h8, true) == 0);
+            
+            h6 = graph.change_sequence(h6, "AAAT");
+            h7 = graph.change_sequence(h7, "G");
+            assert(graph.get_sequence(h6) == "AAAT");
+            assert(graph.get_sequence(graph.flip(h6)) == "ATTT");
+            assert(graph.get_sequence(h7) == "G");
+            assert(graph.get_sequence(graph.flip(h7)) == "C");
         }
     }
 
@@ -4685,8 +4692,8 @@ int main(void) {
     test_paged_vector<PagedVector<5, MappedBackend>>();
     test_packed_deque();
     test_packed_set();
-    test_deletable_handle_graphs();
     test_mutable_path_handle_graphs();
+    test_deletable_handle_graphs();
     test_serializable_handle_graphs();
     test_packed_graph();
     test_path_position_overlays();