---

yaml
---
r: 29885
b: refs/heads/incoming
c: 942649a
h: refs/heads/master
i:
  29883: 5beed8c
v: v3

Author: eholk

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: d324a424d8f84b1eb049b12cf34182bda91b0024
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df
-refs/heads/incoming: b206920d9d8c46ee38d3d3930afc57d2a0cfb3f7
+refs/heads/incoming: 942649a26073bb84797f8831d39d0b35018e931b
 refs/heads/dist-snap: 2f32a1581f522e524009138b33b1c7049ced668d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/src/libcore/pipes.rs

@@ -581,14 +581,14 @@ that vector. The index points to an endpoint that has either been
 closed by the sender or has a message waiting to be received.
 
 */
-fn wait_many(pkts: &[*packet_header]) -> uint {
+fn wait_many<T: selectable>(pkts: &[T]) -> uint {
     let this = rustrt::rust_get_task();
 
     rustrt::task_clear_event_reject(this);
     let mut data_avail = false;
     let mut ready_packet = pkts.len();
     for pkts.eachi |i, p| unsafe {
-        let p = unsafe { &*p };
+        let p = unsafe { &*p.header() };
         let old = p.mark_blocked(this);
         match old {
           full | terminated => {
@@ -605,7 +605,7 @@ fn wait_many(pkts: &[*packet_header]) -> uint {
     while !data_avail {
         debug!{"sleeping on %? packets", pkts.len()};
         let event = wait_event(this) as *packet_header;
-        let pos = vec::position(pkts, |p| p == event);
+        let pos = vec::position(pkts, |p| p.header() == event);
 
         match pos {
           some(i) => {
@@ -618,13 +618,13 @@ fn wait_many(pkts: &[*packet_header]) -> uint {
 
     debug!{"%?", pkts[ready_packet]};
 
-    for pkts.each |p| { unsafe{ (*p).unblock()} }
+    for pkts.each |p| { unsafe{ (*p.header()).unblock()} }
 
     debug!("%?, %?", ready_packet, pkts[ready_packet]);
 
     unsafe {
-        assert (*pkts[ready_packet]).state == full
-            || (*pkts[ready_packet]).state == terminated;
+        assert (*pkts[ready_packet].header()).state == full
+            || (*pkts[ready_packet].header()).state == terminated;
     }
 
     ready_packet
@@ -686,7 +686,7 @@ impl *packet_header: selectable {
 
 /// Returns the index of an endpoint that is ready to receive.
 fn selecti<T: selectable>(endpoints: &[T]) -> uint {
-    wait_many(endpoints.map(|p| p.header()))
+    wait_many(endpoints)
 }
 
 /// Returns 0 or 1 depending on which endpoint is ready to receive