Make more progress with integration

Author: johnpalsberg

flatgfa/src/file.rs

@@ -1,8 +1,7 @@
 #![allow(clippy::repr_packed_without_abi)]
 
-use crate::packedseq::{PackedSeqView, PackedToc};
+use crate::flatgfa;
 use crate::pool::{FixedStore, Pool, Span, Store};
-use crate::{flatgfa, packedseq};
 use std::mem::{size_of, size_of_val};
 use tinyvec::SliceVec;
 use zerocopy::{AsBytes, FromBytes, FromZeroes};
@@ -19,7 +18,7 @@ pub struct Toc {
     paths: Size,
     links: Size,
     steps: Size,
-    seq_data: usize,
+    seq_data: Size,
     overlaps: Size,
     alignment: Size,
     name_data: Size,
@@ -71,7 +70,7 @@ impl Toc {
             + self.paths.bytes::<flatgfa::Path>()
             + self.links.bytes::<flatgfa::Link>()
             + self.steps.bytes::<flatgfa::Handle>()
-            + PackedToc::size(&self)
+            + self.seq_data.bytes::<u8>()
             + self.overlaps.bytes::<Span<flatgfa::AlignOp>>()
             + self.alignment.bytes::<flatgfa::AlignOp>()
             + self.name_data.bytes::<u8>()
@@ -123,7 +122,7 @@ impl Toc {
             paths: Size::empty(factor),
             links: Size::empty(32 * factor * factor),
             steps: Size::empty(1024 * factor * factor),
-            seq_data: 512 * factor * factor,
+            seq_data: Size::empty(512 * factor * factor),
             overlaps: Size::empty(256 * factor),
             alignment: Size::empty(64 * factor * factor),
             name_data: Size::empty(64 * factor),
@@ -149,7 +148,7 @@ impl Toc {
             paths: Size::empty(paths),
             links: Size::empty(links),
             steps: Size::empty(path_bytes / 3),
-            seq_data: 0,
+            seq_data: Size::empty(seg_bytes),
             overlaps: Size::empty((links + paths) * 2),
             alignment: Size::empty(links * 2 + paths * 4),
             name_data: Size::empty(paths * 512),
@@ -193,9 +192,7 @@ pub fn view(data: &[u8]) -> flatgfa::FlatGFA {
     let (paths, rest) = slice_prefix(rest, toc.paths);
     let (links, rest) = slice_prefix(rest, toc.links);
     let (steps, rest) = slice_prefix(rest, toc.steps);
-
-    let (seq_data, rest) = PackedSeqView::view_remaining(rest);
-
+    let (seq_data, rest) = slice_prefix(rest, toc.seq_data);
     let (overlaps, rest) = slice_prefix(rest, toc.overlaps);
     let (alignment, rest) = slice_prefix(rest, toc.alignment);
     let (name_data, rest) = slice_prefix(rest, toc.name_data);
@@ -300,7 +297,7 @@ pub fn dump(gfa: &flatgfa::FlatGFA, buf: &mut [u8]) {
     let rest = write_bump(rest, gfa.paths.all()).unwrap();
     let rest = write_bump(rest, gfa.links.all()).unwrap();
     let rest = write_bump(rest, gfa.steps.all()).unwrap();
-    let rest = PackedSeqView::dump_remaining(&gfa.seq_data, rest);
+    let rest = write_bytes(rest, gfa.seq_data.all()).unwrap();
     let rest = write_bump(rest, gfa.overlaps.all()).unwrap();
     let rest = write_bump(rest, gfa.alignment.all()).unwrap();
     let rest = write_bytes(rest, gfa.name_data.all()).unwrap();

flatgfa/src/flatgfa.rs

@@ -43,7 +43,7 @@ pub struct FlatGFA<'a> {
     /// TODO: This could certainly use a smaller representation than `u8`
     /// (since we care only about 4 base pairs). If we want to pay the cost
     /// of bit-packing.
-    pub seq_data: PackedSeqView<'a>,
+    pub seq_data: Pool<'a, u8>,
 
     /// Both paths and links can have overlaps, which are CIGAR sequences. They
     /// are all stored together here in a flat pool, elements of which point
@@ -400,6 +400,22 @@ pub struct SeqSpan {
     pub high_nibble_end: u8,
 }
 
+impl SeqSpan {
+    pub fn len(&self) -> usize {
+        let begin = match self.high_nibble_begin {
+            1 => 1,
+            0 => 0,
+            _ => panic!("invalid value in high_nibble_begin"),
+        };
+        let end = match self.high_nibble_end {
+            1 => 0,
+            0 => 1,
+            _ => panic!("invalid value in high_nibble_end"),
+        };
+        (self.end - self.start) * 2 - begin - end
+    }
+}
+
 /// The data storage pools for a `FlatGFA`.
 #[derive(Default)]
 pub struct GFAStore<'a, P: StoreFamily<'a>> {

flatgfa/src/packedseq.rs

@@ -134,41 +134,12 @@ impl<'a> PackedSeqView<'a> {
         }
     }
 
-    pub fn view_remaining(data: &'a [u8]) -> (Self, &'a [u8]) {
-        let (toc, rest) = read_packed_toc(data);
-
-        let (data, remaining) = slice_prefix(rest, toc.data);
-        (
-            Self {
-                data: data.into(),
-                high_nibble_end: match toc.high_nibble_end {
-                    0u8 => false,
-                    1u8 => true,
-                    _ => panic!("Invalid value in high_nibble_end"),
-                },
-                high_nibble_begin: match toc.high_nibble_begin {
-                    0u8 => false,
-                    1u8 => true,
-                    _ => panic!("Invalid value in high_nibble_begin"),
-                },
-            },
-            remaining,
-        )
-    }
-
     pub fn dump(&self, buf: &mut [u8]) {
         let toc = PackedToc::full(self);
         let rest = write_bump(buf, &toc).unwrap();
         write_bytes(rest, self.data).unwrap();
     }
 
-    pub fn dump_remaining(&self, buf: &'a mut [u8]) -> &'a mut [u8] {
-        let toc = PackedToc::full(self);
-        let rest = write_bump(buf, &toc).unwrap();
-        let rest = write_bytes(rest, self.data).unwrap();
-        rest
-    }
-
     pub fn len(&self) -> usize {
         let begin = if self.high_nibble_begin { 1 } else { 0 };
         let end = if self.high_nibble_end { 0 } else { 1 };