C++17: Use std::invoke().

murraycu · murraycu · commit f3da00bcbc68 · 2018-04-07T22:58:06.000+02:00
This makes code more generic. Maybe this will let us simplify code.
diff --git a/sigc++/adaptors/adaptor_trait.h b/sigc++/adaptors/adaptor_trait.h
@@ -25,6 +25,7 @@
 #include <sigc++/functors/ptr_fun.h>
 #include <sigc++/functors/mem_fun.h>
 #include <sigc++/adaptors/adaptor_base.h>
+#include <functional>
 
 /*
  * The idea here is simple.  To prevent the need to
@@ -96,7 +97,7 @@ struct adaptor_functor : public adaptor_base
   template <typename... T_arg>
   decltype(auto) operator()(T_arg&&... arg) const
   {
-    return functor_(std::forward<T_arg>(arg)...);
+    return std::invoke(functor_, std::forward<T_arg>(arg)...);
   }
 
   /// Constructs an invalid functor.
diff --git a/sigc++/adaptors/bind.h b/sigc++/adaptors/bind.h
@@ -26,6 +26,7 @@
 #include <sigc++/tuple-utils/tuple_start.h>
 #include <sigc++/tuple-utils/tuple_end.h>
 #include <sigc++/tuple-utils/tuple_transform_each.h>
+#include <functional>
 
 
 namespace sigc
diff --git a/sigc++/adaptors/bind_return.h b/sigc++/adaptors/bind_return.h
@@ -49,6 +49,7 @@ struct bind_return_functor : public adapts<T_functor>
   template <typename... T_arg>
   inline typename unwrap_reference<T_return>::type operator()(T_arg... a)
   {
+    //TODO: Use std::invoke() here?
     this->functor_.template operator()<type_trait_pass_t<T_arg>...>(a...);
     return ret_value_.invoke();
   }
@@ -71,7 +72,7 @@ template <typename T_return, typename T_functor>
 typename unwrap_reference<T_return>::type
 bind_return_functor<T_return, T_functor>::operator()()
 {
-  this->functor_();
+  std::invoke(this->functor_);
   return ret_value_.invoke();
 }
 
diff --git a/sigc++/adaptors/compose.h b/sigc++/adaptors/compose.h
@@ -19,6 +19,7 @@
 #ifndef SIGC_ADAPTORS_COMPOSE_H
 #define SIGC_ADAPTORS_COMPOSE_H
 #include <sigc++/adaptors/adapts.h>
+#include <functional>
 
 namespace sigc
 {
@@ -61,12 +62,14 @@ namespace sigc
 template <typename T_setter, typename T_getter>
 struct compose1_functor : public adapts<T_setter>
 {
-  decltype(auto) operator()() { return this->functor_(get_()); }
+  decltype(auto) operator()() {
+    return std::invoke(this->functor_, get_());
+  }
 
   template <typename... T_arg>
   decltype(auto) operator()(T_arg&&... a)
   {
-    return this->functor_(get_(std::forward<T_arg>(a)...));
+    return std::invoke(this->functor_, get_(std::forward<T_arg>(a)...));
   }
 
   /** Constructs a compose1_functor object that combines the passed functors.
@@ -95,12 +98,14 @@ struct compose1_functor : public adapts<T_setter>
 template <typename T_setter, typename T_getter1, typename T_getter2>
 struct compose2_functor : public adapts<T_setter>
 {
-  decltype(auto) operator()() { return this->functor_(get1_(), get2_()); }
+  decltype(auto) operator()() {
+    return std::invoke(this->functor_, get1_(), get2_());
+  }
 
   template <typename... T_arg>
   decltype(auto) operator()(T_arg... a)
   {
-    return this->functor_(get1_(a...), get2_(a...));
+    return std::invoke(this->functor_, get1_(a...), get2_(a...));
   }
 
   /** Constructs a compose2_functor object that combines the passed functors.
diff --git a/sigc++/adaptors/exception_catch.h b/sigc++/adaptors/exception_catch.h
@@ -80,7 +80,7 @@ struct exception_catch_functor : public adapts<T_functor>
   {
     try
     {
-      return this->functor_();
+      return std::invoke(this->functor_);
     }
     catch (...)
     {
@@ -93,6 +93,7 @@ struct exception_catch_functor : public adapts<T_functor>
   {
     try
     {
+      //TODO: Use std::invoke here?
       return this->functor_.template operator()<type_trait_pass_t<T_arg>...>(a...);
     }
     catch (...)
diff --git a/sigc++/adaptors/retype.h b/sigc++/adaptors/retype.h
@@ -82,6 +82,7 @@ struct retype_functor : public adapts<T_functor>
   template <typename... T_arg>
   decltype(auto) operator()(T_arg... a)
   {
+    //TODO: Use std::invoke() here?
     return this->functor_.template operator()<type_trait_take_t<T_type>...>(
       static_cast<T_type>(a)...);
   }
diff --git a/sigc++/adaptors/retype_return.h b/sigc++/adaptors/retype_return.h
@@ -41,6 +41,7 @@ struct retype_return_functor : public adapts<T_functor>
   template <typename... T_arg>
   inline T_return operator()(T_arg&&... a)
   {
+    //TODO: Use std::invoke() here?
     return T_return(this->functor_.template operator() < T_arg... > (std::forward<T_arg>(a)...));
   }
 
@@ -60,7 +61,7 @@ template <typename T_return, typename T_functor>
 T_return
 retype_return_functor<T_return, T_functor>::operator()()
 {
-  return T_return(this->functor_());
+  return T_return(std::invoke(this->functor_));
 }
 
 /** Adaptor that performs a C-style cast on the return value of a functor.
@@ -81,6 +82,7 @@ struct retype_return_functor<void, T_functor> : public adapts<T_functor>
   template <typename... T_arg>
   inline void operator()(T_arg... a)
   {
+    //TODO: Use std::invoke() here?
     this->functor_.template operator()<T_arg...>(a...);
   }
 
@@ -92,7 +94,7 @@ template <typename T_functor>
 void
 retype_return_functor<void, T_functor>::operator()()
 {
-  this->functor_();
+  std::invoke(this->functor_);
 }
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
diff --git a/sigc++/adaptors/track_obj.h b/sigc++/adaptors/track_obj.h
@@ -83,7 +83,9 @@ class track_obj_functor : public adapts<T_functor>
   /** Invokes the wrapped functor.
    * @return The return value of the functor invocation.
    */
