tuple: Use everywhere std::size_t...

2011-09-09  Paolo Carlini  <paolo.carlini@oracle.com>

	* include/std/tuple: Use everywhere std::size_t... instead of int...
	* include/std/functional: Likewise.
	* include/std/scoped_allocator: Likewise.
	* include/bits/stl_pair.h: Likewise.

From-SVN: r178746

diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog
index ac4215cc8675ec63eba62b8ce541c3dd74f05773..64f7551cc37c9518e55cb340379957bc553994e3 100644 (file)
--- a/libstdc++-v3/ChangeLog
+++ b/libstdc++-v3/ChangeLog
@@ -1,3 +1,10 @@
+2011-09-09  Paolo Carlini  <paolo.carlini@oracle.com>
+
+       * include/std/tuple: Use everywhere std::size_t... instead of int...
+       * include/std/functional: Likewise.
+       * include/std/scoped_allocator: Likewise.
+       * include/bits/stl_pair.h: Likewise.
+
 2011-09-09  Paolo Carlini  <paolo.carlini@oracle.com>
 
        PR libstdc++/50336

diff --git a/libstdc++-v3/include/bits/stl_pair.h b/libstdc++-v3/include/bits/stl_pair.h
index c4f33d0dcf68d6b874148be28d1f964a66a14fe7..bb33cc6437d938a71a10f2cbd016c291f41c0365 100644 (file)
--- a/libstdc++-v3/include/bits/stl_pair.h
+++ b/libstdc++-v3/include/bits/stl_pair.h
@@ -79,7 +79,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template<typename...>
     class tuple;
 
-  template<int...>
+  template<std::size_t...>
     struct _Index_tuple;
 #endif
 
@@ -206,7 +206,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
        static _Tp
        __cons(tuple<_Args...>&&);
 
-      template<typename _Tp, typename... _Args, int... _Indexes>
+      template<typename _Tp, typename... _Args, std::size_t... _Indexes>
        static _Tp
        __do_cons(tuple<_Args...>&&, const _Index_tuple<_Indexes...>&);
 #endif

diff --git a/libstdc++-v3/include/std/functional b/libstdc++-v3/include/std/functional
index 9296d755faae0751ae499d13382c5da7aff0c46c..4a04eca896973cbf6b3233227ef67a743b7fb948 100644 (file)
--- a/libstdc++-v3/include/std/functional
+++ b/libstdc++-v3/include/std/functional
@@ -914,7 +914,7 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
    * template handles the case where it is safe to use @c
    * tuple_element.
    */
-  template<int __i, typename _Tuple, bool _IsSafe>
+  template<std::size_t __i, typename _Tuple, bool _IsSafe>
     struct _Safe_tuple_element_impl
     : tuple_element<__i, _Tuple> { };
 
@@ -923,7 +923,7 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
    * specialization handles the case where it is not safe to use @c
    * tuple_element. We just return @c _No_tuple_element.
    */
