uv: Provide a helper fn to Result<(), IoError>

diff --git a/src/librustuv/lib.rs b/src/librustuv/lib.rs
index 64aea4f01744d14e444d73537d37b6b025410503..6aa8723a4017dadd1a4d3aa26cc264354d306ac0 100644 (file)
--- a/src/librustuv/lib.rs
+++ b/src/librustuv/lib.rs
@@ -341,9 +341,8 @@ pub fn uv_error_to_io_error(uverr: UvError) -> IoError {
     }
 }
 
-/// Given a uv handle, convert a callback status to a UvError
-pub fn status_to_maybe_uv_error(status: c_int) -> Option<UvError>
-{
+/// Given a uv error code, convert a callback status to a UvError
+pub fn status_to_maybe_uv_error(status: c_int) -> Option<UvError> {
     if status >= 0 {
         None
     } else {
@@ -351,6 +350,10 @@ pub fn status_to_maybe_uv_error(status: c_int) -> Option<UvError>
     }
 }
 
+pub fn status_to_io_result(status: c_int) -> Result<(), IoError> {
+    if status >= 0 {Ok(())} else {Err(uv_error_to_io_error(UvError(status)))}
+}
+
 /// The uv buffer type
 pub type Buf = uvll::uv_buf_t;
 

diff --git a/src/librustuv/uvio.rs b/src/librustuv/uvio.rs
index b4382ab4cee2564e49eaa4fcee773f120a6e5d87..1dbc7d71543e1aa7a25cfe50ef32a39d25c112f1 100644 (file)
--- a/src/librustuv/uvio.rs
+++ b/src/librustuv/uvio.rs
@@ -992,11 +992,7 @@ fn accept_simultaneously(stream: StreamWatcher, a: int) -> Result<(), IoError> {
     let r = unsafe {
         uvll::uv_tcp_simultaneous_accepts(stream.native_handle(), a as c_int)
     };
-
-    match status_to_maybe_uv_error(r) {
-        Some(err) => Err(uv_error_to_io_error(err)),
-        None => Ok(())
-    }
+    status_to_io_result(r)
 }
 
 impl RtioTcpAcceptor for UvTcpAcceptor {
@@ -1197,11 +1193,7 @@ fn control_congestion(&mut self) -> Result<(), IoError> {
             let r = unsafe {
                 uvll::uv_tcp_nodelay(self_.watcher.native_handle(), 0 as c_int)
             };
-
-            match status_to_maybe_uv_error(r) {
-                Some(err) => Err(uv_error_to_io_error(err)),
-                None => Ok(())
-            }
+            status_to_io_result(r)
         }
     }
 
@@ -1210,11 +1202,7 @@ fn nodelay(&mut self) -> Result<(), IoError> {
             let r = unsafe {
                 uvll::uv_tcp_nodelay(self_.watcher.native_handle(), 1 as c_int)
             };
-
-            match status_to_maybe_uv_error(r) {
-                Some(err) => Err(uv_error_to_io_error(err)),
-                None => Ok(())
-            }
+            status_to_io_result(r)
         }
     }
 
@@ -1224,11 +1212,7 @@ fn keepalive(&mut self, delay_in_seconds: uint) -> Result<(), IoError> {
                 uvll::uv_tcp_keepalive(self_.watcher.native_handle(), 1 as c_int,
                                        delay_in_seconds as c_uint)
             };
-
-            match status_to_maybe_uv_error(r) {
-                Some(err) => Err(uv_error_to_io_error(err)),
-                None => Ok(())
-            }
+            status_to_io_result(r)
         }
     }
 
@@ -1238,11 +1222,7 @@ fn letdie(&mut self) -> Result<(), IoError> {
                 uvll::uv_tcp_keepalive(self_.watcher.native_handle(),
                                        0 as c_int, 0 as c_uint)
             };
