Rename reserve to reserve_exact and reserve_at_least to reserve

Changes in std::{str,vec,hashmap} and extra::{priority_queue,ringbuf}.
Fixes #11949

3 files changed, 32 insertions, 38 deletions

diff --git a/src/libstd/hashmap.rs b/src/libstd/hashmap.rs
index a97feea786d..7669467d4bb 100644
--- a/src/libstd/hashmap.rs
+++ b/src/libstd/hashmap.rs
@@ -384,7 +384,7 @@ impl<K: Hash + Eq, V> HashMap<K, V> {
     }
 
     /// Reserve space for at least `n` elements in the hash table.
-    pub fn reserve_at_least(&mut self, n: uint) {
+    pub fn reserve(&mut self, n: uint) {
         if n > self.buckets.len() {
             let buckets = n * 4 / 3 + 1;
             self.resize(num::next_power_of_two(buckets));
@@ -793,8 +793,8 @@ impl<T:Hash + Eq> HashSet<T> {
     }
 
     /// Reserve space for at least `n` elements in the hash table.
-    pub fn reserve_at_least(&mut self, n: uint) {
-        self.map.reserve_at_least(n)
+    pub fn reserve(&mut self, n: uint) {
+        self.map.reserve(n)
     }
 
     /// Returns true if the hash set contains a value equivalent to the
diff --git a/src/libstd/str.rs b/src/libstd/str.rs
index 3cc199ce195..e1387332e9f 100644
--- a/src/libstd/str.rs
+++ b/src/libstd/str.rs
@@ -104,7 +104,7 @@ use iter::{Iterator, FromIterator, Extendable, range};
 use iter::{Filter, AdditiveIterator, Map};
 use iter::{Rev, DoubleEndedIterator, ExactSize};
 use libc;
-use num::{Saturating, checked_next_power_of_two};
+use num::Saturating;
 use option::{None, Option, Some};
 use ptr;
 use ptr::RawPtr;
@@ -186,12 +186,7 @@ pub fn from_char(ch: char) -> ~str {
 
 /// Convert a vector of chars to a string
 pub fn from_chars(chs: &[char]) -> ~str {
-    let mut buf = ~"";
-    buf.reserve(chs.len());
-    for ch in chs.iter() {
-        buf.push_char(*ch)
-    }
-    buf
+    chs.iter().map(|c| *c).collect()
 }
 
 #[doc(hidden)]
@@ -875,8 +870,7 @@ pub fn utf16_chars(v: &[u16], f: |char|) {
 
 /// Allocates a new string from the utf-16 slice provided
 pub fn from_utf16(v: &[u16]) -> ~str {
-    let mut buf = ~"";
-    buf.reserve(v.len());
+    let mut buf = with_capacity(v.len());
     utf16_chars(v, |ch| buf.push_char(ch));
     buf
 }
@@ -2166,8 +2160,7 @@ impl<'a> StrSlice<'a> for &'a str {
     }
 
     fn escape_default(&self) -> ~str {
-        let mut out: ~str = ~"";
-        out.reserve_at_least(self.len());
+        let mut out = with_capacity(self.len());
         for c in self.chars() {
             c.escape_default(|c| out.push_char(c));
         }
@@ -2175,8 +2168,7 @@ impl<'a> StrSlice<'a> for &'a str {
     }
 
     fn escape_unicode(&self) -> ~str {
-        let mut out: ~str = ~"";
-        out.reserve_at_least(self.len());
+        let mut out = with_capacity(self.len());
         for c in self.chars() {
             c.escape_unicode(|c| out.push_char(c));
         }
@@ -2508,7 +2500,7 @@ pub trait OwnedStr {
     ///
     /// * s - A string
     /// * n - The number of bytes to reserve space for
-    fn reserve(&mut self, n: uint);
+    fn reserve_exact(&mut self, n: uint);
 
     /// Reserves capacity for at least `n` bytes in the given string.
     ///
@@ -2526,7 +2518,7 @@ pub trait OwnedStr {
     ///
     /// * s - A string
     /// * n - The number of bytes to reserve space for
-    fn reserve_at_least(&mut self, n: uint);
+    fn reserve(&mut self, n: uint);
 
     /// Returns the number of single-byte characters the string can hold without
     /// reallocating
@@ -2552,7 +2544,7 @@ impl OwnedStr for ~str {
     #[inline]
     fn push_str_no_overallocate(&mut self, rhs: &str) {
         let new_cap = self.len() + rhs.len();
-        self.reserve(new_cap);
+        self.reserve_exact(new_cap);
         self.push_str(rhs);
     }
 
@@ -2631,15 +2623,17 @@ impl OwnedStr for ~str {
     }
 
     #[inline]
-    fn reserve(&mut self, n: uint) {
+    fn reserve_exact(&mut self, n: uint) {
         unsafe {
-            raw::as_owned_vec(self).reserve(n)
+            raw::as_owned_vec(self).reserve_exact(n)
         }
     }
 
     #[inline]
-    fn reserve_at_least(&mut self, n: uint) {
-        self.reserve(checked_next_power_of_two(n).unwrap_or(n))
+    fn reserve(&mut self, n: uint) {
+        unsafe {
+            raw::as_owned_vec(self).reserve(n)
+        }
     }
 
     #[inline]
@@ -2711,7 +2705,7 @@ impl Extendable<char> for ~str {
     fn extend<T: Iterator<char>>(&mut self, iterator: &mut T) {
         let (lower, _) = iterator.size_hint();
         let reserve = lower + self.len();
-        self.reserve_at_least(reserve);
+        self.reserve(reserve);
         for ch in *iterator {
             self.push_char(ch)
         }
diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs
index 15cd5ce3343..f9a90150ad4 100644
--- a/src/libstd/vec.rs
+++ b/src/libstd/vec.rs
@@ -1335,7 +1335,7 @@ pub trait OwnedVector<T> {
      * This method always succeeds in reserving space for `n` elements, or it does
      * not return.
      */
-    fn reserve(&mut self, n: uint);
+    fn reserve_exact(&mut self, n: uint);
     /**
      * Reserves capacity for at least `n` elements in the given vector.
      *
@@ -1350,7 +1350,7 @@ pub trait OwnedVector<T> {
      *
      * * n - The number of elements to reserve space for
      */
-    fn reserve_at_least(&mut self, n: uint);
+    fn reserve(&mut self, n: uint);
     /**
      * Reserves capacity for at least `n` additional elements in the given vector.
      *
@@ -1468,7 +1468,7 @@ impl<T> OwnedVector<T> for ~[T] {
         self.move_iter().rev()
     }
 
-    fn reserve(&mut self, n: uint) {
+    fn reserve_exact(&mut self, n: uint) {
         // Only make the (slow) call into the runtime if we have to
         if self.capacity() < n {
             unsafe {
@@ -1486,8 +1486,8 @@ impl<T> OwnedVector<T> for ~[T] {
     }
 
     #[inline]
-    fn reserve_at_least(&mut self, n: uint) {
-        self.reserve(checked_next_power_of_two(n).unwrap_or(n));
+    fn reserve(&mut self, n: uint) {
+        self.reserve_exact(checked_next_power_of_two(n).unwrap_or(n));
     }
 
     #[inline]
@@ -1495,7 +1495,7 @@ impl<T> OwnedVector<T> for ~[T] {
         if self.capacity() - self.len() < n {
             match self.len().checked_add(&n) {
                 None => fail!("vec::reserve_additional: `uint` overflow"),
-                Some(new_cap) => self.reserve_at_least(new_cap)
+                Some(new_cap) => self.reserve(new_cap)
             }
         }
     }
@@ -1678,7 +1678,7 @@ impl<T> OwnedVector<T> for ~[T] {
     }
     fn grow_fn(&mut self, n: uint, op: |uint| -> T) {
         let new_len = self.len() + n;
-        self.reserve_at_least(new_len);
+        self.reserve(new_len);
         let mut i: uint = 0u;
         while i < n {
             self.push(op(i));
@@ -1737,7 +1737,7 @@ impl<T:Clone> OwnedCloneableVector<T> for ~[T] {
     #[inline]
     fn push_all(&mut self, rhs: &[T]) {
         let new_len = self.len() + rhs.len();
-        self.reserve(new_len);
+        self.reserve_exact(new_len);
 
         for elt in rhs.iter() {
             self.push((*elt).clone())
@@ -1745,7 +1745,7 @@ impl<T:Clone> OwnedCloneableVector<T> for ~[T] {
     }
     fn grow(&mut self, n: uint, initval: &T) {
         let new_len = self.len() + n;
-        self.reserve_at_least(new_len);
+        self.reserve(new_len);
         let mut i: uint = 0u;
 
         while i < n {
@@ -2900,7 +2900,7 @@ impl<A> Extendable<A> for ~[A] {
     fn extend<T: Iterator<A>>(&mut self, iterator: &mut T) {
         let (lower, _) = iterator.size_hint();
         let len = self.len();
-        self.reserve(len + lower);
+        self.reserve_exact(len + lower);
         for x in *iterator {
             self.push(x);
         }
@@ -3630,10 +3630,10 @@ mod tests {
     #[test]
     fn test_capacity() {
         let mut v = ~[0u64];
-        v.reserve(10u);
+        v.reserve_exact(10u);
         assert_eq!(v.capacity(), 10u);
         let mut v = ~[0u32];
-        v.reserve(10u);
+        v.reserve_exact(10u);
         assert_eq!(v.capacity(), 10u);
     }
 
@@ -4070,7 +4070,7 @@ mod tests {
     #[should_fail]
     fn test_overflow_does_not_cause_segfault() {
         let mut v = ~[];
-        v.reserve(-1);
+        v.reserve_exact(-1);
         v.push(1);
         v.push(2);
     }
@@ -4080,7 +4080,7 @@ mod tests {
     fn test_overflow_does_not_cause_segfault_managed() {
         use rc::Rc;
         let mut v = ~[Rc::new(1)];
-        v.reserve(-1);
+        v.reserve_exact(-1);
         v.push(Rc::new(2));
     }