-  decltype(auto) operator()() { return this->functor_(); }
+  decltype(auto) operator()() {
+    return std::invoke(this->functor_);
+  }
 
   /** Invokes the wrapped functor passing on the arguments.
    * @param arg Arguments to be passed on to the functor.
@@ -92,6 +94,7 @@ class track_obj_functor : public adapts<T_functor>
   template <typename... T_arg>
   decltype(auto) operator()(T_arg&&... arg)
   {
+    //TODO: Use std::invoke() here?
     return this->functor_.template operator()<type_trait_pass_t<T_arg>...>(
       std::forward<T_arg>(arg)...);
   }
diff --git a/sigc++/functors/mem_fun.h b/sigc++/functors/mem_fun.h
@@ -21,6 +21,7 @@
 #include <sigc++/type_traits.h>
 #include <sigc++/limit_reference.h>
 #include <sigc++/member_method_trait.h>
+#include <functional>
 
 // implementation notes:
 //  - we do not use bind here, because it would introduce
@@ -113,7 +114,7 @@ class mem_functor
    */
   decltype(auto) operator()(obj_type_with_modifier& obj, type_trait_take_t<T_arg>... a) const
   {
-    return (obj.*func_ptr_)(a...);
+    return std::invoke(func_ptr_, obj, a...);
   }
 
 protected:
