libstdc++: Remove redundant std:: qualification
* include/bits/stl_pair.h (_Index_tuple): Remove redundant namespace qualification. (pair::pair(tuple<>&, tuple<>&, _Index_tuple, _Index_tuple)): Likewise. * include/std/tuple (_Head_base, _Tuple_impl, tuple_size) (tuple_element, __get_helper, get, __make_tuple_impl) (__make_1st_indices, __tuple_concater) (pair::pair(tuple<>&, tuple<>&, _Index_tuple, _Index_tuple)): Likewise. * include/std/utility (tuple_element, __is_tuple_like_impl) (tuple_size, __pair_get, get): Likewise.
This commit is contained in:
Jonathan Wakely
parent
abed8b56b9
commit
a7a3932e4b
@ -89,7 +89,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
||||
template<typename...>
|
||||
class tuple;
|
||||
|
||||
template<std::size_t...>
|
||||
template<size_t...>
|
||||
struct _Index_tuple;
|
||||
|
||||
// Concept utility functions, reused in conditionally-explicit
|
||||
@ -446,11 +446,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
||||
}
|
||||
|
||||
private:
|
||||
template<typename... _Args1, std::size_t... _Indexes1,
|
||||
typename... _Args2, std::size_t... _Indexes2>
|
||||
template<typename... _Args1, size_t... _Indexes1,
|
||||
typename... _Args2, size_t... _Indexes2>
|
||||
_GLIBCXX20_CONSTEXPR
|
||||
pair(tuple<_Args1...>&, tuple<_Args2...>&,
|
||||
_Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>);
|
||||
_Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>);
|
||||
#endif // C++11
|
||||
};
|
||||
|
||||
|
||||
@ -69,11 +69,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
||||
= typename conditional<__is_final(_Tp), false_type,
|
||||
__is_empty_non_tuple<_Tp>>::type;
|
||||
|
||||
template<std::size_t _Idx, typename _Head,
|
||||
template<size_t _Idx, typename _Head,
|
||||
bool = __empty_not_final<_Head>::value>
|
||||
struct _Head_base;
|
||||
|
||||
template<std::size_t _Idx, typename _Head>
|
||||
template<size_t _Idx, typename _Head>
|
||||
struct _Head_base<_Idx, _Head, true>
|
||||
: public _Head
|
||||
{
|
||||
@ -120,7 +120,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
||||
_M_head(const _Head_base& __b) noexcept { return __b; }
|
||||
};
|
||||
|
||||
template<std::size_t _Idx, typename _Head>
|
||||
template<size_t _Idx, typename _Head>
|
||||
struct _Head_base<_Idx, _Head, false>
|
||||
{
|
||||
constexpr _Head_base()
|
||||
@ -179,7 +179,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
||||
* point in the hierarchy; we use it to implement a constant-time
|
||||
* get() operation.
|
||||
*/
|
||||
template<std::size_t _Idx, typename... _Elements>
|
||||
template<size_t _Idx, typename... _Elements>
|
||||
struct _Tuple_impl;
|
||||
|
||||
/**
|
||||
@ -187,12 +187,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
||||
* and derive from a @c Tuple_impl containing the remaining elements
|
||||
* (which contains the @c Tail).
|
||||
*/
|
||||
template<std::size_t _Idx, typename _Head, typename... _Tail>
|
||||
template<size_t _Idx, typename _Head, typename... _Tail>
|
||||
struct _Tuple_impl<_Idx, _Head, _Tail...>
|
||||
: public _Tuple_impl<_Idx + 1, _Tail...>,
|
||||
private _Head_base<_Idx, _Head>
|
||||
{
|
||||
template<std::size_t, typename...> friend class _Tuple_impl;
|
||||
template<size_t, typename...> friend class _Tuple_impl;
|
||||
|
||||
typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
|
||||
typedef _Head_base<_Idx, _Head> _Base;
|
||||
@ -337,11 +337,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
||||
};
|
||||
|
||||
// Basis case of inheritance recursion.
|
||||
template<std::size_t _Idx, typename _Head>
|
||||
template<size_t _Idx, typename _Head>
|
||||
struct _Tuple_impl<_Idx, _Head>
|
||||
: private _Head_base<_Idx, _Head>
|
||||
{
|
||||
template<std::size_t, typename...> friend class _Tuple_impl;
|
||||
template<size_t, typename...> friend class _Tuple_impl;
|
||||
|
||||
typedef _Head_base<_Idx, _Head> _Base;
|
||||
|
||||
@ -1244,7 +1244,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
||||
/// class tuple_size
|
||||
template<typename... _Elements>
|
||||
struct tuple_size<tuple<_Elements...>>
|
||||
: public integral_constant<std::size_t, sizeof...(_Elements)> { };
|
||||
: public integral_constant<size_t, sizeof...(_Elements)> { };
|
||||
|
||||
#if __cplusplus > 201402L
|
||||
template <typename _Tp>
|
||||
@ -1255,7 +1255,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
||||
* Recursive case for tuple_element: strip off the first element in
|
||||
* the tuple and retrieve the (i-1)th element of the remaining tuple.
|
||||
*/
|
||||
template<std::size_t __i, typename _Head, typename... _Tail>
|
||||
template<size_t __i, typename _Head, typename... _Tail>
|
||||
struct tuple_element<__i, tuple<_Head, _Tail...> >
|
||||
: tuple_element<__i - 1, tuple<_Tail...> > { };
|
||||
|
||||
@ -1278,30 +1278,30 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
||||
"tuple index is in range");
|
||||
};
|
||||
|
||||
template<std::size_t __i, typename _Head, typename... _Tail>
|
||||
template<size_t __i, typename _Head, typename... _Tail>
|
||||
constexpr _Head&
|
||||
__get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
|
||||
{ return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
|
||||
|
||||
template<std::size_t __i, typename _Head, typename... _Tail>
|
||||
template<size_t __i, typename _Head, typename... _Tail>
|
||||
constexpr const _Head&
|
||||
__get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
|
||||
{ return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
|
||||
|
||||
/// Return a reference to the ith element of a tuple.
|
||||
template<std::size_t __i, typename... _Elements>
|
||||
template<size_t __i, typename... _Elements>
|
||||
constexpr __tuple_element_t<__i, tuple<_Elements...>>&
|
||||
get(tuple<_Elements...>& __t) noexcept
|
||||
{ return std::__get_helper<__i>(__t); }
|
||||
|
||||
/// Return a const reference to the ith element of a const tuple.
|
||||
template<std::size_t __i, typename... _Elements>
|
||||
template<size_t __i, typename... _Elements>
|
||||
constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
|
||||
get(const tuple<_Elements...>& __t) noexcept
|
||||
{ return std::__get_helper<__i>(__t); }
|
||||
|
||||
/// Return an rvalue reference to the ith element of a tuple rvalue.
|
||||
template<std::size_t __i, typename... _Elements>
|
||||
template<size_t __i, typename... _Elements>
|
||||
constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
|
||||
get(tuple<_Elements...>&& __t) noexcept
|
||||
{
|
||||
@ -1310,7 +1310,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
||||
}
|
||||
|
||||
/// Return a const rvalue reference to the ith element of a const tuple rvalue.
|
||||
template<std::size_t __i, typename... _Elements>
|
||||
template<size_t __i, typename... _Elements>
|
||||
constexpr const __tuple_element_t<__i, tuple<_Elements...>>&&
|
||||
get(const tuple<_Elements...>&& __t) noexcept
|
||||
{
|
||||
@ -1496,7 +1496,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
||||
_Tuple, _Nm>
|
||||
{ };
|
||||
|
||||
template<std::size_t _Nm, typename _Tuple, typename... _Tp>
|
||||
template<size_t _Nm, typename _Tuple, typename... _Tp>
|
||||
struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm>
|
||||
{
|
||||
typedef tuple<_Tp...> __type;
|
||||
@ -1504,7 +1504,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
||||
|
||||
template<typename _Tuple>
|
||||
struct __do_make_tuple
|
||||
: __make_tuple_impl<0, tuple<>, _Tuple, std::tuple_size<_Tuple>::value>
|
||||
: __make_tuple_impl<0, tuple<>, _Tuple, tuple_size<_Tuple>::value>
|
||||
{ };
|
||||
|
||||
// Returns the std::tuple equivalent of a tuple-like type.
|
||||
@ -1552,14 +1552,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
||||
template<>
|
||||
struct __make_1st_indices<>
|
||||
{
|
||||
typedef std::_Index_tuple<> __type;
|
||||
typedef _Index_tuple<> __type;
|
||||
};
|
||||
|
||||
template<typename _Tp, typename... _Tpls>
|
||||
struct __make_1st_indices<_Tp, _Tpls...>
|
||||
{
|
||||
typedef typename std::_Build_index_tuple<std::tuple_size<
|
||||
typename std::remove_reference<_Tp>::type>::value>::__type __type;
|
||||
typedef typename _Build_index_tuple<tuple_size<
|
||||
typename remove_reference<_Tp>::type>::value>::__type __type;
|
||||
};
|
||||
|
||||
// Performs the actual concatenation by step-wise expanding tuple-like
|
||||
@ -1568,8 +1568,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
||||
template<typename _Ret, typename _Indices, typename... _Tpls>
|
||||
struct __tuple_concater;
|
||||
|
||||
template<typename _Ret, std::size_t... _Is, typename _Tp, typename... _Tpls>
|
||||
struct __tuple_concater<_Ret, std::_Index_tuple<_Is...>, _Tp, _Tpls...>
|
||||
template<typename _Ret, size_t... _Is, typename _Tp, typename... _Tpls>
|
||||
struct __tuple_concater<_Ret, _Index_tuple<_Is...>, _Tp, _Tpls...>
|
||||
{
|
||||
template<typename... _Us>
|
||||
static constexpr _Ret
|
||||
@ -1584,7 +1584,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
||||
};
|
||||
|
||||
template<typename _Ret>
|
||||
struct __tuple_concater<_Ret, std::_Index_tuple<>>
|
||||
struct __tuple_concater<_Ret, _Index_tuple<>>
|
||||
{
|
||||
template<typename... _Us>
|
||||
static constexpr _Ret
|
||||
@ -1679,14 +1679,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
||||
{ }
|
||||
|
||||
template<class _T1, class _T2>
|
||||
template<typename... _Args1, std::size_t... _Indexes1,
|
||||
typename... _Args2, std::size_t... _Indexes2>
|
||||
template<typename... _Args1, size_t... _Indexes1,
|
||||
typename... _Args2, size_t... _Indexes2>
|
||||
_GLIBCXX20_CONSTEXPR inline
|
||||
pair<_T1, _T2>::
|
||||
pair(tuple<_Args1...>& __tuple1, tuple<_Args2...>& __tuple2,
|
||||
_Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>)
|
||||
: first(std::forward<_Args1>(std::get<_Indexes1>(__tuple1))...),
|
||||
second(std::forward<_Args2>(std::get<_Indexes2>(__tuple2))...)
|
||||
second(std::forward<_Args2>(std::get<_Indexes2>(__tuple2))...)
|
||||
{ }
|
||||
|
||||
#if __cplusplus >= 201703L
|
||||
|
||||
@ -110,26 +110,26 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
||||
: public tuple_size<_Tp> { };
|
||||
|
||||
/// Gives the type of the ith element of a given tuple type.
|
||||
template<std::size_t __i, typename _Tp>
|
||||
template<size_t __i, typename _Tp>
|
||||
struct tuple_element;
|
||||
|
||||
// Duplicate of C++14's tuple_element_t for internal use in C++11 mode
|
||||
template<std::size_t __i, typename _Tp>
|
||||
template<size_t __i, typename _Tp>
|
||||
using __tuple_element_t = typename tuple_element<__i, _Tp>::type;
|
||||
|
||||
template<std::size_t __i, typename _Tp>
|
||||
template<size_t __i, typename _Tp>
|
||||
struct tuple_element<__i, const _Tp>
|
||||
{
|
||||
typedef typename add_const<__tuple_element_t<__i, _Tp>>::type type;
|
||||
};
|
||||
|
||||
template<std::size_t __i, typename _Tp>
|
||||
template<size_t __i, typename _Tp>
|
||||
struct tuple_element<__i, volatile _Tp>
|
||||
{
|
||||
typedef typename add_volatile<__tuple_element_t<__i, _Tp>>::type type;
|
||||
};
|
||||
|
||||
template<std::size_t __i, typename _Tp>
|
||||
template<size_t __i, typename _Tp>
|
||||
struct tuple_element<__i, const volatile _Tp>
|
||||
{
|
||||
typedef typename add_cv<__tuple_element_t<__i, _Tp>>::type type;
|
||||
@ -141,7 +141,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
||||
// of tuple_element<pair<T,U>> and tuple_element<array<T,N>> are defined.
|
||||
#define __cpp_lib_tuple_element_t 201402L
|
||||
|
||||
template<std::size_t __i, typename _Tp>
|
||||
template<size_t __i, typename _Tp>
|
||||
using tuple_element_t = typename tuple_element<__i, _Tp>::type;
|
||||
#endif
|
||||
|
||||
@ -149,93 +149,93 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
||||
|
||||
/// Partial specialization for std::pair
|
||||
template<typename _T1, typename _T2>
|
||||
struct __is_tuple_like_impl<std::pair<_T1, _T2>> : true_type
|
||||
struct __is_tuple_like_impl<pair<_T1, _T2>> : true_type
|
||||
{ };
|
||||
|
||||
/// Partial specialization for std::pair
|
||||
template<class _Tp1, class _Tp2>
|
||||
struct tuple_size<std::pair<_Tp1, _Tp2>>
|
||||
: public integral_constant<std::size_t, 2> { };
|
||||
struct tuple_size<pair<_Tp1, _Tp2>>
|
||||
: public integral_constant<size_t, 2> { };
|
||||
|
||||
/// Partial specialization for std::pair
|
||||
template<class _Tp1, class _Tp2>
|
||||
struct tuple_element<0, std::pair<_Tp1, _Tp2>>
|
||||
struct tuple_element<0, pair<_Tp1, _Tp2>>
|
||||
{ typedef _Tp1 type; };
|
||||
|
||||
/// Partial specialization for std::pair
|
||||
template<class _Tp1, class _Tp2>
|
||||
struct tuple_element<1, std::pair<_Tp1, _Tp2>>
|
||||
struct tuple_element<1, pair<_Tp1, _Tp2>>
|
||||
{ typedef _Tp2 type; };
|
||||
|
||||
template<std::size_t _Int>
|
||||
template<size_t _Int>
|
||||
struct __pair_get;
|
||||
|
||||
template<>
|
||||
struct __pair_get<0>
|
||||
{
|
||||
template<typename _Tp1, typename _Tp2>
|
||||
static constexpr _Tp1&
|
||||
__get(std::pair<_Tp1, _Tp2>& __pair) noexcept
|
||||
{ return __pair.first; }
|
||||
static constexpr _Tp1&
|
||||
__get(pair<_Tp1, _Tp2>& __pair) noexcept
|
||||
{ return __pair.first; }
|
||||
|
||||
template<typename _Tp1, typename _Tp2>
|
||||
static constexpr _Tp1&&
|
||||
__move_get(std::pair<_Tp1, _Tp2>&& __pair) noexcept
|
||||
{ return std::forward<_Tp1>(__pair.first); }
|
||||
static constexpr _Tp1&&
|
||||
__move_get(pair<_Tp1, _Tp2>&& __pair) noexcept
|
||||
{ return std::forward<_Tp1>(__pair.first); }
|
||||
|
||||
template<typename _Tp1, typename _Tp2>
|
||||
static constexpr const _Tp1&
|
||||
__const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept
|
||||
{ return __pair.first; }
|
||||
static constexpr const _Tp1&
|
||||
__const_get(const pair<_Tp1, _Tp2>& __pair) noexcept
|
||||
{ return __pair.first; }
|
||||
|
||||
template<typename _Tp1, typename _Tp2>
|
||||
static constexpr const _Tp1&&
|
||||
__const_move_get(const std::pair<_Tp1, _Tp2>&& __pair) noexcept
|
||||
{ return std::forward<const _Tp1>(__pair.first); }
|
||||
static constexpr const _Tp1&&
|
||||
__const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept
|
||||
{ return std::forward<const _Tp1>(__pair.first); }
|
||||
};
|
||||
|
||||
template<>
|
||||
struct __pair_get<1>
|
||||
{
|
||||
template<typename _Tp1, typename _Tp2>
|
||||
static constexpr _Tp2&
|
||||
__get(std::pair<_Tp1, _Tp2>& __pair) noexcept
|
||||
{ return __pair.second; }
|
||||
static constexpr _Tp2&
|
||||
__get(pair<_Tp1, _Tp2>& __pair) noexcept
|
||||
{ return __pair.second; }
|
||||
|
||||
template<typename _Tp1, typename _Tp2>
|
||||
static constexpr _Tp2&&
|
||||
__move_get(std::pair<_Tp1, _Tp2>&& __pair) noexcept
|
||||
{ return std::forward<_Tp2>(__pair.second); }
|
||||
static constexpr _Tp2&&
|
||||
__move_get(pair<_Tp1, _Tp2>&& __pair) noexcept
|
||||
{ return std::forward<_Tp2>(__pair.second); }
|
||||
|
||||
template<typename _Tp1, typename _Tp2>
|
||||
static constexpr const _Tp2&
|
||||
__const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept
|
||||
{ return __pair.second; }
|
||||
static constexpr const _Tp2&
|
||||
__const_get(const pair<_Tp1, _Tp2>& __pair) noexcept
|
||||
{ return __pair.second; }
|
||||
|
||||
template<typename _Tp1, typename _Tp2>
|
||||
static constexpr const _Tp2&&
|
||||
__const_move_get(const std::pair<_Tp1, _Tp2>&& __pair) noexcept
|
||||
{ return std::forward<const _Tp2>(__pair.second); }
|
||||
static constexpr const _Tp2&&
|
||||
__const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept
|
||||
{ return std::forward<const _Tp2>(__pair.second); }
|
||||
};
|
||||
|
||||
template<std::size_t _Int, class _Tp1, class _Tp2>
|
||||
constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
|
||||
get(std::pair<_Tp1, _Tp2>& __in) noexcept
|
||||
template<size_t _Int, class _Tp1, class _Tp2>
|
||||
constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&
|
||||
get(pair<_Tp1, _Tp2>& __in) noexcept
|
||||
{ return __pair_get<_Int>::__get(__in); }
|
||||
|
||||
template<std::size_t _Int, class _Tp1, class _Tp2>
|
||||
constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&&
|
||||
get(std::pair<_Tp1, _Tp2>&& __in) noexcept
|
||||
template<size_t _Int, class _Tp1, class _Tp2>
|
||||
constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&&
|
||||
get(pair<_Tp1, _Tp2>&& __in) noexcept
|
||||
{ return __pair_get<_Int>::__move_get(std::move(__in)); }
|
||||
|
||||
template<std::size_t _Int, class _Tp1, class _Tp2>
|
||||
constexpr const typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
|
||||
get(const std::pair<_Tp1, _Tp2>& __in) noexcept
|
||||
template<size_t _Int, class _Tp1, class _Tp2>
|
||||
constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&
|
||||
get(const pair<_Tp1, _Tp2>& __in) noexcept
|
||||
{ return __pair_get<_Int>::__const_get(__in); }
|
||||
|
||||
template<std::size_t _Int, class _Tp1, class _Tp2>
|
||||
constexpr const typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&&
|
||||
get(const std::pair<_Tp1, _Tp2>&& __in) noexcept
|
||||
template<size_t _Int, class _Tp1, class _Tp2>
|
||||
constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&&
|
||||
get(const pair<_Tp1, _Tp2>&& __in) noexcept
|
||||
{ return __pair_get<_Int>::__const_move_get(std::move(__in)); }
|
||||
|
||||
#if __cplusplus >= 201402L
|
||||
|
||||
Loading…
Reference in New Issue
Block a user