1 files changed, 42 insertions, 94 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"
+            )
         );
     }
 }