From 22e7bfac5479cf1b323aa77cf16abd0ac8329685 Mon Sep 17 00:00:00 2001
From: Curve <fynnbwdt@gmail.com>
Date: Mon, 25 Dec 2023 19:51:01 +0100
Subject: [PATCH] refactor(hook): return hook pointer for lambdas

---
 include/lime/hooks/hook.hpp | 23 +++++------------------
 include/lime/hooks/hook.inl | 35 ++++++++++++++++++++++++++++++-----
 2 files changed, 35 insertions(+), 23 deletions(-)

diff --git a/include/lime/hooks/hook.hpp b/include/lime/hooks/hook.hpp
index 94bc620..d5af056 100644
--- a/include/lime/hooks/hook.hpp
+++ b/include/lime/hooks/hook.hpp
@@ -4,9 +4,7 @@
 #include <cstdint>
 #include <concepts>
 
-#include <functional>
 #include <tl/expected.hpp>
-#include <boost/callable_traits.hpp>
 
 namespace lime
 {
@@ -47,19 +45,7 @@ namespace lime
     concept Address = requires() { requires std::integral<T> || std::is_pointer_v<T>; };
 
     template <typename Hook, typename Signature>
-    consteval auto lambda_target()
-    {
-        using args_t = boost::callable_traits::args_t<Signature>;
-        using rtn_t  = boost::callable_traits::return_type_t<Signature>;
-
-        return std::apply(
-            []<typename... T>(T &&...)
-            {
-                using func_t = std::function<rtn_t(Hook, T...)>;
-                return std::type_identity<func_t>{};
-            },
-            args_t{});
-    }
+    consteval auto lambda_target();
 
     template <typename Hook, typename Signature>
     using lambda_target_t = typename decltype(lambda_target<Hook, Signature>())::type;
@@ -67,19 +53,20 @@ namespace lime
     template <typename Signature>
     class hook : public hook_base
     {
+        template <template <typename...> typename T>
+        using rtn_t       = tl::expected<T<hook>, hook_error>;
         using signature_t = std::conditional_t<std::is_pointer_v<Signature>, Signature, Signature *>;
-        using rtn_t       = tl::expected<std::unique_ptr<hook>, hook_error>;
 
       public:
         signature_t original() const;
 
       public:
         template <Address Source, Address Target>
-        [[nodiscard]] static rtn_t create(Source source, Target target);
+        [[nodiscard]] static rtn_t<std::unique_ptr> create(Source source, Target target);
 
       public:
         template <Address Source>
-        static void create(Source source, lambda_target_t<hook *, Signature> &&target);
+        static rtn_t<std::add_pointer_t> create(Source source, lambda_target_t<hook *, Signature> &&target);
     };
 } // namespace lime
 
diff --git a/include/lime/hooks/hook.inl b/include/lime/hooks/hook.inl
index 8a777ae..265aa69 100644
--- a/include/lime/hooks/hook.inl
+++ b/include/lime/hooks/hook.inl
@@ -2,9 +2,27 @@
 #include "hook.hpp"
 
 #include <cassert>
+#include <functional>
+
+#include <boost/callable_traits.hpp>
 
 namespace lime
 {
+    template <typename Hook, typename Signature>
+    consteval auto lambda_target()
+    {
+        using args_t   = boost::callable_traits::args_t<Signature>;
+        using return_t = boost::callable_traits::return_type_t<Signature>;
+
+        return std::apply(
+            []<typename... T>(T &&...)
+            {
+                using function_t = std::function<return_t(Hook, T...)>;
+                return std::type_identity<function_t>{};
+            },
+            args_t{});
+    }
+
     template <typename Signature>
     typename hook<Signature>::signature_t hook<Signature>::original() const
     {
@@ -13,7 +31,7 @@ namespace lime
 
     template <typename Signature>
     template <Address Source, Address Target>
-    typename hook<Signature>::rtn_t hook<Signature>::create(Source source, Target target)
+    hook<Signature>::template rtn_t<std::unique_ptr> hook<Signature>::create(Source source, Target target)
     {
         auto source_address = reinterpret_cast<std::uintptr_t>(source);
         auto target_address = reinterpret_cast<std::uintptr_t>(target);
@@ -31,7 +49,8 @@ namespace lime
 
     template <typename Signature>
     template <Address Source>
-    void hook<Signature>::create(Source source, lambda_target_t<hook *, Signature> &&target)
+    hook<Signature>::template rtn_t<std::add_pointer_t>
+    hook<Signature>::create(Source source, lambda_target_t<hook *, Signature> &&target)
     {
         using args_t = boost::callable_traits::args_t<Signature>;
         using rtn_t  = boost::callable_traits::return_type_t<Signature>;
@@ -49,9 +68,15 @@ namespace lime
             },
             args_t{});
 
-        auto _hook = create(source, +wrapper);
-        assert(_hook && "Failed to create hook");
+        auto result = create(source, static_cast<signature_t>(wrapper));
+
+        if (!result)
+        {
+            return tl::make_unexpected(result.error());
+        }
+
+        hook = result->release();
 
-        hook = _hook->release();
+        return hook;
     }
 } // namespace lime