From dba4a884ca67d90f9173a1bdd41d76356a0b35eb Mon Sep 17 00:00:00 2001
From: Reece Wilson <code@reece.sx>
Date: Thu, 17 Nov 2022 02:28:23 +0000
Subject: [PATCH] [+] AuTryCall [+] AuTryCallPair [+] AuIsCallable [+]
 AuIsCallable_v [*] Improved AuResetMember

---
 Include/auROXTL/Objects/ResetMember.hpp | 15 ++++-
 Include/auROXTL/auResult.hpp            | 11 +---
 Include/auROXTL/auTemplateMeta.hpp      | 28 ++++++++-
 Include/auROXTL/auTryCall.hpp           | 38 +++++++++++++
 Include/auROXTL/auTryCallUtils.hpp      | 76 +++++++++++++++++++++++++
 Include/auROXTLTypes.hpp                |  1 +
 Include/auROXTLUtils.hpp                |  1 +
 7 files changed, 155 insertions(+), 15 deletions(-)
 create mode 100644 Include/auROXTL/auTryCall.hpp
 create mode 100644 Include/auROXTL/auTryCallUtils.hpp

diff --git a/Include/auROXTL/Objects/ResetMember.hpp b/Include/auROXTL/Objects/ResetMember.hpp
index 6e74cfd..96d96c8 100644
--- a/Include/auROXTL/Objects/ResetMember.hpp
+++ b/Include/auROXTL/Objects/ResetMember.hpp
@@ -7,10 +7,19 @@
 ***/
 #pragma once
 
-template <class T>
-static void AuResetMember(T &ref)
+template <class T, class ...Args>
+static void AuResetMember(T &ref, Args &&...args)
 {
-    ref = AuDecay_t<T>();
+    if constexpr (AuIsClass_v<T>)
+    {
+        ref.~T();
+        AuMemset(&ref, 0, sizeof(ref));
+        new (&ref) T(AuForward<Args &&>(args)...);
+    }
+    else
+    {
+        ref = AuDecay_t<T>();
+    }
 }
 
 template <class T>
diff --git a/Include/auROXTL/auResult.hpp b/Include/auROXTL/auResult.hpp
index aae4bbb..dbd4223 100644
--- a/Include/auROXTL/auResult.hpp
+++ b/Include/auROXTL/auResult.hpp
@@ -25,16 +25,7 @@ struct AuResult
     AuResult(T &&value) : type(value), success(true)
     {}
 
-    // I could be pulling this out of my ass, but i'd assume with callee provided stack space being provided through arg0 in most abis,
-    // and with the callers binary originating from a file in which contains the T declaration, i'd assume it would be faster to chuck 
-    // the return value in the callers' stack **and** access it by reference in the callee, rather than assigning a value using move
-    // constructors/assignment operators whenever the data is available.
-    // Feels like a landmine of accidental allocates:
-    //  ...what is the default constructor doing in the caller? (hopefully nothing)
-    //  ...does the object even support move semantics? (would AuResult<T>(AuMove(t)) result in a copy no matter what?)
-    // 
-    // generally recommend ::GetResult() 
-
+    // Forced return value optimization.
     T &GetResult()
     {
         return type;
diff --git a/Include/auROXTL/auTemplateMeta.hpp b/Include/auROXTL/auTemplateMeta.hpp
index 1bcd682..71c167c 100644
--- a/Include/auROXTL/auTemplateMeta.hpp
+++ b/Include/auROXTL/auTemplateMeta.hpp
@@ -68,6 +68,10 @@ namespace _audetail
 
     template <class B, typename D>
     auto TestIsBaseOf(int) -> decltype(TestIsPtrConvertible<B>(static_cast<D *>(nullptr)));
+
+    // yoinked: https://stackoverflow.com/a/40867906
+    template<typename Func, typename...Params> static auto IsCallable(int) -> decltype((void)AuDeclVal<Func>()(AuDeclVal<Params>()...), AuTrueType {});
+    template<typename Func, typename...Params> static AuFalseType IsCallable(...);
 }
 
 template <class T>
