---

yaml
---
r: 15191
b: refs/heads/try
c: b3d7823
h: refs/heads/master
i:
  15189: 91ced65
  15187: 2df6433
  15183: 1312154
v: v3

Author: brson

[refs]

@@ -2,5 +2,5 @@
 refs/heads/master: 61b1875c16de39c166b0f4d54bba19f9c6777d1a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
-refs/heads/try: 8e743b2981754f1aa7e0eb5b57d79e5a8ad7d172
+refs/heads/try: b3d7823381cd2d3d89ba4ca85a709df6622180ab
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

branches/try/src/libcore/vec.rs

@@ -1,14 +1,14 @@
 #[doc = "Vectors"];
 
 import option::{some, none};
-import uint::next_power_of_two;
 import ptr::addr_of;
 
 export init_op;
 export is_empty;
 export is_not_empty;
 export same_length;
 export reserve;
+export reserve_at_least;
 export len;
 export from_fn;
 export from_elem;
@@ -115,6 +115,25 @@ fn reserve<T>(&v: [const T], n: uint) {
     rustrt::vec_reserve_shared(sys::get_type_desc::<T>(), v, n);
 }
 
+#[doc = "
+Reserves capacity for at least `n` elements in the given vector.
+
+This function will over-allocate in order to amortize the allocation costs
+in scenarios where the caller may need to repeatedly reserve additional
+space.
+
+If the capacity for `v` is already equal to or greater than the requested
+capacity, then no action is taken.
+
+# Arguments
+
+* v - A vector
+* n - The number of elements to reserve space for
+"]
+fn reserve_at_least<T>(&v: [const T], n: uint) {
+    reserve(v, uint::next_power_of_two(n));
+}
+
 #[doc = "Returns the length of a vector"]
 #[inline(always)]
 pure fn len<T>(&&v: [const T]) -> uint unsafe {
@@ -364,7 +383,7 @@ Expands a vector in place, initializing the new elements to a given value
 * initval - The value for the new elements
 "]
 fn grow<T: copy>(&v: [const T], n: uint, initval: T) {
-    reserve(v, next_power_of_two(len(v) + n));
+    reserve_at_least(v, len(v) + n);
     let mut i: uint = 0u;
     while i < n { v += [initval]; i += 1u; }
 }
@@ -383,7 +402,7 @@ Function `init_op` is called `n` times with the values [0..`n`)
             value
 "]
 fn grow_fn<T>(&v: [const T], n: uint, op: init_op<T>) {
-    reserve(v, next_power_of_two(len(v) + n));
+    reserve_at_least(v, len(v) + n);
     let mut i: uint = 0u;
     while i < n { v += [op(i)]; i += 1u; }
 }