core: Add send/recv/peek methods for both ports and chans

Calling peek or recv on channels can fail when the associated port
is dead or unowned.

Author: brson

src/libcore/comm.rs

@@ -33,6 +33,7 @@ export recv;
 export peek;
 export recv_chan;
 export select2;
+export methods;
 
 
 #[doc = "
@@ -67,37 +68,22 @@ fn port<T: send>() -> port<T> {
     port_t(@port_ptr(rustrt::new_port(sys::size_of::<T>())))
 }
 
-#[doc = "
-Constructs a channel. The channel is bound to the port used to
-construct it.
-"]
-fn chan<T: send>(p: port<T>) -> chan<T> {
-    chan_t(rustrt::get_port_id(***p))
-}
+impl methods<T: send> for port<T> {
+
+    fn chan() -> chan<T> { chan(self) }
+    fn send(+v: T) { self.chan().send(v) }
+    fn recv() -> T { recv(self) }
+    fn peek() -> bool { peek(self) }
 
-#[doc = "
-Sends data over a channel. The sent data is moved into the channel,
-whereupon the caller loses access to it.
-"]
-fn send<T: send>(ch: chan<T>, -data: T) {
-    let chan_t(p) = ch;
-    let res = rustrt::rust_port_id_send(p, data);
-    if res != 0u unsafe {
-        // Data sent successfully
-        unsafe::forget(data);
-    }
-    task::yield();
 }
 
-#[doc = "
-Receive from a port.  If no data is available on the port then the
-task will block until data becomes available.
-"]
-fn recv<T: send>(p: port<T>) -> T { recv_(***p) }
+impl methods<T: send> for chan<T> {
+
+    fn chan() -> chan<T> { self }
+    fn send(+v: T) { send(self, v) }
+    fn recv() -> T { recv_chan(self) }
+    fn peek() -> bool { peek_chan(self) }
 
-#[doc = "Returns true if there are messages available"]
-fn peek<T: send>(p: port<T>) -> bool {
-    rustrt::rust_port_size(***p) != 0u as libc::size_t
 }
 
 resource port_ptr<T: send>(po: *rust_port) {
@@ -121,9 +107,15 @@ resource port_ptr<T: send>(po: *rust_port) {
     rustrt::del_port(po);
 }
 
+#[doc = "
+Internal function for converting from a channel to a port
 
-#[doc(hidden)]
-fn recv_chan<T: send>(ch: comm::chan<T>) -> T {
+# Failure
+
+Fails if the port is detached or dead. Fails if the port
+is owned by a different task.
+"]
+fn as_raw_port<T: send, U>(ch: comm::chan<T>, f: fn(*rust_port) -> U) -> U {
     resource portref(p: *rust_port) {
         if !ptr::is_null(p) {
             rustrt::rust_port_drop(p);
@@ -135,10 +127,50 @@ fn recv_chan<T: send>(ch: comm::chan<T>) -> T {
     if ptr::is_null(*p) {
         fail "unable to locate port for channel"
     } else if rustrt::get_task_id() != rustrt::rust_port_task(*p) {
-        fail "attempting to receive on unowned channel"
+        fail "unable to access unowned port"
     }
 
-    recv_(*p)
+    f(*p)
+}
+
+#[doc = "
+Constructs a channel. The channel is bound to the port used to
+construct it.
+"]
+fn chan<T: send>(p: port<T>) -> chan<T> {
+    chan_t(rustrt::get_port_id(***p))
+}
+
+#[doc = "
+Sends data over a channel. The sent data is moved into the channel,
+whereupon the caller loses access to it.
+"]
+fn send<T: send>(ch: chan<T>, -data: T) {
+    let chan_t(p) = ch;
+    let res = rustrt::rust_port_id_send(p, data);
+    if res != 0u unsafe {
+        // Data sent successfully
+        unsafe::forget(data);
+    }
+    task::yield();
+}
+
+#[doc = "
+Receive from a port.  If no data is available on the port then the
+task will block until data becomes available.
+"]
+fn recv<T: send>(p: port<T>) -> T { recv_(***p) }
+
+#[doc = "Returns true if there are messages available"]
+fn peek<T: send>(p: port<T>) -> bool { peek_(***p) }
+
+#[doc(hidden)]
+fn recv_chan<T: send>(ch: comm::chan<T>) -> T {
+    as_raw_port(ch, recv_(_))
+}
+
+fn peek_chan<T: send>(ch: comm::chan<T>) -> bool {
+    as_raw_port(ch, peek_(_))
 }
 
 #[doc = "Receive on a raw port pointer"]
@@ -160,6 +192,10 @@ fn recv_<T: send>(p: *rust_port) -> T {
     ret res;
 }
 
+fn peek_(p: *rust_port) -> bool unsafe {
+    rustrt::rust_port_size(p) != 0u as libc::size_t
+}
+
 #[doc = "Receive on one of two ports"]
 fn select2<A: send, B: send>(p_a: port<A>, p_b: port<B>)
     -> either<A, B> unsafe {
@@ -391,3 +427,18 @@ fn test_recv_chan_wrong_task() {
         recv_chan(ch)
     })
 }
+
+#[test]
+fn test_port_send() {
+    let po = port();
+    po.send(());
+    po.recv();
+}
+
+#[test]
+fn test_chan_peek() {
+    let po = port();
+    let ch = po.chan();
+    ch.send(());
+    assert ch.peek();
+}