---

yaml
---
r: 34159
b: refs/heads/snap-stage3
c: b3463ea
h: refs/heads/master
i:
  34157: fa5077c
  34155: 981eed2
  34151: 6b0c52e
  34143: e22c2dc
v: v3

Author: thestinger

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 6c433f22a152f6825f3610382176aaa191ebf7cb
+refs/heads/snap-stage3: b3463ea65773972e4b5ec9ba4ef35b5f9e595284
 refs/heads/try: d324a424d8f84b1eb049b12cf34182bda91b0024
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/libstd/priority_queue.rs

@@ -1,12 +1,18 @@
 
 /// A priority queue implemented with a binary heap
 use core::cmp::Ord;
+use ptr::addr_of;
 
-pub struct PriorityQueue <T: Copy Ord>{
+#[abi = "rust-intrinsic"]
+extern "C" mod rusti {
+    fn move_val_init<T>(dst: &mut T, -src: T);
+}
+
+pub struct PriorityQueue <T: Ord>{
     priv data: ~[T],
 }
 
-impl <T: Copy Ord> PriorityQueue<T> {
+impl <T: Ord> PriorityQueue<T> {
     /// Returns the greatest item in the queue - fails if empty
     pure fn top(&self) -> &self/T { &self.data[0] }
 
@@ -97,38 +103,46 @@ impl <T: Copy Ord> PriorityQueue<T> {
         q
     }
 
-    priv fn siftup(&mut self, start: uint, pos: uint) {
+    // The implementations of siftup and siftdown use unsafe blocks in order to
+    // move an element out of the vector (leaving behind a junk element), shift
+    // along the others and move it back into the vector over the junk element.
+    // This reduces the constant factor compared to using swaps, which involves
+    // twice as many moves.
+
+    priv fn siftup(&mut self, start: uint, pos: uint) unsafe {
         let mut pos = pos;
-        let new = self.data[pos];
+        let new = move *addr_of(&self.data[pos]);
 
         while pos > start {
             let parent = (pos - 1) >> 1;
             if new > self.data[parent] {
-                self.data[pos] = self.data[parent];
+                rusti::move_val_init(&mut self.data[pos],
+                                     move *addr_of(&self.data[parent]));
                 pos = parent;
                 loop
             }
             break
         }
-        self.data[pos] = new;
+        rusti::move_val_init(&mut self.data[pos], move new);
     }
 
-    priv fn siftdown_range(&mut self, pos: uint, end: uint) {
+    priv fn siftdown_range(&mut self, pos: uint, end: uint) unsafe {
         let mut pos = pos;
         let start = pos;
-        let new = self.data[pos];
+        let new = move *addr_of(&self.data[pos]);
 
         let mut child = 2 * pos + 1;
         while child < end {
             let right = child + 1;
             if right < end && !(self.data[child] > self.data[right]) {
                 child = right;
             }
-            self.data[pos] = self.data[child];
+            rusti::move_val_init(&mut self.data[pos],
+                                 move *addr_of(&self.data[child]));
             pos = child;
             child = 2 * pos + 1;
         }
-        self.data[pos] = new;
+        rusti::move_val_init(&mut self.data[pos], move new);
         self.siftup(start, pos);
     }