change constructor requirements

Author: robert-andrzejuk

include/beman/scope/scope.hpp

@@ -15,11 +15,10 @@
 #include <version>
 
 #if (!(defined(__cpp_concepts) || !(defined(__cpp_lib_concepts))))
-    static_assert(false, "C++20 Concepts Required");
+static_assert(false, "C++20 Concepts Required");
 #endif
 
 
-
 #include <concepts>
 #include <functional>
 #include <exception>
@@ -112,56 +111,63 @@ template<scope_exit_function ScopeExitFunc, scope_invoke_checker InvokeChecker =
 class [[nodiscard]] scope_guard
 {
 public:
-    explicit constexpr scope_guard(ScopeExitFunc&& exit_func)
-          // Is the noexcept depending only on scope_exit construct or also on invoke_checker construct?
-          noexcept(std::is_nothrow_constructible_v<ScopeExitFunc>)
-          //noexcept(std::is_nothrow_constructible_v<ScopeExitFunc> && std::is_nothrow_constructible_v<InvokeChecker>)
-        requires (!std::is_same_v<decltype(exit_func), scope_guard>)
+    template<typename T, typename S>
+    explicit constexpr scope_guard(T&& exit_func, S&& invoke_checker)
+          noexcept(std::is_nothrow_constructible_v<ScopeExitFunc> && std::is_nothrow_constructible_v<InvokeChecker>)
     try
-          : m_exit_func(std::forward<ScopeExitFunc>(exit_func))
+          : m_exit_func(std::forward<T>(exit_func)),
+            m_invoke_checker{ std::forward<S>(invoke_checker) }
     {}
     catch (...)
     {
         if constexpr (!std::is_nothrow_constructible_v<ScopeExitFunc>)
         {
             if constexpr (!HasDontInvokeOnCreationException<ScopeExitFunc>)
             {
-                // Can we call the invoke_checker?? we don't know who threw the exception? (exit_func or invoke_checker default construct?)
-
                 exit_func();
             }
 
             throw;
         }
     }
 
-    explicit constexpr scope_guard(ScopeExitFunc&& exit_func, InvokeChecker&& invoke_checker)
+
+    template<typename T>
+    explicit constexpr scope_guard(T&& exit_func)
+          // Is the noexcept depending only on scope_exit construct or also on invoke_checker construct?
+          //noexcept(std::is_nothrow_constructible_v<ScopeExitFunc>)
           noexcept(std::is_nothrow_constructible_v<ScopeExitFunc> && std::is_nothrow_constructible_v<InvokeChecker>)
+        requires (!std::is_same_v<decltype(exit_func), scope_guard>)
     try
-          : m_exit_func(std::forward<ScopeExitFunc>(exit_func)),
-            m_invoke_checker{ std::forward<InvokeChecker>(invoke_checker) }
+          : m_exit_func(std::forward<T>(exit_func))
     {}
     catch (...)
     {
         if constexpr (!std::is_nothrow_constructible_v<ScopeExitFunc>)
         {
             if constexpr (!HasDontInvokeOnCreationException<ScopeExitFunc>)
             {
+                // Can we call the invoke_checker?? we don't know who threw the exception? (exit_func or invoke_checker default construct?)
+
                 exit_func();
             }
 
             throw;
         }
     }
 
+
     explicit constexpr scope_guard(scope_guard&& rhs) noexcept(std::is_nothrow_move_constructible_v<ScopeExitFunc>
                                                                && std::is_nothrow_move_constructible_v<InvokeChecker>)
+        requires (HasRelease<InvokeChecker> || HasStaticRelease<InvokeChecker>)
           : m_exit_func { std::move(rhs.m_exit_func) },
             m_invoke_checker { std::move(rhs.m_invoke_checker) }
     {
+        rhs.release();
         //rhs.m_invoke_checker = NeverExecute {};
     }
 
+
     scope_guard(const scope_guard&)            = delete;
     scope_guard& operator=(const scope_guard&) = delete;
     scope_guard& operator=(scope_guard&&)      = delete;
@@ -212,12 +218,12 @@ class [[nodiscard]] scope_guard
 
 //==================================================================================================
 
-template<std::invocable ExitFunc>
-scope_guard(ExitFunc&&) -> scope_guard<ExitFunc>;
-
 template<std::invocable ExitFunc, scope_invoke_checker InvokeChecker>
 scope_guard(ExitFunc&&, InvokeChecker&&) -> scope_guard<ExitFunc, InvokeChecker>;
 
+template<std::invocable ExitFunc>
+scope_guard(ExitFunc&&) -> scope_guard<ExitFunc>;
+
 //==================================================================================================
 
 class ExecuteAlways
@@ -329,15 +335,19 @@ class Releasable<InvokeChecker>
 
 //==================================================================================================
 
+
 template<class ExitFunc>
 using scope_exit = scope_guard<ExitFunc, Releasable<>>;
 
+
 template<class ExitFunc>
 using scope_success = scope_guard<ExitFunc, Releasable<ExecuteWhenNoException>>;
 
+
 template<class ExitFunc>
 using scope_fail = scope_guard<ExitFunc, Releasable<ExecuteOnlyWhenException>>;
 
+
 //==================================================================================================
 
 //

tests/beman/scope/scope.test.cpp

@@ -72,7 +72,7 @@ TEST_CASE("scope_guard")
 
             beman::scope::Releasable<> releaser;
 
-            SECTION("Multiple exit guards disabled by releaser")
+            SECTION("Multiple exit guards disabled by 1 releaser")
             {
                 {
                     auto exit_guard3_1 = beman::scope::scope_guard { exit_func_onj, releaser };
@@ -103,9 +103,13 @@ TEST_CASE("scope_guard")
         } exit_func_onj;
 
 
-        auto guard = beman::scope::scope_guard { exit_func_onj };
+        {
+            auto guard = beman::scope::scope_guard { exit_func_onj,
+                                                     beman::scope::Releasable<>{} };
+
 
-        // auto guard2(std::move(guard));
+            auto guard2(std::move(guard));
+        }
 
         REQUIRE(exit_func_onj.invoked_count == 1);
     }
@@ -123,7 +127,7 @@ TEST_CASE("scope_exit")
 
         auto exit_guard4 = beman::scope::scope_exit([] {});
 
-        auto exit_guard5 = beman::scope::scope_guard { [] {},
+        auto exit_guard5 = beman::scope::scope_exit { [] {},
                                                        []
                                                        {
                                                            return true;