-  template<int __i, typename _Tuple>
+  template<std::size_t __i, typename _Tuple>
     struct _Safe_tuple_element_impl<__i, _Tuple, false>
     {
       typedef _No_tuple_element type;
@@ -933,10 +933,10 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
    * Like tuple_element, but returns @c _No_tuple_element when
    * tuple_element would return an error.
    */
- template<int __i, typename _Tuple>
+ template<std::size_t __i, typename _Tuple>
    struct _Safe_tuple_element
    : _Safe_tuple_element_impl<__i, _Tuple,
-                             (__i >= 0 && __i < tuple_size<_Tuple>::value)>
+                             (__i < tuple_size<_Tuple>::value)>
    { };
 
   /**
@@ -999,7 +999,7 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
     private:
       // Invokes the underlying function object __arg by unpacking all
       // of the arguments in the tuple.
-      template<typename _CVArg, typename... _Args, int... _Indexes>
+      template<typename _CVArg, typename... _Args, std::size_t... _Indexes>
        auto
        __call(_CVArg& __arg, tuple<_Args...>& __tuple,
               const _Index_tuple<_Indexes...>&) const volatile
@@ -1112,14 +1112,14 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
     };
 
   // std::get<I> for volatile-qualified tuples
-  template<size_t _Ind, typename... _Tp>
+  template<std::size_t _Ind, typename... _Tp>
     inline auto
     __volget(volatile tuple<_Tp...>& __tuple)
     -> typename tuple_element<_Ind, tuple<_Tp...>>::type volatile&
     { return std::get<_Ind>(const_cast<tuple<_Tp...>&>(__tuple)); }
 
   // std::get<I> for const-volatile-qualified tuples
-  template<size_t _Ind, typename... _Tp>
+  template<std::size_t _Ind, typename... _Tp>
     inline auto
     __volget(const volatile tuple<_Tp...>& __tuple)
     -> typename tuple_element<_Ind, tuple<_Tp...>>::type const volatile&
@@ -1141,7 +1141,7 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
       tuple<_Bound_args...> _M_bound_args;
 
       // Call unqualified
-      template<typename _Result, typename... _Args, int... _Indexes>
+      template<typename _Result, typename... _Args, std::size_t... _Indexes>
        _Result
        __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>)
        {
@@ -1150,7 +1150,7 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
        }
 
       // Call as const
-      template<typename _Result, typename... _Args, int... _Indexes>
+      template<typename _Result, typename... _Args, std::size_t... _Indexes>
        _Result
        __call_c(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const
        {
@@ -1159,7 +1159,7 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
        }
 
       // Call as volatile
-      template<typename _Result, typename... _Args, int... _Indexes>
+      template<typename _Result, typename... _Args, std::size_t... _Indexes>
        _Result
        __call_v(tuple<_Args...>&& __args,
                 _Index_tuple<_Indexes...>) volatile
@@ -1169,7 +1169,7 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
        }
 
       // Call as const volatile
-      template<typename _Result, typename... _Args, int... _Indexes>
+      template<typename _Result, typename... _Args, std::size_t... _Indexes>
        _Result
        __call_c_v(tuple<_Args...>&& __args,
                   _Index_tuple<_Indexes...>) const volatile
@@ -1272,7 +1272,7 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
        struct __disable_if_void : enable_if<!is_void<_Res>::value, int> { };
 
       // Call unqualified
-      template<typename _Res, typename... _Args, int... _Indexes>
+      template<typename _Res, typename... _Args, std::size_t... _Indexes>
        _Result
        __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
            typename __disable_if_void<_Res>::type = 0)
@@ -1282,7 +1282,7 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
        }
 
       // Call unqualified, return void
-      template<typename _Res, typename... _Args, int... _Indexes>
+      template<typename _Res, typename... _Args, std::size_t... _Indexes>
        void
        __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
            typename __enable_if_void<_Res>::type = 0)
@@ -1292,7 +1292,7 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
        }
 
       // Call as const
-      template<typename _Res, typename... _Args, int... _Indexes>
+      template<typename _Res, typename... _Args, std::size_t... _Indexes>
        _Result
        __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
            typename __disable_if_void<_Res>::type = 0) const
@@ -1302,7 +1302,7 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
        }
 
       // Call as const, return void
-      template<typename _Res, typename... _Args, int... _Indexes>
+      template<typename _Res, typename... _Args, std::size_t... _Indexes>
        void
        __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
            typename __enable_if_void<_Res>::type = 0) const
@@ -1312,7 +1312,7 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
        }
 
       // Call as volatile
-      template<typename _Res, typename... _Args, int... _Indexes>
+      template<typename _Res, typename... _Args, std::size_t... _Indexes>
        _Result
        __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
            typename __disable_if_void<_Res>::type = 0) volatile
@@ -1322,7 +1322,7 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
        }
 
       // Call as volatile, return void
-      template<typename _Res, typename... _Args, int... _Indexes>
+      template<typename _Res, typename... _Args, std::size_t... _Indexes>
        void
        __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
            typename __enable_if_void<_Res>::type = 0) volatile
@@ -1332,7 +1332,7 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
        }
 
       // Call as const volatile
-      template<typename _Res, typename... _Args, int... _Indexes>
+      template<typename _Res, typename... _Args, std::size_t... _Indexes>
        _Result
        __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
            typename __disable_if_void<_Res>::type = 0) const volatile
@@ -1342,7 +1342,7 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
        }
 
       // Call as const volatile, return void
-      template<typename _Res, typename... _Args, int... _Indexes>
+      template<typename _Res, typename... _Args, std::size_t... _Indexes>
        void
        __call(tuple<_Args...>&& __args,
               _Index_tuple<_Indexes...>,
@@ -1533,7 +1533,7 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
 
     private:
 
-      template<int... _Indices>
+      template<std::size_t... _Indices>
         typename result_of<_Callable(_Args...)>::type
         _M_invoke(_Index_tuple<_Indices...>)
         {

diff --git a/libstdc++-v3/include/std/scoped_allocator b/libstdc++-v3/include/std/scoped_allocator
index bebbbd29cc9837a73d9ab78acae26d777d1f3255..9fd53db6133a54039a5b99a83dce51ef6a542e94 100644 (file)
--- a/libstdc++-v3/include/std/scoped_allocator
+++ b/libstdc++-v3/include/std/scoped_allocator
@@ -234,7 +234,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
           return __a_traits::select_on_container_copy_construction(__a);
         }
 
-      template<int... _Indices>
+      template<std::size_t... _Indices>
         scoped_allocator_adaptor(tuple<const _OuterAlloc&,
                                        const _InnerAllocs&...> __refs,
                                  _Index_tuple<_Indices...>)

diff --git a/libstdc++-v3/include/std/tuple b/libstdc++-v3/include/std/tuple
index f68766f57477391b4c9bc9b3d1c099852c47825f..515fb4ea001102279a8f8aded396f02b5b4f63aa 100644 (file)
--- a/libstdc++-v3/include/std/tuple
+++ b/libstdc++-v3/include/std/tuple
@@ -1011,7 +1011,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
    * Stores a tuple of indices. Used by bind() to extract the elements
    * in a tuple. 
    */
-  template<int... _Indexes>
+  template<std::size_t... _Indexes>
     struct _Index_tuple
     {
       typedef _Index_tuple<_Indexes..., sizeof...(_Indexes)> __next;
@@ -1042,7 +1042,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       }
 
   template<class _T1, class _T2>
-    template<typename _Tp, typename... _Args, int... _Indexes>
+    template<typename _Tp, typename... _Args, std::size_t... _Indexes>
       inline _Tp
       pair<_T1, _T2>::__do_cons(tuple<_Args...>&& __tuple,
                                const _Index_tuple<_Indexes...>&)