aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/dependency_history.rs20
-rw-r--r--src/di_container/asynchronous/binding/builder.rs107
-rw-r--r--src/di_container/asynchronous/binding/scope_configurator.rs78
-rw-r--r--src/di_container/asynchronous/binding/when_configurator.rs17
-rw-r--r--src/di_container/asynchronous/mod.rs44
-rw-r--r--src/di_container/blocking/binding/builder.rs78
-rw-r--r--src/di_container/blocking/binding/scope_configurator.rs79
-rw-r--r--src/di_container/blocking/binding/when_configurator.rs17
-rw-r--r--src/di_container/blocking/mod.rs43
-rw-r--r--src/interfaces/async_injectable.rs17
-rw-r--r--src/interfaces/injectable.rs17
-rw-r--r--src/lib.rs1
-rw-r--r--src/provider/async.rs153
-rw-r--r--src/provider/blocking.rs124
-rw-r--r--src/test_utils.rs155
-rw-r--r--src/util.rs15
16 files changed, 386 insertions, 579 deletions
diff --git a/src/dependency_history.rs b/src/dependency_history.rs
index 4e36a7b..cd4e77d 100644
--- a/src/dependency_history.rs
+++ b/src/dependency_history.rs
@@ -7,18 +7,6 @@ use std::fmt::{Debug, Display};
const BOLD_MODE: &str = "\x1b[1m";
const RESET_BOLD_MODE: &str = "\x1b[22m";
-/// Dependency history interface.
-///
-/// **This trait is sealed and cannot be implemented for types outside this crate.**
-pub trait IDependencyHistory: private::Sealed
-{
- #[doc(hidden)]
- fn push<Dependency: 'static + ?Sized>(&mut self);
-
- #[doc(hidden)]
- fn contains<Dependency: 'static + ?Sized>(&self) -> bool;
-}
-
/// Dependency history.
#[derive(Clone, Debug)]
pub struct DependencyHistory
@@ -35,16 +23,18 @@ impl DependencyHistory
}
}
-impl IDependencyHistory for DependencyHistory
+#[cfg_attr(test, mockall::automock)]
+impl DependencyHistory
{
#[doc(hidden)]
- fn push<Dependency: 'static + ?Sized>(&mut self)
+ pub fn push<Dependency: 'static + ?Sized>(&mut self)
{
self.inner.push(type_name::<Dependency>());
}
#[doc(hidden)]
- fn contains<Dependency: 'static + ?Sized>(&self) -> bool
+ #[allow(clippy::must_use_candidate)]
+ pub fn contains<Dependency: 'static + ?Sized>(&self) -> bool
{
self.inner.contains(&type_name::<Dependency>())
}
diff --git a/src/di_container/asynchronous/binding/builder.rs b/src/di_container/asynchronous/binding/builder.rs
index d33b840..45597e8 100644
--- a/src/di_container/asynchronous/binding/builder.rs
+++ b/src/di_container/asynchronous/binding/builder.rs
@@ -5,13 +5,15 @@ use std::any::type_name;
use std::marker::PhantomData;
use std::sync::Arc;
-use crate::dependency_history::IDependencyHistory;
use crate::di_container::asynchronous::binding::scope_configurator::AsyncBindingScopeConfigurator;
#[cfg(feature = "factory")]
use crate::di_container::asynchronous::binding::when_configurator::AsyncBindingWhenConfigurator;
use crate::di_container::asynchronous::IAsyncDIContainer;
use crate::errors::async_di_container::AsyncBindingBuilderError;
use crate::interfaces::async_injectable::AsyncInjectable;
+use crate::util::use_dependency_history;
+
+use_dependency_history!();
/// Alias for a threadsafe boxed function.
#[cfg(feature = "factory")]
@@ -22,28 +24,25 @@ pub type BoxFn<Args, Return> = Box<(dyn Fn<Args, Output = Return> + Send + Sync)
///
/// [`IAsyncDIContainer`]: crate::di_container::asynchronous::IAsyncDIContainer
#[must_use = "No binding will be created if you don't use the binding builder"]
-pub struct AsyncBindingBuilder<Interface, DIContainerType, DependencyHistoryType>
+pub struct AsyncBindingBuilder<Interface, DIContainerType>
where
Interface: 'static + ?Sized + Send + Sync,
- DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory + Send + Sync,
+ DIContainerType: IAsyncDIContainer,
{
di_container: Arc<DIContainerType>,
- dependency_history_factory: fn() -> DependencyHistoryType,
+ dependency_history_factory: fn() -> DependencyHistory,
interface_phantom: PhantomData<Interface>,
}
-impl<Interface, DIContainerType, DependencyHistoryType>
- AsyncBindingBuilder<Interface, DIContainerType, DependencyHistoryType>
+impl<Interface, DIContainerType> AsyncBindingBuilder<Interface, DIContainerType>
where
Interface: 'static + ?Sized + Send + Sync,
- DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory + Send + Sync + 'static,
+ DIContainerType: IAsyncDIContainer,
{
pub(crate) fn new(
di_container: Arc<DIContainerType>,
- dependency_history_factory: fn() -> DependencyHistoryType,
+ dependency_history_factory: fn() -> DependencyHistory,
) -> Self
{
Self {
@@ -99,16 +98,11 @@ where
pub async fn to<Implementation>(
self,
) -> Result<
- AsyncBindingScopeConfigurator<
- Interface,
- Implementation,
- DIContainerType,
- DependencyHistoryType,
- >,
+ AsyncBindingScopeConfigurator<Interface, Implementation, DIContainerType>,
AsyncBindingBuilderError,
>
where
- Implementation: AsyncInjectable<DIContainerType, DependencyHistoryType>,
+ Implementation: AsyncInjectable<DIContainerType>,
{
if self.di_container.has_binding::<Interface>(None).await {
return Err(AsyncBindingBuilderError::BindingAlreadyExists(type_name::<
@@ -182,7 +176,7 @@ where
self,
factory_func: &'static FactoryFunc,
) -> Result<
- AsyncBindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType>,
+ AsyncBindingWhenConfigurator<Interface, DIContainerType>,
AsyncBindingBuilderError,
>
where
@@ -277,7 +271,7 @@ where
self,
factory_func: &'static FactoryFunc,
) -> Result<
- AsyncBindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType>,
+ AsyncBindingWhenConfigurator<Interface, DIContainerType>,
AsyncBindingBuilderError,
>
where
@@ -370,7 +364,7 @@ where
self,
factory_func: &'static FactoryFunc,
) -> Result<
- AsyncBindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType>,
+ AsyncBindingWhenConfigurator<Interface, DIContainerType>,
AsyncBindingBuilderError,
>
where
@@ -465,7 +459,7 @@ where
self,
factory_func: &'static FactoryFunc,
) -> Result<
- AsyncBindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType>,
+ AsyncBindingWhenConfigurator<Interface, DIContainerType>,
AsyncBindingBuilderError,
>
where
@@ -510,14 +504,14 @@ mod tests
use mockall::predicate::eq;
use super::*;
+ use crate::dependency_history::MockDependencyHistory;
use crate::test_utils::{mocks, subjects_async};
#[tokio::test]
async fn can_bind_to() -> Result<(), Box<dyn Error>>
{
- let mut di_container_mock = mocks::async_di_container::MockAsyncDIContainer::<
- mocks::MockDependencyHistory,
- >::new();
+ let mut di_container_mock =
+ mocks::async_di_container::MockAsyncDIContainer::new();
di_container_mock
.expect_has_binding::<dyn subjects_async::IUserManager>()
@@ -531,14 +525,11 @@ mod tests
.return_once(|_name, _provider| ())
.once();
- let binding_builder = AsyncBindingBuilder::<
- dyn subjects_async::IUserManager,
- mocks::async_di_container::MockAsyncDIContainer<mocks::MockDependencyHistory>,
- mocks::MockDependencyHistory,
- >::new(
- Arc::new(di_container_mock),
- mocks::MockDependencyHistory::new,
- );
+ let binding_builder =
+ AsyncBindingBuilder::<
+ dyn subjects_async::IUserManager,
+ mocks::async_di_container::MockAsyncDIContainer,
+ >::new(Arc::new(di_container_mock), MockDependencyHistory::new);
binding_builder.to::<subjects_async::UserManager>().await?;
@@ -575,14 +566,11 @@ mod tests
.return_once(|_name, _provider| ())
.once();
- let binding_builder = AsyncBindingBuilder::<
- IUserManagerFactory,
- mocks::async_di_container::MockAsyncDIContainer<mocks::MockDependencyHistory>,
- mocks::MockDependencyHistory,
- >::new(
- Arc::new(di_container_mock),
- mocks::MockDependencyHistory::new,
- );
+ let binding_builder =
+ AsyncBindingBuilder::<
+ IUserManagerFactory,
+ mocks::async_di_container::MockAsyncDIContainer,
+ >::new(Arc::new(di_container_mock), MockDependencyHistory::new);
binding_builder
.to_factory(&|_| {
@@ -624,14 +612,11 @@ mod tests
.return_once(|_name, _provider| ())
.once();
- let binding_builder = AsyncBindingBuilder::<
- IUserManagerFactory,
- mocks::async_di_container::MockAsyncDIContainer<mocks::MockDependencyHistory>,
- mocks::MockDependencyHistory,
- >::new(
- Arc::new(di_container_mock),
- mocks::MockDependencyHistory::new,
- );
+ let binding_builder =
+ AsyncBindingBuilder::<
+ IUserManagerFactory,
+ mocks::async_di_container::MockAsyncDIContainer,
+ >::new(Arc::new(di_container_mock), MockDependencyHistory::new);
binding_builder
.to_async_factory(&|_| {
@@ -673,14 +658,11 @@ mod tests
.return_once(|_name, _provider| ())
.once();
- let binding_builder = AsyncBindingBuilder::<
- dyn subjects_async::IUserManager,
- mocks::async_di_container::MockAsyncDIContainer<mocks::MockDependencyHistory>,
- mocks::MockDependencyHistory,
- >::new(
- Arc::new(di_container_mock),
- mocks::MockDependencyHistory::new,
- );
+ let binding_builder =
+ AsyncBindingBuilder::<
+ dyn subjects_async::IUserManager,
+ mocks::async_di_container::MockAsyncDIContainer,
+ >::new(Arc::new(di_container_mock), MockDependencyHistory::new);
binding_builder
.to_default_factory(&|_| {
@@ -723,14 +705,11 @@ mod tests
.return_once(|_name, _provider| ())
.once();
- let binding_builder = AsyncBindingBuilder::<
- dyn subjects_async::IUserManager,
- mocks::async_di_container::MockAsyncDIContainer<mocks::MockDependencyHistory>,
- mocks::MockDependencyHistory,
- >::new(
- Arc::new(di_container_mock),
- mocks::MockDependencyHistory::new,
- );
+ let binding_builder =
+ AsyncBindingBuilder::<
+ dyn subjects_async::IUserManager,
+ mocks::async_di_container::MockAsyncDIContainer,
+ >::new(Arc::new(di_container_mock), MockDependencyHistory::new);
binding_builder
.to_async_default_factory(&|_| {
diff --git a/src/di_container/asynchronous/binding/scope_configurator.rs b/src/di_container/asynchronous/binding/scope_configurator.rs
index 023bb5e..a4a684b 100644
--- a/src/di_container/asynchronous/binding/scope_configurator.rs
+++ b/src/di_container/asynchronous/binding/scope_configurator.rs
@@ -4,51 +4,42 @@
use std::marker::PhantomData;
use std::sync::Arc;
-use crate::dependency_history::IDependencyHistory;
use crate::di_container::asynchronous::binding::when_configurator::AsyncBindingWhenConfigurator;
use crate::di_container::asynchronous::IAsyncDIContainer;
use crate::errors::async_di_container::AsyncBindingScopeConfiguratorError;
use crate::interfaces::async_injectable::AsyncInjectable;
use crate::provider::r#async::{AsyncSingletonProvider, AsyncTransientTypeProvider};
use crate::ptr::ThreadsafeSingletonPtr;
+use crate::util::use_dependency_history;
+
+use_dependency_history!();
/// Scope configurator for a binding for type `Interface` inside a [`IAsyncDIContainer`].
///
/// [`IAsyncDIContainer`]: crate::di_container::asynchronous::IAsyncDIContainer
-pub struct AsyncBindingScopeConfigurator<
- Interface,
- Implementation,
- DIContainerType,
- DependencyHistoryType,
-> where
+pub struct AsyncBindingScopeConfigurator<Interface, Implementation, DIContainerType>
+where
Interface: 'static + ?Sized + Send + Sync,
- Implementation: AsyncInjectable<DIContainerType, DependencyHistoryType>,
- DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory + Send + Sync,
+ Implementation: AsyncInjectable<DIContainerType>,
+ DIContainerType: IAsyncDIContainer,
{
di_container: Arc<DIContainerType>,
- dependency_history_factory: fn() -> DependencyHistoryType,
+ dependency_history_factory: fn() -> DependencyHistory,
interface_phantom: PhantomData<Interface>,
implementation_phantom: PhantomData<Implementation>,
}
-impl<Interface, Implementation, DIContainerType, DependencyHistoryType>
- AsyncBindingScopeConfigurator<
- Interface,
- Implementation,
- DIContainerType,
- DependencyHistoryType,
- >
+impl<Interface, Implementation, DIContainerType>
+ AsyncBindingScopeConfigurator<Interface, Implementation, DIContainerType>
where
Interface: 'static + ?Sized + Send + Sync,
- Implementation: AsyncInjectable<DIContainerType, DependencyHistoryType>,
- DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory + Send + Sync + 'static,
+ Implementation: AsyncInjectable<DIContainerType>,
+ DIContainerType: IAsyncDIContainer,
{
pub(crate) fn new(
di_container: Arc<DIContainerType>,
- dependency_history_factory: fn() -> DependencyHistoryType,
+ dependency_history_factory: fn() -> DependencyHistory,
) -> Self
{
Self {
@@ -64,7 +55,7 @@ where
/// This is the default.
pub async fn in_transient_scope(
self,
- ) -> AsyncBindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType>
+ ) -> AsyncBindingWhenConfigurator<Interface, DIContainerType>
{
self.set_in_transient_scope().await;
@@ -78,7 +69,7 @@ where
pub async fn in_singleton_scope(
self,
) -> Result<
- AsyncBindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType>,
+ AsyncBindingWhenConfigurator<Interface, DIContainerType>,
AsyncBindingScopeConfiguratorError,
>
{
@@ -107,11 +98,9 @@ where
self.di_container
.set_binding::<Interface>(
None,
- Box::new(AsyncTransientTypeProvider::<
- Implementation,
- DIContainerType,
- DependencyHistoryType,
- >::new()),
+ Box::new(
+ AsyncTransientTypeProvider::<Implementation, DIContainerType>::new(),
+ ),
)
.await;
}
@@ -121,6 +110,7 @@ where
mod tests
{
use super::*;
+ use crate::dependency_history::MockDependencyHistory;
use crate::test_utils::{mocks, subjects_async};
#[tokio::test]
@@ -135,15 +125,12 @@ mod tests
.return_once(|_name, _provider| ())
.once();
- let binding_scope_configurator = AsyncBindingScopeConfigurator::<
- dyn subjects_async::IUserManager,
- subjects_async::UserManager,
- mocks::async_di_container::MockAsyncDIContainer<mocks::MockDependencyHistory>,
- mocks::MockDependencyHistory,
- >::new(
- Arc::new(di_container_mock),
- mocks::MockDependencyHistory::new,
- );
+ let binding_scope_configurator =
+ AsyncBindingScopeConfigurator::<
+ dyn subjects_async::IUserManager,
+ subjects_async::UserManager,
+ mocks::async_di_container::MockAsyncDIContainer,
+ >::new(Arc::new(di_container_mock), MockDependencyHistory::new);
binding_scope_configurator.in_transient_scope().await;
}
@@ -160,15 +147,12 @@ mod tests
.return_once(|_name, _provider| ())
.once();
- let binding_scope_configurator = AsyncBindingScopeConfigurator::<
- dyn subjects_async::IUserManager,
- subjects_async::UserManager,
- mocks::async_di_container::MockAsyncDIContainer<mocks::MockDependencyHistory>,
- mocks::MockDependencyHistory,
- >::new(
- Arc::new(di_container_mock),
- mocks::MockDependencyHistory::new,
- );
+ let binding_scope_configurator =
+ AsyncBindingScopeConfigurator::<
+ dyn subjects_async::IUserManager,
+ subjects_async::UserManager,
+ mocks::async_di_container::MockAsyncDIContainer,
+ >::new(Arc::new(di_container_mock), MockDependencyHistory::new);
assert!(binding_scope_configurator
.in_singleton_scope()
diff --git a/src/di_container/asynchronous/binding/when_configurator.rs b/src/di_container/asynchronous/binding/when_configurator.rs
index 39e1807..d08239e 100644
--- a/src/di_container/asynchronous/binding/when_configurator.rs
+++ b/src/di_container/asynchronous/binding/when_configurator.rs
@@ -5,38 +5,32 @@ use std::any::type_name;
use std::marker::PhantomData;
use std::sync::Arc;
-use crate::dependency_history::IDependencyHistory;
use crate::di_container::asynchronous::IAsyncDIContainer;
use crate::errors::async_di_container::AsyncBindingWhenConfiguratorError;
/// When configurator for a binding for type `Interface` inside a [`IAsyncDIContainer`].
///
/// [`IAsyncDIContainer`]: crate::di_container::asynchronous::IAsyncDIContainer
-pub struct AsyncBindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType>
+pub struct AsyncBindingWhenConfigurator<Interface, DIContainerType>
where
Interface: 'static + ?Sized + Send + Sync,
- DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory + Send + Sync,
+ DIContainerType: IAsyncDIContainer,
{
di_container: Arc<DIContainerType>,
interface_phantom: PhantomData<Interface>,
- dependency_history_phantom: PhantomData<DependencyHistoryType>,
}
-impl<Interface, DIContainerType, DependencyHistoryType>
- AsyncBindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType>
+impl<Interface, DIContainerType> AsyncBindingWhenConfigurator<Interface, DIContainerType>
where
Interface: 'static + ?Sized + Send + Sync,
- DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory + Send + Sync,
+ DIContainerType: IAsyncDIContainer,
{
pub(crate) fn new(di_container: Arc<DIContainerType>) -> Self
{
Self {
di_container,
interface_phantom: PhantomData,
- dependency_history_phantom: PhantomData,
}
}
@@ -99,8 +93,7 @@ mod tests
let binding_when_configurator = AsyncBindingWhenConfigurator::<
dyn subjects_async::INumber,
- mocks::async_di_container::MockAsyncDIContainer<mocks::MockDependencyHistory>,
- mocks::MockDependencyHistory,
+ mocks::async_di_container::MockAsyncDIContainer,
>::new(Arc::new(di_container_mock));
assert!(binding_when_configurator
diff --git a/src/di_container/asynchronous/mod.rs b/src/di_container/asynchronous/mod.rs
index b603e88..927f549 100644
--- a/src/di_container/asynchronous/mod.rs
+++ b/src/di_container/asynchronous/mod.rs
@@ -57,7 +57,6 @@ use std::sync::Arc;
use async_lock::Mutex;
use async_trait::async_trait;
-use crate::dependency_history::{DependencyHistory, IDependencyHistory};
use crate::di_container::asynchronous::binding::builder::AsyncBindingBuilder;
use crate::di_container::binding_storage::DIContainerBindingStorage;
use crate::errors::async_di_container::AsyncDIContainerError;
@@ -67,6 +66,9 @@ use crate::private::cast::boxed::CastBox;
use crate::private::cast::error::CastError;
use crate::provider::r#async::{AsyncProvidable, IAsyncProvider};
use crate::ptr::{SomePtr, TransientPtr};
+use crate::util::use_dependency_history;
+
+use_dependency_history!();
pub mod binding;
pub mod prelude;
@@ -75,15 +77,11 @@ pub mod prelude;
///
/// **This trait is sealed and cannot be implemented for types outside this crate.**
#[async_trait]
-pub trait IAsyncDIContainer<DependencyHistoryType>:
- Sized + 'static + Send + Sync + details::DIContainerInternals<DependencyHistoryType>
-where
- DependencyHistoryType: IDependencyHistory + Send + Sync,
+pub trait IAsyncDIContainer:
+ Sized + 'static + Send + Sync + details::DIContainerInternals
{
/// Returns a new [`AsyncBindingBuilder`] for the given interface.
- fn bind<Interface>(
- self: &mut Arc<Self>,
- ) -> AsyncBindingBuilder<Interface, Self, DependencyHistoryType>
+ fn bind<Interface>(self: &mut Arc<Self>) -> AsyncBindingBuilder<Interface, Self>
where
Interface: 'static + ?Sized + Send + Sync;
@@ -121,7 +119,7 @@ where
#[doc(hidden)]
async fn get_bound<Interface>(
self: &Arc<Self>,
- dependency_history: DependencyHistoryType,
+ dependency_history: DependencyHistory,
name: Option<&'static str>,
) -> Result<SomePtr<Interface>, AsyncDIContainerError>
where
@@ -131,8 +129,7 @@ where
/// Async dependency injection container.
pub struct AsyncDIContainer
{
- binding_storage:
- Mutex<DIContainerBindingStorage<dyn IAsyncProvider<Self, DependencyHistory>>>,
+ binding_storage: Mutex<DIContainerBindingStorage<dyn IAsyncProvider<Self>>>,
}
impl AsyncDIContainer
@@ -148,11 +145,9 @@ impl AsyncDIContainer
}
#[async_trait]
-impl IAsyncDIContainer<DependencyHistory> for AsyncDIContainer
+impl IAsyncDIContainer for AsyncDIContainer
{
- fn bind<Interface>(
- self: &mut Arc<Self>,
- ) -> AsyncBindingBuilder<Interface, Self, DependencyHistory>
+ fn bind<Interface>(self: &mut Arc<Self>) -> AsyncBindingBuilder<Interface, Self>
where
Interface: 'static + ?Sized + Send + Sync,
{
@@ -205,7 +200,7 @@ impl IAsyncDIContainer<DependencyHistory> for AsyncDIContainer
}
#[async_trait]
-impl details::DIContainerInternals<DependencyHistory> for AsyncDIContainer
+impl details::DIContainerInternals for AsyncDIContainer
{
async fn has_binding<Interface>(self: &Arc<Self>, name: Option<&'static str>) -> bool
where
@@ -217,7 +212,7 @@ impl details::DIContainerInternals<DependencyHistory> for AsyncDIContainer
async fn set_binding<Interface>(
self: &Arc<Self>,
name: Option<&'static str>,
- provider: Box<dyn IAsyncProvider<Self, DependencyHistory>>,
+ provider: Box<dyn IAsyncProvider<Self>>,
) where
Interface: 'static + ?Sized,
{
@@ -230,7 +225,7 @@ impl details::DIContainerInternals<DependencyHistory> for AsyncDIContainer
async fn remove_binding<Interface>(
self: &Arc<Self>,
name: Option<&'static str>,
- ) -> Option<Box<dyn IAsyncProvider<Self, DependencyHistory>>>
+ ) -> Option<Box<dyn IAsyncProvider<Self>>>
where
Interface: 'static + ?Sized,
{
@@ -242,7 +237,7 @@ impl AsyncDIContainer
{
async fn handle_binding_providable<Interface>(
self: &Arc<Self>,
- binding_providable: AsyncProvidable<Self, DependencyHistory>,
+ binding_providable: AsyncProvidable<Self>,
) -> Result<SomePtr<Interface>, AsyncDIContainerError>
where
Interface: 'static + ?Sized + Send + Sync,
@@ -369,7 +364,7 @@ impl AsyncDIContainer
self: &Arc<Self>,
name: Option<&'static str>,
dependency_history: DependencyHistory,
- ) -> Result<AsyncProvidable<Self, DependencyHistory>, AsyncDIContainerError>
+ ) -> Result<AsyncProvidable<Self>, AsyncDIContainerError>
where
Interface: 'static + ?Sized + Send + Sync,
{
@@ -408,13 +403,10 @@ pub(crate) mod details
use async_trait::async_trait;
- use crate::dependency_history::IDependencyHistory;
use crate::provider::r#async::IAsyncProvider;
#[async_trait]
- pub trait DIContainerInternals<DependencyHistoryType>
- where
- DependencyHistoryType: IDependencyHistory,
+ pub trait DIContainerInternals
{
async fn has_binding<Interface>(
self: &Arc<Self>,
@@ -426,14 +418,14 @@ pub(crate) mod details
async fn set_binding<Interface>(
self: &Arc<Self>,
name: Option<&'static str>,
- provider: Box<dyn IAsyncProvider<Self, DependencyHistoryType>>,
+ provider: Box<dyn IAsyncProvider<Self>>,
) where
Interface: 'static + ?Sized;
async fn remove_binding<Interface>(
self: &Arc<Self>,
name: Option<&'static str>,
- ) -> Option<Box<dyn IAsyncProvider<Self, DependencyHistoryType>>>
+ ) -> Option<Box<dyn IAsyncProvider<Self>>>
where
Interface: 'static + ?Sized;
}
diff --git a/src/di_container/blocking/binding/builder.rs b/src/di_container/blocking/binding/builder.rs
index 27151d7..991961c 100644
--- a/src/di_container/blocking/binding/builder.rs
+++ b/src/di_container/blocking/binding/builder.rs
@@ -5,40 +5,39 @@ use std::any::type_name;
use std::marker::PhantomData;
use std::rc::Rc;
-use crate::dependency_history::IDependencyHistory;
use crate::di_container::blocking::binding::scope_configurator::BindingScopeConfigurator;
#[cfg(feature = "factory")]
use crate::di_container::blocking::binding::when_configurator::BindingWhenConfigurator;
use crate::di_container::blocking::IDIContainer;
use crate::errors::di_container::BindingBuilderError;
use crate::interfaces::injectable::Injectable;
+use crate::util::use_dependency_history;
+
+use_dependency_history!();
/// Binding builder for type `Interface` inside a [`IDIContainer`].
///
/// [`IDIContainer`]: crate::di_container::blocking::IDIContainer
#[must_use = "No binding will be created if you don't use the binding builder"]
-pub struct BindingBuilder<Interface, DIContainerType, DependencyHistoryType>
+pub struct BindingBuilder<Interface, DIContainerType>
where
Interface: 'static + ?Sized,
- DIContainerType: IDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory,
+ DIContainerType: IDIContainer,
{
di_container: Rc<DIContainerType>,
- dependency_history_factory: fn() -> DependencyHistoryType,
+ dependency_history_factory: fn() -> DependencyHistory,
interface_phantom: PhantomData<Interface>,
}
-impl<Interface, DIContainerType, DependencyHistoryType>
- BindingBuilder<Interface, DIContainerType, DependencyHistoryType>
+impl<Interface, DIContainerType> BindingBuilder<Interface, DIContainerType>
where
Interface: 'static + ?Sized,
- DIContainerType: IDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory + 'static,
+ DIContainerType: IDIContainer,
{
pub(crate) fn new(
di_container: Rc<DIContainerType>,
- dependency_history_factory: fn() -> DependencyHistoryType,
+ dependency_history_factory: fn() -> DependencyHistory,
) -> Self
{
Self {
@@ -93,16 +92,11 @@ where
pub fn to<Implementation>(
self,
) -> Result<
- BindingScopeConfigurator<
- Interface,
- Implementation,
- DIContainerType,
- DependencyHistoryType,
- >,
+ BindingScopeConfigurator<Interface, Implementation, DIContainerType>,
BindingBuilderError,
>
where
- Implementation: Injectable<DIContainerType, DependencyHistoryType>,
+ Implementation: Injectable<DIContainerType>,
{
{
if self.di_container.has_binding::<Interface>(None) {
@@ -194,10 +188,7 @@ where
pub fn to_factory<Args, Return, Func>(
self,
factory_func: &'static Func,
- ) -> Result<
- BindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType>,
- BindingBuilderError,
- >
+ ) -> Result<BindingWhenConfigurator<Interface, DIContainerType>, BindingBuilderError>
where
Args: std::marker::Tuple + 'static,
Return: 'static + ?Sized,
@@ -283,10 +274,7 @@ where
pub fn to_default_factory<Return, FactoryFunc>(
self,
factory_func: &'static FactoryFunc,
- ) -> Result<
- BindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType>,
- BindingBuilderError,
- >
+ ) -> Result<BindingWhenConfigurator<Interface, DIContainerType>, BindingBuilderError>
where
Return: 'static + ?Sized,
FactoryFunc: Fn<
@@ -326,6 +314,7 @@ mod tests
use mockall::predicate::eq;
use super::*;
+ use crate::dependency_history::MockDependencyHistory;
use crate::test_utils::{mocks, subjects};
#[test]
@@ -345,14 +334,11 @@ mod tests
.return_once(|_name, _provider| ())
.once();
- let binding_builder = BindingBuilder::<
- dyn subjects::INumber,
- mocks::blocking_di_container::MockDIContainer<mocks::MockDependencyHistory>,
- mocks::MockDependencyHistory,
- >::new(
- Rc::new(mock_di_container),
- mocks::MockDependencyHistory::new,
- );
+ let binding_builder =
+ BindingBuilder::<
+ dyn subjects::INumber,
+ mocks::blocking_di_container::MockDIContainer,
+ >::new(Rc::new(mock_di_container), MockDependencyHistory::new);
binding_builder.to::<subjects::Number>()?;
@@ -384,14 +370,11 @@ mod tests
.return_once(|_name, _provider| ())
.once();
- let binding_builder = BindingBuilder::<
- IUserManagerFactory,
- mocks::blocking_di_container::MockDIContainer<mocks::MockDependencyHistory>,
- mocks::MockDependencyHistory,
- >::new(
- Rc::new(mock_di_container),
- mocks::MockDependencyHistory::new,
- );
+ let binding_builder =
+ BindingBuilder::<
+ IUserManagerFactory,
+ mocks::blocking_di_container::MockDIContainer,
+ >::new(Rc::new(mock_di_container), MockDependencyHistory::new);
binding_builder.to_factory(&|_| {
Box::new(move |_num, _text| {
@@ -430,14 +413,11 @@ mod tests
.return_once(|_name, _provider| ())
.once();
- let binding_builder = BindingBuilder::<
- dyn subjects::IUserManager,
- mocks::blocking_di_container::MockDIContainer<mocks::MockDependencyHistory>,
- mocks::MockDependencyHistory,
- >::new(
- Rc::new(mock_di_container),
- mocks::MockDependencyHistory::new,
- );
+ let binding_builder =
+ BindingBuilder::<
+ dyn subjects::IUserManager,
+ mocks::blocking_di_container::MockDIContainer,
+ >::new(Rc::new(mock_di_container), MockDependencyHistory::new);
binding_builder.to_default_factory(&|_| {
Box::new(move || {
diff --git a/src/di_container/blocking/binding/scope_configurator.rs b/src/di_container/blocking/binding/scope_configurator.rs
index f318dd6..0e2437f 100644
--- a/src/di_container/blocking/binding/scope_configurator.rs
+++ b/src/di_container/blocking/binding/scope_configurator.rs
@@ -4,51 +4,42 @@
use std::marker::PhantomData;
use std::rc::Rc;
-use crate::dependency_history::IDependencyHistory;
use crate::di_container::blocking::binding::when_configurator::BindingWhenConfigurator;
use crate::di_container::blocking::IDIContainer;
use crate::errors::di_container::BindingScopeConfiguratorError;
use crate::interfaces::injectable::Injectable;
use crate::provider::blocking::{SingletonProvider, TransientTypeProvider};
use crate::ptr::SingletonPtr;
+use crate::util::use_dependency_history;
+
+use_dependency_history!();
/// Scope configurator for a binding for type `Interface` inside a [`IDIContainer`].
///
/// [`IDIContainer`]: crate::di_container::blocking::IDIContainer
-pub struct BindingScopeConfigurator<
- Interface,
- Implementation,
- DIContainerType,
- DependencyHistoryType,
-> where
+pub struct BindingScopeConfigurator<Interface, Implementation, DIContainerType>
+where
Interface: 'static + ?Sized,
- Implementation: Injectable<DIContainerType, DependencyHistoryType>,
- DIContainerType: IDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory,
+ Implementation: Injectable<DIContainerType>,
+ DIContainerType: IDIContainer,
{
di_container: Rc<DIContainerType>,
- dependency_history_factory: fn() -> DependencyHistoryType,
+ dependency_history_factory: fn() -> DependencyHistory,
interface_phantom: PhantomData<Interface>,
implementation_phantom: PhantomData<Implementation>,
}
-impl<Interface, Implementation, DIContainerType, DependencyHistoryType>
- BindingScopeConfigurator<
- Interface,
- Implementation,
- DIContainerType,
- DependencyHistoryType,
- >
+impl<Interface, Implementation, DIContainerType>
+ BindingScopeConfigurator<Interface, Implementation, DIContainerType>
where
Interface: 'static + ?Sized,
- Implementation: Injectable<DIContainerType, DependencyHistoryType>,
- DIContainerType: IDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory + 'static,
+ Implementation: Injectable<DIContainerType>,
+ DIContainerType: IDIContainer,
{
pub(crate) fn new(
di_container: Rc<DIContainerType>,
- dependency_history_factory: fn() -> DependencyHistoryType,
+ dependency_history_factory: fn() -> DependencyHistory,
) -> Self
{
Self {
@@ -63,9 +54,8 @@ where
///
/// This is the default.
#[allow(clippy::must_use_candidate)]
- pub fn in_transient_scope(
- self,
- ) -> BindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType>
+ pub fn in_transient_scope(self)
+ -> BindingWhenConfigurator<Interface, DIContainerType>
{
self.set_in_transient_scope();
@@ -79,7 +69,7 @@ where
pub fn in_singleton_scope(
self,
) -> Result<
- BindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType>,
+ BindingWhenConfigurator<Interface, DIContainerType>,
BindingScopeConfiguratorError,
>
{
@@ -101,11 +91,7 @@ where
{
self.di_container.set_binding::<Interface>(
None,
- Box::new(TransientTypeProvider::<
- Implementation,
- DIContainerType,
- DependencyHistoryType,
- >::new()),
+ Box::new(TransientTypeProvider::<Implementation, DIContainerType>::new()),
);
}
}
@@ -114,6 +100,7 @@ where
mod tests
{
use super::*;
+ use crate::dependency_history::MockDependencyHistory;
use crate::test_utils::{mocks, subjects};
#[test]
@@ -127,15 +114,12 @@ mod tests
.return_once(|_name, _provider| ())
.once();
- let binding_scope_configurator = BindingScopeConfigurator::<
- dyn subjects::IUserManager,
- subjects::UserManager,
- mocks::blocking_di_container::MockDIContainer<mocks::MockDependencyHistory>,
- mocks::MockDependencyHistory,
- >::new(
- Rc::new(di_container_mock),
- mocks::MockDependencyHistory::new,
- );
+ let binding_scope_configurator =
+ BindingScopeConfigurator::<
+ dyn subjects::IUserManager,
+ subjects::UserManager,
+ mocks::blocking_di_container::MockDIContainer,
+ >::new(Rc::new(di_container_mock), MockDependencyHistory::new);
binding_scope_configurator.in_transient_scope();
}
@@ -151,15 +135,12 @@ mod tests
.return_once(|_name, _provider| ())
.once();
- let binding_scope_configurator = BindingScopeConfigurator::<
- dyn subjects::IUserManager,
- subjects::UserManager,
- mocks::blocking_di_container::MockDIContainer<mocks::MockDependencyHistory>,
- mocks::MockDependencyHistory,
- >::new(
- Rc::new(di_container_mock),
- mocks::MockDependencyHistory::new,
- );
+ let binding_scope_configurator =
+ BindingScopeConfigurator::<
+ dyn subjects::IUserManager,
+ subjects::UserManager,
+ mocks::blocking_di_container::MockDIContainer,
+ >::new(Rc::new(di_container_mock), MockDependencyHistory::new);
assert!(binding_scope_configurator.in_singleton_scope().is_ok());
}
diff --git a/src/di_container/blocking/binding/when_configurator.rs b/src/di_container/blocking/binding/when_configurator.rs
index 31b1b48..fcef377 100644
--- a/src/di_container/blocking/binding/when_configurator.rs
+++ b/src/di_container/blocking/binding/when_configurator.rs
@@ -5,38 +5,32 @@ use std::any::type_name;
use std::marker::PhantomData;
use std::rc::Rc;
-use crate::dependency_history::IDependencyHistory;
use crate::di_container::blocking::IDIContainer;
use crate::errors::di_container::BindingWhenConfiguratorError;
/// When configurator for a binding for type `Interface` inside a [`IDIContainer`].
///
/// [`IDIContainer`]: crate::di_container::blocking::IDIContainer
-pub struct BindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType>
+pub struct BindingWhenConfigurator<Interface, DIContainerType>
where
Interface: 'static + ?Sized,
- DIContainerType: IDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory,
+ DIContainerType: IDIContainer,
{
di_container: Rc<DIContainerType>,
interface_phantom: PhantomData<Interface>,
- dependency_history_phantom: PhantomData<DependencyHistoryType>,
}
-impl<Interface, DIContainerType, DependencyHistoryType>
- BindingWhenConfigurator<Interface, DIContainerType, DependencyHistoryType>
+impl<Interface, DIContainerType> BindingWhenConfigurator<Interface, DIContainerType>
where
Interface: 'static + ?Sized,
- DIContainerType: IDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory,
+ DIContainerType: IDIContainer,
{
pub(crate) fn new(di_container: Rc<DIContainerType>) -> Self
{
Self {
di_container,
interface_phantom: PhantomData,
- dependency_history_phantom: PhantomData,
}
}
@@ -97,8 +91,7 @@ mod tests
let binding_when_configurator = BindingWhenConfigurator::<
dyn subjects::INumber,
- mocks::blocking_di_container::MockDIContainer<mocks::MockDependencyHistory>,
- mocks::MockDependencyHistory,
+ mocks::blocking_di_container::MockDIContainer,
>::new(Rc::new(di_container_mock));
assert!(binding_when_configurator.when_named("cool").is_ok());
diff --git a/src/di_container/blocking/mod.rs b/src/di_container/blocking/mod.rs
index cd7065c..5781583 100644
--- a/src/di_container/blocking/mod.rs
+++ b/src/di_container/blocking/mod.rs
@@ -54,7 +54,6 @@ use std::any::type_name;
use std::cell::RefCell;
use std::rc::Rc;
-use crate::dependency_history::{DependencyHistory, IDependencyHistory};
use crate::di_container::binding_storage::DIContainerBindingStorage;
use crate::di_container::blocking::binding::builder::BindingBuilder;
use crate::errors::di_container::DIContainerError;
@@ -62,6 +61,9 @@ use crate::private::cast::boxed::CastBox;
use crate::private::cast::rc::CastRc;
use crate::provider::blocking::{IProvider, Providable};
use crate::ptr::SomePtr;
+use crate::util::use_dependency_history;
+
+use_dependency_history!();
pub mod binding;
pub mod prelude;
@@ -69,15 +71,10 @@ pub mod prelude;
/// Blocking dependency injection container interface.
///
/// **This trait is sealed and cannot be implemented for types outside this crate.**
-pub trait IDIContainer<DependencyHistoryType>:
- Sized + 'static + details::DIContainerInternals<DependencyHistoryType>
-where
- DependencyHistoryType: IDependencyHistory,
+pub trait IDIContainer: Sized + 'static + details::DIContainerInternals
{
/// Returns a new [`BindingBuilder`] for the given interface.
- fn bind<Interface>(
- self: &mut Rc<Self>,
- ) -> BindingBuilder<Interface, Self, DependencyHistoryType>
+ fn bind<Interface>(self: &mut Rc<Self>) -> BindingBuilder<Interface, Self>
where
Interface: 'static + ?Sized;
@@ -109,7 +106,7 @@ where
#[doc(hidden)]
fn get_bound<Interface>(
self: &Rc<Self>,
- dependency_history: DependencyHistoryType,
+ dependency_history: DependencyHistory,
name: Option<&'static str>,
) -> Result<SomePtr<Interface>, DIContainerError>
where
@@ -119,8 +116,7 @@ where
/// Blocking dependency injection container.
pub struct DIContainer
{
- binding_storage:
- RefCell<DIContainerBindingStorage<dyn IProvider<Self, DependencyHistory>>>,
+ binding_storage: RefCell<DIContainerBindingStorage<dyn IProvider<Self>>>,
}
impl DIContainer
@@ -135,11 +131,9 @@ impl DIContainer
}
}
-impl IDIContainer<DependencyHistory> for DIContainer
+impl IDIContainer for DIContainer
{
- fn bind<Interface>(
- self: &mut Rc<Self>,
- ) -> BindingBuilder<Interface, Self, DependencyHistory>
+ fn bind<Interface>(self: &mut Rc<Self>) -> BindingBuilder<Interface, Self>
where
Interface: 'static + ?Sized,
{
@@ -183,7 +177,7 @@ impl IDIContainer<DependencyHistory> for DIContainer
}
}
-impl details::DIContainerInternals<DependencyHistory> for DIContainer
+impl details::DIContainerInternals for DIContainer
{
fn has_binding<Interface>(self: &Rc<Self>, name: Option<&'static str>) -> bool
where
@@ -195,7 +189,7 @@ impl details::DIContainerInternals<DependencyHistory> for DIContainer
fn set_binding<Interface>(
self: &Rc<Self>,
name: Option<&'static str>,
- provider: Box<dyn IProvider<Self, DependencyHistory>>,
+ provider: Box<dyn IProvider<Self>>,
) where
Interface: 'static + ?Sized,
{
@@ -207,7 +201,7 @@ impl details::DIContainerInternals<DependencyHistory> for DIContainer
fn remove_binding<Interface>(
self: &Rc<Self>,
name: Option<&'static str>,
- ) -> Option<Box<dyn IProvider<Self, DependencyHistory>>>
+ ) -> Option<Box<dyn IProvider<Self>>>
where
Interface: 'static + ?Sized,
{
@@ -219,7 +213,7 @@ impl DIContainer
{
fn handle_binding_providable<Interface>(
#[cfg(feature = "factory")] self: &Rc<Self>,
- binding_providable: Providable<Self, DependencyHistory>,
+ binding_providable: Providable<Self>,
) -> Result<SomePtr<Interface>, DIContainerError>
where
Interface: 'static + ?Sized,
@@ -278,7 +272,7 @@ impl DIContainer
self: &Rc<Self>,
name: Option<&'static str>,
dependency_history: DependencyHistory,
- ) -> Result<Providable<Self, DependencyHistory>, DIContainerError>
+ ) -> Result<Providable<Self>, DIContainerError>
where
Interface: 'static + ?Sized,
{
@@ -306,12 +300,9 @@ pub(crate) mod details
{
use std::rc::Rc;
- use crate::dependency_history::IDependencyHistory;
use crate::provider::blocking::IProvider;
- pub trait DIContainerInternals<DependencyHistoryType>
- where
- DependencyHistoryType: IDependencyHistory,
+ pub trait DIContainerInternals
{
fn has_binding<Interface>(self: &Rc<Self>, name: Option<&'static str>) -> bool
where
@@ -320,14 +311,14 @@ pub(crate) mod details
fn set_binding<Interface>(
self: &Rc<Self>,
name: Option<&'static str>,
- provider: Box<dyn IProvider<Self, DependencyHistoryType>>,
+ provider: Box<dyn IProvider<Self>>,
) where
Interface: 'static + ?Sized;
fn remove_binding<Interface>(
self: &Rc<Self>,
name: Option<&'static str>,
- ) -> Option<Box<dyn IProvider<Self, DependencyHistoryType>>>
+ ) -> Option<Box<dyn IProvider<Self>>>
where
Interface: 'static + ?Sized;
}
diff --git a/src/interfaces/async_injectable.rs b/src/interfaces/async_injectable.rs
index d8e7dfc..2364ae1 100644
--- a/src/interfaces/async_injectable.rs
+++ b/src/interfaces/async_injectable.rs
@@ -2,18 +2,19 @@
use std::fmt::Debug;
use std::sync::Arc;
-use crate::dependency_history::IDependencyHistory;
use crate::di_container::asynchronous::IAsyncDIContainer;
use crate::errors::injectable::InjectableError;
use crate::future::BoxFuture;
use crate::private::cast::CastFromArc;
use crate::ptr::TransientPtr;
+use crate::util::use_dependency_history;
+
+use_dependency_history!();
/// Interface for structs that can be injected into or be injected to.
-pub trait AsyncInjectable<DIContainerType, DependencyHistoryType>: CastFromArc
+pub trait AsyncInjectable<DIContainerType>: CastFromArc
where
- DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory + Send + Sync,
+ DIContainerType: IAsyncDIContainer,
{
/// Resolves the dependencies of the injectable.
///
@@ -21,18 +22,16 @@ where
/// Will return `Err` if resolving the dependencies fails.
fn resolve<'di_container, 'fut>(
di_container: &'di_container Arc<DIContainerType>,
- dependency_history: DependencyHistoryType,
+ dependency_history: DependencyHistory,
) -> BoxFuture<'fut, Result<TransientPtr<Self>, InjectableError>>
where
Self: Sized + 'fut,
'di_container: 'fut;
}
-impl<DIContainerType, DependencyHistoryType> Debug
- for dyn AsyncInjectable<DIContainerType, DependencyHistoryType>
+impl<DIContainerType> Debug for dyn AsyncInjectable<DIContainerType>
where
- DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory + Send + Sync,
+ DIContainerType: IAsyncDIContainer,
{
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result
{
diff --git a/src/interfaces/injectable.rs b/src/interfaces/injectable.rs
index b70e13f..82b773a 100644
--- a/src/interfaces/injectable.rs
+++ b/src/interfaces/injectable.rs
@@ -2,17 +2,18 @@
use std::fmt::Debug;
use std::rc::Rc;
-use crate::dependency_history::IDependencyHistory;
use crate::di_container::blocking::IDIContainer;
use crate::errors::injectable::InjectableError;
use crate::private::cast::CastFrom;
use crate::ptr::TransientPtr;
+use crate::util::use_dependency_history;
+
+use_dependency_history!();
/// Interface for structs that can be injected into or be injected to.
-pub trait Injectable<DIContainerType, DependencyHistoryType>: CastFrom
+pub trait Injectable<DIContainerType>: CastFrom
where
- DIContainerType: IDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory,
+ DIContainerType: IDIContainer,
{
/// Resolves the dependencies of the injectable.
///
@@ -20,17 +21,15 @@ where
/// Will return `Err` if resolving the dependencies fails.
fn resolve(
di_container: &Rc<DIContainerType>,
- dependency_history: DependencyHistoryType,
+ dependency_history: DependencyHistory,
) -> Result<TransientPtr<Self>, InjectableError>
where
Self: Sized;
}
-impl<DIContainerType, DependencyHistoryType> Debug
- for dyn Injectable<DIContainerType, DependencyHistoryType>
+impl<DIContainerType> Debug for dyn Injectable<DIContainerType>
where
- DIContainerType: IDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory,
+ DIContainerType: IDIContainer,
{
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result
{
diff --git a/src/lib.rs b/src/lib.rs
index 4807f61..40bf6e6 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -112,6 +112,7 @@ pub use syrette_macros::{declare_interface, injectable, named};
pub mod private;
mod provider;
+mod util;
#[cfg(test)]
#[cfg(not(tarpaulin_include))]
diff --git a/src/provider/async.rs b/src/provider/async.rs
index da42c7b..38600c9 100644
--- a/src/provider/async.rs
+++ b/src/provider/async.rs
@@ -3,24 +3,21 @@ use std::sync::Arc;
use async_trait::async_trait;
-use crate::dependency_history::IDependencyHistory;
use crate::di_container::asynchronous::IAsyncDIContainer;
use crate::errors::injectable::InjectableError;
use crate::interfaces::async_injectable::AsyncInjectable;
use crate::ptr::{ThreadsafeSingletonPtr, TransientPtr};
+use crate::util::use_dependency_history;
+
+use_dependency_history!();
#[derive(strum_macros::Display, Debug)]
-pub enum AsyncProvidable<DIContainerType, DependencyHistoryType>
+pub enum AsyncProvidable<DIContainerType>
where
- DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory + Send + Sync,
+ DIContainerType: IAsyncDIContainer,
{
- Transient(TransientPtr<dyn AsyncInjectable<DIContainerType, DependencyHistoryType>>),
- Singleton(
- ThreadsafeSingletonPtr<
- dyn AsyncInjectable<DIContainerType, DependencyHistoryType>,
- >,
- ),
+ Transient(TransientPtr<dyn AsyncInjectable<DIContainerType>>),
+ Singleton(ThreadsafeSingletonPtr<dyn AsyncInjectable<DIContainerType>>),
#[cfg(feature = "factory")]
Factory(
crate::ptr::ThreadsafeFactoryPtr<
@@ -43,26 +40,22 @@ where
#[async_trait]
#[cfg_attr(test, mockall::automock, allow(dead_code))]
-pub trait IAsyncProvider<DIContainerType, DependencyHistoryType>: Send + Sync
+pub trait IAsyncProvider<DIContainerType>: Send + Sync
where
- DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory + Send + Sync,
+ DIContainerType: IAsyncDIContainer,
{
async fn provide(
&self,
di_container: &Arc<DIContainerType>,
- dependency_history: DependencyHistoryType,
- ) -> Result<AsyncProvidable<DIContainerType, DependencyHistoryType>, InjectableError>;
+ dependency_history: DependencyHistory,
+ ) -> Result<AsyncProvidable<DIContainerType>, InjectableError>;
- fn do_clone(&self)
- -> Box<dyn IAsyncProvider<DIContainerType, DependencyHistoryType>>;
+ fn do_clone(&self) -> Box<dyn IAsyncProvider<DIContainerType>>;
}
-impl<DIContainerType, DependencyHistoryType> Clone
- for Box<dyn IAsyncProvider<DIContainerType, DependencyHistoryType>>
+impl<DIContainerType> Clone for Box<dyn IAsyncProvider<DIContainerType>>
where
- DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory + Send + Sync,
+ DIContainerType: IAsyncDIContainer,
{
fn clone(&self) -> Self
{
@@ -70,148 +63,127 @@ where
}
}
-pub struct AsyncTransientTypeProvider<
- InjectableType,
- DIContainerType,
- DependencyHistoryType,
-> where
- InjectableType: AsyncInjectable<DIContainerType, DependencyHistoryType>,
- DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory + Send + Sync,
+pub struct AsyncTransientTypeProvider<InjectableType, DIContainerType>
+where
+ InjectableType: AsyncInjectable<DIContainerType>,
+ DIContainerType: IAsyncDIContainer,
{
injectable_phantom: PhantomData<InjectableType>,
di_container_phantom: PhantomData<DIContainerType>,
- dependency_history_phantom: PhantomData<DependencyHistoryType>,
}
-impl<InjectableType, DIContainerType, DependencyHistoryType>
- AsyncTransientTypeProvider<InjectableType, DIContainerType, DependencyHistoryType>
+impl<InjectableType, DIContainerType>
+ AsyncTransientTypeProvider<InjectableType, DIContainerType>
where
- InjectableType: AsyncInjectable<DIContainerType, DependencyHistoryType>,
- DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory + Send + Sync,
+ InjectableType: AsyncInjectable<DIContainerType>,
+ DIContainerType: IAsyncDIContainer,
{
pub fn new() -> Self
{
Self {
injectable_phantom: PhantomData,
di_container_phantom: PhantomData,
- dependency_history_phantom: PhantomData,
}
}
}
#[async_trait]
-impl<InjectableType, DIContainerType, DependencyHistoryType>
- IAsyncProvider<DIContainerType, DependencyHistoryType>
- for AsyncTransientTypeProvider<InjectableType, DIContainerType, DependencyHistoryType>
+impl<InjectableType, DIContainerType> IAsyncProvider<DIContainerType>
+ for AsyncTransientTypeProvider<InjectableType, DIContainerType>
where
- InjectableType: AsyncInjectable<DIContainerType, DependencyHistoryType>,
- DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory + Send + Sync + 'static,
+ InjectableType: AsyncInjectable<DIContainerType>,
+ DIContainerType: IAsyncDIContainer,
{
async fn provide(
&self,
di_container: &Arc<DIContainerType>,
- dependency_history: DependencyHistoryType,
- ) -> Result<AsyncProvidable<DIContainerType, DependencyHistoryType>, InjectableError>
+ dependency_history: DependencyHistory,
+ ) -> Result<AsyncProvidable<DIContainerType>, InjectableError>
{
Ok(AsyncProvidable::Transient(
InjectableType::resolve(di_container, dependency_history).await?,
))
}
- fn do_clone(&self)
- -> Box<dyn IAsyncProvider<DIContainerType, DependencyHistoryType>>
+ fn do_clone(&self) -> Box<dyn IAsyncProvider<DIContainerType>>
{
Box::new(self.clone())
}
}
-impl<InjectableType, DIContainerType, DependencyHistoryType> Clone
- for AsyncTransientTypeProvider<InjectableType, DIContainerType, DependencyHistoryType>
+impl<InjectableType, DIContainerType> Clone
+ for AsyncTransientTypeProvider<InjectableType, DIContainerType>
where
- InjectableType: AsyncInjectable<DIContainerType, DependencyHistoryType>,
- DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory + Send + Sync,
+ InjectableType: AsyncInjectable<DIContainerType>,
+ DIContainerType: IAsyncDIContainer,
{
fn clone(&self) -> Self
{
Self {
injectable_phantom: self.injectable_phantom,
di_container_phantom: PhantomData,
- dependency_history_phantom: PhantomData,
}
}
}
-pub struct AsyncSingletonProvider<InjectableType, DIContainerType, DependencyHistoryType>
+pub struct AsyncSingletonProvider<InjectableType, DIContainerType>
where
- InjectableType: AsyncInjectable<DIContainerType, DependencyHistoryType>,
- DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory + Send + Sync,
+ InjectableType: AsyncInjectable<DIContainerType>,
+ DIContainerType: IAsyncDIContainer,
{
singleton: ThreadsafeSingletonPtr<InjectableType>,
di_container_phantom: PhantomData<DIContainerType>,
- dependency_history_phantom: PhantomData<DependencyHistoryType>,
}
-impl<InjectableType, DIContainerType, DependencyHistoryType>
- AsyncSingletonProvider<InjectableType, DIContainerType, DependencyHistoryType>
+impl<InjectableType, DIContainerType>
+ AsyncSingletonProvider<InjectableType, DIContainerType>
where
- InjectableType: AsyncInjectable<DIContainerType, DependencyHistoryType>,
- DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory + Send + Sync,
+ InjectableType: AsyncInjectable<DIContainerType>,
+ DIContainerType: IAsyncDIContainer,
{
pub fn new(singleton: ThreadsafeSingletonPtr<InjectableType>) -> Self
{
Self {
singleton,
di_container_phantom: PhantomData,
- dependency_history_phantom: PhantomData,
}
}
}
#[async_trait]
-impl<InjectableType, DIContainerType, DependencyHistoryType>
- IAsyncProvider<DIContainerType, DependencyHistoryType>
- for AsyncSingletonProvider<InjectableType, DIContainerType, DependencyHistoryType>
+impl<InjectableType, DIContainerType> IAsyncProvider<DIContainerType>
+ for AsyncSingletonProvider<InjectableType, DIContainerType>
where
- InjectableType: AsyncInjectable<DIContainerType, DependencyHistoryType>,
- DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory + Send + Sync + 'static,
+ InjectableType: AsyncInjectable<DIContainerType>,
+ DIContainerType: IAsyncDIContainer,
{
async fn provide(
&self,
_di_container: &Arc<DIContainerType>,
- _dependency_history: DependencyHistoryType,
- ) -> Result<AsyncProvidable<DIContainerType, DependencyHistoryType>, InjectableError>
+ _dependency_history: DependencyHistory,
+ ) -> Result<AsyncProvidable<DIContainerType>, InjectableError>
{
Ok(AsyncProvidable::Singleton(self.singleton.clone()))
}
- fn do_clone(&self)
- -> Box<dyn IAsyncProvider<DIContainerType, DependencyHistoryType>>
+ fn do_clone(&self) -> Box<dyn IAsyncProvider<DIContainerType>>
{
Box::new(self.clone())
}
}
-impl<InjectableType, DIContainerType, DependencyHistoryType> Clone
- for AsyncSingletonProvider<InjectableType, DIContainerType, DependencyHistoryType>
+impl<InjectableType, DIContainerType> Clone
+ for AsyncSingletonProvider<InjectableType, DIContainerType>
where
- InjectableType: AsyncInjectable<DIContainerType, DependencyHistoryType>,
- DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory + Send + Sync,
+ InjectableType: AsyncInjectable<DIContainerType>,
+ DIContainerType: IAsyncDIContainer,
{
fn clone(&self) -> Self
{
Self {
singleton: self.singleton.clone(),
di_container_phantom: PhantomData,
- dependency_history_phantom: PhantomData,
}
}
}
@@ -249,17 +221,15 @@ impl AsyncFactoryProvider
#[cfg(feature = "factory")]
#[async_trait]
-impl<DIContainerType, DependencyHistoryType>
- IAsyncProvider<DIContainerType, DependencyHistoryType> for AsyncFactoryProvider
+impl<DIContainerType> IAsyncProvider<DIContainerType> for AsyncFactoryProvider
where
- DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory + Send + Sync + 'static,
+ DIContainerType: IAsyncDIContainer,
{
async fn provide(
&self,
_di_container: &Arc<DIContainerType>,
- _dependency_history: DependencyHistoryType,
- ) -> Result<AsyncProvidable<DIContainerType, DependencyHistoryType>, InjectableError>
+ _dependency_history: DependencyHistory,
+ ) -> Result<AsyncProvidable<DIContainerType>, InjectableError>
{
Ok(match self.variant {
AsyncFactoryVariant::Normal => AsyncProvidable::Factory(self.factory.clone()),
@@ -272,8 +242,7 @@ where
})
}
- fn do_clone(&self)
- -> Box<dyn IAsyncProvider<DIContainerType, DependencyHistoryType>>
+ fn do_clone(&self) -> Box<dyn IAsyncProvider<DIContainerType>>
{
Box::new(self.clone())
}
@@ -297,7 +266,7 @@ mod tests
use std::error::Error;
use super::*;
- use crate::test_utils::mocks::MockDependencyHistory;
+ use crate::dependency_history::MockDependencyHistory;
use crate::test_utils::{mocks, subjects_async};
#[tokio::test]
@@ -305,8 +274,7 @@ mod tests
{
let transient_type_provider = AsyncTransientTypeProvider::<
subjects_async::UserManager,
- mocks::async_di_container::MockAsyncDIContainer<mocks::MockDependencyHistory>,
- mocks::MockDependencyHistory,
+ mocks::async_di_container::MockAsyncDIContainer,
>::new();
let di_container = mocks::async_di_container::MockAsyncDIContainer::new();
@@ -329,8 +297,7 @@ mod tests
{
let singleton_provider = AsyncSingletonProvider::<
subjects_async::UserManager,
- mocks::async_di_container::MockAsyncDIContainer<mocks::MockDependencyHistory>,
- mocks::MockDependencyHistory,
+ mocks::async_di_container::MockAsyncDIContainer,
>::new(ThreadsafeSingletonPtr::new(
subjects_async::UserManager {},
));
@@ -383,7 +350,7 @@ mod tests
assert!(
matches!(
factory_provider
- .provide(&di_container, mocks::MockDependencyHistory::new())
+ .provide(&di_container, MockDependencyHistory::new())
.await?,
AsyncProvidable::Factory(_)
),
diff --git a/src/provider/blocking.rs b/src/provider/blocking.rs
index ea506ab..a18e997 100644
--- a/src/provider/blocking.rs
+++ b/src/provider/blocking.rs
@@ -1,20 +1,21 @@
use std::marker::PhantomData;
use std::rc::Rc;
-use crate::dependency_history::IDependencyHistory;
use crate::di_container::blocking::IDIContainer;
use crate::errors::injectable::InjectableError;
use crate::interfaces::injectable::Injectable;
use crate::ptr::{SingletonPtr, TransientPtr};
+use crate::util::use_dependency_history;
+
+use_dependency_history!();
#[derive(strum_macros::Display, Debug)]
-pub enum Providable<DIContainerType, DependencyHistoryType>
+pub enum Providable<DIContainerType>
where
- DIContainerType: IDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory,
+ DIContainerType: IDIContainer,
{
- Transient(TransientPtr<dyn Injectable<DIContainerType, DependencyHistoryType>>),
- Singleton(SingletonPtr<dyn Injectable<DIContainerType, DependencyHistoryType>>),
+ Transient(TransientPtr<dyn Injectable<DIContainerType>>),
+ Singleton(SingletonPtr<dyn Injectable<DIContainerType>>),
#[cfg(feature = "factory")]
Factory(crate::ptr::FactoryPtr<dyn crate::private::any_factory::AnyFactory>),
#[cfg(feature = "factory")]
@@ -22,35 +23,32 @@ where
}
#[cfg_attr(test, mockall::automock, allow(dead_code))]
-pub trait IProvider<DIContainerType, DependencyHistoryType>
+pub trait IProvider<DIContainerType>
where
- DIContainerType: IDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory,
+ DIContainerType: IDIContainer,
{
fn provide(
&self,
di_container: &Rc<DIContainerType>,
- dependency_history: DependencyHistoryType,
- ) -> Result<Providable<DIContainerType, DependencyHistoryType>, InjectableError>;
+ dependency_history: DependencyHistory,
+ ) -> Result<Providable<DIContainerType>, InjectableError>;
}
-pub struct TransientTypeProvider<InjectableType, DIContainerType, DependencyHistoryType>
+pub struct TransientTypeProvider<InjectableType, DIContainerType>
where
- InjectableType: Injectable<DIContainerType, DependencyHistoryType>,
- DIContainerType: IDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory,
+ InjectableType: Injectable<DIContainerType>,
+ DIContainerType: IDIContainer,
{
injectable_phantom: PhantomData<InjectableType>,
di_container_phantom: PhantomData<DIContainerType>,
- dependency_history_phantom: PhantomData<DependencyHistoryType>,
+ dependency_history_phantom: PhantomData<DependencyHistory>,
}
-impl<InjectableType, DIContainerType, DependencyHistoryType>
- TransientTypeProvider<InjectableType, DIContainerType, DependencyHistoryType>
+impl<InjectableType, DIContainerType>
+ TransientTypeProvider<InjectableType, DIContainerType>
where
- InjectableType: Injectable<DIContainerType, DependencyHistoryType>,
- DIContainerType: IDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory,
+ InjectableType: Injectable<DIContainerType>,
+ DIContainerType: IDIContainer,
{
pub fn new() -> Self
{
@@ -62,19 +60,17 @@ where
}
}
-impl<InjectableType, DIContainerType, DependencyHistoryType>
- IProvider<DIContainerType, DependencyHistoryType>
- for TransientTypeProvider<InjectableType, DIContainerType, DependencyHistoryType>
+impl<InjectableType, DIContainerType> IProvider<DIContainerType>
+ for TransientTypeProvider<InjectableType, DIContainerType>
where
- InjectableType: Injectable<DIContainerType, DependencyHistoryType>,
- DIContainerType: IDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory,
+ InjectableType: Injectable<DIContainerType>,
+ DIContainerType: IDIContainer,
{
fn provide(
&self,
di_container: &Rc<DIContainerType>,
- dependency_history: DependencyHistoryType,
- ) -> Result<Providable<DIContainerType, DependencyHistoryType>, InjectableError>
+ dependency_history: DependencyHistory,
+ ) -> Result<Providable<DIContainerType>, InjectableError>
{
Ok(Providable::Transient(InjectableType::resolve(
di_container,
@@ -83,24 +79,21 @@ where
}
}
-pub struct SingletonProvider<InjectableType, DIContainerType, DependencyHistoryType>
+pub struct SingletonProvider<InjectableType, DIContainerType>
where
- InjectableType: Injectable<DIContainerType, DependencyHistoryType>,
- DIContainerType: IDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory,
+ InjectableType: Injectable<DIContainerType>,
+ DIContainerType: IDIContainer,
{
singleton: SingletonPtr<InjectableType>,
di_container_phantom: PhantomData<DIContainerType>,
- dependency_history_phantom: PhantomData<DependencyHistoryType>,
+ dependency_history_phantom: PhantomData<DependencyHistory>,
}
-impl<InjectableType, DIContainerType, DependencyHistoryType>
- SingletonProvider<InjectableType, DIContainerType, DependencyHistoryType>
+impl<InjectableType, DIContainerType> SingletonProvider<InjectableType, DIContainerType>
where
- InjectableType: Injectable<DIContainerType, DependencyHistoryType>,
- DIContainerType: IDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory,
+ InjectableType: Injectable<DIContainerType>,
+ DIContainerType: IDIContainer,
{
pub fn new(singleton: SingletonPtr<InjectableType>) -> Self
{
@@ -112,19 +105,17 @@ where
}
}
-impl<InjectableType, DIContainerType, DependencyHistoryType>
- IProvider<DIContainerType, DependencyHistoryType>
- for SingletonProvider<InjectableType, DIContainerType, DependencyHistoryType>
+impl<InjectableType, DIContainerType> IProvider<DIContainerType>
+ for SingletonProvider<InjectableType, DIContainerType>
where
- InjectableType: Injectable<DIContainerType, DependencyHistoryType>,
- DIContainerType: IDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory,
+ InjectableType: Injectable<DIContainerType>,
+ DIContainerType: IDIContainer,
{
fn provide(
&self,
_di_container: &Rc<DIContainerType>,
- _dependency_history: DependencyHistoryType,
- ) -> Result<Providable<DIContainerType, DependencyHistoryType>, InjectableError>
+ _dependency_history: DependencyHistory,
+ ) -> Result<Providable<DIContainerType>, InjectableError>
{
Ok(Providable::Singleton(self.singleton.clone()))
}
@@ -153,17 +144,15 @@ impl FactoryProvider
}
#[cfg(feature = "factory")]
-impl<DIContainerType, DependencyHistoryType>
- IProvider<DIContainerType, DependencyHistoryType> for FactoryProvider
+impl<DIContainerType> IProvider<DIContainerType> for FactoryProvider
where
- DIContainerType: IDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory,
+ DIContainerType: IDIContainer,
{
fn provide(
&self,
_di_container: &Rc<DIContainerType>,
- _dependency_history: DependencyHistoryType,
- ) -> Result<Providable<DIContainerType, DependencyHistoryType>, InjectableError>
+ _dependency_history: DependencyHistory,
+ ) -> Result<Providable<DIContainerType>, InjectableError>
{
Ok(if self.is_default_factory {
Providable::DefaultFactory(self.factory.clone())
@@ -179,6 +168,7 @@ mod tests
use std::error::Error;
use super::*;
+ use crate::dependency_history::MockDependencyHistory;
use crate::test_utils::{mocks, subjects};
#[test]
@@ -186,13 +176,12 @@ mod tests
{
let transient_type_provider = TransientTypeProvider::<
subjects::UserManager,
- mocks::blocking_di_container::MockDIContainer<mocks::MockDependencyHistory>,
- mocks::MockDependencyHistory,
+ mocks::blocking_di_container::MockDIContainer,
>::new();
let di_container = mocks::blocking_di_container::MockDIContainer::new();
- let dependency_history_mock = mocks::MockDependencyHistory::new();
+ let dependency_history_mock = MockDependencyHistory::new();
assert!(
matches!(
@@ -209,22 +198,18 @@ mod tests
#[test]
fn singleton_provider_works() -> Result<(), Box<dyn Error>>
{
- let singleton_provider = SingletonProvider::<
- subjects::UserManager,
- mocks::blocking_di_container::MockDIContainer<mocks::MockDependencyHistory>,
- mocks::MockDependencyHistory,
- >::new(SingletonPtr::new(
- subjects::UserManager {},
- ));
+ let singleton_provider =
+ SingletonProvider::<
+ subjects::UserManager,
+ mocks::blocking_di_container::MockDIContainer,
+ >::new(SingletonPtr::new(subjects::UserManager {}));
let di_container = mocks::blocking_di_container::MockDIContainer::new();
assert!(
matches!(
- singleton_provider.provide(
- &Rc::new(di_container),
- mocks::MockDependencyHistory::new()
- )?,
+ singleton_provider
+ .provide(&Rc::new(di_container), MockDependencyHistory::new())?,
Providable::Singleton(_)
),
"The provided type is not a singleton"
@@ -253,8 +238,7 @@ mod tests
assert!(
matches!(
- factory_provider
- .provide(&di_container, mocks::MockDependencyHistory::new())?,
+ factory_provider.provide(&di_container, MockDependencyHistory::new())?,
Providable::Factory(_)
),
"The provided type is not a factory"
@@ -263,7 +247,7 @@ mod tests
assert!(
matches!(
default_factory_provider
- .provide(&di_container, mocks::MockDependencyHistory::new())?,
+ .provide(&di_container, MockDependencyHistory::new())?,
Providable::DefaultFactory(_)
),
"The provided type is not a default factory"
diff --git a/src/test_utils.rs b/src/test_utils.rs
index 78ad63b..2bc1671 100644
--- a/src/test_utils.rs
+++ b/src/test_utils.rs
@@ -7,12 +7,13 @@ pub mod subjects
use syrette_macros::declare_interface;
- use crate::dependency_history::IDependencyHistory;
use crate::di_container::blocking::IDIContainer;
use crate::interfaces::injectable::Injectable;
use crate::private::cast::CastFromArc;
use crate::ptr::TransientPtr;
+ use_dependency_history!();
+
pub trait IUserManager
{
fn add_user(&self, user_id: i128);
@@ -44,18 +45,17 @@ pub mod subjects
}
use crate as syrette;
+ use crate::util::use_dependency_history;
declare_interface!(UserManager -> IUserManager);
- impl<DIContainerType, DependencyHistoryType>
- Injectable<DIContainerType, DependencyHistoryType> for UserManager
+ impl<DIContainerType> Injectable<DIContainerType> for UserManager
where
- DIContainerType: IDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory,
+ DIContainerType: IDIContainer,
{
fn resolve(
_di_container: &Rc<DIContainerType>,
- _dependency_history: DependencyHistoryType,
+ _dependency_history: DependencyHistory,
) -> Result<TransientPtr<Self>, crate::errors::injectable::InjectableError>
where
Self: Sized,
@@ -115,15 +115,13 @@ pub mod subjects
declare_interface!(Number -> INumber);
- impl<DIContainerType, DependencyHistoryType>
- Injectable<DIContainerType, DependencyHistoryType> for Number
+ impl<DIContainerType> Injectable<DIContainerType> for Number
where
- DIContainerType: IDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory,
+ DIContainerType: IDIContainer,
{
fn resolve(
_di_container: &Rc<DIContainerType>,
- _dependency_history: DependencyHistoryType,
+ _dependency_history: DependencyHistory,
) -> Result<TransientPtr<Self>, crate::errors::injectable::InjectableError>
where
Self: Sized,
@@ -151,11 +149,12 @@ pub mod subjects_async
use async_trait::async_trait;
use syrette_macros::declare_interface;
- use crate::dependency_history::IDependencyHistory;
use crate::di_container::asynchronous::IAsyncDIContainer;
use crate::interfaces::async_injectable::AsyncInjectable;
use crate::ptr::TransientPtr;
+ use_dependency_history!();
+
pub trait IUserManager: Send + Sync
{
fn add_user(&self, user_id: i128);
@@ -187,19 +186,18 @@ pub mod subjects_async
}
use crate as syrette;
+ use crate::util::use_dependency_history;
declare_interface!(UserManager -> IUserManager);
#[async_trait]
- impl<DIContainerType, DependencyHistoryType>
- AsyncInjectable<DIContainerType, DependencyHistoryType> for UserManager
+ impl<DIContainerType> AsyncInjectable<DIContainerType> for UserManager
where
- DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory + Send + Sync + 'static,
+ DIContainerType: IAsyncDIContainer,
{
async fn resolve(
_: &Arc<DIContainerType>,
- _dependency_history: DependencyHistoryType,
+ _dependency_history: DependencyHistory,
) -> Result<TransientPtr<Self>, crate::errors::injectable::InjectableError>
where
Self: Sized,
@@ -260,15 +258,13 @@ pub mod subjects_async
declare_interface!(Number -> INumber, threadsafe_sharable = true);
#[async_trait]
- impl<DIContainerType, DependencyHistoryType>
- AsyncInjectable<DIContainerType, DependencyHistoryType> for Number
+ impl<DIContainerType> AsyncInjectable<DIContainerType> for Number
where
- DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory + Send + Sync + 'static,
+ DIContainerType: IAsyncDIContainer,
{
async fn resolve(
_: &Arc<DIContainerType>,
- _dependency_history: DependencyHistoryType,
+ _dependency_history: DependencyHistory,
) -> Result<TransientPtr<Self>, crate::errors::injectable::InjectableError>
where
Self: Sized,
@@ -290,27 +286,22 @@ pub mod mocks
use std::rc::Rc;
use super::*;
- use crate::dependency_history::IDependencyHistory;
use crate::di_container::blocking::binding::builder::BindingBuilder;
use crate::di_container::blocking::details::DIContainerInternals;
use crate::di_container::blocking::IDIContainer;
use crate::errors::di_container::DIContainerError;
use crate::provider::blocking::IProvider;
use crate::ptr::SomePtr;
+ use crate::util::use_dependency_history;
+
+ use_dependency_history!();
mock! {
- pub DIContainer<DependencyHistoryType>
- where
- DependencyHistoryType: IDependencyHistory + 'static
- {}
+ pub DIContainer {}
- impl<DependencyHistoryType> IDIContainer<DependencyHistoryType> for
- DIContainer<DependencyHistoryType>
- where
- DependencyHistoryType: IDependencyHistory + 'static
+ impl IDIContainer for DIContainer
{
- fn bind<Interface>(self: &mut Rc<Self>) ->
- BindingBuilder<Interface, Self, DependencyHistoryType>
+ fn bind<Interface>(self: &mut Rc<Self>) -> BindingBuilder<Interface, Self>
where
Interface: 'static + ?Sized;
@@ -328,18 +319,14 @@ pub mod mocks
#[doc(hidden)]
fn get_bound<Interface>(
self: &Rc<Self>,
- dependency_history: DependencyHistoryType,
+ dependency_history: DependencyHistory,
name: Option<&'static str>,
) -> Result<SomePtr<Interface>, DIContainerError>
where
Interface: 'static + ?Sized;
}
- impl<DependencyHistoryType> DIContainerInternals<
- DependencyHistoryType
- > for DIContainer<DependencyHistoryType>
- where
- DependencyHistoryType: IDependencyHistory
+ impl DIContainerInternals for DIContainer
{
fn has_binding<Interface>(self: &Rc<Self>, name: Option<&'static str>) -> bool
where
@@ -349,14 +336,14 @@ pub mod mocks
fn set_binding<Interface>(
self: &Rc<Self>,
name: Option<&'static str>,
- provider: Box<dyn IProvider<Self, DependencyHistoryType>>,
+ provider: Box<dyn IProvider<Self>>,
) where
Interface: 'static + ?Sized;
fn remove_binding<Interface>(
self: &Rc<Self>,
name: Option<&'static str>,
- ) -> Option<Box<dyn IProvider<Self, DependencyHistoryType>>>
+ ) -> Option<Box<dyn IProvider<Self>>>
where
Interface: 'static + ?Sized;
}
@@ -369,29 +356,24 @@ pub mod mocks
use std::sync::Arc;
use super::*;
- use crate::dependency_history::IDependencyHistory;
use crate::di_container::asynchronous::binding::builder::AsyncBindingBuilder;
use crate::di_container::asynchronous::details::DIContainerInternals;
use crate::di_container::asynchronous::IAsyncDIContainer;
use crate::errors::async_di_container::AsyncDIContainerError;
use crate::provider::r#async::IAsyncProvider;
use crate::ptr::SomePtr;
+ use crate::util::use_dependency_history;
+
+ use_dependency_history!();
mock! {
- pub AsyncDIContainer<DependencyHistoryType>
- where
- DependencyHistoryType: IDependencyHistory + 'static + Send + Sync
- {}
+ pub AsyncDIContainer {}
#[async_trait::async_trait]
- impl<DependencyHistoryType> IAsyncDIContainer<
- DependencyHistoryType
- > for AsyncDIContainer<DependencyHistoryType>
- where
- DependencyHistoryType: IDependencyHistory + 'static + Send + Sync
+ impl IAsyncDIContainer for AsyncDIContainer
{
fn bind<Interface>(self: &mut Arc<Self>) ->
- AsyncBindingBuilder<Interface, Self, DependencyHistoryType>
+ AsyncBindingBuilder<Interface, Self>
where
Interface: 'static + ?Sized + Send + Sync;
@@ -411,7 +393,7 @@ pub mod mocks
#[doc(hidden)]
async fn get_bound<Interface>(
self: &Arc<Self>,
- dependency_history: DependencyHistoryType,
+ dependency_history: DependencyHistory,
name: Option<&'static str>,
) -> Result<SomePtr<Interface>, AsyncDIContainerError>
where
@@ -419,11 +401,7 @@ pub mod mocks
}
#[async_trait::async_trait]
- impl<DependencyHistoryType> DIContainerInternals<
- DependencyHistoryType
- > for AsyncDIContainer<DependencyHistoryType>
- where
- DependencyHistoryType: IDependencyHistory + 'static + Send + Sync
+ impl DIContainerInternals for AsyncDIContainer
{
async fn has_binding<Interface>(
self: &Arc<Self>,
@@ -435,14 +413,14 @@ pub mod mocks
async fn set_binding<Interface>(
self: &Arc<Self>,
name: Option<&'static str>,
- provider: Box<dyn IAsyncProvider<Self, DependencyHistoryType>>,
+ provider: Box<dyn IAsyncProvider<Self>>,
) where
Interface: 'static + ?Sized;
async fn remove_binding<Interface>(
self: &Arc<Self>,
name: Option<&'static str>,
- ) -> Option<Box<dyn IAsyncProvider<Self, DependencyHistoryType>>>
+ ) -> Option<Box<dyn IAsyncProvider<Self>>>
where
Interface: 'static + ?Sized;
}
@@ -457,34 +435,31 @@ pub mod mocks
use async_trait::async_trait;
use super::*;
- use crate::dependency_history::IDependencyHistory;
use crate::di_container::asynchronous::IAsyncDIContainer;
use crate::errors::injectable::InjectableError;
use crate::provider::r#async::{AsyncProvidable, IAsyncProvider};
+ use crate::util::use_dependency_history;
+
+ use_dependency_history!();
mock! {
- pub AsyncProvider<
- DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory + Send + Sync
- > {}
+ pub AsyncProvider<DIContainerType: IAsyncDIContainer> {}
#[async_trait]
impl<
- DIContainerType: IAsyncDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory + Send + Sync
- > IAsyncProvider<DIContainerType, DependencyHistoryType> for AsyncProvider<
+ DIContainerType: IAsyncDIContainer,
+ > IAsyncProvider<DIContainerType> for AsyncProvider<
DIContainerType,
- DependencyHistoryType
>
{
async fn provide(
&self,
di_container: &Arc<DIContainerType>,
- dependency_history: DependencyHistoryType
- ) -> Result<AsyncProvidable<DIContainerType, DependencyHistoryType>, InjectableError>;
+ dependency_history: DependencyHistory
+ ) -> Result<AsyncProvidable<DIContainerType>, InjectableError>;
fn do_clone(&self) ->
- Box<dyn IAsyncProvider<DIContainerType, DependencyHistoryType>>;
+ Box<dyn IAsyncProvider<DIContainerType>>;
}
}
}
@@ -494,47 +469,31 @@ pub mod mocks
use std::rc::Rc;
use super::*;
- use crate::dependency_history::IDependencyHistory;
use crate::di_container::blocking::IDIContainer;
use crate::errors::injectable::InjectableError;
use crate::provider::blocking::{IProvider, Providable};
+ use crate::util::use_dependency_history;
+
+ use_dependency_history!();
mock! {
- pub Provider<DIContainerType, DependencyHistoryType>
+ pub Provider<DIContainerType>
where
- DIContainerType: IDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory,
+ DIContainerType: IDIContainer
{}
- impl<DIContainerType, DependencyHistoryType> IProvider<
- DIContainerType,
- DependencyHistoryType
- > for Provider<DIContainerType, DependencyHistoryType>
- where
- DIContainerType: IDIContainer<DependencyHistoryType>,
- DependencyHistoryType: IDependencyHistory
+ impl<DIContainerType> IProvider<DIContainerType> for Provider<DIContainerType>
+ where
+ DIContainerType: IDIContainer,
{
fn provide(
&self,
di_container: &Rc<DIContainerType>,
- dependency_history: DependencyHistoryType,
- ) -> Result<Providable<DIContainerType, DependencyHistoryType>, InjectableError>;
+ dependency_history: DependencyHistory,
+ ) -> Result<Providable<DIContainerType>, InjectableError>;
}
}
}
-
- mock! {
- pub DependencyHistory {}
-
- impl crate::dependency_history::IDependencyHistory for DependencyHistory
- {
- fn push<Dependency: 'static + ?Sized>(&mut self);
-
- fn contains<Dependency: 'static + ?Sized>(&self) -> bool;
- }
-
- impl crate::dependency_history::private::Sealed for DependencyHistory {}
- }
}
#[cfg(feature = "async")]
diff --git a/src/util.rs b/src/util.rs
new file mode 100644
index 0000000..2d2d911
--- /dev/null
+++ b/src/util.rs
@@ -0,0 +1,15 @@
+#[cfg(not(test))]
+macro_rules! use_dependency_history {
+ () => {
+ use $crate::dependency_history::DependencyHistory;
+ };
+}
+
+#[cfg(test)]
+macro_rules! use_dependency_history {
+ () => {
+ use $crate::dependency_history::MockDependencyHistory as DependencyHistory;
+ };
+}
+
+pub(crate) use use_dependency_history;
generated by cgit v1.2.3-18-g5258 (git 2.32.0) at 2024-11-01 07:21:01 +0000