From ab08b4fbfde7e9cc9e0de07aed17b4d4e06ccc3e Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Mon, 1 Apr 2013 18:17:16 -0700 Subject: [PATCH] core: Remove pipes::spawn_service, spawn_service_recv These are only used in test cases; pipes isn't the right place for them; they are unnecessary. Conflicts: src/libcore/rt/uv/mod.rs --- src/libcore/pipes.rs | 46 ------------------------- src/test/bench/pingpong.rs | 49 ++++++++++++++++++++++++++- src/test/run-pass/pipe-detect-term.rs | 10 +++--- src/test/run-pass/pipe-select.rs | 22 ++++++++++-- src/test/run-pass/pipe-sleep.rs | 30 ++++++++++++++-- 5 files changed, 102 insertions(+), 55 deletions(-) diff --git a/src/libcore/pipes.rs b/src/libcore/pipes.rs index fddb2af55870..fd50ecc5274a 100644 --- a/src/libcore/pipes.rs +++ b/src/libcore/pipes.rs @@ -83,7 +83,6 @@ bounded and unbounded protocols allows for less code duplication. */ use cast::{forget, reinterpret_cast, transmute}; -use cell::Cell; use either::{Either, Left, Right}; use kinds::Owned; use libc; @@ -902,51 +901,6 @@ pub fn entangle() -> (SendPacket, RecvPacket) { (SendPacket(p), RecvPacket(p)) } -/** Spawn a task to provide a service. - -It takes an initialization function that produces a send and receive -endpoint. The send endpoint is returned to the caller and the receive -endpoint is passed to the new task. - -*/ -pub fn spawn_service( - init: extern fn() -> (SendPacketBuffered, - RecvPacketBuffered), - service: ~fn(v: RecvPacketBuffered)) - -> SendPacketBuffered { - let (client, server) = init(); - - // This is some nasty gymnastics required to safely move the pipe - // into a new task. - let server = Cell(server); - do task::spawn { - service(server.take()); - } - - client -} - -/** Like `spawn_service_recv`, but for protocols that start in the -receive state. - -*/ -pub fn spawn_service_recv( - init: extern fn() -> (RecvPacketBuffered, - SendPacketBuffered), - service: ~fn(v: SendPacketBuffered)) - -> RecvPacketBuffered { - let (client, server) = init(); - - // This is some nasty gymnastics required to safely move the pipe - // into a new task. - let server = Cell(server); - do task::spawn { - service(server.take()) - } - - client -} - pub mod rt { use option::{None, Option, Some}; diff --git a/src/test/bench/pingpong.rs b/src/test/bench/pingpong.rs index 731605e82bd1..64fb9652ceae 100644 --- a/src/test/bench/pingpong.rs +++ b/src/test/bench/pingpong.rs @@ -14,7 +14,8 @@ extern mod std; -use core::pipes::{spawn_service, recv}; +use core::cell::Cell; +use core::pipes::*; use std::time::precise_time_s; proto! pingpong ( @@ -70,6 +71,52 @@ macro_rules! follow ( ) ) + +/** Spawn a task to provide a service. + +It takes an initialization function that produces a send and receive +endpoint. The send endpoint is returned to the caller and the receive +endpoint is passed to the new task. + +*/ +pub fn spawn_service( + init: extern fn() -> (SendPacketBuffered, + RecvPacketBuffered), + service: ~fn(v: RecvPacketBuffered)) + -> SendPacketBuffered { + let (client, server) = init(); + + // This is some nasty gymnastics required to safely move the pipe + // into a new task. + let server = Cell(server); + do task::spawn { + service(server.take()); + } + + client +} + +/** Like `spawn_service_recv`, but for protocols that start in the +receive state. + +*/ +pub fn spawn_service_recv( + init: extern fn() -> (RecvPacketBuffered, + SendPacketBuffered), + service: ~fn(v: SendPacketBuffered)) + -> RecvPacketBuffered { + let (client, server) = init(); + + // This is some nasty gymnastics required to safely move the pipe + // into a new task. + let server = Cell(server); + do task::spawn { + service(server.take()) + } + + client +} + fn switch(+endp: core::pipes::RecvPacketBuffered, f: &fn(+v: Option) -> U) -> U { f(core::pipes::try_recv(endp)) diff --git a/src/test/run-pass/pipe-detect-term.rs b/src/test/run-pass/pipe-detect-term.rs index 6afa9e29349f..bd0ffa645906 100644 --- a/src/test/run-pass/pipe-detect-term.rs +++ b/src/test/run-pass/pipe-detect-term.rs @@ -18,7 +18,7 @@ extern mod std; use std::timer::sleep; use std::uv; -use core::pipes; +use core::cell::Cell; use core::pipes::{try_recv, recv}; proto! oneshot ( @@ -30,12 +30,14 @@ proto! oneshot ( pub fn main() { let iotask = &uv::global_loop::get(); - pipes::spawn_service(oneshot::init, |p| { - match try_recv(p) { + let (chan, port) = oneshot::init(); + let port = Cell(port); + do spawn { + match try_recv(port.take()) { Some(*) => { fail!() } None => { } } - }); + } sleep(iotask, 100); diff --git a/src/test/run-pass/pipe-select.rs b/src/test/run-pass/pipe-select.rs index 221ecbfcf02e..12d60c9d6ab0 100644 --- a/src/test/run-pass/pipe-select.rs +++ b/src/test/run-pass/pipe-select.rs @@ -17,8 +17,9 @@ extern mod std; use std::timer::sleep; use std::uv; +use core::cell::Cell; use core::pipes; -use core::pipes::{recv, select}; +use core::pipes::*; proto! oneshot ( waiting:send { @@ -32,13 +33,30 @@ proto! stream ( } ) +pub fn spawn_service( + init: extern fn() -> (SendPacketBuffered, + RecvPacketBuffered), + service: ~fn(v: RecvPacketBuffered)) + -> SendPacketBuffered { + let (client, server) = init(); + + // This is some nasty gymnastics required to safely move the pipe + // into a new task. + let server = Cell(server); + do task::spawn { + service(server.take()); + } + + client +} + pub fn main() { use oneshot::client::*; use stream::client::*; let iotask = &uv::global_loop::get(); - let c = pipes::spawn_service(stream::init, |p| { + let c = spawn_service(stream::init, |p| { error!("waiting for pipes"); let stream::send(x, p) = recv(p); error!("got pipes"); diff --git a/src/test/run-pass/pipe-sleep.rs b/src/test/run-pass/pipe-sleep.rs index 57d72edd0a46..86ffc96e89ae 100644 --- a/src/test/run-pass/pipe-sleep.rs +++ b/src/test/run-pass/pipe-sleep.rs @@ -13,8 +13,9 @@ extern mod std; use std::timer::sleep; use std::uv; +use core::cell::Cell; use core::pipes; -use core::pipes::recv; +use core::pipes::*; proto! oneshot ( waiting:send { @@ -22,10 +23,35 @@ proto! oneshot ( } ) + +/** Spawn a task to provide a service. + +It takes an initialization function that produces a send and receive +endpoint. The send endpoint is returned to the caller and the receive +endpoint is passed to the new task. + +*/ +pub fn spawn_service( + init: extern fn() -> (SendPacketBuffered, + RecvPacketBuffered), + service: ~fn(v: RecvPacketBuffered)) + -> SendPacketBuffered { + let (client, server) = init(); + + // This is some nasty gymnastics required to safely move the pipe + // into a new task. + let server = Cell(server); + do task::spawn { + service(server.take()); + } + + client +} + pub fn main() { use oneshot::client::*; - let c = pipes::spawn_service(oneshot::init, |p| { recv(p); }); + let c = spawn_service(oneshot::init, |p| { recv(p); }); let iotask = &uv::global_loop::get(); sleep(iotask, 500);