diff --git a/src/libextra/priority_queue.rs b/src/libextra/priority_queue.rs index 33b3931e9897a..3ae3dae9ea307 100644 --- a/src/libextra/priority_queue.rs +++ b/src/libextra/priority_queue.rs @@ -51,10 +51,14 @@ impl PriorityQueue { /// Returns the number of elements the queue can hold without reallocating pub fn capacity(&self) -> uint { self.data.capacity() } - pub fn reserve(&mut self, n: uint) { self.data.reserve(n) } - - pub fn reserve_at_least(&mut self, n: uint) { - self.data.reserve_at_least(n) + /// Reserve capacity for exactly n elements in the PriorityQueue. + /// Do nothing if the capacity is already sufficient. + pub fn reserve_exact(&mut self, n: uint) { self.data.reserve_exact(n) } + + /// Reserve capacity for at least n elements in the PriorityQueue. + /// Do nothing if the capacity is already sufficient. + pub fn reserve(&mut self, n: uint) { + self.data.reserve(n) } /// Pop the greatest item from the queue - fails if empty @@ -203,7 +207,7 @@ impl Extendable for PriorityQueue { let (lower, _) = iter.size_hint(); let len = self.capacity(); - self.reserve_at_least(len + lower); + self.reserve(len + lower); for elem in *iter { self.push(elem); diff --git a/src/libextra/ringbuf.rs b/src/libextra/ringbuf.rs index ddef2f0a37a8f..f7ea1b0822d22 100644 --- a/src/libextra/ringbuf.rs +++ b/src/libextra/ringbuf.rs @@ -168,8 +168,8 @@ impl RingBuf { /// # Arguments /// /// * n - The number of elements to reserve space for - pub fn reserve(&mut self, n: uint) { - self.elts.reserve(n); + pub fn reserve_exact(&mut self, n: uint) { + self.elts.reserve_exact(n); } /// Reserve capacity for at least `n` elements in the given RingBuf, @@ -182,8 +182,8 @@ impl RingBuf { /// # Arguments /// /// * n - The number of elements to reserve space for - pub fn reserve_at_least(&mut self, n: uint) { - self.elts.reserve_at_least(n); + pub fn reserve(&mut self, n: uint) { + self.elts.reserve(n); } /// Front-to-back iterator. @@ -641,26 +641,26 @@ mod tests { } #[test] - fn test_reserve() { + fn test_reserve_exact() { let mut d = RingBuf::new(); d.push_back(0u64); - d.reserve(50); + d.reserve_exact(50); assert_eq!(d.elts.capacity(), 50); let mut d = RingBuf::new(); d.push_back(0u32); - d.reserve(50); + d.reserve_exact(50); assert_eq!(d.elts.capacity(), 50); } #[test] - fn test_reserve_at_least() { + fn test_reserve() { let mut d = RingBuf::new(); d.push_back(0u64); - d.reserve_at_least(50); + d.reserve(50); assert_eq!(d.elts.capacity(), 64); let mut d = RingBuf::new(); d.push_back(0u32); - d.reserve_at_least(50); + d.reserve(50); assert_eq!(d.elts.capacity(), 64); } diff --git a/src/libstd/hashmap.rs b/src/libstd/hashmap.rs index a97feea786d19..7669467d4bbe8 100644 --- a/src/libstd/hashmap.rs +++ b/src/libstd/hashmap.rs @@ -384,7 +384,7 @@ impl HashMap { } /// 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 HashSet { } /// 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 3cc199ce19571..e1387332e9fbf 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 for ~str { fn extend>(&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 15cd5ce334323..f9a90150ad473 100644 --- a/src/libstd/vec.rs +++ b/src/libstd/vec.rs @@ -1335,7 +1335,7 @@ pub trait OwnedVector { * 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 { * * * 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 OwnedVector 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 OwnedVector 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 OwnedVector 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 OwnedVector 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 OwnedCloneableVector 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 OwnedCloneableVector 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 Extendable for ~[A] { fn extend>(&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)); }