[libsigcplusplus/variadic_mem_fun3: 129/148] limit_reference_base: Rename template parameter back to T_type.

[Murray Cumming <murrayc src gnome org>]

commit fb8c3da82e1fe7ec79da504ca4dd9101f4855b74
Author: Murray Cumming <murrayc murrayc com>
Date:   Sat Mar 5 11:35:23 2016 +0100

    limit_reference_base: Rename template parameter back to T_type.
    
    Because I think that is what this really is.
    Now this limit_reference_base<> is again as simple as *_limit_reference
    in libsigc++-2.0 but without the code generation and multiple classes.

 sigc++/macros/limit_reference.h.m4 |   28 ++++++++++++++--------------
 1 files changed, 14 insertions(+), 14 deletions(-)
---
diff --git a/sigc++/macros/limit_reference.h.m4 b/sigc++/macros/limit_reference.h.m4
index d220502..cdd0c5c 100644
--- a/sigc++/macros/limit_reference.h.m4
+++ b/sigc++/macros/limit_reference.h.m4
@@ -71,15 +71,15 @@ namespace sigc {
  * This is used for bound (sigc::bind) slot parameters (via bound_argument), bound return values,
  * and, with mem_fun(), the reference to the handling object.
  *
- * - @e T_type_invoke_result The type of the reference.
+ * - @e T_type The type of the reference.
  */
-template <class T_type_invoke_result,
+template <class T_type,
           bool I_derives_trackable =
-            std::is_base_of<trackable, std::decay_t<T_type_invoke_result>>::value>
+            std::is_base_of<trackable, std::decay_t<T_type>>::value>
 class limit_reference_base
 {
 public:
-  using reference_type = typename std::remove_volatile_t<T_type_invoke_result>;
+  using reference_type = typename std::remove_volatile_t<T_type>;
 
   /** Constructor.
    * @param _A_target The reference to limit.
@@ -89,7 +89,7 @@ public:
     {}
 
   /** Retrieve the entity to visit for visit_each().
-   * Depending on the template specialization, this is either a derived reference, or sigc::trackable& if 
T_type_invoke_result derives from sigc::trackable.
+   * Depending on the template specialization, this is either a derived reference, or sigc::trackable& if 
T_type derives from sigc::trackable.
    * @return The reference.
    */
   inline const reference_type& visit() const
@@ -99,7 +99,7 @@ public:
    * This is always a reference to the derived instance.
    * @return The reference.
    */
-  inline T_type_invoke_result& invoke() const
+  inline T_type& invoke() const
     { return visited; }
 
 private:
@@ -111,11 +111,11 @@ private:
 /** limit_reference_base object for a class that derives from trackable.
  * - @e T_type The type of the reference.
  */
-template <class T_type_invoke_result>
-class limit_reference_base<T_type_invoke_result, true>
+template <class T_type>
+class limit_reference_base<T_type, true>
 {
 public:
-  using reference_type = typename std::remove_volatile_t<T_type_invoke_result>;
+  using reference_type = typename std::remove_volatile_t<T_type>;
 
   /** Constructor.
    * @param _A_target The reference to limit.
@@ -136,7 +136,7 @@ public:
    * This is always a reference to the derived instance.
    * @return The reference.
    */
-  inline T_type_invoke_result& invoke() const
+  inline T_type& invoke() const
     { return invoked; }
 
 private:
@@ -156,17 +156,17 @@ private:
 /** Implementation of visitor specialized for the [$1]limit_reference
  * class, to call visit_each() on the entity returned by the [$1]limit_reference's
  * visit() method.
- * @tparam T_type_invoke_result The type of the reference
+ * @tparam T_type The type of the reference
  * @tparam T_action The type of functor to invoke.
  * @param _A_action The functor to invoke.
  * @param _A_target The visited instance.
  */
-template <class T_type_invoke_result>
-struct visitor<limit_reference_base<T_type_invoke_result> >
+template <class T_type>
+struct visitor<limit_reference_base<T_type> >
 {
   template <class T_action>
   static void do_visit_each(const T_action& _A_action,
-                            const limit_reference_base<T_type_invoke_result>& _A_target)
+                            const limit_reference_base<T_type>& _A_target)
   {
     sigc::visit_each(_A_action, _A_target.visit());
   }