Building segment_steps, and some basic get fns

Author: ashwinsawant17

flatgfa/src/flatgfa.rs

@@ -550,3 +550,95 @@ pub type FixedGFAStore<'a> = GFAStore<'a, FixedFamily>;
 /// `FlatGFA`. It exposes an API for building up a GFA data structure, so it is
 /// useful for creating new ones from scratch.
 pub type HeapGFAStore = GFAStore<'static, HeapFamily>;
+
+
+pub struct StepRef {
+    path: Id<Path>,
+    offset: u32
+}
+
+pub struct StepsBySegIndex {
+    steps: Vec<StepRef>,
+    segment_steps: Vec<Span<StepRef>>
+}
+
+
+impl StepsBySegIndex {
+
+    pub fn new(fgfa: &FlatGFA)  -> Self{
+
+
+        /// helper to extract the segment index from the stepref
+        fn segment_of_step(fgfa: &FlatGFA, step: &StepRef) -> usize {
+            let path = &fgfa.paths[step.path];
+            let step_span = path.steps;
+            let step_slice = &fgfa.steps[step_span];
+            step_slice[step.offset as usize].segment().index()
+        }
+        
+        // will be our `steps` vector that contains all steprefs
+        let mut all_steps = Vec::new();
+
+        // build the vector of all the steprefs, by iterating over each path, so we can construct using a path id and offset
+        for (path_id, path) in fgfa.paths.items() {
+            for (offset, _) in fgfa.get_path_steps(path).enumerate() {
+                all_steps.push(StepRef {
+                    path: path_id,
+                    offset: offset as u32,
+                });
+            }
+        }
+        
+        // organize by the index of the segment in the segment pool
+        all_steps.sort_by_key(|a| {
+            segment_of_step(fgfa, a)
+        });
+
+        // the working segment's index
+        let mut seg_ind: usize = segment_of_step(fgfa, &all_steps[0]);
+
+        // the working start of the span of StepRefs
+        let mut span_start: usize = 0;
+        
+        // the vector of spans of step refs that will act as our index
+        let mut segment_steps: Vec<Span<StepRef>> = Vec::new();
+
+
+
+        for (i, step_ref) in all_steps.iter().enumerate() {
+            let curr_seg_ind: usize = segment_of_step(fgfa, step_ref);
+
+            // if we have moved onto a new segment add to the segment_steps vec
+            if curr_seg_ind > seg_ind {
+                // create and push the new span of step refs for this segment
+                // it will be left inclusive right exclusive
+                let new_seg: Span<StepRef> = Span::new(Id::new(span_start), Id::new(i));
+                segment_steps.push(new_seg);
+
+                // update the working seg_ind and range_start variables to reflect the new segment/range
+                seg_ind = curr_seg_ind;
+                span_start = i;       
+            }
+
+        }
+        
+
+        Self {
+            steps: all_steps,
+            segment_steps: segment_steps
+        }
+    }
+
+
+    /// Returns a slice of StepRefs that cross over the given segment
+    pub fn get_steps_slice(&self, segment: Id<Segment>) -> &[StepRef] {
+        let range: Range<usize> = Range::from(&self.segment_steps[segment.index()]);
+        &(self.steps[range])
+    }
+
+    /// Returns the number of steps that cross over this segment
+    pub fn get_num_steps(&self, segment: Id<Segment>) -> usize {
+        self.segment_steps[segment.index()].len()
+    }
+
+}