From 2d8381a1be1e00bfcc0bad5b53371875f8dd4956 Mon Sep 17 00:00:00 2001
From: TimePath <andrew.hardaker1995@gmail.com>
Date: Sun, 31 Dec 2017 21:05:49 +1100
Subject: [PATCH] Support lambda callbacks

---
 libs/generic/callback.h   |  2 +-
 libs/generic/functional.h | 56 ++++++++++++++++++++++++++++++++++++---
 libs/signal/isignal.h     |  2 +-
 3 files changed, 55 insertions(+), 5 deletions(-)

diff --git a/libs/generic/callback.h b/libs/generic/callback.h
index ef74e0cc..4110691e 100644
--- a/libs/generic/callback.h
+++ b/libs/generic/callback.h
@@ -148,7 +148,7 @@ public:
 };
 
 template<class Caller>
-using BindFirstOpaque = BindFirstOpaqueN<Caller, typename Caller::func>;
+using BindFirstOpaque = BindFirstOpaqueN<Caller, get_func<Caller>>;
 
 template<class F>
 class CallbackN;
diff --git a/libs/generic/functional.h b/libs/generic/functional.h
index 7d76a8b0..8843e363 100644
--- a/libs/generic/functional.h
+++ b/libs/generic/functional.h
@@ -1,9 +1,56 @@
 #if !defined( INCLUDED_FUNCTIONAL_H )
 #define INCLUDED_FUNCTIONAL_H
 
+#include <functional>
 #include <tuple>
 
 namespace detail {
+
+    template<int N>
+    struct rank : rank<N - 1> {
+    };
+
+    template<>
+    struct rank<0> {
+    };
+
+    struct get_func {
+
+        template<class T>
+        struct wrapper {
+            using type = T;
+        };
+
+        template<class F>
+        using func_member = wrapper<typename F::func>;
+
+        template<class F>
+        static wrapper<func_member<F>> test(rank<2>) { return {}; }
+
+        template<class F>
+        struct func_lambda {
+            using type = typename func_lambda<decltype(&F::operator())>::type;
+        };
+
+        template<class R, class... Ts>
+        struct func_lambda<R(*)(Ts...)> {
+            using type = R(Ts...);
+        };
+
+        template<class Object, class R, class... Ts>
+        struct func_lambda<R(Object::*)(Ts...) const> {
+            using type = R(Ts...);
+        };
+
+        template<class Object, class R, class... Ts>
+        struct func_lambda<R(Object::*)(Ts...)> {
+            using type = R(Ts...);
+        };
+
+        template<class F, class = func_lambda<F>>
+        static wrapper<func_lambda<F>> test(rank<1>) { return {}; }
+    };
+
     template<class F>
     struct Fn;
 
@@ -17,10 +64,13 @@ namespace detail {
 }
 
 template<class Caller>
-using get_result_type = typename detail::Fn<typename Caller::func>::result_type;
+using get_func = typename decltype(detail::get_func::test<Caller>(detail::rank<2>{}))::type::type;
+
+template<class Caller>
+using get_result_type = typename detail::Fn<get_func<Caller>>::result_type;
 
 template<class Caller, int N>
-using get_argument = typename detail::Fn<typename Caller::func>::template get<N>;
+using get_argument = typename detail::Fn<get_func<Caller>>::template get<N>;
 
 template<class Object, class F>
 class MemberN;
@@ -132,7 +182,7 @@ public:
 };
 
 template<class Functor>
-using FunctorInvoke = FunctorNInvoke<Functor, typename Functor::func>;
+using FunctorInvoke = FunctorNInvoke<Functor, get_func<Functor>>;
 
 template<class Object, class R, R(Object::*member)()>
 using Member = typename MemberN<Object, R()>::template instance<member>;
diff --git a/libs/signal/isignal.h b/libs/signal/isignal.h
index c447d71b..9eaa9d0b 100644
--- a/libs/signal/isignal.h
+++ b/libs/signal/isignal.h
@@ -37,7 +37,7 @@ public:
 };
 
 template<class Caller>
-using SignalHandlerCaller = SignalHandlerCallerN<Caller, typename Caller::func>;
+using SignalHandlerCaller = SignalHandlerCallerN<Caller, get_func<Caller>>;
 
 template<class Caller>
 using SignalHandlerCaller1 = SignalHandlerCaller<Caller>;
-- 
2.39.2