vendor/miow-0.2.1/src/handle.rs

   1 use std::io;
   2 use std::cmp;
   3
   4 use winapi::*;
   5 use kernel32::*;
   6
   7 #[derive(Debug)]
   8 pub struct Handle(HANDLE);
   9
  10 unsafe impl Send for Handle {}
  11 unsafe impl Sync for Handle {}
  12
  13 impl Handle {
  14     pub fn new(handle: HANDLE) -> Handle {
  15         Handle(handle)
  16     }
  17
  18     pub fn raw(&self) -> HANDLE { self.0 }
  19
  20     pub fn into_raw(self) -> HANDLE {
  21         use std::mem;
  22
  23         let ret = self.0;
  24         mem::forget(self);
  25         ret
  26     }
  27
  28     pub fn write(&self, buf: &[u8]) -> io::Result<usize> {
  29         let mut bytes = 0;
  30         let len = cmp::min(buf.len(), <DWORD>::max_value() as usize) as DWORD;
  31         try!(::cvt(unsafe {
  32             WriteFile(self.0, buf.as_ptr() as *const _, len, &mut bytes,
  33                       0 as *mut _)
  34         }));
  35         Ok(bytes as usize)
  36     }
  37
  38     pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
  39         let mut bytes = 0;
  40         let len = cmp::min(buf.len(), <DWORD>::max_value() as usize) as DWORD;
  41         try!(::cvt(unsafe {
  42             ReadFile(self.0, buf.as_mut_ptr() as *mut _, len, &mut bytes,
  43                      0 as *mut _)
  44         }));
  45         Ok(bytes as usize)
  46     }
  47
  48     pub unsafe fn read_overlapped(&self, buf: &mut [u8],
  49                                   overlapped: *mut OVERLAPPED)
  50                                   -> io::Result<Option<usize>> {
  51         let len = cmp::min(buf.len(), <DWORD>::max_value() as usize) as DWORD;
  52         let mut bytes = 0;
  53         let res = ::cvt({
  54             ReadFile(self.0,
  55                      buf.as_mut_ptr() as *mut _,
  56                      len,
  57                      &mut bytes,
  58                      overlapped)
  59         });
  60         match res {
  61             Ok(_) => Ok(Some(bytes as usize)),
  62             Err(ref e) if e.raw_os_error() == Some(ERROR_IO_PENDING as i32)
  63                 => Ok(None),
  64             Err(e) => Err(e),
  65         }
  66     }
  67
  68     pub unsafe fn write_overlapped(&self, buf: &[u8],
  69                                    overlapped: *mut OVERLAPPED)
  70                                    -> io::Result<Option<usize>> {
  71         let len = cmp::min(buf.len(), <DWORD>::max_value() as usize) as DWORD;
  72         let mut bytes = 0;
  73         let res = ::cvt({
  74             WriteFile(self.0,
  75                       buf.as_ptr() as *const _,
  76                       len,
  77                       &mut bytes,
  78                       overlapped)
  79         });
  80         match res {
  81             Ok(_) => Ok(Some(bytes as usize)),
  82             Err(ref e) if e.raw_os_error() == Some(ERROR_IO_PENDING as i32)
  83                 => Ok(None),
  84             Err(e) => Err(e),
  85         }
  86     }
  87 }
  88
  89 impl Drop for Handle {
  90     fn drop(&mut self) {
  91         unsafe { CloseHandle(self.0) };
  92     }
  93 }