summaryrefslogtreecommitdiffstats
path: root/futures/src/backend
diff options
context:
space:
mode:
Diffstat (limited to 'futures/src/backend')
-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.rs16
-rw-r--r--futures/src/backend/native/tokio.rs72
-rw-r--r--futures/src/backend/null.rs18
-rw-r--r--futures/src/backend/wasm.rs2
-rw-r--r--futures/src/backend/wasm/wasm_bindgen.rs15
9 files changed, 295 insertions, 0 deletions
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/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<Self, futures::io::Error> {
+ futures::executor::ThreadPool::new()
+ }
+
+ fn spawn(&self, future: impl Future<Output = ()> + 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<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/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<Self, futures::io::Error> {
+ Ok(Self)
+ }
+
+ #[cfg(not(target_arch = "wasm32"))]
+ fn spawn(&self, _future: impl Future<Output = ()> + Send + 'static) {}
+
+ #[cfg(target_arch = "wasm32")]
+ fn spawn(&self, _future: impl Future<Output = ()> + '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<Self, futures::io::Error> {
+ Ok(Self)
+ }
+
+ fn spawn(&self, future: impl futures::Future<Output = ()> + 'static) {
+ wasm_bindgen_futures::spawn_local(future);
+ }
+}
generated by cgit (git 2.34.1) at 2025-04-17 08:48:53 +0000