-
-            match status_to_maybe_uv_error(r) {
-                Some(err) => Err(uv_error_to_io_error(err)),
-                None => Ok(())
-            }
+            status_to_io_result(r)
         }
     }
 }
@@ -1348,11 +1328,7 @@ fn join_multicast(&mut self, multi: IpAddr) -> Result<(), IoError> {
                                                 uvll::UV_JOIN_GROUP)
                 }
             };
-
-            match status_to_maybe_uv_error(r) {
-                Some(err) => Err(uv_error_to_io_error(err)),
-                None => Ok(())
-            }
+            status_to_io_result(r)
         }
     }
 
@@ -1365,100 +1341,66 @@ fn leave_multicast(&mut self, multi: IpAddr) -> Result<(), IoError> {
                                                 uvll::UV_LEAVE_GROUP)
                 }
             };
-
-            match status_to_maybe_uv_error(r) {
-                Some(err) => Err(uv_error_to_io_error(err)),
-                None => Ok(())
-            }
+            status_to_io_result(r)
         }
     }
 
     fn loop_multicast_locally(&mut self) -> Result<(), IoError> {
         do self.home_for_io |self_| {
-
             let r = unsafe {
                 uvll::uv_udp_set_multicast_loop(self_.watcher.native_handle(),
                                                 1 as c_int)
             };
-
-            match status_to_maybe_uv_error(r) {
-                Some(err) => Err(uv_error_to_io_error(err)),
-                None => Ok(())
-            }
+            status_to_io_result(r)
         }
     }
 
     fn dont_loop_multicast_locally(&mut self) -> Result<(), IoError> {
         do self.home_for_io |self_| {
-
             let r = unsafe {
                 uvll::uv_udp_set_multicast_loop(self_.watcher.native_handle(),
                                                 0 as c_int)
             };
-
-            match status_to_maybe_uv_error(r) {
-                Some(err) => Err(uv_error_to_io_error(err)),
-                None => Ok(())
-            }
+            status_to_io_result(r)
         }
     }
 
     fn multicast_time_to_live(&mut self, ttl: int) -> Result<(), IoError> {
         do self.home_for_io |self_| {
-
             let r = unsafe {
                 uvll::uv_udp_set_multicast_ttl(self_.watcher.native_handle(),
                                                ttl as c_int)
             };
-
-            match status_to_maybe_uv_error(r) {
-                Some(err) => Err(uv_error_to_io_error(err)),
-                None => Ok(())
-            }
+            status_to_io_result(r)
         }
     }
 
     fn time_to_live(&mut self, ttl: int) -> Result<(), IoError> {
         do self.home_for_io |self_| {
-
             let r = unsafe {
                 uvll::uv_udp_set_ttl(self_.watcher.native_handle(), ttl as c_int)
             };
-
-            match status_to_maybe_uv_error(r) {
-                Some(err) => Err(uv_error_to_io_error(err)),
-                None => Ok(())
-            }
+            status_to_io_result(r)
         }
     }
 
     fn hear_broadcasts(&mut self) -> Result<(), IoError> {
         do self.home_for_io |self_| {
-
             let r = unsafe {
                 uvll::uv_udp_set_broadcast(self_.watcher.native_handle(),
                                            1 as c_int)
             };
-
-            match status_to_maybe_uv_error(r) {
-                Some(err) => Err(uv_error_to_io_error(err)),
-                None => Ok(())
-            }
+            status_to_io_result(r)
         }
     }
 
     fn ignore_broadcasts(&mut self) -> Result<(), IoError> {
         do self.home_for_io |self_| {
-
             let r = unsafe {
                 uvll::uv_udp_set_broadcast(self_.watcher.native_handle(),
                                            0 as c_int)
             };
-
-            match status_to_maybe_uv_error(r) {
-                Some(err) => Err(uv_error_to_io_error(err)),
-                None => Ok(())
-            }
+            status_to_io_result(r)
         }
     }
 }