OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

tuple: Use noexcept where appropriate. 

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

	* include/std/tuple: Use noexcept where appropriate.
	(tuple<>::swap): Rework implementation.
	(_Head_base<>::_M_swap_impl): Remove.
	(get(std::tuple<>&&)): Add.
	* testsuite/20_util/tuple/element_access/get2.cc: New.
	* testsuite/20_util/weak_ptr/comparison/cmp_neg.cc: Adjust dg-error
	line number.

From-SVN: r173838
This commit is contained in:
Paolo Carlini 2011-05-18 00:12:58 +00:00 committed by Paolo Carlini
parent 82bd45d7f0
commit 1aa1114b63
4 changed files with 101 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
libstdc++-v3/ChangeLog
View File

@ -1,3 +1,13 @@
2011-05-17 Paolo Carlini <paolo.carlini@oracle.com>
* include/std/tuple: Use noexcept where appropriate.
(tuple<>::swap): Rework implementation.
(_Head_base<>::_M_swap_impl): Remove.
(get(std::tuple<>&&)): Add.
* testsuite/20_util/tuple/element_access/get2.cc: New.
* testsuite/20_util/weak_ptr/comparison/cmp_neg.cc: Adjust dg-error
line number.
2011-05-16 Paolo Carlini <paolo.carlini@oracle.com>
* include/std/utility: Simplify the last commit, the whole

85
libstdc++-v3/include/std/tuple
View File

@ -59,6 +59,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
struct __add_ref<_Tp&>
{ typedef _Tp& type; };
// Adds an rvalue reference to a non-reference type.
template<typename _Tp>
struct __add_r_ref
{ typedef _Tp&& type; };
template<typename _Tp>
struct __add_r_ref<_Tp&>
{ typedef _Tp& type; };
template<std::size_t _Idx, typename _Head, bool _IsEmpty>
struct _Head_base;
@ -78,13 +87,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_Head& _M_head() { return *this; }
const _Head& _M_head() const { return *this; }
void
_M_swap_impl(_Head& __h)
{
using std::swap;
swap(__h, _M_head());
}
};
template<std::size_t _Idx, typename _Head>
@ -103,13 +105,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_Head& _M_head() { return _M_head_impl; }
const _Head& _M_head() const { return _M_head_impl; }
void
_M_swap_impl(_Head& __h)
{
using std::swap;
swap(__h, _M_head());
}
_Head _M_head_impl;
};
@ -130,9 +125,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
*/
template<std::size_t _Idx>
struct _Tuple_impl<_Idx>
{
{
template<std::size_t, typename...> friend class _Tuple_impl;
protected:
void _M_swap_impl(_Tuple_impl&) { /* no-op */ }
void _M_swap(_Tuple_impl&) noexcept { /* no-op */ }
};
/**
@ -145,6 +142,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
: public _Tuple_impl<_Idx + 1, _Tail...>,
private _Head_base<_Idx, _Head, std::is_empty<_Head>::value>
{
template<std::size_t, typename...> friend class _Tuple_impl;
typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
typedef _Head_base<_Idx, _Head, std::is_empty<_Head>::value> _Base;
@ -218,10 +217,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
protected:
void
_M_swap_impl(_Tuple_impl& __in)
_M_swap(_Tuple_impl& __in)
noexcept(noexcept(swap(std::declval<_Head&>(),
std::declval<_Head&>()))
&& noexcept(__in._M_tail()._M_swap(__in._M_tail())))
{
_Base::_M_swap_impl(__in._M_head());
_Inherited::_M_swap_impl(__in._M_tail());
using std::swap;
swap(this->_M_head(), __in._M_head());
_Inherited::_M_swap(__in._M_tail());
}
};
@ -300,14 +303,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
void
swap(tuple& __in)
{ _Inherited::_M_swap_impl(__in); }
noexcept(noexcept(__in._M_swap(__in)))
{ _Inherited::_M_swap(__in); }
};
template<>
class tuple<>
{
public:
void swap(tuple&) { /* no-op */ }
void swap(tuple&) noexcept { /* no-op */ }
};
/// tuple (2-element), with construction and assignment from a pair.
@ -360,6 +364,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
tuple&
operator=(tuple&& __in)
// noexcept has to wait is_nothrow_move_assignable
{
static_cast<_Inherited&>(*this) = std::move(__in);
return *this;
@ -392,7 +397,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _U1, typename _U2>
tuple&
operator=(pair<_U1, _U2>&& __in)
operator=(pair<_U1, _U2>&& __in) noexcept
{
this->_M_head() = std::forward<_U1>(__in.first);
this->_M_tail()._M_head() = std::forward<_U2>(__in.second);
@ -401,11 +406,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
void
swap(tuple& __in)
{
using std::swap;
swap(this->_M_head(), __in._M_head());
swap(this->_M_tail()._M_head(), __in._M_tail()._M_head());
}
noexcept(noexcept(__in._M_swap(__in)))
{ _Inherited::_M_swap(__in); }
};
/// tuple (1-element).
@ -473,7 +475,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
void
swap(tuple& __in)
{ _Inherited::_M_swap_impl(__in); }
noexcept(noexcept(__in._M_swap(__in)))
{ _Inherited::_M_swap(__in); }
};
@ -522,22 +525,31 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
__get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t)
{ return __t._M_head(); }
// Return a reference (const reference) to the ith element of a tuple.
// Any const or non-const ref elements are returned with their original type.
// Return a reference (const reference, rvalue reference) to the ith element
// of a tuple. Any const or non-const ref elements are returned with their
// original type.
template<std::size_t __i, typename... _Elements>
inline typename __add_ref<
typename tuple_element<__i, tuple<_Elements...> >::type
typename tuple_element<__i, tuple<_Elements...>>::type
>::type
get(tuple<_Elements...>& __t)
get(tuple<_Elements...>& __t) noexcept
{ return __get_helper<__i>(__t); }
template<std::size_t __i, typename... _Elements>
inline typename __add_c_ref<
typename tuple_element<__i, tuple<_Elements...> >::type
typename tuple_element<__i, tuple<_Elements...>>::type
>::type
get(const tuple<_Elements...>& __t)
get(const tuple<_Elements...>& __t) noexcept
{ return __get_helper<__i>(__t); }
template<std::size_t __i, typename... _Elements>
inline typename __add_r_ref<
typename tuple_element<__i, tuple<_Elements...>>::type
>::type
get(tuple<_Elements...>&& __t) noexcept
{ return std::forward<typename tuple_element<__i,
tuple<_Elements...>>::type&&>(get<__i>(__t)); }
// This class helps construct the various comparison operations on tuples
template<std::size_t __check_equal_size, std::size_t __i, std::size_t __j,
typename _Tp, typename _Up>
@ -628,7 +640,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename... _Elements>
inline tuple<_Elements&&...>
forward_as_tuple(_Elements&&... __args)
forward_as_tuple(_Elements&&... __args) noexcept
{ return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); }
template<std::size_t...> struct __index_holder { };
@ -737,12 +749,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename... _Elements>
inline tuple<_Elements&...>
tie(_Elements&... __args)
tie(_Elements&... __args) noexcept
{ return tuple<_Elements&...>(__args...); }
template<typename... _Elements>
inline void
swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y)
noexcept(noexcept(__x.swap(__y)))
{ __x.swap(__y); }
// A class (and instance) which can be used in 'tie' when an element

