aboutsummaryrefslogtreecommitdiff
path: root/src/provider
diff options
context:
space:
mode:
Diffstat (limited to 'src/provider')
-rw-r--r--src/provider/async.rs136
-rw-r--r--src/provider/blocking.rs74
-rw-r--r--src/provider/mod.rs4
3 files changed, 75 insertions, 139 deletions
diff --git a/src/provider/async.rs b/src/provider/async.rs
index 68eed87..787ef06 100644
--- a/src/provider/async.rs
+++ b/src/provider/async.rs
@@ -1,7 +1,9 @@
use std::marker::PhantomData;
+use std::sync::Arc;
use async_trait::async_trait;
+use crate::castable_function::threadsafe::AnyThreadsafeCastableFunction;
use crate::errors::injectable::InjectableError;
use crate::interfaces::async_injectable::AsyncInjectable;
use crate::ptr::{ThreadsafeSingletonPtr, TransientPtr};
@@ -14,24 +16,19 @@ pub enum AsyncProvidable<DIContainerT>
{
Transient(TransientPtr<dyn AsyncInjectable<DIContainerT>>),
Singleton(ThreadsafeSingletonPtr<dyn AsyncInjectable<DIContainerT>>),
- #[cfg(feature = "factory")]
- Factory(
- crate::ptr::ThreadsafeFactoryPtr<
- dyn crate::castable_function::threadsafe::AnyThreadsafeCastableFunction,
- >,
- ),
- #[cfg(feature = "factory")]
- DefaultFactory(
- crate::ptr::ThreadsafeFactoryPtr<
- dyn crate::castable_function::threadsafe::AnyThreadsafeCastableFunction,
- >,
+ Function(
+ Arc<dyn crate::castable_function::threadsafe::AnyThreadsafeCastableFunction>,
+ ProvidableFunctionKind,
),
+}
+
+#[derive(Debug, Clone, Copy)]
+pub enum ProvidableFunctionKind
+{
#[cfg(feature = "factory")]
- AsyncDefaultFactory(
- crate::ptr::ThreadsafeFactoryPtr<
- dyn crate::castable_function::threadsafe::AnyThreadsafeCastableFunction,
- >,
- ),
+ UserCalled,
+ Instant,
+ AsyncInstant,
}
#[async_trait]
@@ -176,41 +173,28 @@ where
}
}
-#[cfg(feature = "factory")]
-#[derive(Clone, Copy)]
-pub enum AsyncFactoryVariant
-{
- Normal,
- Default,
- AsyncDefault,
-}
-
-#[cfg(feature = "factory")]
-pub struct AsyncFactoryProvider
+pub struct AsyncFunctionProvider
{
- factory: crate::ptr::ThreadsafeFactoryPtr<
- dyn crate::castable_function::threadsafe::AnyThreadsafeCastableFunction,
- >,
- variant: AsyncFactoryVariant,
+ function: Arc<dyn AnyThreadsafeCastableFunction>,
+ providable_func_kind: ProvidableFunctionKind,
}
-#[cfg(feature = "factory")]
-impl AsyncFactoryProvider
+impl AsyncFunctionProvider
{
pub fn new(
- factory: crate::ptr::ThreadsafeFactoryPtr<
- dyn crate::castable_function::threadsafe::AnyThreadsafeCastableFunction,
- >,
- variant: AsyncFactoryVariant,
+ function: Arc<dyn AnyThreadsafeCastableFunction>,
+ providable_func_kind: ProvidableFunctionKind,
) -> Self
{
- Self { factory, variant }
+ Self {
+ function,
+ providable_func_kind,
+ }
}
}
-#[cfg(feature = "factory")]
#[async_trait]
-impl<DIContainerT> IAsyncProvider<DIContainerT> for AsyncFactoryProvider
+impl<DIContainerT> IAsyncProvider<DIContainerT> for AsyncFunctionProvider
where
DIContainerT: Send + Sync,
{
@@ -220,15 +204,10 @@ where
_dependency_history: DependencyHistory,
) -> Result<AsyncProvidable<DIContainerT>, InjectableError>
{
- Ok(match self.variant {
- AsyncFactoryVariant::Normal => AsyncProvidable::Factory(self.factory.clone()),
- AsyncFactoryVariant::Default => {
- AsyncProvidable::DefaultFactory(self.factory.clone())
- }
- AsyncFactoryVariant::AsyncDefault => {
- AsyncProvidable::AsyncDefaultFactory(self.factory.clone())
- }
- })
+ Ok(AsyncProvidable::Function(
+ self.function.clone(),
+ self.providable_func_kind,
+ ))
}
fn do_clone(&self) -> Box<dyn IAsyncProvider<DIContainerT>>
@@ -237,14 +216,13 @@ where
}
}
-#[cfg(feature = "factory")]
-impl Clone for AsyncFactoryProvider
+impl Clone for AsyncFunctionProvider
{
fn clone(&self) -> Self
{
Self {
- factory: self.factory.clone(),
- variant: self.variant,
+ function: self.function.clone(),
+ providable_func_kind: self.providable_func_kind,
}
}
}
@@ -304,14 +282,13 @@ mod tests
}
#[tokio::test]
- #[cfg(feature = "factory")]
- async fn async_factory_provider_works()
+ async fn function_provider_works()
{
use std::any::Any;
+ use std::sync::Arc;
use crate::castable_function::threadsafe::AnyThreadsafeCastableFunction;
use crate::castable_function::AnyCastableFunction;
- use crate::ptr::ThreadsafeFactoryPtr;
#[derive(Debug)]
struct FooFactory;
@@ -326,54 +303,25 @@ mod tests
impl AnyThreadsafeCastableFunction for FooFactory {}
- let factory_provider = AsyncFactoryProvider::new(
- ThreadsafeFactoryPtr::new(FooFactory),
- AsyncFactoryVariant::Normal,
- );
-
- let default_factory_provider = AsyncFactoryProvider::new(
- ThreadsafeFactoryPtr::new(FooFactory),
- AsyncFactoryVariant::Default,
- );
-
- let async_default_factory_provider = AsyncFactoryProvider::new(
- ThreadsafeFactoryPtr::new(FooFactory),
- AsyncFactoryVariant::AsyncDefault,
+ let instant_func_provider = AsyncFunctionProvider::new(
+ Arc::new(FooFactory),
+ ProvidableFunctionKind::Instant,
);
let di_container = MockAsyncDIContainer::new();
assert!(
matches!(
- factory_provider
- .provide(&di_container, MockDependencyHistory::new())
- .await
- .unwrap(),
- AsyncProvidable::Factory(_)
- ),
- "The provided type is not a factory"
- );
-
- assert!(
- matches!(
- default_factory_provider
- .provide(&di_container, MockDependencyHistory::new())
- .await
- .unwrap(),
- AsyncProvidable::DefaultFactory(_)
- ),
- "The provided type is not a default factory"
- );
-
- assert!(
- matches!(
- async_default_factory_provider
+ instant_func_provider
.provide(&di_container, MockDependencyHistory::new())
.await
.unwrap(),
- AsyncProvidable::AsyncDefaultFactory(_)
+ AsyncProvidable::Function(_, ProvidableFunctionKind::Instant)
),
- "The provided type is not a async default factory"
+ concat!(
+ "The provided type is not a AsyncProvidable::Function of kind ",
+ "ProvidableFunctionKind::Instant"
+ )
);
}
}
diff --git a/src/provider/blocking.rs b/src/provider/blocking.rs
index 6475dc7..6b22ad0 100644
--- a/src/provider/blocking.rs
+++ b/src/provider/blocking.rs
@@ -1,5 +1,7 @@
use std::marker::PhantomData;
+use std::rc::Rc;
+use crate::castable_function::AnyCastableFunction;
use crate::errors::injectable::InjectableError;
use crate::interfaces::injectable::Injectable;
use crate::ptr::{SingletonPtr, TransientPtr};
@@ -12,12 +14,15 @@ pub enum Providable<DIContainerType>
{
Transient(TransientPtr<dyn Injectable<DIContainerType>>),
Singleton(SingletonPtr<dyn Injectable<DIContainerType>>),
+ Function(Rc<dyn AnyCastableFunction>, ProvidableFunctionKind),
+}
+
+#[derive(Debug, Clone, Copy)]
+pub enum ProvidableFunctionKind
+{
#[cfg(feature = "factory")]
- Factory(crate::ptr::FactoryPtr<dyn crate::castable_function::AnyCastableFunction>),
- #[cfg(feature = "factory")]
- DefaultFactory(
- crate::ptr::FactoryPtr<dyn crate::castable_function::AnyCastableFunction>,
- ),
+ UserCalled,
+ Instant,
}
#[cfg_attr(test, mockall::automock)]
@@ -107,32 +112,27 @@ where
}
}
-#[cfg(feature = "factory")]
-pub struct FactoryProvider
+pub struct FunctionProvider
{
- factory: crate::ptr::FactoryPtr<dyn crate::castable_function::AnyCastableFunction>,
- is_default_factory: bool,
+ function: Rc<dyn AnyCastableFunction>,
+ providable_func_kind: ProvidableFunctionKind,
}
-#[cfg(feature = "factory")]
-impl FactoryProvider
+impl FunctionProvider
{
pub fn new(
- factory: crate::ptr::FactoryPtr<
- dyn crate::castable_function::AnyCastableFunction,
- >,
- is_default_factory: bool,
+ function: Rc<dyn AnyCastableFunction>,
+ providable_func_kind: ProvidableFunctionKind,
) -> Self
{
Self {
- factory,
- is_default_factory,
+ function,
+ providable_func_kind,
}
}
}
-#[cfg(feature = "factory")]
-impl<DIContainerType> IProvider<DIContainerType> for FactoryProvider
+impl<DIContainerType> IProvider<DIContainerType> for FunctionProvider
{
fn provide(
&self,
@@ -140,11 +140,10 @@ impl<DIContainerType> IProvider<DIContainerType> for FactoryProvider
_dependency_history: DependencyHistory,
) -> Result<Providable<DIContainerType>, InjectableError>
{
- Ok(if self.is_default_factory {
- Providable::DefaultFactory(self.factory.clone())
- } else {
- Providable::Factory(self.factory.clone())
- })
+ Ok(Providable::Function(
+ self.function.clone(),
+ self.providable_func_kind,
+ ))
}
}
@@ -197,13 +196,12 @@ mod tests
}
#[test]
- #[cfg(feature = "factory")]
- fn factory_provider_works()
+ fn function_provider_works()
{
use std::any::Any;
+ use std::rc::Rc;
use crate::castable_function::AnyCastableFunction;
- use crate::ptr::FactoryPtr;
#[derive(Debug)]
struct FooFactory;
@@ -216,27 +214,21 @@ mod tests
}
}
- let factory_provider = FactoryProvider::new(FactoryPtr::new(FooFactory), false);
- let default_factory_provider =
- FactoryProvider::new(FactoryPtr::new(FooFactory), true);
+ let instant_func_provider =
+ FunctionProvider::new(Rc::new(FooFactory), ProvidableFunctionKind::Instant);
let di_container = MockDIContainer::new();
assert!(
matches!(
- factory_provider.provide(&di_container, MockDependencyHistory::new()),
- Ok(Providable::Factory(_))
- ),
- "The provided type is not a factory"
- );
-
- assert!(
- matches!(
- default_factory_provider
+ instant_func_provider
.provide(&di_container, MockDependencyHistory::new()),
- Ok(Providable::DefaultFactory(_))
+ Ok(Providable::Function(_, ProvidableFunctionKind::Instant))
),
- "The provided type is not a default factory"
+ concat!(
+ "The provided type is not a Providable::Function of kind ",
+ "ProvidableFunctionKind::Instant"
+ )
);
}
}
diff --git a/src/provider/mod.rs b/src/provider/mod.rs
deleted file mode 100644
index 7fb96bb..0000000
--- a/src/provider/mod.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-pub mod blocking;
-
-#[cfg(feature = "async")]
-pub mod r#async;
generated by cgit v1.2.3-18-g5258 (git 2.32.0) at 2024-09-19 22:55:44 +0000