summaryrefslogtreecommitdiffstats
path: root/futures/src/backend
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--futures/src/backend.rs10
-rw-r--r--futures/src/backend/default.rs38
-rw-r--r--futures/src/backend/native.rs16
-rw-r--r--futures/src/backend/native/async_std.rs59
-rw-r--r--futures/src/backend/native/smol.rs59
-rw-r--r--futures/src/backend/native/thread_pool.rs (renamed from futures/src/executor/thread_pool.rs)7
-rw-r--r--futures/src/backend/native/tokio.rs72
-rw-r--r--futures/src/backend/null.rs (renamed from futures/src/executor/null.rs)7
-rw-r--r--futures/src/backend/wasm.rs2
-rw-r--r--futures/src/backend/wasm/wasm_bindgen.rs (renamed from futures/src/executor/wasm_bindgen.rs)8
10 files changed, 266 insertions, 12 deletions
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<Self, futures::io::Error> {
+ Ok(Self)
+ }
+
+ fn spawn(&self, future: impl Future<Output = ()> + 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<H: std::hash::Hasher, E>(
+ duration: std::time::Duration,
+ ) -> Subscription<H, E, std::time::Instant> {
+ Subscription::from_recipe(Every(duration))
+ }
+
+ #[derive(Debug)]
+ struct Every(std::time::Duration);
+
+ impl<H, E> subscription::Recipe<H, E> 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::<Self>().hash(state);
+ self.0.hash(state);
+ }
+
+ fn stream(
+ self: Box<Self>,
+ _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<Self, futures::io::Error> {
+ Ok(Self)
+ }
+
+ fn spawn(&self, future: impl Future<Output = ()> + 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<H: std::hash::Hasher, E>(
+ duration: std::time::Duration,
+ ) -> Subscription<H, E, std::time::Instant> {
+ Subscription::from_recipe(Every(duration))
+ }
+
+ #[derive(Debug)]
+ struct Every(std::time::Duration);
+
+ impl<H, E> subscription::Recipe<H, E> 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::<Self>().hash(state);
+ self.0.hash(state);
+ }
+
+ fn stream(
+ self: Box<Self>,
+ _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/executor/thread_pool.rs b/futures/src/backend/native/thread_pool.rs
index a6c6168e..6e791533 100644
--- a/futures/src/executor/thread_pool.rs
+++ b/futures/src/backend/native/thread_pool.rs
@@ -1,12 +1,11 @@
-use crate::Executor;
-
+//! A `ThreadPool` backend.
use futures::Future;
-/// A thread pool runtime for futures.
+/// A thread pool executor for futures.
#[cfg_attr(docsrs, doc(cfg(feature = "thread-pool")))]
pub type ThreadPool = futures::executor::ThreadPool;
-impl Executor for futures::executor::ThreadPool {
+impl crate::Executor for futures::executor::ThreadPool {
fn new() -> Result<Self, futures::io::Error> {
futures::executor::ThreadPool::new()
}
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<Self, futures::io::Error> {
+ tokio::runtime::Runtime::new()
+ }
+
+ fn spawn(&self, future: impl Future<Output = ()> + Send + 'static) {
+ let _ = tokio::runtime::Runtime::spawn(self, future);
+ }
+
+ fn enter<R>(&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<H: std::hash::Hasher, E>(
+ duration: std::time::Duration,
+ ) -> Subscription<H, E, std::time::Instant> {
+ Subscription::from_recipe(Every(duration))
+ }
+
+ #[derive(Debug)]
+ struct Every(std::time::Duration);
+
+ impl<H, E> subscription::Recipe<H, E> 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::<Self>().hash(state);
+ self.0.hash(state);
+ }
+
+ fn stream(
+ self: Box<Self>,
+ _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/executor/null.rs b/futures/src/backend/null.rs
index 65e2e2df..e22e7921 100644
--- a/futures/src/executor/null.rs
+++ b/futures/src/backend/null.rs
@@ -1,12 +1,11 @@
-use crate::Executor;
-
+//! A backend that does nothing!
use futures::Future;
/// An executor that drops all the futures, instead of spawning them.
#[derive(Debug)]
-pub struct Null;
+pub struct Executor;
-impl Executor for Null {
+impl crate::Executor for Executor {
fn new() -> Result<Self, futures::io::Error> {
Ok(Self)
}
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/executor/wasm_bindgen.rs b/futures/src/backend/wasm/wasm_bindgen.rs
index 94d694c8..e914aeba 100644
--- a/futures/src/executor/wasm_bindgen.rs
+++ b/futures/src/backend/wasm/wasm_bindgen.rs
@@ -1,10 +1,10 @@
-use crate::Executor;
+//! A `wasm-bindgein-futures` backend.
-/// A `wasm-bindgen-futures` runtime.
+/// A `wasm-bindgen-futures` executor.
#[derive(Debug)]
-pub struct WasmBindgen;
+pub struct Executor;
-impl Executor for WasmBindgen {
+impl crate::Executor for Executor {
fn new() -> Result<Self, futures::io::Error> {
Ok(Self)
}
generated by cgit (git 2.34.1) at 2025-05-09 10:31:26 +0000