Bump to version 0.3 and clean up API/fix issues

 - support read-only mmaps
 - make range u128 by default and remove `u128` feature
 - provide default implemetations of get/set_range
 - fix rank/select and provide default implementations
 - implement BitVector for u8 to u128 and for Vec<u8>/&[u8]
 - include combinatorial functions from downstream (choose and rank/unrank bit permutations; note different type of rank)

Author: Roderick Bovee

Cargo.toml

@@ -1,14 +1,13 @@
 [package]
 name = "mmap-bitvec"
-version = "0.2.0"
+version = "0.3.0"
 authors = ["Roderick Bovee <roderick@onecodex.com>"]
 
 [dependencies]
 memmap = "0.6.2"
 murmurhash3 = "0.0.5"
 
 [features]
-u128 = []
 backward_bytes = []
 
 [dev-dependencies]

LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2017 One Codex
+Copyright (c) Reference Genomics, Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

src/bin/test_get_range.rs

@@ -1,23 +1,132 @@
 use std::ops::Range;
 
-#[cfg(not(feature = "u128"))]
-pub type BitVecSlice = u64;
-#[cfg(not(feature = "u128"))]
-pub const BIT_VEC_SLICE_SIZE: u8 = 64;
-#[cfg(feature = "u128")]
-pub type BitVecSlice = u128;
-#[cfg(feature = "u128")]
-pub const BIT_VEC_SLICE_SIZE: u8 = 128;
-
 pub trait BitVector {
-    fn size(&self) -> usize;
     fn get(&self, i: usize) -> bool;
-    fn get_range(&self, r: Range<usize>) -> BitVecSlice;
     fn set(&mut self, i: usize, x: bool);
-    fn set_range(&mut self, r: Range<usize>, x: BitVecSlice);
-    fn clear_range(&mut self, r: Range<usize>);
-    fn rank(&self, r: Range<usize>) -> usize;
-    fn select(&self, n: usize, start: usize) -> Option<usize>;
+    fn size(&self) -> usize;
+
+    fn rank(&self, r: Range<usize>) -> usize {
+        r.fold(0, |a, x| a + if self.get(x) { 1 } else { 0 })
+    }
+
+    fn select(&self, n: usize, start: usize) -> Option<usize> {
+        let mut bits_left = n;
+
+        for i in start..self.size() {
+            if self.get(i) {
+                bits_left -= 1;
+            }
+
+            if bits_left == 0 {
+                return Some(i);
+            }
+        }
+        None
+    }
+
+    fn get_range(&self, r: Range<usize>) -> u128 {
+        if r.end - r.start > 128usize {
+            panic!("Range too large (>128)")
+        } else if r.end > self.size() {
+            panic!("Range ends outside of BitVec")
+        }
+
+        let mut bvs = 0;
+        let mut bit_pos = 127;
+        for i in r {
+            if self.get(i) {
+                bvs += 1 << bit_pos;
+            };
+            bit_pos -= 1;
+        }
+        bvs
+    }
+
+    fn set_range(&mut self, r: Range<usize>, x: u128) {
+        let mut cur = x;
+        for i in r.rev() {
+            self.set(i, cur & 1 == 1);
+            cur >>= 1;
+        }
+    }
+
+    fn clear_range(&mut self, r: Range<usize>) {
+        for i in r.rev() {
+            self.set(i, false);
+        }
+    }
+}
+
+macro_rules! impl_bitvector {
+    ( $type:ty, $type_size:expr ) => {
+        impl BitVector for $type {
+            fn get(&self, i: usize) -> bool {
+                if i > $type_size - 1 {
+                    panic!("Invalid bit vector index");
+                }
+                (self & 1 << ($type_size - i)) > 0
+            }
+
+            fn set(&mut self, i: usize, x: bool) {
+                if x {
+                    self.clone_from(&(*self | (1 << ($type_size - i))));
+                } else {
+                    self.clone_from(&(*self & !(1 << ($type_size - i))));
+                }
+            }
+
+            fn size(&self) -> usize {
+                $type_size
+            }
+        }
+    };
+}
+
+impl_bitvector!(u8, 8);
+impl_bitvector!(u16, 16);
+impl_bitvector!(u32, 32);
+impl_bitvector!(u64, 64);
+impl_bitvector!(u128, 128);
+
+impl BitVector for &[u8] {
+    fn get(&self, i: usize) -> bool {
+        if i / 8 >= self.len() {
+            panic!("Invalid bit vector index");
+        }
+        self[i / 8] >> (8 - i % 8) & 1 == 1
+    }
+
+    fn set(&mut self, _: usize, _: bool) {
+        panic!("Can not set bits on a non-mut slice");
+    }
+
+    fn size(&self) -> usize {
+        self.len() / 8
+    }
+}
+
+impl BitVector for Vec<u8> {
+    fn get(&self, i: usize) -> bool {
+        if i / 8 >= self.len() {
+            panic!("Invalid bit vector index");
+        }
+        self[i / 8] >> (8 - i % 8) & 1 == 1
+    }
+
+    fn set(&mut self, i: usize, x: bool) {
+        if i / 8 >= self.len() {
+            panic!("Invalid bit vector index");
+        }
+        if x {
+            self[i / 8] |= 1 << (8 - i);
+        } else {
+            self[i / 8] &= !(1 << (8 - i));
+        }
+    }
+
+    fn size(&self) -> usize {
+        self.len() / 8
+    }
 }
 
-// TODO: impl for `std::collections::BitVec`?
+// TODO: impl for `bv::BitVec` and `bit-vec::BitVec`?