@@ -253,7 +257,7 @@ template <class T>
 using AuAddRReference_t = typename AuAddRReference<T>::type;
 
 template <class T>
-AuAddRReference_t<T> AuDeclVal();
+T &&AuDeclVal();
 
 template <class T>
 struct AuAddConst
@@ -353,4 +357,24 @@ template <template <class...> class Base, typename Derived>
 using AuIsBaseOfTemplate = typename AuIsBaseOfTemplateImpl<Base, Derived>::type;
 
 template <template <class...> class Base, typename Derived>
-inline constexpr bool AuIsBaseOfTemplate_v = AuIsBaseOfTemplateImpl<Base, Derived>::type::value;
\ No newline at end of file
+inline constexpr bool AuIsBaseOfTemplate_v = AuIsBaseOfTemplateImpl<Base, Derived>::type::value;
+
+// :(
+// we have a boost licensed call traits in auv8pp
+#include <type_traits>
+
+#if defined(AU_LANG_CPP_14)
+    template <class T, class... Args>
+    using AuResultOf_t = typename std::result_of_t<T, Args...>;
+#else
+    template <class T, class... Args>
+    using AuResultOf_t = typename std::invoke_result_t<T, Args...>;
+#endif
+
+template <class Func, class ...Params>
+struct AuCallable : decltype(_audetail::IsCallable<Func, Params...>(0))
+{
+};
+
+template <class F, class... Args>
+constexpr auto AuIsCallable_v = AuCallable<F, Args...>::value;
diff --git a/Include/auROXTL/auTryCall.hpp b/Include/auROXTL/auTryCall.hpp
new file mode 100644
index 0000000..9f734f4
--- /dev/null
+++ b/Include/auROXTL/auTryCall.hpp
@@ -0,0 +1,38 @@
+/***
+    Copyright (C) 2022 J Reece Wilson (a/k/a "Reece"). All rights reserved.
+
+    File: auTryCall.hpp
+    Date: 2022-11-16
+    Author: Reece
+***/
+#pragma once
+
+struct AuCallErrorTag
+{
+    /*
+        Thy shall fulfill the following requirements:
+            operator bool() const;
+            static constexpr AuCallErrorTag Failed ();
+            static constexpr AuCallErrorTag Success();
+    */
+};
+
+struct AuErrorCode_t : AuCallErrorTag
+{
+    AuUInt32 uValue;
+
+    inline constexpr AuErrorCode_t()
+    {};
+
+    inline constexpr AuErrorCode_t(AuUInt32 uValue) : uValue(uValue)
+    {};
+
+    explicit inline operator bool() const
+    {
+        return bool(uValue == 0);
+    }
+    
+    static constexpr AuErrorCode_t Failed () { return AuErrorCode_t { AuUInt32(1) << 31 }; }
+    static constexpr AuErrorCode_t Catch  () { return AuErrorCode_t { (AuUInt32(1) << 31) | 1 }; }
+    static constexpr AuErrorCode_t Success() { return AuErrorCode_t { 0 };  }
+};
\ No newline at end of file
diff --git a/Include/auROXTL/auTryCallUtils.hpp b/Include/auROXTL/auTryCallUtils.hpp
new file mode 100644
index 0000000..cea1f81
--- /dev/null
+++ b/Include/auROXTL/auTryCallUtils.hpp
@@ -0,0 +1,76 @@
+/***
+    Copyright (C) 2022 J Reece Wilson (a/k/a "Reece"). All rights reserved.
+
+    File: auTryCallUtils.hpp
+    Date: 2022-11-16
+    Author: Reece
+***/
+#pragma once
+
+#define _AU_TRYCALL_CHECKCODE(X)  AU_TEMPLATE_ENABLE_WHEN(AuIsBaseOf_v<AuCallErrorTag, CtorCode_t> && !AuIsSame_v<X, CtorCode_t>)
+
+template <class CtorCode_t = AuErrorCode_t, class Callable_t, typename ... Args, _AU_TRYCALL_CHECKCODE(Callable_t)>
+inline auto AuTryCall(Callable_t callable, CtorCode_t &status, Args&& ... args)
+{
+    if constexpr (AuIsCallable_v<Callable_t, Args&& ..., CtorCode_t &>)
+    {
+        status = CtorCode_t::Failed();
+        return callable(AuForward<Args&&>(args)..., AuReference(status));
+    }
+    else
+    {
+        static_assert(AuIsCallable_v<Callable_t, Args&& ...>, "bad try-call prototype");
+    
+        try
+        {
+            status = CtorCode_t::Success();
+            return callable(AuForward<Args &&>(args)...);
+        }
+        catch (...)
+        {
+            status = CtorCode_t::Failed();
+            return AuResultOf_t<Callable_t, Args...>();
+        }
+    }
+}
+
+template <class CtorCode_t = AuErrorCode_t, class Callable_t, typename ... Args, class T, _AU_TRYCALL_CHECKCODE(T)>
+inline CtorCode_t AuTryCall(Callable_t callable, T &ref, Args&& ... args)
+{
+    CtorCode_t status;
+    if constexpr (AuIsCallable_v<Callable_t, Args ..., CtorCode_t &>)
+    {
+        ref = callable(AuForward<Args>(args)..., AuReference(status));
+        return status;
+    }
+    else
+    {
+        try
+        {
+            ref = callable(AuForward<Args>(args)...);
+            return CtorCode_t::Success();
+        }
+        catch (...)
+        {
+            ref = AuMove(T());
+            if constexpr (AuIsSame_v<CtorCode_t, AuErrorCode_t>)
+            {
+                return CtorCode_t::Catch();
+            }
+            else
+            {
+                return CtorCode_t::Failed();
+            }
+        }
+    }
+}
+
+template <class CtorCode_t = AuErrorCode_t, class Callable_t, typename ... Args, _AU_TRYCALL_CHECKCODE(Callable_t)>
+inline auto AuTryCallPair(Callable_t callable, Args&& ... args)
+{
+    CtorCode_t code;
+    auto a = AuTryCall<CtorCode_t, Callable_t, Args...>(callable, AuReference(code), AuForward<Args &&>(args)...);
+    return AuMakePair(AuMove(code), a);
+}
+
+#undef _AU_TRYCALL_CHECKCODE
\ No newline at end of file
diff --git a/Include/auROXTLTypes.hpp b/Include/auROXTLTypes.hpp
index 64bb8f6..81579e1 100644
--- a/Include/auROXTLTypes.hpp
+++ b/Include/auROXTLTypes.hpp
@@ -27,6 +27,7 @@
 
 #include <auROXTL/auTypes.hpp>
 #include <auROXTL/auTryConstruct.hpp>
+#include <auROXTL/auTryCall.hpp>
 #include <auROXTL/auTemplateMeta.hpp>
 #include <auROXTL/auResult.hpp>
 #include <auROXTL/auMemoryModel.hpp>
diff --git a/Include/auROXTLUtils.hpp b/Include/auROXTLUtils.hpp
index 2a928a7..72968bb 100644
--- a/Include/auROXTLUtils.hpp
+++ b/Include/auROXTLUtils.hpp
@@ -48,6 +48,7 @@
 #include <auROXTL/auFNV1Utils.hpp>
 #include <auROXTL/auHashUtils.hpp>
 #include <auROXTL/auTryConstructUtils.hpp>
+#include <auROXTL/auTryCallUtils.hpp>
 
 #include <auROXTL/Objects/SafeDestroy.hpp>
 #include <auROXTL/Objects/ResetMember.hpp>