core: Refactor uv bindings

I can already see these are going to get massive. Putting them into multiple
files.

Author: brson

src/libcore/rt/io/file.rs

@@ -16,21 +16,21 @@ use super::Stream;
 pub struct FileStream;
 
 pub impl FileStream {
-    static fn new(path: Path) -> FileStream {
+    static fn new(_path: Path) -> FileStream {
         fail!()
     }
 }
 
 impl Stream for FileStream {
-    fn read(&mut self, buf: &mut [u8]) -> uint {
+    fn read(&mut self, _buf: &mut [u8]) -> uint {
         fail!()
     }
 
     fn eof(&mut self) -> bool {
         fail!()
     }
 
-    fn write(&mut self, v: &const [u8]) {
+    fn write(&mut self, _v: &const [u8]) {
         fail!()
     }
 }

src/libcore/rt/mod.rs

@@ -33,6 +33,7 @@ mod sched;
 mod rtio;
 pub mod uvll;
 mod uvio;
+#[path = "uv/mod.rs"]
 mod uv;
 #[path = "io/mod.rs"]
 mod io;

src/libcore/rt/thread.rs

@@ -14,12 +14,12 @@ use ops::Drop;
 #[allow(non_camel_case_types)] // runtime type
 type raw_thread = libc::c_void;
 
-struct Thread {
+pub struct Thread {
     main: ~fn(),
     raw_thread: *raw_thread
 }
 
-impl Thread {
+pub impl Thread {
     static fn start(main: ~fn()) -> Thread {
         fn substart(main: &fn()) -> *raw_thread {
             unsafe { rust_raw_thread_start(&main) }

src/libcore/rt/uv/file.rs

@@ -0,0 +1,52 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use prelude::*;
+use ptr::null;
+use libc::c_void;
+use super::{UvError, Callback, Request, NativeHandle, Loop};
+use super::super::uvll;
+use super::super::uvll::*;
+
+pub type FsCallback = ~fn(FsRequest, Option<UvError>);
+impl Callback for FsCallback { }
+
+pub struct FsRequest(*uvll::uv_fs_t);
+
+impl Request for FsRequest;
+
+impl FsRequest {
+    static fn new() -> FsRequest {
+        let fs_req = unsafe { malloc_req(UV_FS) };
+        fail_unless!(fs_req.is_not_null());
+        let fs_req = fs_req as *uvll::uv_write_t;
+        unsafe { uvll::set_data_for_req(fs_req, null::<()>()); }
+        NativeHandle::from_native_handle(fs_req)
+    }
+
+    fn delete(self) {
+        unsafe { free_req(self.native_handle() as *c_void) }
+    }
+
+    fn open(&mut self, _loop_: &Loop, _cb: FsCallback) {
+    }
+
+    fn close(&mut self, _loop_: &Loop, _cb: FsCallback) {
+    }
+}
+
+impl NativeHandle<*uvll::uv_fs_t> for FsRequest {
+    static fn from_native_handle(handle: *uvll:: uv_fs_t) -> FsRequest {
+        FsRequest(handle)
+    }
+    fn native_handle(&self) -> *uvll::uv_fs_t {
+        match self { &FsRequest(ptr) => ptr }
+    }
+}