2012-12-03 18:48:01 -06:00
|
|
|
// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
|
|
|
|
// file at the top-level directory of this distribution and at
|
|
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
|
|
//
|
|
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
|
|
// option. This file may not be copied, modified, or distributed
|
|
|
|
// except according to those terms.
|
|
|
|
|
2012-07-04 16:53:12 -05:00
|
|
|
/*!
|
|
|
|
* A type representing values that may be computed concurrently and
|
|
|
|
* operations for working with them.
|
|
|
|
*
|
|
|
|
* # Example
|
|
|
|
*
|
|
|
|
* ~~~
|
|
|
|
* let delayed_fib = future::spawn {|| fib(5000) };
|
|
|
|
* make_a_sandwich();
|
2012-08-22 19:24:52 -05:00
|
|
|
* io::println(fmt!("fib(5000) = %?", delayed_fib.get()))
|
2012-07-04 16:53:12 -05:00
|
|
|
* ~~~
|
|
|
|
*/
|
2012-02-14 18:39:20 -06:00
|
|
|
|
2012-12-23 16:41:37 -06:00
|
|
|
use core::cast;
|
2013-02-26 13:32:00 -06:00
|
|
|
use core::cell::Cell;
|
2013-05-03 17:57:18 -05:00
|
|
|
use core::comm::{PortOne, oneshot, send_one};
|
2013-02-02 05:10:12 -06:00
|
|
|
use core::pipes::recv;
|
2012-12-23 16:41:37 -06:00
|
|
|
use core::task;
|
2012-03-16 17:14:37 -05:00
|
|
|
|
2012-07-02 21:03:11 -05:00
|
|
|
#[doc = "The future type"]
|
2012-09-26 19:20:14 -05:00
|
|
|
pub struct Future<A> {
|
2013-01-11 02:27:01 -06:00
|
|
|
priv mut state: FutureState<A>,
|
2012-11-13 20:38:18 -06:00
|
|
|
}
|
2012-08-28 23:28:25 -05:00
|
|
|
|
2012-11-13 20:38:18 -06:00
|
|
|
// FIXME(#2829) -- futures should not be copyable, because they close
|
2013-03-01 16:15:15 -06:00
|
|
|
// over ~fn's that have pipes and so forth within!
|
2013-03-20 20:18:57 -05:00
|
|
|
#[unsafe_destructor]
|
2013-02-14 13:47:00 -06:00
|
|
|
impl<A> Drop for Future<A> {
|
2012-11-28 17:42:16 -06:00
|
|
|
fn finalize(&self) {}
|
2012-08-27 18:08:17 -05:00
|
|
|
}
|
2012-02-14 18:39:20 -06:00
|
|
|
|
2012-08-27 18:08:17 -05:00
|
|
|
priv enum FutureState<A> {
|
2013-03-01 16:15:15 -06:00
|
|
|
Pending(~fn() -> A),
|
2012-08-27 18:08:17 -05:00
|
|
|
Evaluating,
|
2012-12-11 17:19:43 -06:00
|
|
|
Forced(A)
|
2012-08-27 18:08:17 -05:00
|
|
|
}
|
2012-02-14 18:39:20 -06:00
|
|
|
|
2012-08-27 18:08:17 -05:00
|
|
|
/// Methods on the `future` type
|
2013-02-26 19:47:41 -06:00
|
|
|
pub impl<A:Copy> Future<A> {
|
2013-03-07 20:11:09 -06:00
|
|
|
fn get(&self) -> A {
|
2012-07-04 16:53:12 -05:00
|
|
|
//! Get the value of the future
|
2012-12-11 17:19:43 -06:00
|
|
|
*(self.get_ref())
|
2012-02-14 18:39:20 -06:00
|
|
|
}
|
2012-08-27 18:08:17 -05:00
|
|
|
}
|
|
|
|
|
2013-02-26 19:47:41 -06:00
|
|
|
pub impl<A> Future<A> {
|
2013-04-10 15:14:06 -05:00
|
|
|
fn get_ref<'a>(&'a self) -> &'a A {
|
|
|
|
/*!
|
|
|
|
* Executes the future's closure and then returns a borrowed
|
|
|
|
* pointer to the result. The borrowed pointer lasts as long as
|
|
|
|
* the future.
|
|
|
|
*/
|
|
|
|
unsafe {
|
|
|
|
match self.state {
|
|
|
|
Forced(ref mut v) => { return cast::transmute(v); }
|
|
|
|
Evaluating => fail!(~"Recursive forcing of future!"),
|
|
|
|
Pending(_) => {}
|
|
|
|
}
|
|
|
|
|
|
|
|
let mut state = Evaluating;
|
|
|
|
self.state <-> state;
|
2013-02-15 01:30:30 -06:00
|
|
|
match state {
|
2013-02-11 21:26:38 -06:00
|
|
|
Forced(_) | Evaluating => fail!(~"Logic error."),
|
2013-02-15 01:30:30 -06:00
|
|
|
Pending(f) => {
|
|
|
|
self.state = Forced(f());
|
2012-12-11 17:19:43 -06:00
|
|
|
self.get_ref()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2012-02-14 18:39:20 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-02 13:37:37 -05:00
|
|
|
pub fn from_value<A>(val: A) -> Future<A> {
|
2012-07-04 16:53:12 -05:00
|
|
|
/*!
|
|
|
|
* Create a future from a value
|
|
|
|
*
|
|
|
|
* The value is immediately available and calling `get` later will
|
|
|
|
* not block.
|
|
|
|
*/
|
2012-02-14 18:39:20 -06:00
|
|
|
|
2013-02-15 01:30:30 -06:00
|
|
|
Future {state: Forced(val)}
|
2012-02-14 18:39:20 -06:00
|
|
|
}
|
|
|
|
|
2013-04-26 20:52:15 -05:00
|
|
|
pub fn from_port<A:Owned>(port: PortOne<A>) -> Future<A> {
|
2012-08-24 18:26:41 -05:00
|
|
|
/*!
|
|
|
|
* Create a future from a port
|
|
|
|
*
|
|
|
|
* The first time that the value is requested the task will block
|
|
|
|
* waiting for the result to be received on the port.
|
|
|
|
*/
|
2012-07-02 21:03:11 -05:00
|
|
|
|
2013-02-26 13:32:00 -06:00
|
|
|
let port = Cell(port);
|
2013-02-15 01:30:30 -06:00
|
|
|
do from_fn || {
|
2013-04-26 20:52:15 -05:00
|
|
|
let port = port.take().unwrap();
|
2013-02-15 01:30:30 -06:00
|
|
|
match recv(port) {
|
|
|
|
oneshot::send(data) => data
|
2012-07-02 21:03:11 -05:00
|
|
|
}
|
2012-02-18 17:23:56 -06:00
|
|
|
}
|
2012-02-14 18:39:20 -06:00
|
|
|
}
|
|
|
|
|
2012-10-04 21:58:31 -05:00
|
|
|
pub fn from_fn<A>(f: ~fn() -> A) -> Future<A> {
|
2012-07-04 16:53:12 -05:00
|
|
|
/*!
|
|
|
|
* Create a future from a function.
|
|
|
|
*
|
|
|
|
* The first time that the value is requested it will be retreived by
|
|
|
|
* calling the function. Note that this function is a local
|
|
|
|
* function. It is not spawned into another task.
|
|
|
|
*/
|
2012-02-14 18:39:20 -06:00
|
|
|
|
2013-02-15 01:30:30 -06:00
|
|
|
Future {state: Pending(f)}
|
2012-02-14 18:39:20 -06:00
|
|
|
}
|
|
|
|
|
2013-03-01 16:15:15 -06:00
|
|
|
pub fn spawn<A:Owned>(blk: ~fn() -> A) -> Future<A> {
|
2012-07-04 16:53:12 -05:00
|
|
|
/*!
|
|
|
|
* Create a future from a unique closure.
|
|
|
|
*
|
|
|
|
* The closure will be run in a new task and its result used as the
|
|
|
|
* value of the future.
|
|
|
|
*/
|
2012-02-14 18:39:20 -06:00
|
|
|
|
2013-04-26 20:52:15 -05:00
|
|
|
let (port, chan) = oneshot();
|
2012-10-22 18:22:47 -05:00
|
|
|
|
2013-02-26 13:32:00 -06:00
|
|
|
let chan = Cell(chan);
|
2013-04-26 20:52:15 -05:00
|
|
|
do task::spawn {
|
2013-02-26 13:32:00 -06:00
|
|
|
let chan = chan.take();
|
2013-02-15 01:30:30 -06:00
|
|
|
send_one(chan, blk());
|
2012-10-22 18:22:47 -05:00
|
|
|
}
|
|
|
|
|
2013-02-15 01:30:30 -06:00
|
|
|
return from_port(port);
|
2012-02-14 18:39:20 -06:00
|
|
|
}
|
|
|
|
|
2012-09-02 18:34:20 -05:00
|
|
|
#[allow(non_implicitly_copyable_typarams)]
|
2013-02-26 23:10:03 -06:00
|
|
|
#[cfg(test)]
|
2013-04-15 10:08:52 -05:00
|
|
|
mod test {
|
2013-01-08 21:37:25 -06:00
|
|
|
|
|
|
|
use future::*;
|
|
|
|
|
2013-02-25 13:11:21 -06:00
|
|
|
use core::comm::{oneshot, send_one};
|
2012-12-28 14:46:08 -06:00
|
|
|
use core::task;
|
|
|
|
|
2012-09-02 18:34:20 -05:00
|
|
|
#[test]
|
2013-04-15 10:08:52 -05:00
|
|
|
fn test_from_value() {
|
2012-09-02 18:34:20 -05:00
|
|
|
let f = from_value(~"snail");
|
2013-03-28 20:39:09 -05:00
|
|
|
assert!(f.get() == ~"snail");
|
2012-09-02 18:34:20 -05:00
|
|
|
}
|
2012-02-14 18:39:20 -06:00
|
|
|
|
2012-09-02 18:34:20 -05:00
|
|
|
#[test]
|
2013-04-15 10:08:52 -05:00
|
|
|
fn test_from_port() {
|
2013-04-28 00:05:39 -05:00
|
|
|
let (po, ch) = oneshot();
|
2013-02-15 01:30:30 -06:00
|
|
|
send_one(ch, ~"whale");
|
|
|
|
let f = from_port(po);
|
2013-03-28 20:39:09 -05:00
|
|
|
assert!(f.get() == ~"whale");
|
2012-09-02 18:34:20 -05:00
|
|
|
}
|
2012-02-14 18:39:20 -06:00
|
|
|
|
2012-09-02 18:34:20 -05:00
|
|
|
#[test]
|
2013-04-15 10:08:52 -05:00
|
|
|
fn test_from_fn() {
|
2012-09-02 18:34:20 -05:00
|
|
|
let f = from_fn(|| ~"brail");
|
2013-03-28 20:39:09 -05:00
|
|
|
assert!(f.get() == ~"brail");
|
2012-09-02 18:34:20 -05:00
|
|
|
}
|
2012-02-18 17:23:56 -06:00
|
|
|
|
2012-09-02 18:34:20 -05:00
|
|
|
#[test]
|
2013-04-15 10:08:52 -05:00
|
|
|
fn test_interface_get() {
|
2012-09-02 18:34:20 -05:00
|
|
|
let f = from_value(~"fail");
|
2013-03-28 20:39:09 -05:00
|
|
|
assert!(f.get() == ~"fail");
|
2012-09-02 18:34:20 -05:00
|
|
|
}
|
2012-02-14 18:39:20 -06:00
|
|
|
|
2012-09-02 18:34:20 -05:00
|
|
|
#[test]
|
2013-04-15 10:08:52 -05:00
|
|
|
fn test_get_ref_method() {
|
2012-09-02 18:34:20 -05:00
|
|
|
let f = from_value(22);
|
2013-03-28 20:39:09 -05:00
|
|
|
assert!(*f.get_ref() == 22);
|
2012-09-02 18:34:20 -05:00
|
|
|
}
|
2012-08-27 18:08:17 -05:00
|
|
|
|
2012-09-02 18:34:20 -05:00
|
|
|
#[test]
|
2013-04-15 10:08:52 -05:00
|
|
|
fn test_spawn() {
|
2012-09-02 18:34:20 -05:00
|
|
|
let f = spawn(|| ~"bale");
|
2013-03-28 20:39:09 -05:00
|
|
|
assert!(f.get() == ~"bale");
|
2012-09-02 18:34:20 -05:00
|
|
|
}
|
2012-02-14 18:39:20 -06:00
|
|
|
|
2012-09-02 18:34:20 -05:00
|
|
|
#[test]
|
|
|
|
#[should_fail]
|
|
|
|
#[ignore(cfg(target_os = "win32"))]
|
2013-04-15 10:08:52 -05:00
|
|
|
fn test_futurefail() {
|
2013-02-11 21:26:38 -06:00
|
|
|
let f = spawn(|| fail!());
|
2012-12-11 17:19:43 -06:00
|
|
|
let _x: ~str = f.get();
|
2012-09-02 18:34:20 -05:00
|
|
|
}
|
2012-08-28 08:43:58 -05:00
|
|
|
|
|
|
|
#[test]
|
2013-04-15 10:08:52 -05:00
|
|
|
fn test_sendable_future() {
|
2012-08-28 08:43:58 -05:00
|
|
|
let expected = ~"schlorf";
|
2013-02-16 16:54:34 -06:00
|
|
|
let f = do spawn { copy expected };
|
2013-02-15 02:18:22 -06:00
|
|
|
do task::spawn || {
|
2012-12-11 17:19:43 -06:00
|
|
|
let actual = f.get();
|
2013-03-28 20:39:09 -05:00
|
|
|
assert!(actual == expected);
|
2012-08-28 08:43:58 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|