std: moved static file actions (open,unlink) to FsRequest

src/libstd/rt/uv/file.rs

@@ -37,6 +37,58 @@ pub fn new(cb: Option<FsCallback>) -> FsRequest {
         fs_req
     }
 
+    fn open_common<P: PathLike>(loop_: Loop, path: &P, flags: int, mode: int,
+               cb: Option<FsCallback>) -> int {
+        let complete_cb_ptr = match cb {
+            Some(_) => compl_cb as *u8,
+            None => 0 as *u8
+        };
+        let is_sync = cb.is_none();
+        let req = FsRequest::new(cb);
+        let result = path.path_as_str(|p| {
+            p.to_c_str().with_ref(|p| unsafe {
+            uvll::fs_open(loop_.native_handle(),
+                          req.native_handle(), p, flags, mode, complete_cb_ptr) as int
+            })
+        });
+        if is_sync { req.cleanup_and_delete(); }
+        result
+    }
+    pub fn open<P: PathLike>(loop_: Loop, path: &P, flags: int, mode: int,
+               cb: FsCallback) {
+        FsRequest::open_common(loop_, path, flags, mode, Some(cb));
+    }
+
+    pub fn open_sync<P: PathLike>(loop_: Loop, path: &P, flags: int, mode: int) -> Result<int, UvError> {
+        let result = FsRequest::open_common(loop_, path, flags, mode, None);
+        sync_cleanup(&loop_, result)
+    }
+
+    fn unlink_common<P: PathLike>(loop_: Loop, path: &P, cb: Option<FsCallback>) -> int {
+        let complete_cb_ptr = match cb {
+            Some(_) => compl_cb as *u8,
+            None => 0 as *u8
+        };
+        let is_sync = cb.is_none();
+        let req = FsRequest::new(cb);
+        let result = path.path_as_str(|p| {
+            p.to_c_str().with_ref(|p| unsafe {
+                uvll::fs_unlink(loop_.native_handle(),
+                              req.native_handle(), p, complete_cb_ptr) as int
+            })
+        });
+        if is_sync { req.cleanup_and_delete(); }
+        result
+    }
+    pub fn unlink<P: PathLike>(loop_: Loop, path: &P, cb: FsCallback) {
+        let result = FsRequest::unlink_common(loop_, path, Some(cb));
+        sync_cleanup(&loop_, result);
+    }
+    pub fn unlink_sync<P: PathLike>(loop_: Loop, path: &P) -> Result<int, UvError> {
+        let result = FsRequest::unlink_common(loop_, path, None);
+        sync_cleanup(&loop_, result)
+    }
+
     pub fn install_req_data(&self, cb: Option<FsCallback>) {
         let fs_req = (self.native_handle()) as *uvll::uv_write_t;
         let data = ~RequestData {
@@ -105,63 +157,11 @@ pub fn from_open_req(req: &mut FsRequest) -> FileDescriptor {
         FileDescriptor::new(req.get_result())
     }
 
-    fn open_common<P: PathLike>(loop_: Loop, path: &P, flags: int, mode: int,
-               cb: Option<FsCallback>) -> int {
-        let complete_cb_ptr = match cb {
-            Some(_) => compl_cb,
-            None => 0 as *u8
-        };
-        let is_sync = cb.is_none();
-        let req = FsRequest::new(cb);
-        let result = path.path_as_str(|p| {
-            p.to_c_str().with_ref(|p| unsafe {
-            uvll::fs_open(loop_.native_handle(),
-                          req.native_handle(), p, flags, mode, complete_cb_ptr) as int
-            })
-        });
-        if is_sync { req.cleanup_and_delete(); }
-        result
-    }
-    pub fn open<P: PathLike>(loop_: Loop, path: &P, flags: int, mode: int,
-               cb: FsCallback) {
-        FileDescriptor::open_common(loop_, path, flags, mode, Some(cb));
-    }
-
-    pub fn open_sync<P: PathLike>(loop_: Loop, path: &P, flags: int, mode: int) -> Result<int, UvError> {
-        let result = FileDescriptor::open_common(loop_, path, flags, mode, None);
-        sync_cleanup(&loop_, result)
-    }
-
-    fn unlink_common<P: PathLike>(loop_: Loop, path: &P, cb: Option<FsCallback>) -> int {
-        let complete_cb_ptr = match cb {
-            Some(_) => compl_cb,
-            None => 0 as *u8
-        };
-        let is_sync = cb.is_none();
-        let req = FsRequest::new(cb);
-        let result = path.path_as_str(|p| {
-            p.to_c_str().with_ref(|p| unsafe {
-                uvll::fs_unlink(loop_.native_handle(),
-                              req.native_handle(), p, complete_cb_ptr) as int
-            })
-        });
-        if is_sync { req.cleanup_and_delete(); }
-        result
-    }
-    pub fn unlink<P: PathLike>(loop_: Loop, path: &P, cb: FsCallback) {
-        let result = FileDescriptor::unlink_common(loop_, path, Some(cb));
-        sync_cleanup(&loop_, result);
-    }
-    pub fn unlink_sync<P: PathLike>(loop_: Loop, path: &P) -> Result<int, UvError> {
-        let result = FileDescriptor::unlink_common(loop_, path, None);
-        sync_cleanup(&loop_, result)
-    }
-
     // as per bnoordhuis in #libuv: offset >= 0 uses prwrite instead of write
     fn write_common(&mut self, loop_: Loop, buf: Buf, offset: i64, cb: Option<FsCallback>)
           -> int {
         let complete_cb_ptr = match cb {
-            Some(_) => compl_cb,
+            Some(_) => compl_cb as *u8,
             None => 0 as *u8
         };
         let is_sync = cb.is_none();
@@ -190,7 +190,7 @@ fn read_common(&mut self, loop_: Loop, buf: Buf,
                    offset: i64, cb: Option<FsCallback>)
           -> int {
         let complete_cb_ptr = match cb {
-            Some(_) => compl_cb,
+            Some(_) => compl_cb as *u8,
             None => 0 as *u8
         };
         let is_sync = cb.is_none();
@@ -216,7 +216,7 @@ pub fn read_sync(&mut self, loop_: Loop, buf: Buf, offset: i64)
 
     fn close_common(self, loop_: Loop, cb: Option<FsCallback>) -> int {
         let complete_cb_ptr = match cb {
-            Some(_) => compl_cb,
+            Some(_) => compl_cb as *u8,
             None => 0 as *u8
         };
         let is_sync = cb.is_none();
@@ -301,7 +301,7 @@ fn file_test_full_simple_impl() {
             let read_buf = slice_to_uv_buf(read_mem);
             let read_buf_ptr: *Buf = &read_buf;
             let p = Path(path_str);
-            do FileDescriptor::open(loop_, &p, create_flags as int, mode as int)
+            do FsRequest::open(loop_, &p, create_flags as int, mode as int)
             |req, uverr| {
                 let loop_ = req.get_loop();
                 assert!(uverr.is_none());
@@ -313,7 +313,7 @@ fn file_test_full_simple_impl() {
                     do fd.close(loop_) |req, _| {
                         let loop_ = req.get_loop();
                         assert!(uverr.is_none());
-                        do FileDescriptor::open(loop_, &Path(path_str), read_flags as int,0)
+                        do FsRequest::open(loop_, &Path(path_str), read_flags as int,0)
                             |req, uverr| {
                             assert!(uverr.is_none());
                             let loop_ = req.get_loop();
@@ -336,7 +336,7 @@ fn file_test_full_simple_impl() {
                                     assert!(read_str == ~"hello");
                                     do FileDescriptor(raw_fd).close(loop_) |_,uverr| {
                                         assert!(uverr.is_none());
-                                        do FileDescriptor::unlink(loop_, &Path(path_str))
+                                        do FsRequest::unlink(loop_, &Path(path_str))
                                         |_,uverr| {
                                             assert!(uverr.is_none());
                                         };
@@ -367,7 +367,7 @@ fn file_test_full_simple_impl_sync() {
             let write_val = "hello".as_bytes().to_owned();
             let write_buf = slice_to_uv_buf(write_val);
             // open/create
-            let result = FileDescriptor::open_sync(loop_, &Path(path_str),
+            let result = FsRequest::open_sync(loop_, &Path(path_str),
                                                    create_flags as int, mode as int);
             assert!(result.is_ok());
             let mut fd = FileDescriptor(result.unwrap() as i32);
@@ -378,7 +378,7 @@ fn file_test_full_simple_impl_sync() {
             let result = fd.close_sync(loop_);
             assert!(result.is_ok());
             // re-open
-            let result = FileDescriptor::open_sync(loop_, &Path(path_str),
+            let result = FsRequest::open_sync(loop_, &Path(path_str),
                                                    read_flags as int,0);
             assert!(result.is_ok());
             let len = 1028;
@@ -399,7 +399,7 @@ fn file_test_full_simple_impl_sync() {
                 let result = fd.close_sync(loop_);
                 assert!(result.is_ok());
                 // unlink
-                let result = FileDescriptor::unlink_sync(loop_, &Path(path_str));
+                let result = FsRequest::unlink_sync(loop_, &Path(path_str));
                 assert!(result.is_ok());
             } else { fail!("nread was 0.. wudn't expectin' that."); }
             loop_.close();

src/libstd/rt/uv/uvio.rs

@@ -477,7 +477,7 @@ fn fs_open<P: PathLike>(&mut self, path: &P, flags: int, mode: int)
         do scheduler.deschedule_running_task_and_then |_, task| {
             let task_cell = Cell::new(task);
             let path = path_cell.take();
-            do file::FileDescriptor::open(loop_, path, flags, mode) |req,err| {
+            do file::FsRequest::open(loop_, path, flags, mode) |req,err| {
                 if err.is_none() {
                     let home = get_handle_to_current_scheduler!();
                     let fd = file::FileDescriptor(req.get_result());
@@ -508,7 +508,7 @@ fn fs_unlink<P: PathLike>(&mut self, path: &P) -> Result<(), IoError> {
         do scheduler.deschedule_running_task_and_then |_, task| {
             let task_cell = Cell::new(task);
             let path = path_cell.take();
-            do file::FileDescriptor::unlink(loop_, path) |_, err| {
+            do file::FsRequest::unlink(loop_, path) |_, err| {
                 let res = match err {
                     None => Ok(()),
                     Some(err) => Err(uv_error_to_io_error(err))