@@ -152,7 +153,7 @@ class bound_mem_functor : mem_functor<T_func, T_arg...>
    */
   decltype(auto) operator()(type_trait_take_t<T_arg>... a) const
   {
-    return (obj_.invoke().*(this->func_ptr_))(a...);
+    return std::invoke(this->func_ptr_, obj_.invoke(), a...);
   }
 
   // protected:
diff --git a/sigc++/functors/ptr_fun.h b/sigc++/functors/ptr_fun.h
@@ -19,6 +19,7 @@
 #ifndef SIGC_FUNCTORS_PTR_FUN_H
 #define SIGC_FUNCTORS_PTR_FUN_H
 #include <sigc++/type_traits.h>
+#include <functional>
 
 namespace sigc
 {
@@ -92,7 +93,9 @@ class pointer_functor<T_return(T_args...)>
    * @param a Arguments to be passed on to the function.
    * @return The return value of the function invocation.
    */
-  T_return operator()(type_trait_take_t<T_args>... a) const { return func_ptr_(a...); }
+  T_return operator()(type_trait_take_t<T_args>... a) const {
+    return std::invoke(func_ptr_, a...);
+  }
 };
 
 /** Creates a functor of type sigc::pointer_functor which wraps an existing non-member function.
diff --git a/sigc++/functors/slot.h b/sigc++/functors/slot.h
@@ -23,6 +23,7 @@
 #include <sigc++/visit_each.h>
 #include <sigc++/adaptors/adaptor_trait.h>
 #include <sigc++/functors/slot_base.h>
+#include <functional>
 
 #include <memory>
 
@@ -190,8 +191,10 @@ class slot<T_return(T_arg...)> : public slot_base
    */
   inline T_return operator()(type_trait_take_t<T_arg>... a) const
   {
-    if (!empty() && !blocked())
-      return (reinterpret_cast<call_type>(slot_base::rep_->call_))(slot_base::rep_, a...);
+    if (!empty() && !blocked()) {
+      return std::invoke(reinterpret_cast<call_type>(slot_base::rep_->call_), slot_base::rep_, a...);
+    }
+
     return T_return();
   }
 
diff --git a/sigc++/visit_each.h b/sigc++/visit_each.h
@@ -21,6 +21,7 @@
 #include <sigc++/type_traits.h>
 #include <type_traits>
 #include <utility> // std::forward
