From 6813690e893bc461bd2be60509850a5a80454c6a Mon Sep 17 00:00:00 2001 From: HampusM Date: Sun, 18 Sep 2022 20:20:53 +0200 Subject: feat: add binding async factories to async DI container --- README.md | 1 + examples/async-factory/main.rs | 65 ++++++++++++++++++++++++++++++++++++++++++ macros/src/lib.rs | 4 +-- src/async_di_container.rs | 48 +++++++++++++++++++++++++++++++ src/future.rs | 10 +++++++ src/lib.rs | 51 +++++++++++++++++++++++++++++++++ 6 files changed, 176 insertions(+), 3 deletions(-) create mode 100644 examples/async-factory/main.rs create mode 100644 src/future.rs diff --git a/README.md b/README.md index 55ff28e..b71d6e3 100644 --- a/README.md +++ b/README.md @@ -22,6 +22,7 @@ From the [syrette Wikipedia article](https://en.wikipedia.org/wiki/Syrette). - Binding singletons - Injection of third-party structs & traits - Named bindings +- Async factories ## Optional features - `factory`. Binding factories (Rust nightly required) diff --git a/examples/async-factory/main.rs b/examples/async-factory/main.rs new file mode 100644 index 0000000..74e12c7 --- /dev/null +++ b/examples/async-factory/main.rs @@ -0,0 +1,65 @@ +#![deny(clippy::all)] +#![deny(clippy::pedantic)] +#![allow(clippy::module_name_repetitions)] + +use anyhow::Result; +use syrette::{async_closure, factory, AsyncDIContainer}; + +trait IFoo +{ + fn bar(&self); +} + +#[factory(async = true)] +type IFooFactory = dyn Fn(i32) -> dyn IFoo; + +struct Foo +{ + cnt: i32, +} + +impl Foo +{ + fn new(cnt: i32) -> Self + { + Self { cnt } + } +} + +impl IFoo for Foo +{ + fn bar(&self) + { + for _ in 1..self.cnt { + println!("Foobar"); + } + } +} + +#[tokio::main] +async fn main() -> Result<()> +{ + let mut di_container = AsyncDIContainer::new(); + + di_container + .bind::() + .to_async_factory(&|_| { + async_closure!(|cnt| { + let foo = Box::new(Foo::new(cnt)); + + foo as Box + }) + }) + .await?; + + let foo_factory = di_container + .get::() + .await? + .threadsafe_factory()?; + + let foo = foo_factory(4).await; + + foo.bar(); + + Ok(()) +} diff --git a/macros/src/lib.rs b/macros/src/lib.rs index 2715f3d..2cd57f0 100644 --- a/macros/src/lib.rs +++ b/macros/src/lib.rs @@ -225,9 +225,7 @@ pub fn factory(args_stream: TokenStream, type_alias_stream: TokenStream) -> Toke factory_interface.output = parse( if is_async { quote! { - std::pin::Pin> - >> + syrette::future::BoxFuture<'static, syrette::ptr::TransientPtr<#output>> } } else { quote! { diff --git a/src/async_di_container.rs b/src/async_di_container.rs index 7dcca57..1ead116 100644 --- a/src/async_di_container.rs +++ b/src/async_di_container.rs @@ -294,6 +294,54 @@ where Ok(AsyncBindingWhenConfigurator::new(self.di_container.clone())) } + /// Creates a binding of factory type `Interface` to a async factory inside of the + /// associated [`AsyncDIContainer`]. + /// + /// *This function is only available if Syrette is built with the "factory" and + /// "async" features.* + /// + /// # Errors + /// Will return Err if the associated [`AsyncDIContainer`] already have a binding for + /// the interface. + #[cfg(all(feature = "factory", feature = "async"))] + pub async fn to_async_factory( + &self, + factory_func: &'static FactoryFunc, + ) -> Result, AsyncBindingBuilderError> + where + Args: 'static, + Return: 'static + ?Sized, + Interface: Fn>, + FactoryFunc: Fn< + (Arc,), + Output = Box< + (dyn Fn>), + >, + > + Send + + Sync, + { + let mut bindings_lock = self.di_container.bindings.lock().await; + + if bindings_lock.has::(None) { + return Err(AsyncBindingBuilderError::BindingAlreadyExists(type_name::< + Interface, + >( + ))); + } + + let factory_impl = ThreadsafeCastableFactory::new(factory_func); + + bindings_lock.set::( + None, + Box::new(crate::provider::r#async::AsyncFactoryProvider::new( + crate::ptr::ThreadsafeFactoryPtr::new(factory_impl), + false, + )), + ); + + Ok(AsyncBindingWhenConfigurator::new(self.di_container.clone())) + } + /// Creates a binding of type `Interface` to a factory that takes no arguments /// inside of the associated [`AsyncDIContainer`]. /// diff --git a/src/future.rs b/src/future.rs new file mode 100644 index 0000000..ae4b3a2 --- /dev/null +++ b/src/future.rs @@ -0,0 +1,10 @@ +//! Future related utilities. +//! +//! *This module is only available if Syrette is built with the "async" feature.* + +#![allow(clippy::module_name_repetitions)] +use std::future::Future; +use std::pin::Pin; + +/// A boxed future. +pub type BoxFuture<'a, T> = Pin + Send + 'a>>; diff --git a/src/lib.rs b/src/lib.rs index 2155350..247f907 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -15,6 +15,9 @@ pub mod ptr; #[cfg(feature = "async")] pub mod async_di_container; +#[cfg(feature = "async")] +pub mod future; + #[cfg(feature = "async")] pub use async_di_container::AsyncDIContainer; pub use di_container::DIContainer; @@ -75,3 +78,51 @@ macro_rules! di_container_bind { syrette::declare_interface!($implementation -> $interface); }; } + +/// Creates a async closure. +/// +/// *This macro is only available if Syrette is built with the "async" feature.* +/// +/// # Examples +/// ``` +/// # use syrette::async_closure; +/// # +/// # async fn do_heavy_operation(timeout: u32, size: u32) -> String { String::new() } +/// # +/// # async fn do_other_heavy_operation(input: String) -> String { String::new() } +/// # +/// async_closure!(|timeout, size| { +/// let value = do_heavy_operation(timeout, size).await; +/// +/// let final_value = do_other_heavy_operation(value).await; +/// +/// final_value +/// }); +/// ``` +/// +/// expands to the following +/// +/// ```rust +/// # async fn do_heavy_operation(timeout: u32, size: u32) -> String { String::new() } +/// # +/// # async fn do_other_heavy_operation(input: String) -> String { String::new() } +/// # +/// Box::new(|timeout, size| { +/// Box::pin(async move { +/// let value = do_heavy_operation(timeout, size).await; +/// +/// let final_value = do_other_heavy_operation(value).await; +/// +/// final_value +/// }) +/// }); +/// ``` +#[cfg(feature = "async")] +#[macro_export] +macro_rules! async_closure { + (|$($args: ident),*| { $($inner: stmt);* }) => { + Box::new(|$($args),*| { + Box::pin(async move { $($inner)* }) + }) + }; +} -- cgit v1.2.3-18-g5258