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<H, W: Watcher + NativeHandle<*H>> WatcherInterop for W {
@@ -172,7 +172,7 @@ impl<H, W: Watcher + NativeHandle<*H>> 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<H, W: Watcher + NativeHandle<*H>> 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<H, W: Watcher + NativeHandle<*H>> 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<UvPipeStream>], 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<uint, IoError> {
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();