[libsigc++2/variadic_mem_fun2] Rename limit_reference_base to limit_reference.

[Murray Cumming <murrayc src gnome org>]

commit d69ab061e4fdac1567b2099c905124a261e01245
Author: Murray Cumming <murrayc murrayc com>
Date:   Sat Mar 5 11:50:45 2016 +0100

    Rename limit_reference_base to limit_reference.

 sigc++/adaptors/bound_argument.h    |    8 ++++----
 sigc++/adaptors/track_obj.h         |    2 +-
 sigc++/functors/macros/mem_fun.h.m4 |    6 +++---
 sigc++/macros/limit_reference.h.m4  |   16 ++++++++--------
 4 files changed, 16 insertions(+), 16 deletions(-)
---
diff --git a/sigc++/adaptors/bound_argument.h b/sigc++/adaptors/bound_argument.h
index c577ead..60b26b1 100644
--- a/sigc++/adaptors/bound_argument.h
+++ b/sigc++/adaptors/bound_argument.h
@@ -93,7 +93,7 @@ public:
   /** Retrieve the entity to visit in visit_each().
    * @return The limited_reference to the bound argument.
    */
-  inline const limit_reference_base<T_wrapped>& visit() const
+  inline const limit_reference<T_wrapped>& visit() const
     { return visited_; }
 
   /** Retrieve the entity to pass to the bound functor or return.
@@ -105,7 +105,7 @@ public:
 private:
   /** The limited_reference to the bound argument.
    */
-  limit_reference_base<T_wrapped> visited_;
+  limit_reference<T_wrapped> visited_;
 };
 
 /** bound_argument object for a bound argument that is passed by bind() or
@@ -126,7 +126,7 @@ public:
   /** Retrieve the entity to visit in visit_each().
    * @return The const_limited_reference to the bound argument.
    */
-  inline const limit_reference_base<const T_wrapped>& visit() const
+  inline const limit_reference<const T_wrapped>& visit() const
     { return visited_; }
 
   /** Retrieve the entity to pass to the bound functor or return.
@@ -138,7 +138,7 @@ public:
 private:
   /** The const_limited_reference to the bound argument.
    */
-  limit_reference_base<const T_wrapped> visited_;
+  limit_reference<const T_wrapped> visited_;
 };
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
diff --git a/sigc++/adaptors/track_obj.h b/sigc++/adaptors/track_obj.h
index 7c5631f..039dd27 100644
--- a/sigc++/adaptors/track_obj.h
+++ b/sigc++/adaptors/track_obj.h
@@ -83,7 +83,7 @@ public:
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 //protected:
   // public, so that visit_each() can access it.
-  std::tuple<limit_reference_base<const T_obj>...> obj_;
+  std::tuple<limit_reference<const T_obj>...> obj_;
 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
 }; // end class track_obj_functor
diff --git a/sigc++/functors/macros/mem_fun.h.m4 b/sigc++/functors/macros/mem_fun.h.m4
index 09d8489..077f55b 100644
--- a/sigc++/functors/macros/mem_fun.h.m4
+++ b/sigc++/functors/macros/mem_fun.h.m4
@@ -51,7 +51,7 @@ define([BOUND_MEMBER_FUNCTOR],[dnl
 template<class T_return, class T_obj, class... T_arg>
 using bound_[$1]mem_functor =
   bound_mem_functor_base<
-    limit_reference_base<$2 T_obj>,
+    limit_reference<$2 T_obj>,
     T_return (T_obj::*)(T_arg...) $2,
     T_return, T_obj, T_arg...>;
 ])
@@ -84,7 +84,7 @@ inline decltype(auto)
 mem_fun(/*$2*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(T_arg...) $3)
 {
   return bound_mem_functor_base<
-    limit_reference_base<$3 T_obj>,
+    limit_reference<$3 T_obj>,
     T_return (T_obj::*)(T_arg...) $3,
     T_return, T_obj, T_arg...>(_A_obj, _A_func);
 }
@@ -101,7 +101,7 @@ inline decltype(auto)
 mem_fun(/*$2*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(T_arg...) $3)
 {
   return bound_mem_functor_base<
-    limit_reference_base<$3 T_obj>,
+    limit_reference<$3 T_obj>,
     T_return (T_obj::*)(T_arg...) $3,
     T_return, T_obj, T_arg...>(_A_obj, _A_func);
 }
diff --git a/sigc++/macros/limit_reference.h.m4 b/sigc++/macros/limit_reference.h.m4
index 8584e20..9fa0de9 100644
--- a/sigc++/macros/limit_reference.h.m4
+++ b/sigc++/macros/limit_reference.h.m4
@@ -28,7 +28,7 @@ _FIREWALL([LIMIT_REFERENCE])
 
 namespace sigc {
 
-/** A limit_reference_base<Foo> object stores a reference (Foo&), but makes sure that,
+/** A limit_reference<Foo> object stores a reference (Foo&), but makes sure that,
  * if Foo inherits from sigc::trackable, then visit_each<>() will "limit" itself to the
  * sigc::trackable reference instead of the derived reference. This avoids use of
  * a reference to the derived type when the derived destructor has run. That can be
@@ -51,7 +51,7 @@ namespace sigc {
 template <class T_type,
           bool I_derives_trackable =
             std::is_base_of<trackable, std::decay_t<T_type>>::value>
-class limit_reference_base
+class limit_reference
 {
 public:
   using reference_type = typename std::remove_volatile_t<T_type>;
@@ -59,7 +59,7 @@ public:
   /** Constructor.
    * @param _A_target The reference to limit.
    */
-  limit_reference_base(reference_type& _A_target)
+  limit_reference(reference_type& _A_target)
     : visited(_A_target)
     {}
 
@@ -83,11 +83,11 @@ private:
   reference_type& visited;
 };
 
-/** limit_reference_base object for a class that derives from trackable.
+/** limit_reference object for a class that derives from trackable.
  * - @e T_type The type of the reference.
  */
 template <class T_type>
-class limit_reference_base<T_type, true>
+class limit_reference<T_type, true>
 {
 public:
   using reference_type = typename std::remove_volatile_t<T_type>;
@@ -95,7 +95,7 @@ public:
   /** Constructor.
    * @param _A_target The reference to limit.
    */
-  limit_reference_base(reference_type& _A_target)
+  limit_reference(reference_type& _A_target)
     : visited(_A_target),
       invoked(_A_target)
     {}
@@ -137,11 +137,11 @@ private:
  * @param _A_target The visited instance.
  */
 template <class T_type>
-struct visitor<limit_reference_base<T_type> >
+struct visitor<limit_reference<T_type> >
 {
   template <class T_action>
   static void do_visit_each(const T_action& _A_action,
-                            const limit_reference_base<T_type>& _A_target)
+                            const limit_reference<T_type>& _A_target)
   {
     sigc::visit_each(_A_action, _A_target.visit());
   }