41
libstdc++-v3/testsuite/20_util/tuple/element_access/get2.cc Normal file
View File

@ -0,0 +1,41 @@
// { dg-do compile }
// { dg-options "-std=gnu++0x" }
// 2011-05-17 Paolo Carlini <paolo.carlini@oracle.com>
//
// Copyright (C) 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <tuple>
void test01()
{
std::tuple<int> t1;
int&& t1one __attribute__((unused)) = std::get<0>(std::move(t1));
std::tuple<float, int> t2;
float&& t2one __attribute__((unused)) = std::get<0>(std::move(t2));
int&& t2two __attribute__((unused)) = std::get<1>(std::move(t2));
std::tuple<short, int, double> t3;
short&& t3one __attribute__((unused)) = std::get<0>(std::move(t3));
int&& t3two __attribute__((unused)) = std::get<1>(std::move(t3));
double&& t3thr __attribute__((unused)) = std::get<2>(std::move(t3));
}

2
libstdc++-v3/testsuite/20_util/weak_ptr/comparison/cmp_neg.cc
View File

@ -51,7 +51,7 @@ main()
// { dg-warning "note" "" { target *-*-* } 485 }
// { dg-warning "note" "" { target *-*-* } 479 }
// { dg-warning "note" "" { target *-*-* } 469 }
// { dg-warning "note" "" { target *-*-* } 587 }
// { dg-warning "note" "" { target *-*-* } 599 }
// { dg-warning "note" "" { target *-*-* } 1056 }
// { dg-warning "note" "" { target *-*-* } 1050 }
// { dg-warning "note" "" { target *-*-* } 342 }