|
| 1 | +// Copyright 2013 The Rust Project Developers. See the COPYRIGHT |
| 2 | +// file at the top-level directory of this distribution and at |
| 3 | +// http://rust-lang.org/COPYRIGHT. |
| 4 | +// |
| 5 | +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or |
| 6 | +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license |
| 7 | +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your |
| 8 | +// option. This file may not be copied, modified, or distributed |
| 9 | +// except according to those terms. |
| 10 | + |
| 11 | +use libc::{c_int, c_void}; |
| 12 | +use option::Some; |
| 13 | +use rt::uv::uvll; |
| 14 | +use rt::uv::uvll::UV_ASYNC; |
| 15 | +use rt::uv::{Watcher, Loop, NativeHandle, AsyncCallback, NullCallback}; |
| 16 | +use rt::uv::WatcherInterop; |
| 17 | +use rt::uv::status_to_maybe_uv_error; |
| 18 | + |
| 19 | +pub struct AsyncWatcher(*uvll::uv_async_t); |
| 20 | +impl Watcher for AsyncWatcher { } |
| 21 | + |
| 22 | +impl AsyncWatcher { |
| 23 | + fn new(loop_: &mut Loop, cb: AsyncCallback) -> AsyncWatcher { |
| 24 | + unsafe { |
| 25 | + let handle = uvll::malloc_handle(UV_ASYNC); |
| 26 | + assert!(handle.is_not_null()); |
| 27 | + let mut watcher: AsyncWatcher = NativeHandle::from_native_handle(handle); |
| 28 | + watcher.install_watcher_data(); |
| 29 | + let data = watcher.get_watcher_data(); |
| 30 | + data.async_cb = Some(cb); |
| 31 | + assert_eq!(0, uvll::async_init(loop_.native_handle(), handle, async_cb)); |
| 32 | + return watcher; |
| 33 | + } |
| 34 | + |
| 35 | + extern fn async_cb(handle: *uvll::uv_async_t, status: c_int) { |
| 36 | + let mut watcher: AsyncWatcher = NativeHandle::from_native_handle(handle); |
| 37 | + let status = status_to_maybe_uv_error(watcher.native_handle(), status); |
| 38 | + let data = watcher.get_watcher_data(); |
| 39 | + let cb = data.async_cb.get_ref(); |
| 40 | + (*cb)(watcher, status); |
| 41 | + } |
| 42 | + } |
| 43 | + |
| 44 | + fn send(&mut self) { |
| 45 | + unsafe { |
| 46 | + let handle = self.native_handle(); |
| 47 | + uvll::async_send(handle); |
| 48 | + } |
| 49 | + } |
| 50 | + |
| 51 | + fn close(self, cb: NullCallback) { |
| 52 | + let mut this = self; |
| 53 | + let data = this.get_watcher_data(); |
| 54 | + assert!(data.close_cb.is_none()); |
| 55 | + data.close_cb = Some(cb); |
| 56 | + |
| 57 | + unsafe { |
| 58 | + uvll::close(self.native_handle(), close_cb); |
| 59 | + } |
| 60 | + |
| 61 | + extern fn close_cb(handle: *uvll::uv_stream_t) { |
| 62 | + let mut watcher: AsyncWatcher = NativeHandle::from_native_handle(handle); |
| 63 | + { |
| 64 | + let data = watcher.get_watcher_data(); |
| 65 | + data.close_cb.swap_unwrap()(); |
| 66 | + } |
| 67 | + watcher.drop_watcher_data(); |
| 68 | + unsafe { uvll::free_handle(handle as *c_void); } |
| 69 | + } |
| 70 | + } |
| 71 | +} |
| 72 | + |
| 73 | +impl NativeHandle<*uvll::uv_async_t> for AsyncWatcher { |
| 74 | + fn from_native_handle(handle: *uvll::uv_async_t) -> AsyncWatcher { |
| 75 | + AsyncWatcher(handle) |
| 76 | + } |
| 77 | + fn native_handle(&self) -> *uvll::uv_async_t { |
| 78 | + match self { &AsyncWatcher(ptr) => ptr } |
| 79 | + } |
| 80 | +} |
| 81 | + |
| 82 | +#[cfg(test)] |
| 83 | +mod test { |
| 84 | + |
| 85 | + use super::*; |
| 86 | + use rt::uv::Loop; |
| 87 | + use unstable::run_in_bare_thread; |
| 88 | + use rt::thread::Thread; |
| 89 | + use cell::Cell; |
| 90 | + |
| 91 | + #[test] |
| 92 | + fn smoke_test() { |
| 93 | + do run_in_bare_thread { |
| 94 | + let mut loop_ = Loop::new(); |
| 95 | + let watcher = AsyncWatcher::new(&mut loop_, |w, _| w.close(||()) ); |
| 96 | + let watcher_cell = Cell(watcher); |
| 97 | + let _thread = do Thread::start { |
| 98 | + let mut watcher = watcher_cell.take(); |
| 99 | + watcher.send(); |
| 100 | + }; |
| 101 | + loop_.run(); |
| 102 | + loop_.close(); |
| 103 | + } |
| 104 | + } |
| 105 | +} |
0 commit comments