Make bitv's APIs match RFC + fixup

Author: Gankra

src/libcollections/bit.rs

@@ -91,7 +91,7 @@ use core::num::Int;
 use core::slice::{Items, MutItems};
 use core::{u8, u32, uint};
 
-use hash;
+use core::hash;
 use Vec;
 
 type Blocks<'a> = Cloned<Items<'a, u32>>;
@@ -922,7 +922,7 @@ pub fn from_bytes(bytes: &[u8]) -> Bitv {
 
 /// Deprecated: Now a static method on Bitv.
 #[deprecated = "Now a static method on Bitv"]
-pub fn from_fn<F>(len: uint, mut f: F) -> Bitv where F: FnMut(uint) -> bool {
+pub fn from_fn<F>(len: uint, f: F) -> Bitv where F: FnMut(uint) -> bool {
     Bitv::from_fn(len, f)
 }
 
@@ -1226,55 +1226,53 @@ impl BitvSet {
         self.bitv.capacity()
     }
 
-    /// Reserves capacity for an element to be inserted at `index` in the given
-    /// `Bitv`. The collection may reserve more space to avoid frequent reallocations.
+    /// Reserves capacity for the given `BitvSet` to contain `len` distinct elements. In the case
+    /// of `BitvSet` this means reallocations will not occur as long as all inserted elements
+    /// are less than `len`.
     ///
-    /// # Panics
+    /// The collection may reserve more space to avoid frequent reallocations.
     ///
-    /// Panics if the new capacity overflows `uint`.
     ///
     /// # Examples
     ///
     /// ```
     /// use std::collections::BitvSet;
     ///
     /// let mut s = BitvSet::new();
-    /// s.reserve_index(10);
-    /// assert!(s.capacity() >= 11);
+    /// s.reserve_len(10);
+    /// assert!(s.capacity() >= 10);
     /// ```
     #[unstable = "matches collection reform specification, waiting for dust to settle"]
-    pub fn reserve_index(&mut self, index: uint) {
-        let len = self.bitv.len();
-        if index >= len {
-            self.bitv.reserve(index - len + 1);
+    pub fn reserve_len(&mut self, len: uint) {
+        let cur_len = self.bitv.len();
+        if len >= cur_len {
+            self.bitv.reserve(len - cur_len);
         }
     }
 
-    /// Reserves the minimum capacity for an element to be inserted at `index`
-    /// in the given `BitvSet`. Does nothing if the capacity is already sufficient.
+    /// Reserves the minimum capacity for the given `BitvSet` to contain `len` distinct elements.
+    /// In the case of `BitvSet` this means reallocations will not occur as long as all inserted
+    /// elements are less than `len`.
     ///
     /// Note that the allocator may give the collection more space than it requests. Therefore
-    /// capacity can not be relied upon to be precisely minimal. Prefer `reserve_index` if future
+    /// capacity can not be relied upon to be precisely minimal. Prefer `reserve_len` if future
     /// insertions are expected.
     ///
-    /// # Panics
-    ///
-    /// Panics if the new capacity overflows `uint`.
     ///
     /// # Examples
     ///
     /// ```
     /// use std::collections::BitvSet;
     ///
     /// let mut s = BitvSet::new();
-    /// s.reserve_index_exact(10);
-    /// assert!(s.capacity() >= 11);
+    /// s.reserve_len_exact(10);
+    /// assert!(s.capacity() >= 10);
     /// ```
     #[unstable = "matches collection reform specification, waiting for dust to settle"]
-    pub fn reserve_index_exact(&mut self, index: uint) {
-        let len = self.bitv.len();
-        if index >= len {
-            self.bitv.reserve_exact(index - len + 1);
+    pub fn reserve_len_exact(&mut self, len: uint) {
+        let cur_len = self.bitv.len();
+        if len >= cur_len {
+            self.bitv.reserve_exact(len - cur_len);
         }
     }
 
@@ -2636,9 +2634,9 @@ mod bitv_set_test {
         for &b in bools.iter() {
             for &l in lengths.iter() {
                 let bitset = BitvSet::from_bitv(Bitv::from_elem(l, b));
-                assert_eq!(bitset.contains(&1u), b)
-                assert_eq!(bitset.contains(&(l-1u)), b)
-                assert!(!bitset.contains(&l))
+                assert_eq!(bitset.contains(&1u), b);
+                assert_eq!(bitset.contains(&(l-1u)), b);
+                assert!(!bitset.contains(&l));
             }
         }
     }