+#include <functional>
 
 namespace sigc
 {
@@ -45,7 +46,7 @@ struct limit_trackable_target
   {
     //Only call action_() if T_Type derives from trackable.
     if constexpr(is_base_of_or_same_v<sigc::trackable, T_type>) {
-        action_(type);
+        std::invoke(action_, type);
     }
   }
 

Original file line number	Diff line number	Diff line change
`@@ -25,6 +25,7 @@`
`25`	`25`	`#include <sigc++/functors/ptr_fun.h>`
`26`	`26`	`#include <sigc++/functors/mem_fun.h>`
`27`	`27`	`#include <sigc++/adaptors/adaptor_base.h>`
	`28`	`+#include <functional>`
`28`	`29`
`29`	`30`	`/*`
`30`	`31`	`* The idea here is simple. To prevent the need to`
`@@ -96,7 +97,7 @@ struct adaptor_functor : public adaptor_base`
`96`	`97`	`template <typename... T_arg>`
`97`	`98`	`decltype(auto) operator()(T_arg&&... arg) const`
`98`	`99`	`{`
`99`		`- return functor_(std::forward<T_arg>(arg)...);`
	`100`	`+ return std::invoke(functor_, std::forward<T_arg>(arg)...);`
`100`	`101`	`}`
`101`	`102`
`102`	`103`	`/// Constructs an invalid functor.`
Original file line number	Diff line number	Diff line change
`@@ -49,6 +49,7 @@ struct bind_return_functor : public adapts<T_functor>`
`49`	`49`	`template <typename... T_arg>`
`50`	`50`	`inline typename unwrap_reference<T_return>::type operator()(T_arg... a)`
`51`	`51`	`{`
	`52`	`+ //TODO: Use std::invoke() here?`
`52`	`53`	`this->functor_.template operator()<type_trait_pass_t<T_arg>...>(a...);`
`53`	`54`	`return ret_value_.invoke();`
`54`	`55`	`}`
`@@ -71,7 +72,7 @@ template <typename T_return, typename T_functor>`
`71`	`72`	`typename unwrap_reference<T_return>::type`
`72`	`73`	`bind_return_functor<T_return, T_functor>::operator()()`
`73`	`74`	`{`
`74`		`- this->functor_();`
	`75`	`+ std::invoke(this->functor_);`
`75`	`76`	`return ret_value_.invoke();`
`76`	`77`	`}`
`77`	`78`
Original file line number	Diff line number	Diff line change
`@@ -19,6 +19,7 @@`
`19`	`19`	`#ifndef SIGC_ADAPTORS_COMPOSE_H`
`20`	`20`	`#define SIGC_ADAPTORS_COMPOSE_H`
`21`	`21`	`#include <sigc++/adaptors/adapts.h>`
	`22`	`+#include <functional>`
`22`	`23`
`23`	`24`	`namespace sigc`
`24`	`25`	`{`
`@@ -61,12 +62,14 @@ namespace sigc`
`61`	`62`	`template <typename T_setter, typename T_getter>`
`62`	`63`	`struct compose1_functor : public adapts<T_setter>`
`63`	`64`	`{`
`64`		`- decltype(auto) operator()() { return this->functor_(get_()); }`
	`65`	`+ decltype(auto) operator()() {`
	`66`	`+ return std::invoke(this->functor_, get_());`
	`67`	`+ }`
`65`	`68`
`66`	`69`	`template <typename... T_arg>`
`67`	`70`	`decltype(auto) operator()(T_arg&&... a)`
`68`	`71`	`{`
`69`		`- return this->functor_(get_(std::forward<T_arg>(a)...));`
	`72`	`+ return std::invoke(this->functor_, get_(std::forward<T_arg>(a)...));`
`70`	`73`	`}`
`71`	`74`
`72`	`75`	`/** Constructs a compose1_functor object that combines the passed functors.`
`@@ -95,12 +98,14 @@ struct compose1_functor : public adapts<T_setter>`
`95`	`98`	`template <typename T_setter, typename T_getter1, typename T_getter2>`
`96`	`99`	`struct compose2_functor : public adapts<T_setter>`
`97`	`100`	`{`
`98`		`- decltype(auto) operator()() { return this->functor_(get1_(), get2_()); }`
	`101`	`+ decltype(auto) operator()() {`
	`102`	`+ return std::invoke(this->functor_, get1_(), get2_());`
	`103`	`+ }`
`99`	`104`
`100`	`105`	`template <typename... T_arg>`
`101`	`106`	`decltype(auto) operator()(T_arg... a)`
`102`	`107`	`{`
`103`		`- return this->functor_(get1_(a...), get2_(a...));`
	`108`	`+ return std::invoke(this->functor_, get1_(a...), get2_(a...));`
`104`	`109`	`}`
`105`	`110`
`106`	`111`	`/** Constructs a compose2_functor object that combines the passed functors.`
Original file line number	Diff line number	Diff line change
`@@ -80,7 +80,7 @@ struct exception_catch_functor : public adapts<T_functor>`
`80`	`80`	`{`
`81`	`81`	`try`
`82`	`82`	`{`
`83`		`- return this->functor_();`
	`83`	`+ return std::invoke(this->functor_);`
`84`	`84`	`}`
`85`	`85`	`catch (...)`
`86`	`86`	`{`
`@@ -93,6 +93,7 @@ struct exception_catch_functor : public adapts<T_functor>`
`93`	`93`	`{`
`94`	`94`	`try`
`95`	`95`	`{`
	`96`	`+ //TODO: Use std::invoke here?`
`96`	`97`	`return this->functor_.template operator()<type_trait_pass_t<T_arg>...>(a...);`
`97`	`98`	`}`
`98`	`99`	`catch (...)`
Original file line number	Diff line number	Diff line change
`@@ -82,6 +82,7 @@ struct retype_functor : public adapts<T_functor>`
`82`	`82`	`template <typename... T_arg>`
`83`	`83`	`decltype(auto) operator()(T_arg... a)`
`84`	`84`	`{`
	`85`	`+ //TODO: Use std::invoke() here?`
`85`	`86`	`return this->functor_.template operator()<type_trait_take_t<T_type>...>(`
`86`	`87`	`static_cast<T_type>(a)...);`
`87`	`88`	`}`
Original file line number	Diff line number	Diff line change
`@@ -41,6 +41,7 @@ struct retype_return_functor : public adapts<T_functor>`
`41`	`41`	`template <typename... T_arg>`
`42`	`42`	`inline T_return operator()(T_arg&&... a)`
`43`	`43`	`{`
	`44`	`+ //TODO: Use std::invoke() here?`
`44`	`45`	`return T_return(this->functor_.template operator() < T_arg... > (std::forward<T_arg>(a)...));`
`45`	`46`	`}`
`46`	`47`
`@@ -60,7 +61,7 @@ template <typename T_return, typename T_functor>`
`60`	`61`	`T_return`
`61`	`62`	`retype_return_functor<T_return, T_functor>::operator()()`
`62`	`63`	`{`
`63`		`- return T_return(this->functor_());`
	`64`	`+ return T_return(std::invoke(this->functor_));`
`64`	`65`	`}`
`65`	`66`
`66`	`67`	`/** Adaptor that performs a C-style cast on the return value of a functor.`
`@@ -81,6 +82,7 @@ struct retype_return_functor<void, T_functor> : public adapts<T_functor>`
`81`	`82`	`template <typename... T_arg>`
`82`	`83`	`inline void operator()(T_arg... a)`
`83`	`84`	`{`
	`85`	`+ //TODO: Use std::invoke() here?`
`84`	`86`	`this->functor_.template operator()<T_arg...>(a...);`
`85`	`87`	`}`
`86`	`88`
`@@ -92,7 +94,7 @@ template <typename T_functor>`
`92`	`94`	`void`
`93`	`95`	`retype_return_functor<void, T_functor>::operator()()`
`94`	`96`	`{`
`95`		`- this->functor_();`
	`97`	`+ std::invoke(this->functor_);`
`96`	`98`	`}`
`97`	`99`
`98`	`100`	`#ifndef DOXYGEN_SHOULD_SKIP_THIS`
Original file line number	Diff line number	Diff line change
`@@ -21,6 +21,7 @@`
`21`	`21`	`#include <sigc++/type_traits.h>`
`22`	`22`	`#include <sigc++/limit_reference.h>`
`23`	`23`	`#include <sigc++/member_method_trait.h>`
	`24`	`+#include <functional>`
`24`	`25`
`25`	`26`	`// implementation notes:`
`26`	`27`	`// - we do not use bind here, because it would introduce`
`@@ -113,7 +114,7 @@ class mem_functor`
`113`	`114`	`*/`
`114`	`115`	`decltype(auto) operator()(obj_type_with_modifier& obj, type_trait_take_t<T_arg>... a) const`
`115`	`116`	`{`
`116`		`- return (obj.*func_ptr_)(a...);`
	`117`	`+ return std::invoke(func_ptr_, obj, a...);`
`117`	`118`	`}`
`118`	`119`
`119`	`120`	`protected:`
`@@ -152,7 +153,7 @@ class bound_mem_functor : mem_functor<T_func, T_arg...>`
`152`	`153`	`*/`
`153`	`154`	`decltype(auto) operator()(type_trait_take_t<T_arg>... a) const`
`154`	`155`	`{`
`155`		`- return (obj_.invoke().*(this->func_ptr_))(a...);`
	`156`	`+ return std::invoke(this->func_ptr_, obj_.invoke(), a...);`
`156`	`157`	`}`
`157`	`158`
`158`	`159`	`// protected:`