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/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 +++++++++++++++++++++++++++++++ 4 files changed, 206 insertions(+) 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 (limited to 'futures/src/backend/native') 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() + } + } +} -- cgit