From 167be45a7db7c1f60a79116766bdf38300429c6a Mon Sep 17 00:00:00 2001 From: Héctor Ramón Jiménez Date: Fri, 28 Jan 2022 18:24:07 +0700 Subject: Split `iced_futures` into different `backend` implementations --- futures/src/backend.rs | 10 +++ futures/src/backend/default.rs | 38 +++++++++++ futures/src/backend/native.rs | 16 +++++ futures/src/backend/native/async_std.rs | 59 +++++++++++++++++ futures/src/backend/native/smol.rs | 59 +++++++++++++++++ futures/src/backend/native/thread_pool.rs | 16 +++++ futures/src/backend/native/tokio.rs | 72 ++++++++++++++++++++ futures/src/backend/null.rs | 18 +++++ futures/src/backend/wasm.rs | 2 + futures/src/backend/wasm/wasm_bindgen.rs | 15 +++++ futures/src/executor.rs | 34 ---------- futures/src/executor/async_std.rs | 18 ----- futures/src/executor/null.rs | 19 ------ futures/src/executor/smol.rs | 18 ----- futures/src/executor/thread_pool.rs | 17 ----- futures/src/executor/tokio.rs | 22 ------- futures/src/executor/wasm_bindgen.rs | 15 ----- futures/src/lib.rs | 15 +---- futures/src/time.rs | 105 ------------------------------ 19 files changed, 306 insertions(+), 262 deletions(-) create mode 100644 futures/src/backend.rs create mode 100644 futures/src/backend/default.rs create mode 100644 futures/src/backend/native.rs create mode 100644 futures/src/backend/native/async_std.rs create mode 100644 futures/src/backend/native/smol.rs create mode 100644 futures/src/backend/native/thread_pool.rs create mode 100644 futures/src/backend/native/tokio.rs create mode 100644 futures/src/backend/null.rs create mode 100644 futures/src/backend/wasm.rs create mode 100644 futures/src/backend/wasm/wasm_bindgen.rs delete mode 100644 futures/src/executor/async_std.rs delete mode 100644 futures/src/executor/null.rs delete mode 100644 futures/src/executor/smol.rs delete mode 100644 futures/src/executor/thread_pool.rs delete mode 100644 futures/src/executor/tokio.rs delete mode 100644 futures/src/executor/wasm_bindgen.rs delete mode 100644 futures/src/time.rs (limited to 'futures') diff --git a/futures/src/backend.rs b/futures/src/backend.rs new file mode 100644 index 00000000..1cc4af80 --- /dev/null +++ b/futures/src/backend.rs @@ -0,0 +1,10 @@ +//! The underlying implementations of the `iced_futures` contract! +pub mod null; + +#[cfg(not(target_arch = "wasm32"))] +pub mod native; + +#[cfg(target_arch = "wasm32")] +pub mod wasm; + +pub mod default; diff --git a/futures/src/backend/default.rs b/futures/src/backend/default.rs new file mode 100644 index 00000000..76264f55 --- /dev/null +++ b/futures/src/backend/default.rs @@ -0,0 +1,38 @@ +//! A default, cross-platform backend. +//! +//! - On native platforms, it will use: +//! - `backend::native::tokio` when the `tokio` feature is enabled. +//! - `backend::native::async-std` when the `async-std` feature is +//! enabled. +//! - `backend::native::smol` when the `smol` feature is enabled. +//! - `backend::native::thread_pool` otherwise. +//! +//! - On Wasm, it will use `backend::wasm::wasm_bindgen`. +#[cfg(not(target_arch = "wasm32"))] +mod platform { + #[cfg(feature = "tokio")] + pub use crate::backend::native::tokio::*; + + #[cfg(all(feature = "async-std", not(feature = "tokio"),))] + pub use crate::backend::native::async_std::*; + + #[cfg(all( + feature = "smol", + not(any(feature = "tokio", feature = "async-std")), + ))] + pub use crate::backend::native::smol::*; + + #[cfg(not(any( + feature = "tokio", + feature = "async-std", + feature = "smol", + )))] + pub use crate::backend::native::thread_pool::*; +} + +#[cfg(target_arch = "wasm32")] +mod platform { + pub use crate::backend::wasm::wasm_bindgen::*; +} + +pub use platform::*; diff --git a/futures/src/backend/native.rs b/futures/src/backend/native.rs new file mode 100644 index 00000000..4199ad16 --- /dev/null +++ b/futures/src/backend/native.rs @@ -0,0 +1,16 @@ +//! Backends that are only available in native platforms: Windows, macOS, or Linux. +#[cfg_attr(docsrs, doc(cfg(feature = "tokio",)))] +#[cfg(feature = "tokio")] +pub mod tokio; + +#[cfg_attr(docsrs, doc(cfg(feature = "async-std",)))] +#[cfg(feature = "async-std")] +pub mod async_std; + +#[cfg_attr(docsrs, doc(cfg(feature = "smol",)))] +#[cfg(feature = "smol")] +pub mod smol; + +#[cfg_attr(docsrs, doc(cfg(feature = "thread-pool",)))] +#[cfg(feature = "thread-pool")] +pub mod thread_pool; diff --git a/futures/src/backend/native/async_std.rs b/futures/src/backend/native/async_std.rs new file mode 100644 index 00000000..e8641626 --- /dev/null +++ b/futures/src/backend/native/async_std.rs @@ -0,0 +1,59 @@ +//! An `async-std` backend. +use futures::Future; + +/// An `async-std` executor. +#[derive(Debug)] +pub struct Executor; + +impl crate::Executor for Executor { + fn new() -> Result { + Ok(Self) + } + + fn spawn(&self, future: impl Future + Send + 'static) { + let _ = async_std::task::spawn(future); + } +} + +pub mod time { + //! Listen and react to time. + use crate::subscription::{self, Subscription}; + + /// Returns a [`Subscription`] that produces messages at a set interval. + /// + /// The first message is produced after a `duration`, and then continues to + /// produce more messages every `duration` after that. + pub fn every( + duration: std::time::Duration, + ) -> Subscription { + Subscription::from_recipe(Every(duration)) + } + + #[derive(Debug)] + struct Every(std::time::Duration); + + impl subscription::Recipe for Every + where + H: std::hash::Hasher, + { + type Output = std::time::Instant; + + fn hash(&self, state: &mut H) { + use std::hash::Hash; + + std::any::TypeId::of::().hash(state); + self.0.hash(state); + } + + fn stream( + self: Box, + _input: futures::stream::BoxStream<'static, E>, + ) -> futures::stream::BoxStream<'static, Self::Output> { + use futures::stream::StreamExt; + + async_std::stream::interval(self.0) + .map(|_| std::time::Instant::now()) + .boxed() + } + } +} diff --git a/futures/src/backend/native/smol.rs b/futures/src/backend/native/smol.rs new file mode 100644 index 00000000..d5201cde --- /dev/null +++ b/futures/src/backend/native/smol.rs @@ -0,0 +1,59 @@ +//! A `smol` backend. + +use futures::Future; + +/// A `smol` executor. +#[cfg_attr(docsrs, doc(cfg(feature = "smol")))] +#[derive(Debug)] +pub struct Executor; + +impl crate::Executor for Executor { + fn new() -> Result { + Ok(Self) + } + + fn spawn(&self, future: impl Future + Send + 'static) { + smol::spawn(future).detach(); + } +} + +pub mod time { + //! Listen and react to time. + use crate::subscription::{self, Subscription}; + + /// Returns a [`Subscription`] that produces messages at a set interval. + /// + /// The first message is produced after a `duration`, and then continues to + /// produce more messages every `duration` after that. + pub fn every( + duration: std::time::Duration, + ) -> Subscription { + Subscription::from_recipe(Every(duration)) + } + + #[derive(Debug)] + struct Every(std::time::Duration); + + impl subscription::Recipe for Every + where + H: std::hash::Hasher, + { + type Output = std::time::Instant; + + fn hash(&self, state: &mut H) { + use std::hash::Hash; + + std::any::TypeId::of::().hash(state); + self.0.hash(state); + } + + fn stream( + self: Box, + _input: futures::stream::BoxStream<'static, E>, + ) -> futures::stream::BoxStream<'static, Self::Output> { + use futures::stream::StreamExt; + + smol::Timer::interval(self.0).boxed() + } + } +} diff --git a/futures/src/backend/native/thread_pool.rs b/futures/src/backend/native/thread_pool.rs new file mode 100644 index 00000000..6e791533 --- /dev/null +++ b/futures/src/backend/native/thread_pool.rs @@ -0,0 +1,16 @@ +//! A `ThreadPool` backend. +use futures::Future; + +/// A thread pool executor for futures. +#[cfg_attr(docsrs, doc(cfg(feature = "thread-pool")))] +pub type ThreadPool = futures::executor::ThreadPool; + +impl crate::Executor for futures::executor::ThreadPool { + fn new() -> Result { + futures::executor::ThreadPool::new() + } + + fn spawn(&self, future: impl Future + Send + 'static) { + self.spawn_ok(future); + } +} diff --git a/futures/src/backend/native/tokio.rs b/futures/src/backend/native/tokio.rs new file mode 100644 index 00000000..f86b0ea3 --- /dev/null +++ b/futures/src/backend/native/tokio.rs @@ -0,0 +1,72 @@ +//! A `tokio` backend. +use futures::Future; + +/// A `tokio` executor. +pub type Executor = tokio::runtime::Runtime; + +impl crate::Executor for Executor { + fn new() -> Result { + tokio::runtime::Runtime::new() + } + + fn spawn(&self, future: impl Future + Send + 'static) { + let _ = tokio::runtime::Runtime::spawn(self, future); + } + + fn enter(&self, f: impl FnOnce() -> R) -> R { + let _guard = tokio::runtime::Runtime::enter(self); + f() + } +} + +pub mod time { + //! Listen and react to time. + use crate::subscription::{self, Subscription}; + + /// Returns a [`Subscription`] that produces messages at a set interval. + /// + /// The first message is produced after a `duration`, and then continues to + /// produce more messages every `duration` after that. + pub fn every( + duration: std::time::Duration, + ) -> Subscription { + Subscription::from_recipe(Every(duration)) + } + + #[derive(Debug)] + struct Every(std::time::Duration); + + impl subscription::Recipe for Every + where + H: std::hash::Hasher, + { + type Output = std::time::Instant; + + fn hash(&self, state: &mut H) { + use std::hash::Hash; + + std::any::TypeId::of::().hash(state); + self.0.hash(state); + } + + fn stream( + self: Box, + _input: futures::stream::BoxStream<'static, E>, + ) -> futures::stream::BoxStream<'static, Self::Output> { + use futures::stream::StreamExt; + + let start = tokio::time::Instant::now() + self.0; + + let stream = { + futures::stream::unfold( + tokio::time::interval_at(start, self.0), + |mut interval| async move { + Some((interval.tick().await, interval)) + }, + ) + }; + + stream.map(tokio::time::Instant::into_std).boxed() + } + } +} diff --git a/futures/src/backend/null.rs b/futures/src/backend/null.rs new file mode 100644 index 00000000..e22e7921 --- /dev/null +++ b/futures/src/backend/null.rs @@ -0,0 +1,18 @@ +//! A backend that does nothing! +use futures::Future; + +/// An executor that drops all the futures, instead of spawning them. +#[derive(Debug)] +pub struct Executor; + +impl crate::Executor for Executor { + fn new() -> Result { + Ok(Self) + } + + #[cfg(not(target_arch = "wasm32"))] + fn spawn(&self, _future: impl Future + Send + 'static) {} + + #[cfg(target_arch = "wasm32")] + fn spawn(&self, _future: impl Future + 'static) {} +} diff --git a/futures/src/backend/wasm.rs b/futures/src/backend/wasm.rs new file mode 100644 index 00000000..a49d9e55 --- /dev/null +++ b/futures/src/backend/wasm.rs @@ -0,0 +1,2 @@ +//! Backends that are only available on Wasm targets. +pub mod wasm_bindgen; diff --git a/futures/src/backend/wasm/wasm_bindgen.rs b/futures/src/backend/wasm/wasm_bindgen.rs new file mode 100644 index 00000000..e914aeba --- /dev/null +++ b/futures/src/backend/wasm/wasm_bindgen.rs @@ -0,0 +1,15 @@ +//! A `wasm-bindgein-futures` backend. + +/// A `wasm-bindgen-futures` executor. +#[derive(Debug)] +pub struct Executor; + +impl crate::Executor for Executor { + fn new() -> Result { + Ok(Self) + } + + fn spawn(&self, future: impl futures::Future + 'static) { + wasm_bindgen_futures::spawn_local(future); + } +} diff --git a/futures/src/executor.rs b/futures/src/executor.rs index 34e329a0..5ac76081 100644 --- a/futures/src/executor.rs +++ b/futures/src/executor.rs @@ -1,38 +1,4 @@ //! Choose your preferred executor to power a runtime. -mod null; - -#[cfg(all(not(target_arch = "wasm32"), feature = "thread-pool"))] -mod thread_pool; - -#[cfg(all(not(target_arch = "wasm32"), feature = "tokio"))] -mod tokio; - -#[cfg(all(not(target_arch = "wasm32"), feature = "async-std"))] -mod async_std; - -#[cfg(all(not(target_arch = "wasm32"), feature = "smol"))] -mod smol; - -#[cfg(target_arch = "wasm32")] -mod wasm_bindgen; - -pub use null::Null; - -#[cfg(all(not(target_arch = "wasm32"), feature = "thread-pool"))] -pub use thread_pool::ThreadPool; - -#[cfg(all(not(target_arch = "wasm32"), feature = "tokio"))] -pub use self::tokio::Tokio; - -#[cfg(all(not(target_arch = "wasm32"), feature = "async-std"))] -pub use self::async_std::AsyncStd; - -#[cfg(all(not(target_arch = "wasm32"), feature = "smol"))] -pub use self::smol::Smol; - -#[cfg(target_arch = "wasm32")] -pub use wasm_bindgen::WasmBindgen; - use crate::MaybeSend; use futures::Future; diff --git a/futures/src/executor/async_std.rs b/futures/src/executor/async_std.rs deleted file mode 100644 index 471be369..00000000 --- a/futures/src/executor/async_std.rs +++ /dev/null @@ -1,18 +0,0 @@ -use crate::Executor; - -use futures::Future; - -/// An `async-std` runtime. -#[cfg_attr(docsrs, doc(cfg(feature = "async-std")))] -#[derive(Debug)] -pub struct AsyncStd; - -impl Executor for AsyncStd { - fn new() -> Result { - Ok(Self) - } - - fn spawn(&self, future: impl Future + Send + 'static) { - let _ = async_std::task::spawn(future); - } -} diff --git a/futures/src/executor/null.rs b/futures/src/executor/null.rs deleted file mode 100644 index 65e2e2df..00000000 --- a/futures/src/executor/null.rs +++ /dev/null @@ -1,19 +0,0 @@ -use crate::Executor; - -use futures::Future; - -/// An executor that drops all the futures, instead of spawning them. -#[derive(Debug)] -pub struct Null; - -impl Executor for Null { - fn new() -> Result { - Ok(Self) - } - - #[cfg(not(target_arch = "wasm32"))] - fn spawn(&self, _future: impl Future + Send + 'static) {} - - #[cfg(target_arch = "wasm32")] - fn spawn(&self, _future: impl Future + 'static) {} -} diff --git a/futures/src/executor/smol.rs b/futures/src/executor/smol.rs deleted file mode 100644 index deafd43a..00000000 --- a/futures/src/executor/smol.rs +++ /dev/null @@ -1,18 +0,0 @@ -use crate::Executor; - -use futures::Future; - -/// A `smol` runtime. -#[cfg_attr(docsrs, doc(cfg(feature = "smol")))] -#[derive(Debug)] -pub struct Smol; - -impl Executor for Smol { - fn new() -> Result { - Ok(Self) - } - - fn spawn(&self, future: impl Future + Send + 'static) { - smol::spawn(future).detach(); - } -} diff --git a/futures/src/executor/thread_pool.rs b/futures/src/executor/thread_pool.rs deleted file mode 100644 index a6c6168e..00000000 --- a/futures/src/executor/thread_pool.rs +++ /dev/null @@ -1,17 +0,0 @@ -use crate::Executor; - -use futures::Future; - -/// A thread pool runtime for futures. -#[cfg_attr(docsrs, doc(cfg(feature = "thread-pool")))] -pub type ThreadPool = futures::executor::ThreadPool; - -impl Executor for futures::executor::ThreadPool { - fn new() -> Result { - futures::executor::ThreadPool::new() - } - - fn spawn(&self, future: impl Future + Send + 'static) { - self.spawn_ok(future); - } -} diff --git a/futures/src/executor/tokio.rs b/futures/src/executor/tokio.rs deleted file mode 100644 index c6a21cec..00000000 --- a/futures/src/executor/tokio.rs +++ /dev/null @@ -1,22 +0,0 @@ -use crate::Executor; - -use futures::Future; - -/// A `tokio` runtime. -#[cfg_attr(docsrs, doc(cfg(feature = "tokio")))] -pub type Tokio = tokio::runtime::Runtime; - -impl Executor for Tokio { - fn new() -> Result { - tokio::runtime::Runtime::new() - } - - fn spawn(&self, future: impl Future + Send + 'static) { - let _ = tokio::runtime::Runtime::spawn(self, future); - } - - fn enter(&self, f: impl FnOnce() -> R) -> R { - let _guard = tokio::runtime::Runtime::enter(self); - f() - } -} diff --git a/futures/src/executor/wasm_bindgen.rs b/futures/src/executor/wasm_bindgen.rs deleted file mode 100644 index 94d694c8..00000000 --- a/futures/src/executor/wasm_bindgen.rs +++ /dev/null @@ -1,15 +0,0 @@ -use crate::Executor; - -/// A `wasm-bindgen-futures` runtime. -#[derive(Debug)] -pub struct WasmBindgen; - -impl Executor for WasmBindgen { - fn new() -> Result { - Ok(Self) - } - - fn spawn(&self, future: impl futures::Future + 'static) { - wasm_bindgen_futures::spawn_local(future); - } -} diff --git a/futures/src/lib.rs b/futures/src/lib.rs index 10ade9ed..b0b2f6ce 100644 --- a/futures/src/lib.rs +++ b/futures/src/lib.rs @@ -17,23 +17,10 @@ mod command; mod maybe_send; mod runtime; +pub mod backend; pub mod executor; pub mod subscription; -#[cfg(all( - any(feature = "tokio", feature = "async-std", feature = "smol"), - not(target_arch = "wasm32") -))] -#[cfg_attr( - docsrs, - doc(cfg(any( - feature = "tokio", - feature = "async-std", - feature = "smol" - ))) -)] -pub mod time; - pub use command::Command; pub use executor::Executor; pub use maybe_send::MaybeSend; diff --git a/futures/src/time.rs b/futures/src/time.rs deleted file mode 100644 index 0ece6f04..00000000 --- a/futures/src/time.rs +++ /dev/null @@ -1,105 +0,0 @@ -//! Listen and react to time. -use crate::subscription::{self, Subscription}; - -/// Returns a [`Subscription`] that produces messages at a set interval. -/// -/// The first message is produced after a `duration`, and then continues to -/// produce more messages every `duration` after that. -pub fn every( - duration: std::time::Duration, -) -> Subscription { - Subscription::from_recipe(Every(duration)) -} - -struct Every(std::time::Duration); - -#[cfg(all( - not(any(feature = "tokio", feature = "async-std")), - feature = "smol" -))] -impl subscription::Recipe for Every -where - H: std::hash::Hasher, -{ - type Output = std::time::Instant; - - fn hash(&self, state: &mut H) { - use std::hash::Hash; - - std::any::TypeId::of::().hash(state); - self.0.hash(state); - } - - fn stream( - self: Box, - _input: futures::stream::BoxStream<'static, E>, - ) -> futures::stream::BoxStream<'static, Self::Output> { - use futures::stream::StreamExt; - - smol::Timer::interval(self.0).boxed() - } -} - -#[cfg(feature = "async-std")] -impl subscription::Recipe for Every -where - H: std::hash::Hasher, -{ - type Output = std::time::Instant; - - fn hash(&self, state: &mut H) { - use std::hash::Hash; - - std::any::TypeId::of::().hash(state); - self.0.hash(state); - } - - fn stream( - self: Box, - _input: futures::stream::BoxStream<'static, E>, - ) -> futures::stream::BoxStream<'static, Self::Output> { - use futures::stream::StreamExt; - - async_std::stream::interval(self.0) - .map(|_| std::time::Instant::now()) - .boxed() - } -} - -#[cfg(all( - feature = "tokio", - not(any(feature = "async-std", feature = "smol")) -))] -impl subscription::Recipe for Every -where - H: std::hash::Hasher, -{ - type Output = std::time::Instant; - - fn hash(&self, state: &mut H) { - use std::hash::Hash; - - std::any::TypeId::of::().hash(state); - self.0.hash(state); - } - - fn stream( - self: Box, - _input: futures::stream::BoxStream<'static, E>, - ) -> futures::stream::BoxStream<'static, Self::Output> { - use futures::stream::StreamExt; - - let start = tokio::time::Instant::now() + self.0; - - let stream = { - futures::stream::unfold( - tokio::time::interval_at(start, self.0), - |mut interval| async move { - Some((interval.tick().await, interval)) - }, - ) - }; - - stream.map(tokio::time::Instant::into_std).boxed() - } -} -- cgit