WIP: draft PR merging Jason's changes to main.

.gitignore

@@ -1,2 +1,4 @@
 /target
 Cargo.lock
+*.bk
+.vscode

Cargo.toml

@@ -10,7 +10,7 @@ edition = "2021"
 bit_field = "0.10"
 serde = { version = "1.0", features = ["derive"] }
 num = "0.4.0"
-simple-sds = {git = "https://github.com/thejasonfan/simple-sds", branch = "serde_compat", optional = true }
+simple-sds = {git = "https://github.com/COMBINE-lab/simple-sds", branch = "simpler_serde_compat", optional = true }
 
 [features]
 seq-vector = ["dep:simple-sds"]
@@ -23,4 +23,4 @@ quickcheck_macros = "1"
 
 [[bench]]
 name = "simple_benchmark"
-harness = false
+harness = false

README.md

@@ -13,6 +13,7 @@ potentially interested parties via [twitter](https://twitter.com/nomad421/status
   * [Pierre Marijon](https://github.com/natir)
   * [Luiz Irber](https://github.com/luizirber)
   * [Rob Patro](https://github.com/rob-p)
+  * [Jason Fan](https://github.com/theJasonFan)
 
 ## Minimum supported Rust version
 

src/kmer.rs

@@ -2,13 +2,15 @@
 
 /* crate use */
 use bit_field::BitArray;
+use serde::{Deserialize, Serialize};
 use std::u32;
 
 /* project use */
 use crate::encoding;
 
 /// Struct to store and use kmer
-#[derive(Debug)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(bound = "[P; B]: Serialize + for<'a> Deserialize<'a>")]
 pub struct Kmer<P, const K: usize, const B: usize> {
     array: [P; B],
 }

src/naive_impl/canonical_kmer.rs

@@ -4,14 +4,14 @@ use super::Kmer;
 use serde::{Deserialize, Serialize};
 use std::convert::From;
 
-#[derive(Serialize, Deserialize, Eq, PartialEq, Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 pub enum MatchType {
     NoMatch,
     IdentityMatch,
     TwinMatch,
 }
 
-#[derive(Eq, PartialEq, Default, Debug, Clone, Ord, PartialOrd)]
+#[derive(Eq, PartialEq, Default, Debug, Clone, Ord, PartialOrd, Serialize, Deserialize)]
 pub struct CanonicalKmer {
     fw: Kmer,
     rc: Kmer,
@@ -171,6 +171,16 @@ impl From<Kmer> for CanonicalKmer {
     }
 }
 
+impl From<&Kmer> for CanonicalKmer {
+    #[inline]
+    fn from(km: &Kmer) -> Self {
+        Self {
+            rc: km.to_reverse_complement(),
+            fw: km.clone(),
+        }
+    }
+}
+
 impl From<String> for CanonicalKmer {
     fn from(s: String) -> Self {
         let fk = Kmer::from(s);

src/naive_impl/canonical_kmer_iterator.rs

@@ -6,17 +6,32 @@
 
 use super::prelude::*;
 use super::CanonicalKmer;
+use serde::{Deserialize, Serialize};
 
 // holds what is essentially a pair of
 // km: the canonical k-mer on the read
 // pos: the offset on the read where this k-mer starts
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct CanonicalKmerPos {
     pub km: CanonicalKmer,
-    pub pos: i32,
+    pub(super) pos: i32, // FIXME: change to use Wrapping<...>
 }
 
 impl CanonicalKmerPos {
-    fn new(k: u8) -> Self {
+    pub fn new(km: CanonicalKmer, pos: usize) -> Self {
+        Self {
+            km,
+            pos: pos as i32,
+        }
+    }
+
+    pub fn pos(&self) -> usize {
+        self.pos as usize
+    }
+}
+
+impl CanonicalKmerPos {
+    fn blank_of_size(k: u8) -> Self {
         Self {
             km: CanonicalKmer::blank_of_size(k),
             pos: -1i32,
@@ -29,6 +44,7 @@ impl CanonicalKmerPos {
 // It is capable of iterating over this sequence (skipping invalid
 // k-mers, e.g. k-mers containing `N`), and producing
 // a `CanonicalKmerPos` struct for all valid k-mers in `seq`.
+#[derive(Debug, Clone)]
 pub struct CanonicalKmerIterator<'a> {
     seq: &'a [u8],
     value_pair: CanonicalKmerPos,
@@ -72,7 +88,7 @@ impl<'slice> CanonicalKmerIterator<'slice> {
     pub fn from_u8_slice(s: &'slice [u8], k: u8) -> CanonicalKmerIterator {
         let mut r = Self {
             seq: s,
-            value_pair: CanonicalKmerPos::new(k),
+            value_pair: CanonicalKmerPos::blank_of_size(k),
             invalid: false,
             last_invalid: -1i32,
             k: k as i32,
@@ -116,6 +132,20 @@ impl<'slice> CanonicalKmerIterator<'slice> {
     }
 }
 
+impl Iterator for CanonicalKmerIterator<'_> {
+    type Item = CanonicalKmerPos;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.exhausted() {
+            None
+        } else {
+            let item = Some(self.get().clone());
+            self.inc();
+            item
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -204,4 +234,17 @@ mod tests {
         ck_iter.inc();
         assert!(ck_iter.exhausted());
     }
+
+    #[test]
+    fn test_iter() {
+        let r = b"NAAANTTT";
+        let k = 3;
+        let ck_iter = CanonicalKmerIterator::from_u8_slice(r, k);
+        let kms: Vec<CanonicalKmerPos> = ck_iter.collect();
+        let kws = vec![
+            CanonicalKmerPos::new(CanonicalKmer::from("AAA"), 1),
+            CanonicalKmerPos::new(CanonicalKmer::from("TTT"), 5),
+        ];
+        assert_eq!(kms, kws)
+    }
 }

src/naive_impl/checked.rs

@@ -0,0 +1,93 @@
+use super::{Base, Kmer};
+
+/// This module can only return one error, the EncodeError
+#[derive(Debug, PartialEq, Eq)]
+pub struct EncodeError;
+type Result<T> = std::result::Result<T, EncodeError>;
+
+impl Kmer {
+    /// Failable conversion from byte slice to Kmer
+    pub fn from_bytes_checked(s: &[u8]) -> Result<Self> {
+        if s.len() > 32 {
+            panic!("kmers longer than 32 bases not supported");
+        }
+
+        let k = s.len() as u8;
+
+        let mut w = 0_u64;
+        // read sequence "left to right" from "lower to higher" order bits
+        for c in s.iter().rev() {
+            w <<= 2;
+            w |= encode_binary_checked(*c as char)?;
+        }
+        let data = w;
+
+        Ok(Kmer { data, k })
+    }
+}
+
+/// Failable encoding
+pub fn encode_binary_checked(c: char) -> Result<Base> {
+    let code = CODES[c as usize];
+    if code >= 0 {
+        Ok(code as Base)
+    } else {
+        Err(EncodeError)
+    }
+}
+
+// see Kmer.hpp
+const R: i32 = -1;
+const I: i32 = -2;
+const O: i32 = -3;
+const A: i32 = 0;
+const C: i32 = 1;
+const G: i32 = 2;
+const T: i32 = 3;
+
+const CODES: [i32; 256] = [
+    O, O, O, O, O, O, O, O, O, O, I, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O,
+    O, O, O, O, O, O, O, O, O, O, O, O, O, R, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O,
+    O, A, R, C, R, O, O, G, R, O, O, R, O, R, R, O, O, O, R, R, T, O, R, R, R, R, O, O, O, O, O, O,
+    O, A, R, C, R, O, O, G, R, O, O, R, O, R, R, O, O, O, R, R, T, O, R, R, R, R, O, O, O, O, O, O,
+    O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O,
+    O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O,
+    O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O,
+    O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O,
+];
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn checked_nuc_encoding() {
+        let allowed = ['A', 'C', 'G', 'T', 'a', 'c', 'g', 't'];
+        let expected_err = Err(EncodeError);
+        for c in 0..(char::MAX as u8) {
+            let c = c as char;
+            if !allowed.contains(&c) {
+                assert_eq!(expected_err, encode_binary_checked(c));
+            }
+        }
+
+        let nucs: Vec<Result<u64>> = allowed.iter().map(|c| encode_binary_checked(*c)).collect();
+        let codes: Vec<Result<u64>> = [0, 1, 2, 3, 0, 1, 2, 3].iter().map(|i| Ok(*i)).collect();
+        assert_eq!(nucs, codes);
+    }
+
+    #[test]
+    fn checked_kmer_encoding() {
+        let bytes = b"ANa";
+        let kw = Kmer::from_bytes_checked(bytes);
+
+        assert_eq!(kw, Err(EncodeError));
+
+        let bytes = b"acgt";
+        let km = Kmer::from(bytes);
+        let kw = Kmer::from_bytes_checked(bytes).unwrap();
+
+        assert_eq!(km, kw);
+        assert_eq!(kw.len(), 4);
+    }
+}