Changed split_at and split_at_mut methods in BitSlice and BitSliceMut to take self as parameter and to return BitSlice<'a, S> and BitSliceMut<'a, S> respectively where 'a is the lifetime of the data inside BitSlice and BitSliceMut respectively, added reborrow() method on BitSlice and BitSliceMut to be able to read the original slice before splitting and added integration tests for a real usecase where this feature was needed.

Author: skiwi2

src/bit_slice.rs

@@ -38,7 +38,7 @@ impl<'a, S: BitStorage + 'a> BitSlice<'a, S> {
         self.capacity
     }
 
-    pub fn split_at(&self, index: usize) -> (BitSlice<S>, BitSlice<S>) {
+    pub fn split_at(self, index: usize) -> (BitSlice<'a, S>, BitSlice<'a, S>) {
         self.panic_index_not_on_storage_bound(index);
         let data_index = S::compute_data_index(index);
         let (capacity_left, capacity_right) = self.compute_capacities(index);
@@ -51,6 +51,14 @@ impl<'a, S: BitStorage + 'a> BitSlice<'a, S> {
         }
     }
 
+    pub fn reborrow<'b>(&'b self) -> BitSlice<'b, S> {
+        BitSlice {
+            pointer: self.pointer,
+            capacity: self.capacity,
+            phantom: self.phantom
+        }
+    }
+
     pub fn iter(&self) -> Iter<S> {
         Iter {
             pointer: self.pointer,
@@ -342,6 +350,38 @@ mod tests {
         slice.split_at(4);
     }
 
+    #[test]
+    fn test_reborrow() {
+        let mut vec_8_32: BitVector<u8> = BitVector::with_capacity(32, false);
+
+        vec_8_32.set(1, true);
+        vec_8_32.set(3, true);
+        vec_8_32.set(5, true);
+        vec_8_32.set(7, true);
+        vec_8_32.set(11, true);
+        vec_8_32.set(13, true);
+
+        let (_, slice) = vec_8_32.split_at(0);
+        let reborrow = slice.reborrow();
+
+        assert_eq!(reborrow[0], false);
+        assert_eq!(reborrow[1], true);
+        assert_eq!(reborrow[2], false);
+        assert_eq!(reborrow[3], true);
+        assert_eq!(reborrow[4], false);
+        assert_eq!(reborrow[5], true);
+        assert_eq!(reborrow[6], false);
+        assert_eq!(reborrow[7], true);
+        assert_eq!(reborrow[8], false);
+        assert_eq!(reborrow[9], false);
+        assert_eq!(reborrow[10], false);
+        assert_eq!(reborrow[11], true);
+        assert_eq!(reborrow[12], false);
+        assert_eq!(reborrow[13], true);
+        assert_eq!(reborrow[14], false);
+        assert_eq!(reborrow[15], false);
+    }
+
     #[test]
     fn test_iter() {
         let mut vec_8_4 = BitVector::<u8>::with_capacity(4, false);

src/bit_slice_mut.rs

@@ -48,7 +48,7 @@ impl<'a, S: BitStorage + 'a> BitSliceMut<'a, S> {
         self.capacity
     }
 
-    pub fn split_at(&self, index: usize) -> (BitSlice<S>, BitSlice<S>) {
+    pub fn split_at(self, index: usize) -> (BitSlice<'a, S>, BitSlice<'a, S>) {
         self.panic_index_not_on_storage_bound(index);
         let data_index = S::compute_data_index(index);
         let (capacity_left, capacity_right) = self.compute_capacities(index);
@@ -61,7 +61,7 @@ impl<'a, S: BitStorage + 'a> BitSliceMut<'a, S> {
         }
     }
 
-    pub fn split_at_mut(&mut self, index: usize) -> (BitSliceMut<S>, BitSliceMut<S>) {
+    pub fn split_at_mut(self, index: usize) -> (BitSliceMut<'a, S>, BitSliceMut<'a, S>) {
         self.panic_index_not_on_storage_bound(index);
         let data_index = S::compute_data_index(index);
         let (capacity_left, capacity_right) = self.compute_capacities(index);
@@ -74,6 +74,14 @@ impl<'a, S: BitStorage + 'a> BitSliceMut<'a, S> {
         }
     }
 
+    pub fn reborrow<'b>(&'b self) -> BitSliceMut<'b, S> {
+        BitSliceMut {
+            pointer: self.pointer,
+            capacity: self.capacity,
+            phantom: self.phantom
+        }
+    }
+
     pub fn iter(&self) -> Iter<S> {
         Iter {
             pointer: self.pointer,
@@ -501,6 +509,7 @@ mod tests {
         slice.set(15, true);
 
         {
+            let slice = slice.reborrow();
             let (mut left, mut right) = slice.split_at_mut(8);
 
             assert_eq!(left[0], true);
@@ -562,10 +571,42 @@ mod tests {
     #[should_panic]
     fn test_split_at_mut_not_on_storage_bound() {
         let mut vec_8_32: BitVector<u8> = BitVector::with_capacity(32, false);
-        let mut slice = create_bitslice_mut_u8_16_from_bitvector_u8_32(&mut vec_8_32);
+        let slice = create_bitslice_mut_u8_16_from_bitvector_u8_32(&mut vec_8_32);
         slice.split_at_mut(4);
     }
 
+    #[test]
+    fn test_reborrow() {
+        let mut vec_8_32: BitVector<u8> = BitVector::with_capacity(32, false);
+
+        vec_8_32.set(1, true);
+        vec_8_32.set(3, true);
+        vec_8_32.set(5, true);
+        vec_8_32.set(7, true);
+        vec_8_32.set(11, true);
+        vec_8_32.set(13, true);
+
+        let (_, slice) = vec_8_32.split_at(0);
+        let reborrow = slice.reborrow();
+
+        assert_eq!(reborrow[0], false);
+        assert_eq!(reborrow[1], true);
+        assert_eq!(reborrow[2], false);
+        assert_eq!(reborrow[3], true);
+        assert_eq!(reborrow[4], false);
+        assert_eq!(reborrow[5], true);
+        assert_eq!(reborrow[6], false);
+        assert_eq!(reborrow[7], true);
+        assert_eq!(reborrow[8], false);
+        assert_eq!(reborrow[9], false);
+        assert_eq!(reborrow[10], false);
+        assert_eq!(reborrow[11], true);
+        assert_eq!(reborrow[12], false);
+        assert_eq!(reborrow[13], true);
+        assert_eq!(reborrow[14], false);
+        assert_eq!(reborrow[15], false);
+    }
+
     #[test]
     fn test_iter() {
         let mut vec_8_4 = BitVector::<u8>::with_capacity(4, false);

tests/lib.rs

@@ -1,7 +1,7 @@
 extern crate bit_vector;
 extern crate crossbeam;
 
-use bit_vector::BitVector;
+use bit_vector::{BitVector,BitSlice,BitSliceMut,BitStorage};
 
 #[test]
 fn test_parallel_immutable() {
@@ -110,7 +110,7 @@ fn test_parallel_mutable() {
 	let mut vec: BitVector<u8> = BitVector::with_capacity(32, false);
 
 	{
-		let (mut left, mut right) = vec.split_at_mut(16);
+		let (left, right) = vec.split_at_mut(16);
 
 		let (mut first, mut second) = left.split_at_mut(8);
 		let (mut third, mut fourth) = right.split_at_mut(8);
@@ -207,4 +207,54 @@ fn test_parallel_mutable() {
 	assert_eq!(vec[29], false);
 	assert_eq!(vec[30], false);
 	assert_eq!(vec[31], true);
+}
+
+#[test]
+fn test_reborrow_immutable() {
+    let mut vector: BitVector<u32> = BitVector::with_capacity(1000, false);
+    let indices = vec![128, 224, 320, 416, 512, 608, 704, 800, 928];
+
+    let slices = split_into_bit_slices(&mut vector, &indices);
+    assert_eq!(slices.len(), 10);
+}
+
+fn split_into_bit_slices<'a, S: BitStorage>(bit_vector: &'a mut BitVector<S>, indices: &[usize]) -> Vec<BitSlice<'a, S>> {
+    let mut bit_slices = vec![];
+
+    bit_slices.push(bit_vector.split_at(0).1);
+    let mut split_indices = 0;
+    for index in indices {
+        let last_slice = bit_slices.pop().unwrap();
+        let (new_slice, remainder) = last_slice.split_at(index - split_indices);
+        split_indices = *index;
+        bit_slices.push(new_slice);
+        bit_slices.push(remainder);
+    }
+
+    bit_slices
+}
+
+#[test]
+fn test_reborrow_mutable() {
+    let mut vector: BitVector<u32> = BitVector::with_capacity(1000, false);
+    let indices = vec![128, 224, 320, 416, 512, 608, 704, 800, 928];
+
+    let slices = split_into_bit_slices_mut(&mut vector, &indices);
+    assert_eq!(slices.len(), 10);
+}
+
+fn split_into_bit_slices_mut<'a, S: BitStorage>(bit_vector: &'a mut BitVector<S>, indices: &[usize]) -> Vec<BitSliceMut<'a, S>> {
+    let mut bit_slices = vec![];
+
+    bit_slices.push(bit_vector.split_at_mut(0).1);
+    let mut split_indices = 0;
+    for index in indices {
+        let last_slice = bit_slices.pop().unwrap();
+        let (new_slice, remainder) = last_slice.split_at_mut(index - split_indices);
+        split_indices = *index;
+        bit_slices.push(new_slice);
+        bit_slices.push(remainder);
+    }
+
+    bit_slices
 }