1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84
use tokio_threadpool::Sender; use futures::future::{self, Future}; /// Executes futures on the runtime /// /// All futures spawned using this executor will be submitted to the associated /// Runtime's executor. This executor is usually a thread pool. /// /// For more details, see the [module level](index.html) documentation. #[derive(Debug, Clone)] pub struct TaskExecutor { pub(super) inner: Sender, } impl TaskExecutor { /// Spawn a future onto the Tokio runtime. /// /// This spawns the given future onto the runtime's executor, usually a /// thread pool. The thread pool is then responsible for polling the future /// until it completes. /// /// See [module level][mod] documentation for more details. /// /// [mod]: index.html /// /// # Examples /// /// ```rust /// # extern crate tokio; /// # extern crate futures; /// # use futures::{future, Future, Stream}; /// use tokio::runtime::Runtime; /// /// # fn dox() { /// // Create the runtime /// let mut rt = Runtime::new().unwrap(); /// let executor = rt.executor(); /// /// // Spawn a future onto the runtime /// executor.spawn(future::lazy(|| { /// println!("now running on a worker thread"); /// Ok(()) /// })); /// # } /// # pub fn main() {} /// ``` /// /// # Panics /// /// This function panics if the spawn fails. Failure occurs if the executor /// is currently at capacity and is unable to spawn a new future. pub fn spawn<F>(&self, future: F) where F: Future<Item = (), Error = ()> + Send + 'static, { self.inner.spawn(future).unwrap(); } } impl<T> future::Executor<T> for TaskExecutor where T: Future<Item = (), Error = ()> + Send + 'static, { fn execute(&self, future: T) -> Result<(), future::ExecuteError<T>> { self.inner.execute(future) } } impl ::executor::Executor for TaskExecutor { fn spawn(&mut self, future: Box<Future<Item = (), Error = ()> + Send>) -> Result<(), ::executor::SpawnError> { self.inner.spawn(future) } } impl<T> ::executor::TypedExecutor<T> for TaskExecutor where T: Future<Item = (), Error = ()> + Send + 'static, { fn spawn(&mut self, future: T) -> Result<(), ::executor::SpawnError> { ::executor::Executor::spawn(self, Box::new(future)) } }