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

Author: alexcrichton

src/librustuv/lib.rs

@@ -347,16 +347,19 @@ 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 {
         Some(UvError(status))
     }
 }
 
+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;
 

src/librustuv/uvio.rs

@@ -974,11 +974,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 {
@@ -1181,11 +1177,7 @@ impl RtioTcpStream for UvTcpStream {
             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)
         }
     }
 
@@ -1194,11 +1186,7 @@ impl RtioTcpStream for UvTcpStream {
             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)
         }
     }
 
@@ -1208,11 +1196,7 @@ impl RtioTcpStream for UvTcpStream {
                 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)
         }
     }
 
@@ -1222,11 +1206,7 @@ impl RtioTcpStream for UvTcpStream {
                 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)
         }
     }
 }
@@ -1333,11 +1313,7 @@ impl RtioUdpSocket for UvUdpSocket {
                                                 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)
         }
     }
 
@@ -1350,100 +1326,66 @@ impl RtioUdpSocket for UvUdpSocket {
                                                 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)
         }
     }
 }