Merge pull request #257 from RoaringBitmap/rename-remove-front-back

Rename the `remove_front/back` methods into `remove_smallest/biggest`

src/bitmap/container.rs

@@ -94,33 +94,33 @@ impl Container {
         result
     }
 
-    pub fn remove_front(&mut self, n: u64) {
+    pub fn remove_smallest(&mut self, n: u64) {
         match &self.store {
             Store::Bitmap(bits) => {
                 if bits.len() - n <= ARRAY_LIMIT {
                     let mut replace_array = Vec::with_capacity((bits.len() - n) as usize);
                     replace_array.extend(bits.iter().skip(n as usize));
                     self.store = Store::Array(store::ArrayStore::from_vec_unchecked(replace_array));
                 } else {
-                    self.store.remove_front(n)
+                    self.store.remove_smallest(n)
                 }
             }
-            Store::Array(_) => self.store.remove_front(n),
+            Store::Array(_) => self.store.remove_smallest(n),
         };
     }
 
-    pub fn remove_back(&mut self, n: u64) {
+    pub fn remove_biggest(&mut self, n: u64) {
         match &self.store {
             Store::Bitmap(bits) => {
                 if bits.len() - n <= ARRAY_LIMIT {
                     let mut replace_array = Vec::with_capacity((bits.len() - n) as usize);
                     replace_array.extend(bits.iter().take((bits.len() - n) as usize));
                     self.store = Store::Array(store::ArrayStore::from_vec_unchecked(replace_array));
                 } else {
-                    self.store.remove_back(n)
+                    self.store.remove_biggest(n)
                 }
             }
-            Store::Array(_) => self.store.remove_back(n),
+            Store::Array(_) => self.store.remove_biggest(n),
         };
     }
 

src/bitmap/inherent.rs

@@ -579,21 +579,21 @@ impl RoaringBitmap {
         None
     }
 
-    /// Removes the specified number of elements from the top.
+    /// Removes the `n` smallests values from this bitmap.
     ///
     /// # Examples
     ///
     /// ```rust
     /// use roaring::RoaringBitmap;
     ///
     /// let mut rb = RoaringBitmap::from_iter([1, 5, 7, 9]);
-    /// rb.remove_front(2);
+    /// rb.remove_smallest(2);
     /// assert_eq!(rb, RoaringBitmap::from_iter([7, 9]));
     ///
     /// let mut rb = RoaringBitmap::from_iter([1, 3, 7, 9]);
-    /// rb.remove_front(2);
+    /// rb.remove_smallest(2);
     /// assert_eq!(rb, RoaringBitmap::from_iter([7, 9]));
-    pub fn remove_front(&mut self, mut n: u64) {
+    pub fn remove_smallest(&mut self, mut n: u64) {
         // remove containers up to the front of the target
         let position = self.containers.iter().position(|container| {
             let container_len = container.len();
@@ -611,23 +611,23 @@ impl RoaringBitmap {
         // remove data in containers if there are still targets for deletion
         if n > 0 && !self.containers.is_empty() {
             // container immediately before should have been deleted, so the target is 0 index
-            self.containers[0].remove_front(n);
+            self.containers[0].remove_smallest(n);
         }
     }
 
-    /// Removes the specified number of elements from the tail.
+    /// Removes the `n` biggests values from this bitmap.
     ///
     /// # Examples
     ///
     /// ```rust
     /// use roaring::RoaringBitmap;
     ///
     /// let mut rb = RoaringBitmap::from_iter([1, 5, 7, 9]);
-    /// rb.remove_back(2);
+    /// rb.remove_biggest(2);
     /// assert_eq!(rb, RoaringBitmap::from_iter([1, 5]));
-    /// rb.remove_back(1);
+    /// rb.remove_biggest(1);
     /// assert_eq!(rb, RoaringBitmap::from_iter([1]));
-    pub fn remove_back(&mut self, mut n: u64) {
+    pub fn remove_biggest(&mut self, mut n: u64) {
         // remove containers up to the back of the target
         let position = self.containers.iter().rposition(|container| {
             let container_len = container.len();
@@ -642,7 +642,7 @@ impl RoaringBitmap {
         if let Some(position) = position {
             self.containers.drain(position + 1..);
             if n > 0 && !self.containers.is_empty() {
-                self.containers[position].remove_back(n);
+                self.containers[position].remove_biggest(n);
             }
         } else {
             self.containers.clear();
@@ -800,127 +800,127 @@ mod tests {
     }
 
     #[test]
-    fn remove_front_for_vec() {
+    fn remove_smallest_for_vec() {
         let mut bitmap = RoaringBitmap::from_iter([1, 2, 3, 7, 9, 11]);
-        bitmap.remove_front(3);
+        bitmap.remove_smallest(3);
         assert_eq!(bitmap.len(), 3);
         assert_eq!(bitmap, RoaringBitmap::from_iter([7, 9, 11]));
 
         bitmap = RoaringBitmap::from_iter([1, 2, 5, 7, 9, 11]);
-        bitmap.remove_front(3);
+        bitmap.remove_smallest(3);
         assert_eq!(bitmap.len(), 3);
         assert_eq!(bitmap, RoaringBitmap::from_iter([7, 9, 11]));
 
         bitmap = RoaringBitmap::from_iter([1, 3]);
-        bitmap.remove_front(2);
+        bitmap.remove_smallest(2);
         assert_eq!(bitmap.len(), 0);
 
         bitmap = RoaringBitmap::from_iter([1, 2, 3, 7, 9, 11]);
-        bitmap.remove_front(0);
+        bitmap.remove_smallest(0);
         assert_eq!(bitmap.len(), 6);
         assert_eq!(bitmap, RoaringBitmap::from_iter([1, 2, 3, 7, 9, 11]));
 
         bitmap = RoaringBitmap::new();
         bitmap.insert_range(0..(1_u32 << 16) + 5);
-        bitmap.remove_front(65537);
+        bitmap.remove_smallest(65537);
         assert_eq!(bitmap.len(), 4);
         assert_eq!(bitmap, RoaringBitmap::from_iter([65537, 65538, 65539, 65540]));
 
         bitmap = RoaringBitmap::from_iter([1, 2, 5, 7, 9, 11]);
-        bitmap.remove_front(7);
+        bitmap.remove_smallest(7);
         assert_eq!(bitmap, RoaringBitmap::default());
     }
 
     #[test]
-    fn remove_front_for_bit() {
+    fn remove_smallest_for_bit() {
         let mut bitmap = RoaringBitmap::new();
         bitmap.insert_range(0..4098);
-        bitmap.remove_front(4095);
+        bitmap.remove_smallest(4095);
         assert_eq!(bitmap.len(), 3);
         // removed bit to vec
         assert_eq!(bitmap, RoaringBitmap::from_iter([4095, 4096, 4097]));
 
         bitmap = RoaringBitmap::new();
         bitmap.insert_range(0..6000);
-        bitmap.remove_front(999);
+        bitmap.remove_smallest(999);
         assert_eq!(bitmap.len(), 5001);
 
         bitmap = RoaringBitmap::new();
         bitmap.insert_range(0..8000);
-        bitmap.remove_front(10);
+        bitmap.remove_smallest(10);
         assert_eq!(bitmap.len(), 7990);
 
         bitmap = RoaringBitmap::new();
         bitmap.insert_range(0..200000);
-        bitmap.remove_front(2000);
+        bitmap.remove_smallest(2000);
         assert_eq!(bitmap.len(), 198000);
         assert_eq!(bitmap, RoaringBitmap::from_iter(2000..200000));
 
         bitmap = RoaringBitmap::new();
         bitmap.insert_range(0..2);
         bitmap.insert_range(4..7);
         bitmap.insert_range(1000..6000);
-        bitmap.remove_front(30);
+        bitmap.remove_smallest(30);
         assert_eq!(bitmap.len(), 4975);
 
         bitmap = RoaringBitmap::new();
         bitmap.insert_range(0..65535);
-        bitmap.remove_front(0);
+        bitmap.remove_smallest(0);
         assert_eq!(bitmap.len(), 65535);
     }
 
     #[test]
-    fn remove_back_for_bit() {
+    fn remove_biggest_for_bit() {
         let mut bitmap = RoaringBitmap::new();
         bitmap.insert_range(0..5000);
-        bitmap.remove_back(1000);
+        bitmap.remove_biggest(1000);
         assert_eq!(bitmap.len(), 4000);
 
         bitmap = RoaringBitmap::new();
         bitmap.insert_range(0..6000);
-        bitmap.remove_back(1000);
+        bitmap.remove_biggest(1000);
         assert_eq!(bitmap.len(), 5000);
 
         bitmap = RoaringBitmap::new();
         bitmap.insert_range(0..200000);
-        bitmap.remove_back(196000);
+        bitmap.remove_biggest(196000);
         assert_eq!(bitmap.len(), 4000);
 
         bitmap = RoaringBitmap::new();
         bitmap.insert_range(0..200000);
-        bitmap.remove_back(2000);
+        bitmap.remove_biggest(2000);
         assert_eq!(bitmap.len(), 198000);
         assert_eq!(bitmap, RoaringBitmap::from_iter(0..198000));
 
         bitmap = RoaringBitmap::new();
         bitmap.insert_range(0..65535);
-        bitmap.remove_back(0);
+        bitmap.remove_biggest(0);
         assert_eq!(bitmap.len(), 65535);
     }
 
     #[test]
-    fn remove_back_for_vec() {
+    fn remove_biggest_for_vec() {
         let mut bitmap = RoaringBitmap::from_iter([1, 2, 3, 7, 9, 11]);
-        bitmap.remove_back(2);
+        bitmap.remove_biggest(2);
         assert_eq!(bitmap, RoaringBitmap::from_iter([1, 2, 3, 7]));
 
         bitmap = RoaringBitmap::from_iter([1, 2, 3, 7, 9, 11]);
-        bitmap.remove_back(6);
+        bitmap.remove_biggest(6);
         assert_eq!(bitmap.len(), 0);
 
         bitmap = RoaringBitmap::from_iter([1, 2, 3, 7, 9, 11]);
-        bitmap.remove_back(0);
+        bitmap.remove_biggest(0);
         assert_eq!(bitmap.len(), 6);
         assert_eq!(bitmap, RoaringBitmap::from_iter([1, 2, 3, 7, 9, 11]));
 
         bitmap = RoaringBitmap::new();
         bitmap.insert_range(0..(1_u32 << 16) + 5);
-        bitmap.remove_back(65537);
+        bitmap.remove_biggest(65537);
         assert_eq!(bitmap.len(), 4);
         assert_eq!(bitmap, RoaringBitmap::from_iter([0, 1, 2, 3]));
 
         let mut bitmap = RoaringBitmap::from_iter([1, 2, 3]);
-        bitmap.remove_back(4);
+        bitmap.remove_biggest(4);
         assert_eq!(bitmap, RoaringBitmap::default());
     }
 }

src/bitmap/store/array_store/mod.rs

@@ -110,12 +110,12 @@ impl ArrayStore {
         (pos_end - pos_start) as u64
     }
 
-    pub fn remove_front(&mut self, n: u64) {
+    pub fn remove_smallest(&mut self, n: u64) {
         self.vec.rotate_left(n as usize);
         self.vec.truncate(self.vec.len() - n as usize);
     }
 
-    pub fn remove_back(&mut self, n: u64) {
+    pub fn remove_biggest(&mut self, n: u64) {
         self.vec.truncate(self.vec.len() - n as usize);
     }
 
@@ -573,16 +573,16 @@ mod tests {
     }
 
     #[test]
-    fn test_bitmap_remove_front() {
+    fn test_bitmap_remove_smallest() {
         let mut store = Store::Array(ArrayStore::from_vec_unchecked(vec![1, 2, 130, 500]));
-        store.remove_front(3);
+        store.remove_smallest(3);
         assert_eq!(into_vec(store), vec![500]);
     }
 
     #[test]
-    fn test_bitmap_remove_back() {
+    fn test_bitmap_remove_biggest() {
         let mut store = Store::Array(ArrayStore::from_vec_unchecked(vec![1, 2, 130, 500]));
-        store.remove_back(2);
+        store.remove_biggest(2);
         assert_eq!(into_vec(store), vec![1, 2]);
     }
 }

src/bitmap/store/bitmap_store.rs

@@ -309,7 +309,7 @@ impl BitmapStore {
     }
 
     /// Set N bits that are currently 1 bit from the lower bit to 0.
-    pub fn remove_front(&mut self, mut clear_bits: u64) {
+    pub fn remove_smallest(&mut self, mut clear_bits: u64) {
         if self.len() < clear_bits {
             self.clear();
             return;
@@ -332,7 +332,7 @@ impl BitmapStore {
     }
 
     /// Set N bits that are currently 1 bit from the lower bit to 0.
-    pub fn remove_back(&mut self, mut clear_bits: u64) {
+    pub fn remove_biggest(&mut self, mut clear_bits: u64) {
         if self.len() < clear_bits {
             self.clear();
             return;
@@ -547,29 +547,29 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_bitmap_remove_front() {
+    fn test_bitmap_remove_smallest() {
         let mut store = BitmapStore::new();
         let range = RangeInclusive::new(1, 3);
         store.insert_range(range);
         let range_second = RangeInclusive::new(5, 65535);
         // store.bits[0] = 0b1111111111111111111111111111111111111111111111111111111111101110
         store.insert_range(range_second);
-        store.remove_front(2);
+        store.remove_smallest(2);
         assert_eq!(
             store.bits[0],
             0b1111111111111111111111111111111111111111111111111111111111101000
         );
     }
 
     #[test]
-    fn test_bitmap_remove_back() {
+    fn test_bitmap_remove_biggest() {
         let mut store = BitmapStore::new();
         let range = RangeInclusive::new(1, 3);
         store.insert_range(range);
         let range_second = RangeInclusive::new(5, 65535);
         // store.bits[1023] = 0b1111111111111111111111111111111111111111111111111111111111111111
         store.insert_range(range_second);
-        store.remove_back(2);
+        store.remove_biggest(2);
         assert_eq!(
             store.bits[1023],
             0b11111111111111111111111111111111111111111111111111111111111111

src/bitmap/store/mod.rs

@@ -106,17 +106,17 @@ impl Store {
         }
     }
 
-    pub fn remove_front(&mut self, index: u64) {
+    pub fn remove_smallest(&mut self, index: u64) {
         match self {
-            Array(vec) => vec.remove_front(index),
-            Bitmap(bits) => bits.remove_front(index),
+            Array(vec) => vec.remove_smallest(index),
+            Bitmap(bits) => bits.remove_smallest(index),
         }
     }
 
-    pub fn remove_back(&mut self, index: u64) {
+    pub fn remove_biggest(&mut self, index: u64) {
         match self {
-            Array(vec) => vec.remove_back(index),
-            Bitmap(bits) => bits.remove_back(index),
+            Array(vec) => vec.remove_biggest(index),
+            Bitmap(bits) => bits.remove_biggest(index),
         }
     }