From b1502931373072aca5e0b6a794d3e30e8b98e4d9 Mon Sep 17 00:00:00 2001 From: Flavio Percoco Date: Wed, 2 Oct 2013 23:39:58 +0200 Subject: [PATCH] Remove unnecessary mutability in WatcherInterop --- src/libstd/rt/uv/async.rs | 13 +++--- src/libstd/rt/uv/idle.rs | 26 +++++------ src/libstd/rt/uv/mod.rs | 12 ++--- src/libstd/rt/uv/net.rs | 92 ++++++++++++++++++------------------- src/libstd/rt/uv/pipe.rs | 14 ++---- src/libstd/rt/uv/process.rs | 17 +++---- src/libstd/rt/uv/timer.rs | 33 ++++++------- src/libstd/rt/uv/uvio.rs | 22 ++++----- 8 files changed, 106 insertions(+), 123 deletions(-) diff --git a/src/libstd/rt/uv/async.rs b/src/libstd/rt/uv/async.rs index ff7bb9dd03abc..cbe126547cd03 100644 --- a/src/libstd/rt/uv/async.rs +++ b/src/libstd/rt/uv/async.rs @@ -24,7 +24,7 @@ impl AsyncWatcher { unsafe { let handle = uvll::malloc_handle(UV_ASYNC); assert!(handle.is_not_null()); - let mut watcher: AsyncWatcher = NativeHandle::from_native_handle(handle); + let watcher: AsyncWatcher = NativeHandle::from_native_handle(handle); watcher.install_watcher_data(); let data = watcher.get_watcher_data(); data.async_cb = Some(cb); @@ -33,7 +33,7 @@ impl AsyncWatcher { } extern fn async_cb(handle: *uvll::uv_async_t, status: c_int) { - let mut watcher: AsyncWatcher = NativeHandle::from_native_handle(handle); + let watcher: AsyncWatcher = NativeHandle::from_native_handle(handle); let status = status_to_maybe_uv_error(status); let data = watcher.get_watcher_data(); let cb = data.async_cb.get_ref(); @@ -41,7 +41,7 @@ impl AsyncWatcher { } } - pub fn send(&mut self) { + pub fn send(&self) { unsafe { let handle = self.native_handle(); uvll::async_send(handle); @@ -49,8 +49,7 @@ impl AsyncWatcher { } pub fn close(self, cb: NullCallback) { - let mut this = self; - let data = this.get_watcher_data(); + let data = self.get_watcher_data(); assert!(data.close_cb.is_none()); data.close_cb = Some(cb); @@ -59,7 +58,7 @@ impl AsyncWatcher { } extern fn close_cb(handle: *uvll::uv_stream_t) { - let mut watcher: AsyncWatcher = NativeHandle::from_native_handle(handle); + let watcher: AsyncWatcher = NativeHandle::from_native_handle(handle); { let data = watcher.get_watcher_data(); data.close_cb.take_unwrap()(); @@ -95,7 +94,7 @@ mod test { let watcher = AsyncWatcher::new(&mut loop_, |w, _| w.close(||()) ); let watcher_cell = Cell::new(watcher); let thread = do Thread::start { - let mut watcher = watcher_cell.take(); + let watcher = watcher_cell.take(); watcher.send(); }; loop_.run(); diff --git a/src/libstd/rt/uv/idle.rs b/src/libstd/rt/uv/idle.rs index 8cbcd7b77c082..10f38398a9e6e 100644 --- a/src/libstd/rt/uv/idle.rs +++ b/src/libstd/rt/uv/idle.rs @@ -23,13 +23,13 @@ impl IdleWatcher { let handle = uvll::idle_new(); assert!(handle.is_not_null()); assert!(0 == uvll::idle_init(loop_.native_handle(), handle)); - let mut watcher: IdleWatcher = NativeHandle::from_native_handle(handle); + let watcher: IdleWatcher = NativeHandle::from_native_handle(handle); watcher.install_watcher_data(); return watcher } } - pub fn start(&mut self, cb: IdleCallback) { + pub fn start(&self, cb: IdleCallback) { { let data = self.get_watcher_data(); data.idle_cb = Some(cb); @@ -40,7 +40,7 @@ impl IdleWatcher { }; extern fn idle_cb(handle: *uvll::uv_idle_t, status: c_int) { - let mut idle_watcher: IdleWatcher = NativeHandle::from_native_handle(handle); + let idle_watcher: IdleWatcher = NativeHandle::from_native_handle(handle); let data = idle_watcher.get_watcher_data(); let cb: &IdleCallback = data.idle_cb.get_ref(); let status = status_to_maybe_uv_error(status); @@ -48,13 +48,13 @@ impl IdleWatcher { } } - pub fn restart(&mut self) { + pub fn restart(&self) { unsafe { assert!(0 == uvll::idle_start(self.native_handle(), idle_cb)) }; extern fn idle_cb(handle: *uvll::uv_idle_t, status: c_int) { - let mut idle_watcher: IdleWatcher = NativeHandle::from_native_handle(handle); + let idle_watcher: IdleWatcher = NativeHandle::from_native_handle(handle); let data = idle_watcher.get_watcher_data(); let cb: &IdleCallback = data.idle_cb.get_ref(); let status = status_to_maybe_uv_error(status); @@ -62,7 +62,7 @@ impl IdleWatcher { } } - pub fn stop(&mut self) { + pub fn stop(&self) { // NB: Not resetting the Rust idle_cb to None here because `stop` is // likely called from *within* the idle callback, causing a use after // free @@ -74,8 +74,7 @@ impl IdleWatcher { pub fn close(self, cb: NullCallback) { { - let mut this = self; - let data = this.get_watcher_data(); + let data = self.get_watcher_data(); assert!(data.close_cb.is_none()); data.close_cb = Some(cb); } @@ -84,7 +83,7 @@ impl IdleWatcher { extern fn close_cb(handle: *uvll::uv_idle_t) { unsafe { - let mut idle_watcher: IdleWatcher = NativeHandle::from_native_handle(handle); + let idle_watcher: IdleWatcher = NativeHandle::from_native_handle(handle); { let data = idle_watcher.get_watcher_data(); data.close_cb.take_unwrap()(); @@ -126,11 +125,10 @@ mod test { fn idle_smoke_test() { do run_in_bare_thread { let mut loop_ = Loop::new(); - let mut idle_watcher = { IdleWatcher::new(&mut loop_) }; + let idle_watcher = { IdleWatcher::new(&mut loop_) }; let mut count = 10; let count_ptr: *mut int = &mut count; do idle_watcher.start |idle_watcher, status| { - let mut idle_watcher = idle_watcher; assert!(status.is_none()); if unsafe { *count_ptr == 10 } { idle_watcher.stop(); @@ -149,14 +147,14 @@ mod test { fn idle_start_stop_start() { do run_in_bare_thread { let mut loop_ = Loop::new(); - let mut idle_watcher = { IdleWatcher::new(&mut loop_) }; + let idle_watcher = { IdleWatcher::new(&mut loop_) }; do idle_watcher.start |idle_watcher, status| { - let mut idle_watcher = idle_watcher; + let idle_watcher = idle_watcher; assert!(status.is_none()); idle_watcher.stop(); do idle_watcher.start |idle_watcher, status| { assert!(status.is_none()); - let mut idle_watcher = idle_watcher; + let idle_watcher = idle_watcher; idle_watcher.stop(); idle_watcher.close(||()); } diff --git a/src/libstd/rt/uv/mod.rs b/src/libstd/rt/uv/mod.rs index 0c5351ea9e46d..6b554fce7fd9d 100644 --- a/src/libstd/rt/uv/mod.rs +++ b/src/libstd/rt/uv/mod.rs @@ -157,9 +157,9 @@ struct WatcherData { pub trait WatcherInterop { fn event_loop(&self) -> Loop; - fn install_watcher_data(&mut self); - fn get_watcher_data<'r>(&'r mut self) -> &'r mut WatcherData; - fn drop_watcher_data(&mut self); + fn install_watcher_data(&self); + fn get_watcher_data<'r>(&'r self) -> &'r mut WatcherData; + fn drop_watcher_data(&self); } impl> WatcherInterop for W { @@ -172,7 +172,7 @@ impl> WatcherInterop for W { } } - fn install_watcher_data(&mut self) { + fn install_watcher_data(&self) { unsafe { let data = ~WatcherData { read_cb: None, @@ -192,7 +192,7 @@ impl> WatcherInterop for W { } } - fn get_watcher_data<'r>(&'r mut self) -> &'r mut WatcherData { + fn get_watcher_data<'r>(&'r self) -> &'r mut WatcherData { unsafe { let data = uvll::get_data_for_uv_handle(self.native_handle()); let data = transmute::<&*c_void, &mut ~WatcherData>(&data); @@ -200,7 +200,7 @@ impl> WatcherInterop for W { } } - fn drop_watcher_data(&mut self) { + fn drop_watcher_data(&self) { unsafe { let data = uvll::get_data_for_uv_handle(self.native_handle()); let _data = transmute::<*c_void, ~WatcherData>(data); diff --git a/src/libstd/rt/uv/net.rs b/src/libstd/rt/uv/net.rs index ca42fd32f096b..f129eea3ed923 100644 --- a/src/libstd/rt/uv/net.rs +++ b/src/libstd/rt/uv/net.rs @@ -140,7 +140,7 @@ pub struct StreamWatcher(*uvll::uv_stream_t); impl Watcher for StreamWatcher { } impl StreamWatcher { - pub fn read_start(&mut self, alloc: AllocCallback, cb: ReadCallback) { + pub fn read_start(&self, alloc: AllocCallback, cb: ReadCallback) { { let data = self.get_watcher_data(); data.alloc_cb = Some(alloc); @@ -150,7 +150,7 @@ impl StreamWatcher { unsafe { uvll::read_start(self.native_handle(), alloc_cb, read_cb); } extern fn alloc_cb(stream: *uvll::uv_stream_t, suggested_size: size_t) -> Buf { - let mut stream_watcher: StreamWatcher = NativeHandle::from_native_handle(stream); + let stream_watcher: StreamWatcher = NativeHandle::from_native_handle(stream); let alloc_cb = stream_watcher.get_watcher_data().alloc_cb.get_ref(); return (*alloc_cb)(suggested_size as uint); } @@ -158,7 +158,7 @@ impl StreamWatcher { extern fn read_cb(stream: *uvll::uv_stream_t, nread: ssize_t, buf: Buf) { rtdebug!("buf addr: {}", buf.base); rtdebug!("buf len: {}", buf.len); - let mut stream_watcher: StreamWatcher = NativeHandle::from_native_handle(stream); + let stream_watcher: StreamWatcher = NativeHandle::from_native_handle(stream); let cb = stream_watcher.get_watcher_data().read_cb.get_ref(); let status = status_to_maybe_uv_error(nread as c_int); (*cb)(stream_watcher, nread as int, buf, status); @@ -173,7 +173,7 @@ impl StreamWatcher { unsafe { uvll::read_stop(handle); } } - pub fn write(&mut self, buf: Buf, cb: ConnectionCallback) { + pub fn write(&self, buf: Buf, cb: ConnectionCallback) { { let data = self.get_watcher_data(); assert!(data.write_cb.is_none()); @@ -187,7 +187,7 @@ impl StreamWatcher { extern fn write_cb(req: *uvll::uv_write_t, status: c_int) { let write_request: WriteRequest = NativeHandle::from_native_handle(req); - let mut stream_watcher = write_request.stream(); + let stream_watcher = write_request.stream(); write_request.delete(); let cb = stream_watcher.get_watcher_data().write_cb.take_unwrap(); let status = status_to_maybe_uv_error(status); @@ -195,7 +195,7 @@ impl StreamWatcher { } } - pub fn accept(&mut self, stream: StreamWatcher) { + pub fn accept(&self, stream: StreamWatcher) { let self_handle = self.native_handle() as *c_void; let stream_handle = stream.native_handle() as *c_void; assert_eq!(0, unsafe { uvll::accept(self_handle, stream_handle) } ); @@ -203,8 +203,7 @@ impl StreamWatcher { pub fn close(self, cb: NullCallback) { { - let mut this = self; - let data = this.get_watcher_data(); + let data = self.get_watcher_data(); assert!(data.close_cb.is_none()); data.close_cb = Some(cb); } @@ -212,7 +211,7 @@ impl StreamWatcher { unsafe { uvll::close(self.native_handle(), close_cb); } extern fn close_cb(handle: *uvll::uv_stream_t) { - let mut stream_watcher: StreamWatcher = NativeHandle::from_native_handle(handle); + let stream_watcher: StreamWatcher = NativeHandle::from_native_handle(handle); let cb = stream_watcher.get_watcher_data().close_cb.take_unwrap(); stream_watcher.drop_watcher_data(); unsafe { free_handle(handle as *c_void) } @@ -239,13 +238,13 @@ impl TcpWatcher { let handle = malloc_handle(UV_TCP); assert!(handle.is_not_null()); assert_eq!(0, uvll::tcp_init(loop_.native_handle(), handle)); - let mut watcher: TcpWatcher = NativeHandle::from_native_handle(handle); + let watcher: TcpWatcher = NativeHandle::from_native_handle(handle); watcher.install_watcher_data(); return watcher; } } - pub fn bind(&mut self, address: SocketAddr) -> Result<(), UvError> { + pub fn bind(&self, address: SocketAddr) -> Result<(), UvError> { do socket_addr_as_uv_socket_addr(address) |addr| { let result = unsafe { match addr { @@ -260,7 +259,7 @@ impl TcpWatcher { } } - pub fn connect(&mut self, address: SocketAddr, cb: ConnectionCallback) { + pub fn connect(&self, address: SocketAddr, cb: ConnectionCallback) { unsafe { assert!(self.get_watcher_data().connect_cb.is_none()); self.get_watcher_data().connect_cb = Some(cb); @@ -280,7 +279,7 @@ impl TcpWatcher { extern fn connect_cb(req: *uvll::uv_connect_t, status: c_int) { rtdebug!("connect_t: {}", req); let connect_request: ConnectRequest = NativeHandle::from_native_handle(req); - let mut stream_watcher = connect_request.stream(); + let stream_watcher = connect_request.stream(); connect_request.delete(); let cb = stream_watcher.get_watcher_data().connect_cb.take_unwrap(); let status = status_to_maybe_uv_error(status); @@ -289,7 +288,7 @@ impl TcpWatcher { } } - pub fn listen(&mut self, cb: ConnectionCallback) { + pub fn listen(&self, cb: ConnectionCallback) { { let data = self.get_watcher_data(); assert!(data.connect_cb.is_none()); @@ -304,7 +303,7 @@ impl TcpWatcher { extern fn connection_cb(handle: *uvll::uv_stream_t, status: c_int) { rtdebug!("connection_cb"); - let mut stream_watcher: StreamWatcher = NativeHandle::from_native_handle(handle); + let stream_watcher: StreamWatcher = NativeHandle::from_native_handle(handle); let cb = stream_watcher.get_watcher_data().connect_cb.get_ref(); let status = status_to_maybe_uv_error(status); (*cb)(stream_watcher, status); @@ -334,13 +333,13 @@ impl UdpWatcher { let handle = malloc_handle(UV_UDP); assert!(handle.is_not_null()); assert_eq!(0, uvll::udp_init(loop_.native_handle(), handle)); - let mut watcher: UdpWatcher = NativeHandle::from_native_handle(handle); + let watcher: UdpWatcher = NativeHandle::from_native_handle(handle); watcher.install_watcher_data(); return watcher; } } - pub fn bind(&mut self, address: SocketAddr) -> Result<(), UvError> { + pub fn bind(&self, address: SocketAddr) -> Result<(), UvError> { do socket_addr_as_uv_socket_addr(address) |addr| { let result = unsafe { match addr { @@ -355,7 +354,7 @@ impl UdpWatcher { } } - pub fn recv_start(&mut self, alloc: AllocCallback, cb: UdpReceiveCallback) { + pub fn recv_start(&self, alloc: AllocCallback, cb: UdpReceiveCallback) { { let data = self.get_watcher_data(); data.alloc_cb = Some(alloc); @@ -365,7 +364,7 @@ impl UdpWatcher { unsafe { uvll::udp_recv_start(self.native_handle(), alloc_cb, recv_cb); } extern fn alloc_cb(handle: *uvll::uv_udp_t, suggested_size: size_t) -> Buf { - let mut udp_watcher: UdpWatcher = NativeHandle::from_native_handle(handle); + let udp_watcher: UdpWatcher = NativeHandle::from_native_handle(handle); let alloc_cb = udp_watcher.get_watcher_data().alloc_cb.get_ref(); return (*alloc_cb)(suggested_size as uint); } @@ -381,7 +380,7 @@ impl UdpWatcher { rtdebug!("buf addr: {}", buf.base); rtdebug!("buf len: {}", buf.len); - let mut udp_watcher: UdpWatcher = NativeHandle::from_native_handle(handle); + let udp_watcher: UdpWatcher = NativeHandle::from_native_handle(handle); let cb = udp_watcher.get_watcher_data().udp_recv_cb.get_ref(); let status = status_to_maybe_uv_error(nread as c_int); let addr = uv_socket_addr_to_socket_addr(sockaddr_to_UvSocketAddr(addr)); @@ -389,11 +388,11 @@ impl UdpWatcher { } } - pub fn recv_stop(&mut self) { + pub fn recv_stop(&self) { unsafe { uvll::udp_recv_stop(self.native_handle()); } } - pub fn send(&mut self, buf: Buf, address: SocketAddr, cb: UdpSendCallback) { + pub fn send(&self, buf: Buf, address: SocketAddr, cb: UdpSendCallback) { { let data = self.get_watcher_data(); assert!(data.udp_send_cb.is_none()); @@ -415,7 +414,7 @@ impl UdpWatcher { extern fn send_cb(req: *uvll::uv_udp_send_t, status: c_int) { let send_request: UdpSendRequest = NativeHandle::from_native_handle(req); - let mut udp_watcher = send_request.handle(); + let udp_watcher = send_request.handle(); send_request.delete(); let cb = udp_watcher.get_watcher_data().udp_send_cb.take_unwrap(); let status = status_to_maybe_uv_error(status); @@ -423,10 +422,9 @@ impl UdpWatcher { } } - pub fn close(self, cb: NullCallback) { + pub fn close(&self, cb: NullCallback) { { - let mut this = self; - let data = this.get_watcher_data(); + let data = self.get_watcher_data(); assert!(data.close_cb.is_none()); data.close_cb = Some(cb); } @@ -434,7 +432,7 @@ impl UdpWatcher { unsafe { uvll::close(self.native_handle(), close_cb); } extern fn close_cb(handle: *uvll::uv_udp_t) { - let mut udp_watcher: UdpWatcher = NativeHandle::from_native_handle(handle); + let udp_watcher: UdpWatcher = NativeHandle::from_native_handle(handle); let cb = udp_watcher.get_watcher_data().close_cb.take_unwrap(); udp_watcher.drop_watcher_data(); unsafe { free_handle(handle as *c_void) } @@ -565,7 +563,7 @@ mod test { fn connect_close_ip4() { do run_in_bare_thread() { let mut loop_ = Loop::new(); - let mut tcp_watcher = { TcpWatcher::new(&mut loop_) }; + let tcp_watcher = { TcpWatcher::new(&mut loop_) }; // Connect to a port where nobody is listening let addr = next_test_ip4(); do tcp_watcher.connect(addr) |stream_watcher, status| { @@ -583,7 +581,7 @@ mod test { fn connect_close_ip6() { do run_in_bare_thread() { let mut loop_ = Loop::new(); - let mut tcp_watcher = { TcpWatcher::new(&mut loop_) }; + let tcp_watcher = { TcpWatcher::new(&mut loop_) }; // Connect to a port where nobody is listening let addr = next_test_ip6(); do tcp_watcher.connect(addr) |stream_watcher, status| { @@ -601,7 +599,7 @@ mod test { fn udp_bind_close_ip4() { do run_in_bare_thread() { let mut loop_ = Loop::new(); - let mut udp_watcher = { UdpWatcher::new(&mut loop_) }; + let udp_watcher = { UdpWatcher::new(&mut loop_) }; let addr = next_test_ip4(); udp_watcher.bind(addr); udp_watcher.close(||()); @@ -614,7 +612,7 @@ mod test { fn udp_bind_close_ip6() { do run_in_bare_thread() { let mut loop_ = Loop::new(); - let mut udp_watcher = { UdpWatcher::new(&mut loop_) }; + let udp_watcher = { UdpWatcher::new(&mut loop_) }; let addr = next_test_ip6(); udp_watcher.bind(addr); udp_watcher.close(||()); @@ -628,17 +626,17 @@ mod test { do run_in_bare_thread() { static MAX: int = 10; let mut loop_ = Loop::new(); - let mut server_tcp_watcher = { TcpWatcher::new(&mut loop_) }; + let server_tcp_watcher = { TcpWatcher::new(&mut loop_) }; let addr = next_test_ip4(); server_tcp_watcher.bind(addr); let loop_ = loop_; rtdebug!("listening"); - do server_tcp_watcher.listen |mut server_stream_watcher, status| { + do server_tcp_watcher.listen |server_stream_watcher, status| { rtdebug!("listened!"); assert!(status.is_none()); let mut loop_ = loop_; let client_tcp_watcher = TcpWatcher::new(&mut loop_); - let mut client_tcp_watcher = client_tcp_watcher.as_stream(); + let client_tcp_watcher = client_tcp_watcher.as_stream(); server_stream_watcher.accept(client_tcp_watcher); let count_cell = Cell::new(0); let server_stream_watcher = server_stream_watcher; @@ -672,8 +670,8 @@ mod test { let client_thread = do Thread::start { rtdebug!("starting client thread"); let mut loop_ = Loop::new(); - let mut tcp_watcher = { TcpWatcher::new(&mut loop_) }; - do tcp_watcher.connect(addr) |mut stream_watcher, status| { + let tcp_watcher = { TcpWatcher::new(&mut loop_) }; + do tcp_watcher.connect(addr) |stream_watcher, status| { rtdebug!("connecting"); assert!(status.is_none()); let msg = ~[0, 1, 2, 3, 4, 5, 6 ,7 ,8, 9]; @@ -702,17 +700,17 @@ mod test { do run_in_bare_thread() { static MAX: int = 10; let mut loop_ = Loop::new(); - let mut server_tcp_watcher = { TcpWatcher::new(&mut loop_) }; + let server_tcp_watcher = { TcpWatcher::new(&mut loop_) }; let addr = next_test_ip6(); server_tcp_watcher.bind(addr); let loop_ = loop_; rtdebug!("listening"); - do server_tcp_watcher.listen |mut server_stream_watcher, status| { + do server_tcp_watcher.listen |server_stream_watcher, status| { rtdebug!("listened!"); assert!(status.is_none()); let mut loop_ = loop_; let client_tcp_watcher = TcpWatcher::new(&mut loop_); - let mut client_tcp_watcher = client_tcp_watcher.as_stream(); + let client_tcp_watcher = client_tcp_watcher.as_stream(); server_stream_watcher.accept(client_tcp_watcher); let count_cell = Cell::new(0); let server_stream_watcher = server_stream_watcher; @@ -748,8 +746,8 @@ mod test { let client_thread = do Thread::start { rtdebug!("starting client thread"); let mut loop_ = Loop::new(); - let mut tcp_watcher = { TcpWatcher::new(&mut loop_) }; - do tcp_watcher.connect(addr) |mut stream_watcher, status| { + let tcp_watcher = { TcpWatcher::new(&mut loop_) }; + do tcp_watcher.connect(addr) |stream_watcher, status| { rtdebug!("connecting"); assert!(status.is_none()); let msg = ~[0, 1, 2, 3, 4, 5, 6 ,7 ,8, 9]; @@ -781,7 +779,7 @@ mod test { let server_addr = next_test_ip4(); let client_addr = next_test_ip4(); - let mut server = UdpWatcher::new(&loop_); + let server = UdpWatcher::new(&loop_); assert!(server.bind(server_addr).is_ok()); rtdebug!("starting read"); @@ -789,7 +787,7 @@ mod test { vec_to_uv_buf(vec::from_elem(size, 0u8)) }; - do server.recv_start(alloc) |mut server, nread, buf, src, flags, status| { + do server.recv_start(alloc) |server, nread, buf, src, flags, status| { server.recv_stop(); rtdebug!("i'm reading!"); assert!(status.is_none()); @@ -813,7 +811,7 @@ mod test { let thread = do Thread::start { let mut loop_ = Loop::new(); - let mut client = UdpWatcher::new(&loop_); + let client = UdpWatcher::new(&loop_); assert!(client.bind(client_addr).is_ok()); let msg = ~[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; let buf = slice_to_uv_buf(msg); @@ -841,7 +839,7 @@ mod test { let server_addr = next_test_ip6(); let client_addr = next_test_ip6(); - let mut server = UdpWatcher::new(&loop_); + let server = UdpWatcher::new(&loop_); assert!(server.bind(server_addr).is_ok()); rtdebug!("starting read"); @@ -849,7 +847,7 @@ mod test { vec_to_uv_buf(vec::from_elem(size, 0u8)) }; - do server.recv_start(alloc) |mut server, nread, buf, src, flags, status| { + do server.recv_start(alloc) |server, nread, buf, src, flags, status| { server.recv_stop(); rtdebug!("i'm reading!"); assert!(status.is_none()); @@ -873,7 +871,7 @@ mod test { let thread = do Thread::start { let mut loop_ = Loop::new(); - let mut client = UdpWatcher::new(&loop_); + let client = UdpWatcher::new(&loop_); assert!(client.bind(client_addr).is_ok()); let msg = ~[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; let buf = slice_to_uv_buf(msg); diff --git a/src/libstd/rt/uv/pipe.rs b/src/libstd/rt/uv/pipe.rs index 1147c731a60c5..960a930a4802a 100644 --- a/src/libstd/rt/uv/pipe.rs +++ b/src/libstd/rt/uv/pipe.rs @@ -26,8 +26,7 @@ impl Pipe { assert!(handle.is_not_null()); let ipc = ipc as libc::c_int; assert_eq!(uvll::pipe_init(loop_.native_handle(), handle, ipc), 0); - let mut ret: Pipe = - uv::NativeHandle::from_native_handle(handle); + let ret: Pipe = uv::NativeHandle::from_native_handle(handle); ret.install_watcher_data(); ret } @@ -38,17 +37,14 @@ impl Pipe { } pub fn close(self, cb: uv::NullCallback) { - { - let mut this = self; - let data = this.get_watcher_data(); - assert!(data.close_cb.is_none()); - data.close_cb = Some(cb); - } + let data = self.get_watcher_data(); + assert!(data.close_cb.is_none()); + data.close_cb = Some(cb); unsafe { uvll::close(self.native_handle(), close_cb); } extern fn close_cb(handle: *uvll::uv_pipe_t) { - let mut process: Pipe = uv::NativeHandle::from_native_handle(handle); + let process: Pipe = uv::NativeHandle::from_native_handle(handle); process.get_watcher_data().close_cb.take_unwrap()(); process.drop_watcher_data(); unsafe { uvll::free_handle(handle as *libc::c_void) } diff --git a/src/libstd/rt/uv/process.rs b/src/libstd/rt/uv/process.rs index ddaf0c2872519..1f989388e316a 100644 --- a/src/libstd/rt/uv/process.rs +++ b/src/libstd/rt/uv/process.rs @@ -30,7 +30,7 @@ impl Process { pub fn new() -> Process { let handle = unsafe { uvll::malloc_handle(uvll::UV_PROCESS) }; assert!(handle.is_not_null()); - let mut ret: Process = uv::NativeHandle::from_native_handle(handle); + let ret: Process = uv::NativeHandle::from_native_handle(handle); ret.install_watcher_data(); return ret; } @@ -42,7 +42,7 @@ impl Process { /// /// Returns either the corresponding process object or an error which /// occurred. - pub fn spawn(&mut self, loop_: &uv::Loop, mut config: ProcessConfig, + pub fn spawn(&self, loop_: &uv::Loop, mut config: ProcessConfig, exit_cb: uv::ExitCallback) -> Result<~[Option], uv::UvError> { @@ -51,7 +51,7 @@ impl Process { extern fn on_exit(p: *uvll::uv_process_t, exit_status: libc::c_int, term_signal: libc::c_int) { - let mut p: Process = uv::NativeHandle::from_native_handle(p); + let p: Process = uv::NativeHandle::from_native_handle(p); let err = match exit_status { 0 => None, _ => uv::status_to_maybe_uv_error(-1) @@ -125,17 +125,14 @@ impl Process { /// Closes this handle, invoking the specified callback once closed pub fn close(self, cb: uv::NullCallback) { - { - let mut this = self; - let data = this.get_watcher_data(); - assert!(data.close_cb.is_none()); - data.close_cb = Some(cb); - } + let data = self.get_watcher_data(); + assert!(data.close_cb.is_none()); + data.close_cb = Some(cb); unsafe { uvll::close(self.native_handle(), close_cb); } extern fn close_cb(handle: *uvll::uv_process_t) { - let mut process: Process = uv::NativeHandle::from_native_handle(handle); + let process: Process = uv::NativeHandle::from_native_handle(handle); process.get_watcher_data().close_cb.take_unwrap()(); process.drop_watcher_data(); unsafe { uvll::free_handle(handle as *libc::c_void) } diff --git a/src/libstd/rt/uv/timer.rs b/src/libstd/rt/uv/timer.rs index 7b09cf2eb0e3a..a336d36ccfbdf 100644 --- a/src/libstd/rt/uv/timer.rs +++ b/src/libstd/rt/uv/timer.rs @@ -23,13 +23,13 @@ impl TimerWatcher { let handle = uvll::malloc_handle(uvll::UV_TIMER); assert!(handle.is_not_null()); assert!(0 == uvll::timer_init(loop_.native_handle(), handle)); - let mut watcher: TimerWatcher = NativeHandle::from_native_handle(handle); + let watcher: TimerWatcher = NativeHandle::from_native_handle(handle); watcher.install_watcher_data(); return watcher; } } - pub fn start(&mut self, timeout: u64, repeat: u64, cb: TimerCallback) { + pub fn start(self, timeout: u64, repeat: u64, cb: TimerCallback) { { let data = self.get_watcher_data(); data.timer_cb = Some(cb); @@ -40,7 +40,7 @@ impl TimerWatcher { } extern fn timer_cb(handle: *uvll::uv_timer_t, status: c_int) { - let mut watcher: TimerWatcher = NativeHandle::from_native_handle(handle); + let watcher: TimerWatcher = NativeHandle::from_native_handle(handle); let data = watcher.get_watcher_data(); let cb = data.timer_cb.get_ref(); let status = status_to_maybe_uv_error(status); @@ -48,26 +48,23 @@ impl TimerWatcher { } } - pub fn stop(&mut self) { + pub fn stop(self) { unsafe { uvll::timer_stop(self.native_handle()); } } pub fn close(self, cb: NullCallback) { - let mut watcher = self; - { - let data = watcher.get_watcher_data(); - assert!(data.close_cb.is_none()); - data.close_cb = Some(cb); - } + let data = self.get_watcher_data(); + assert!(data.close_cb.is_none()); + data.close_cb = Some(cb); unsafe { - uvll::close(watcher.native_handle(), close_cb); + uvll::close(self.native_handle(), close_cb); } extern fn close_cb(handle: *uvll::uv_timer_t) { - let mut watcher: TimerWatcher = NativeHandle::from_native_handle(handle); + let watcher: TimerWatcher = NativeHandle::from_native_handle(handle); { let data = watcher.get_watcher_data(); data.close_cb.take_unwrap()(); @@ -101,7 +98,7 @@ mod test { let mut count = 0; let count_ptr: *mut int = &mut count; let mut loop_ = Loop::new(); - let mut timer = TimerWatcher::new(&mut loop_); + let timer = TimerWatcher::new(&mut loop_); do timer.start(10, 0) |timer, status| { assert!(status.is_none()); unsafe { *count_ptr += 1 }; @@ -119,9 +116,9 @@ mod test { let mut count = 0; let count_ptr: *mut int = &mut count; let mut loop_ = Loop::new(); - let mut timer = TimerWatcher::new(&mut loop_); + let timer = TimerWatcher::new(&mut loop_); do timer.start(10, 0) |timer, status| { - let mut timer = timer; + let timer = timer; assert!(status.is_none()); unsafe { *count_ptr += 1 }; do timer.start(10, 0) |timer, status| { @@ -142,7 +139,7 @@ mod test { let mut count = 0; let count_ptr: *mut int = &mut count; let mut loop_ = Loop::new(); - let mut timer = TimerWatcher::new(&mut loop_); + let timer = TimerWatcher::new(&mut loop_); do timer.start(1, 2) |timer, status| { assert!(status.is_none()); unsafe { @@ -151,13 +148,12 @@ mod test { if *count_ptr == 10 { // Stop the timer and do something else - let mut timer = timer; timer.stop(); // Freeze timer so it can be captured let timer = timer; let mut loop_ = timer.event_loop(); - let mut timer2 = TimerWatcher::new(&mut loop_); + let timer2 = TimerWatcher::new(&mut loop_); do timer2.start(10, 0) |timer2, _| { *count_ptr += 1; @@ -165,7 +161,6 @@ mod test { timer2.close(||()); // Restart the original timer - let mut timer = timer; do timer.start(1, 0) |timer, _| { *count_ptr += 1; timer.close(||()); diff --git a/src/libstd/rt/uv/uvio.rs b/src/libstd/rt/uv/uvio.rs index f9b71db704347..3449668bd2adf 100644 --- a/src/libstd/rt/uv/uvio.rs +++ b/src/libstd/rt/uv/uvio.rs @@ -202,8 +202,8 @@ impl EventLoop for UvEventLoop { } fn callback(&mut self, f: ~fn()) { - let mut idle_watcher = IdleWatcher::new(self.uvio.uv_loop()); - do idle_watcher.start |mut idle_watcher, status| { + let idle_watcher = IdleWatcher::new(self.uvio.uv_loop()); + do idle_watcher.start |idle_watcher, status| { assert!(status.is_none()); idle_watcher.stop(); idle_watcher.close(||()); @@ -221,7 +221,7 @@ impl EventLoop for UvEventLoop { } fn callback_ms(&mut self, ms: u64, f: ~fn()) { - let mut timer = TimerWatcher::new(self.uvio.uv_loop()); + let timer = TimerWatcher::new(self.uvio.uv_loop()); do timer.start(ms, 0) |timer, status| { assert!(status.is_none()); timer.close(||()); @@ -456,7 +456,7 @@ impl IoFactory for UvIoFactory { let scheduler: ~Scheduler = Local::take(); do scheduler.deschedule_running_task_and_then |_, task| { - let mut tcp = TcpWatcher::new(self.uv_loop()); + let tcp = TcpWatcher::new(self.uv_loop()); let task_cell = Cell::new(task); // Wait for a connection @@ -493,7 +493,7 @@ impl IoFactory for UvIoFactory { } fn tcp_bind(&mut self, addr: SocketAddr) -> Result<~RtioTcpListenerObject, IoError> { - let mut watcher = TcpWatcher::new(self.uv_loop()); + let watcher = TcpWatcher::new(self.uv_loop()); match watcher.bind(addr) { Ok(_) => { let home = get_handle_to_current_scheduler!(); @@ -516,7 +516,7 @@ impl IoFactory for UvIoFactory { } fn udp_bind(&mut self, addr: SocketAddr) -> Result<~RtioUdpSocketObject, IoError> { - let mut watcher = UdpWatcher::new(self.uv_loop()); + let watcher = UdpWatcher::new(self.uv_loop()); match watcher.bind(addr) { Ok(_) => { let home = get_handle_to_current_scheduler!(); @@ -837,9 +837,9 @@ impl RtioSocket for UvTcpListener { impl RtioTcpListener for UvTcpListener { fn listen(self) -> Result<~RtioTcpAcceptorObject, IoError> { do self.home_for_io_consume |self_| { - let mut acceptor = ~UvTcpAcceptor::new(self_); + let acceptor = ~UvTcpAcceptor::new(self_); let incoming = Cell::new(acceptor.incoming.clone()); - do acceptor.listener.watcher.listen |mut server, status| { + do acceptor.listener.watcher.listen |server, status| { do incoming.with_mut_ref |incoming| { let inc = match status { Some(_) => Err(standard_error(OtherIoError)), @@ -916,7 +916,7 @@ impl RtioTcpAcceptor for UvTcpAcceptor { } } -fn read_stream(mut watcher: StreamWatcher, +fn read_stream(watcher: StreamWatcher, scheduler: ~Scheduler, buf: &mut [u8]) -> Result { let result_cell = Cell::new_empty(); @@ -956,7 +956,7 @@ fn read_stream(mut watcher: StreamWatcher, result_cell.take() } -fn write_stream(mut watcher: StreamWatcher, +fn write_stream(watcher: StreamWatcher, scheduler: ~Scheduler, buf: &[u8]) -> Result<(), IoError> { let result_cell = Cell::new_empty(); @@ -1177,7 +1177,7 @@ impl RtioUdpSocket for UvUdpSocket { do scheduler.deschedule_running_task_and_then |_, task| { let task_cell = Cell::new(task); let alloc: AllocCallback = |_| unsafe { slice_to_uv_buf(*buf_ptr) }; - do self_.watcher.recv_start(alloc) |mut watcher, nread, _buf, addr, flags, status| { + do self_.watcher.recv_start(alloc) |watcher, nread, _buf, addr, flags, status| { let _ = flags; // /XXX add handling for partials? watcher.recv_stop();