Skip to content

R
riscv-gcc-1
Commit 15ee1a77 by François Dumont
Options

macros.h [...]: Add parameter to pass the 2 instances to check allocator equality. 

2014-05-06  François Dumont  <fdumont@gcc.gnu.org>

	* include/debug/macros.h [__glibcxx_check_equal_allocs]: Add
	parameter to pass the 2 instances to check allocator equality.
	* include/debug/safe_container.h: New, define _Safe_container<>.
	* include/Makefile.am: Add previous.
	* include/debug/deque (std::__debug::deque<>): Inherit
	_Safe_container<>. Use default implementation for all special
	functions.
	* include/debug/forward_list (std::__debug::forward_list<>):
	Likewise.
	* include/debug/list (std::__debug::list<>): Likewise.
	* include/debug/map.h (std::__debug::map<>): Likewise.
	* include/debug/multimap.h (std::__debug::multimap<>): Likewise.
	* include/debug/set.h (std::__debug::set<>): Likewise.
	* include/debug/multiset.h (std::__debug::multiset<>): Likewise.
	* include/debug/string (std::__debug::basic_string<>): Likewise.
	* include/debug/unordered_map
	(std::__debug::unordered_map<>): Likewise.
	(std::__debug::unordered_multimap<>): Likewise.
	* include/debug/unordered_set
	(std::__debug::unordered_set<>): Likewise.
	(std::__debug::unordered_multiset<>): Likewise.
	* include/debug/vector (std::__debug::vector<>): Likewise.
	* include/debug/safe_base.h (_Safe_sequence_base()): Add
	noexcept.
	(_Safe_sequence_base(_Safe_sequence_base&&): Remove.
	(~_Safe_sequence_base()): Add noexcept.
	* include/debug/safe_sequence.h
	(std::__debug::_Safe_node_sequence<>): New.
	* include/debug/safe_unordered_base.h
	(_Safe_unordered_container_base()): Add noexcept.
	(~_Safe_unordered_container_base()): Likewise.
	(_M_swap(_Safe_unordered_container_base&)): Likewise.
	* include/debug/safe_unordered_container.h:
	(_Safe_unordered_container<>::_M_invalidate_locals()): New.
	(_Safe_unordered_container<>::_M_invalidate_all()): New.
	* src/c++11/debug.cc: Limit includes, adapt methods noexcept
	qualifications.
	* testsuite/util/debug/checks.h (check_construct1): Just implement
	an invalid constructor invocation  and no other operations
	potentially not supported by some types of container.
	(check_construct2): Likewise.
	(check_construct3): Likewise.
	* testsuite/23_containers/forward_list/allocator/move.cc: Add
	check on iterators to make sure they are correctly moved in debug
	mode.
	* testsuite/23_containers/forward_list/allocator/move_assign.cc:
	Likewise.
	* testsuite/23_containers/map/allocator/move.cc: Likewise.
	* testsuite/23_containers/map/allocator/move_assign.cc: Likewise.
	* testsuite/23_containers/multimap/allocator/move.cc: Likewise.
	* testsuite/23_containers/multimap/allocator/move_assign.cc:
	Likewise.
	* testsuite/23_containers/multiset/allocator/move.cc: Likewise.
	* testsuite/23_containers/multiset/allocator/move_assign.cc:
	Likewise.
	* testsuite/23_containers/set/allocator/move.cc: Likewise.
	* testsuite/23_containers/set/allocator/move_assign.cc: Likewise.
	* testsuite/23_containers/unordered_map/allocator/move.cc:
	Likewise.
	* testsuite/23_containers/unordered_map/allocator/move_assign.cc:
	Likewise.
	* testsuite/23_containers/unordered_multimap/allocator/move.cc:
	Likewise.
	* testsuite/23_containers/unordered_multimap/allocator/move_assign.cc:
	Likewise.
	* testsuite/23_containers/unordered_multiset/allocator/move.cc:
	Likewise.
	* testsuite/23_containers/unordered_multiset/allocator/move_assign.cc:
	Likewise.
	* testsuite/23_containers/unordered_set/allocator/move.cc:
	Likewise.
	* testsuite/23_containers/unordered_set/allocator/move_assign.cc:
	Likewise.
	* testsuite/23_containers/forward_list/debug/construct1_neg.cc:
	New.
	* testsuite/23_containers/forward_list/debug/construct2_neg.cc:
	New.
	* testsuite/23_containers/forward_list/debug/construct3_neg.cc:
	New.
	* testsuite/23_containers/forward_list/debug/construct4_neg.cc:
	New.
	* testsuite/23_containers/forward_list/debug/move_assign_neg.cc:
	New.
	* testsuite/23_containers/forward_list/debug/move_neg.cc: New.
	* testsuite/23_containers/map/debug/construct5_neg.cc: New.
	* testsuite/23_containers/map/debug/move_assign_neg.cc: New.
	* testsuite/23_containers/map/debug/move_neg.cc: New.
	* testsuite/23_containers/multimap/debug/construct5_neg.cc: New.
	* testsuite/23_containers/multimap/debug/move_assign_neg.cc: New.
	* testsuite/23_containers/multimap/debug/move_neg.cc: New.
	* testsuite/23_containers/multiset/debug/construct5_neg.cc: New.
	* testsuite/23_containers/multiset/debug/move_assign_neg.cc: New.
	* testsuite/23_containers/multiset/debug/move_neg.cc: New.
	* testsuite/23_containers/set/debug/construct5_neg.cc: New.
	* testsuite/23_containers/set/debug/move_assign_neg.cc: New.
	* testsuite/23_containers/set/debug/move_neg.cc: New.
	* testsuite/23_containers/unordered_map/debug/construct5_neg.cc:
	New.
	* testsuite/23_containers/unordered_map/debug/move_assign_neg.cc:
	New.
	* testsuite/23_containers/unordered_map/debug/move_neg.cc: New.
	* testsuite/23_containers/unordered_multimap/debug/construct5_neg.cc:
	New.
	* testsuite/23_containers/unordered_multimap/debug/move_assign_neg.cc:
	New.
	* testsuite/23_containers/unordered_multimap/debug/move_neg.cc:
	New.
	* testsuite/23_containers/unordered_multiset/debug/construct5_neg.cc:
	New.
	* testsuite/23_containers/unordered_multiset/debug/move_assign_neg.cc:
	New.
	* testsuite/23_containers/unordered_multiset/debug/move_neg.cc:
	New.
	* testsuite/23_containers/unordered_set/debug/construct5_neg.cc:
	New.
	* testsuite/23_containers/unordered_set/debug/move_assign_neg.cc:
	New.
	* testsuite/23_containers/unordered_set/debug/move_neg.cc: New.
	* testsuite/23_containers/vector/debug/move_neg.cc: New.

From-SVN: r210123
parent 6f7e0b57
Showing with 2523 additions and 955 deletions
libstdc++-v3/ChangeLog
2014-05-06 François Dumont <fdumont@gcc.gnu.org>
* include/debug/macros.h [__glibcxx_check_equal_allocs]: Add
parameter to pass the 2 instances to check allocator equality.
* include/debug/safe_container.h: New, define _Safe_container<>.
* include/Makefile.am: Add previous.
* include/debug/deque (std::__debug::deque<>): Inherit
_Safe_container<>. Use default implementation for all special
functions.
* include/debug/forward_list (std::__debug::forward_list<>):
Likewise.
* include/debug/list (std::__debug::list<>): Likewise.
* include/debug/map.h (std::__debug::map<>): Likewise.
* include/debug/multimap.h (std::__debug::multimap<>): Likewise.
* include/debug/set.h (std::__debug::set<>): Likewise.
* include/debug/multiset.h (std::__debug::multiset<>): Likewise.
* include/debug/string (std::__debug::basic_string<>): Likewise.
* include/debug/unordered_map
(std::__debug::unordered_map<>): Likewise.
(std::__debug::unordered_multimap<>): Likewise.
* include/debug/unordered_set
(std::__debug::unordered_set<>): Likewise.
(std::__debug::unordered_multiset<>): Likewise.
* include/debug/vector (std::__debug::vector<>): Likewise.
* include/debug/safe_base.h (_Safe_sequence_base()): Add
noexcept.
(_Safe_sequence_base(_Safe_sequence_base&&): Remove.
(~_Safe_sequence_base()): Add noexcept.
* include/debug/safe_sequence.h
(std::__debug::_Safe_node_sequence<>): New.
* include/debug/safe_unordered_base.h
(_Safe_unordered_container_base()): Add noexcept.
(~_Safe_unordered_container_base()): Likewise.
(_M_swap(_Safe_unordered_container_base&)): Likewise.
* include/debug/safe_unordered_container.h:
(_Safe_unordered_container<>::_M_invalidate_locals()): New.
(_Safe_unordered_container<>::_M_invalidate_all()): New.
* src/c++11/debug.cc: Limit includes, adapt methods noexcept
qualifications.
* testsuite/util/debug/checks.h (check_construct1): Just implement
an invalid constructor invocation and no other operations
potentially not supported by some types of container.
(check_construct2): Likewise.
(check_construct3): Likewise.
* testsuite/23_containers/forward_list/allocator/move.cc: Add
check on iterators to make sure they are correctly moved in debug
mode.
* testsuite/23_containers/forward_list/allocator/move_assign.cc:
Likewise.
* testsuite/23_containers/map/allocator/move.cc: Likewise.
* testsuite/23_containers/map/allocator/move_assign.cc: Likewise.
* testsuite/23_containers/multimap/allocator/move.cc: Likewise.
* testsuite/23_containers/multimap/allocator/move_assign.cc:
Likewise.
* testsuite/23_containers/multiset/allocator/move.cc: Likewise.
* testsuite/23_containers/multiset/allocator/move_assign.cc:
Likewise.
* testsuite/23_containers/set/allocator/move.cc: Likewise.
* testsuite/23_containers/set/allocator/move_assign.cc: Likewise.
* testsuite/23_containers/unordered_map/allocator/move.cc:
Likewise.
* testsuite/23_containers/unordered_map/allocator/move_assign.cc:
Likewise.
* testsuite/23_containers/unordered_multimap/allocator/move.cc:
Likewise.
* testsuite/23_containers/unordered_multimap/allocator/move_assign.cc:
Likewise.
* testsuite/23_containers/unordered_multiset/allocator/move.cc:
Likewise.
* testsuite/23_containers/unordered_multiset/allocator/move_assign.cc:
Likewise.
* testsuite/23_containers/unordered_set/allocator/move.cc:
Likewise.
* testsuite/23_containers/unordered_set/allocator/move_assign.cc:
Likewise.
* testsuite/23_containers/forward_list/debug/construct1_neg.cc:
New.
* testsuite/23_containers/forward_list/debug/construct2_neg.cc:
New.
* testsuite/23_containers/forward_list/debug/construct3_neg.cc:
New.
* testsuite/23_containers/forward_list/debug/construct4_neg.cc:
New.
* testsuite/23_containers/forward_list/debug/move_assign_neg.cc:
New.
* testsuite/23_containers/forward_list/debug/move_neg.cc: New.
* testsuite/23_containers/map/debug/construct5_neg.cc: New.
* testsuite/23_containers/map/debug/move_assign_neg.cc: New.
* testsuite/23_containers/map/debug/move_neg.cc: New.
* testsuite/23_containers/multimap/debug/construct5_neg.cc: New.
* testsuite/23_containers/multimap/debug/move_assign_neg.cc: New.
* testsuite/23_containers/multimap/debug/move_neg.cc: New.
* testsuite/23_containers/multiset/debug/construct5_neg.cc: New.
* testsuite/23_containers/multiset/debug/move_assign_neg.cc: New.
* testsuite/23_containers/multiset/debug/move_neg.cc: New.
* testsuite/23_containers/set/debug/construct5_neg.cc: New.
* testsuite/23_containers/set/debug/move_assign_neg.cc: New.
* testsuite/23_containers/set/debug/move_neg.cc: New.
* testsuite/23_containers/unordered_map/debug/construct5_neg.cc:
New.
* testsuite/23_containers/unordered_map/debug/move_assign_neg.cc:
New.
* testsuite/23_containers/unordered_map/debug/move_neg.cc: New.
* testsuite/23_containers/unordered_multimap/debug/construct5_neg.cc:
New.
* testsuite/23_containers/unordered_multimap/debug/move_assign_neg.cc:
New.
* testsuite/23_containers/unordered_multimap/debug/move_neg.cc:
New.
* testsuite/23_containers/unordered_multiset/debug/construct5_neg.cc:
New.
* testsuite/23_containers/unordered_multiset/debug/move_assign_neg.cc:
New.
* testsuite/23_containers/unordered_multiset/debug/move_neg.cc:
New.
* testsuite/23_containers/unordered_set/debug/construct5_neg.cc:
New.
* testsuite/23_containers/unordered_set/debug/move_assign_neg.cc:
New.
* testsuite/23_containers/unordered_set/debug/move_neg.cc: New.
* testsuite/23_containers/vector/debug/move_neg.cc: New.
2014-05-05 Andreas Schwab <schwab@linux-m68k.org>
* config/abi/post/ia64-linux-gnu/baseline_symbols.txt
......
libstdc++-v3/include/Makefile.am
......@@ -733,6 +733,7 @@ debug_headers = \
${debug_srcdir}/multimap.h \
${debug_srcdir}/multiset.h \
${debug_srcdir}/safe_base.h \
${debug_srcdir}/safe_container.h \
${debug_srcdir}/safe_iterator.h \
${debug_srcdir}/safe_iterator.tcc \
${debug_srcdir}/safe_local_iterator.h \
......
libstdc++-v3/include/debug/deque
......@@ -31,6 +31,7 @@
#include <deque>
#include <debug/safe_sequence.h>
#include <debug/safe_container.h>
#include <debug/safe_iterator.h>
namespace std _GLIBCXX_VISIBILITY(default)
......@@ -40,21 +41,26 @@ namespace __debug
/// Class std::deque with safety/checking/debug instrumentation.
template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
class deque
: public _GLIBCXX_STD_C::deque<_Tp, _Allocator>,
public __gnu_debug::_Safe_sequence<deque<_Tp, _Allocator> >
: public __gnu_debug::_Safe_container<
deque<_Tp, _Allocator>, _Allocator,
__gnu_debug::_Safe_sequence, false>,
public _GLIBCXX_STD_C::deque<_Tp, _Allocator>
{
typedef _GLIBCXX_STD_C::deque<_Tp, _Allocator> _Base;
typedef __gnu_debug::_Safe_container<
deque, _Allocator, __gnu_debug::_Safe_sequence, false> _Safe;
typedef typename _Base::const_iterator _Base_const_iterator;
typedef typename _Base::iterator _Base_iterator;
typedef __gnu_debug::_Equal_to<_Base_const_iterator> _Equal;
public:
typedef typename _Base::reference reference;
typedef typename _Base::const_reference const_reference;
typedef __gnu_debug::_Safe_iterator<_Base_iterator,deque>
typedef __gnu_debug::_Safe_iterator<_Base_iterator, deque>
iterator;
typedef __gnu_debug::_Safe_iterator<_Base_const_iterator,deque>
typedef __gnu_debug::_Safe_iterator<_Base_const_iterator, deque>
const_iterator;
typedef typename _Base::size_type size_type;
......@@ -69,7 +75,25 @@ namespace __debug
// 23.2.1.1 construct/copy/destroy:
deque() : _Base() { }
#if __cplusplus < 201103L
deque()
: _Base() { }
deque(const deque& __x)
: _Base(__x) { }
~deque() { }
#else
deque() = default;
deque(const deque&) = default;
deque(deque&&) = default;
deque(initializer_list<value_type> __l,
const allocator_type& __a = allocator_type())
: _Base(__l, __a) { }
~deque() = default;
#endif
explicit
deque(const _Allocator& __a)
......@@ -103,48 +127,28 @@ namespace __debug
__gnu_debug::__base(__last), __a)
{ }
deque(const deque& __x)
: _Base(__x) { }
deque(const _Base& __x)
: _Base(__x) { }
#if __cplusplus >= 201103L
deque(deque&& __x)
: _Base(std::move(__x))
{ this->_M_swap(__x); }
deque(initializer_list<value_type> __l,
const allocator_type& __a = allocator_type())
: _Base(__l, __a) { }
#endif
~deque() _GLIBCXX_NOEXCEPT { }
#if __cplusplus < 201103L
deque&
operator=(const deque& __x)
{
*static_cast<_Base*>(this) = __x;
this->_M_invalidate_all();
this->_M_safe() = __x;
_M_base() = __x;
return *this;
}
#else
deque&
operator=(const deque&) = default;
#if __cplusplus >= 201103L
deque&
operator=(deque&& __x) noexcept
{
// NB: DR 1204.
// NB: DR 675.
__glibcxx_check_self_move_assign(__x);
clear();
swap(__x);
return *this;
}
operator=(deque&&) = default;
deque&
operator=(initializer_list<value_type> __l)
{
*static_cast<_Base*>(this) = __l;
_M_base() = __l;
this->_M_invalidate_all();
return *this;
}
......@@ -559,10 +563,13 @@ namespace __debug
}
void
swap(deque& __x) _GLIBCXX_NOEXCEPT
swap(deque& __x)
#if __cplusplus >= 201103L
noexcept( noexcept(declval<_Base>().swap(__x)) )
#endif
{
_Safe::_M_swap(__x);
_Base::swap(__x);
this->_M_swap(__x);
}
void
......
libstdc++-v3/include/debug/forward_list
......@@ -33,8 +33,139 @@
#include <forward_list>
#include <debug/safe_sequence.h>
#include <debug/safe_container.h>
#include <debug/safe_iterator.h>
namespace __gnu_debug
{
/// Special iterators swap and invalidation for forward_list because of the
/// before_begin iterator.
template<typename _SafeSequence>
class _Safe_forward_list
: public _Safe_sequence<_SafeSequence>
{
_SafeSequence&
_M_this() noexcept
{ return *static_cast<_SafeSequence*>(this); }
static void
_M_swap_aux(_Safe_sequence_base& __lhs,
_Safe_iterator_base*& __lhs_iterators,
_Safe_sequence_base& __rhs,
_Safe_iterator_base*& __rhs_iterators);
void _M_swap_single(_Safe_sequence_base&) noexcept;
protected:
void
_M_invalidate_all()
{
using _Base_const_iterator = __decltype(_M_this()._M_base().cend());
this->_M_invalidate_if([this](_Base_const_iterator __it)
{
return __it != _M_this()._M_base().cbefore_begin()
&& __it != _M_this()._M_base().cend(); });
}
void _M_swap(_Safe_sequence_base&) noexcept;
};
template<typename _SafeSequence>
void
_Safe_forward_list<_SafeSequence>::
_M_swap_aux(_Safe_sequence_base& __lhs,
_Safe_iterator_base*& __lhs_iterators,
_Safe_sequence_base& __rhs,
_Safe_iterator_base*& __rhs_iterators)
{
using const_iterator = typename _SafeSequence::const_iterator;
_Safe_iterator_base* __bbegin_its = 0;
_Safe_iterator_base* __last_bbegin = 0;
_SafeSequence& __rseq = static_cast<_SafeSequence&>(__rhs);
for (_Safe_iterator_base* __iter = __lhs_iterators; __iter;)
{
// Even iterator is cast to const_iterator, not a problem.
const_iterator* __victim = static_cast<const_iterator*>(__iter);
__iter = __iter->_M_next;
if (__victim->base() == __rseq._M_base().cbefore_begin())
{
__victim->_M_unlink();
if (__lhs_iterators == __victim)
__lhs_iterators = __victim->_M_next;
if (__bbegin_its)
{
__victim->_M_next = __bbegin_its;
__bbegin_its->_M_prior = __victim;
}
else
__last_bbegin = __victim;
__bbegin_its = __victim;
}
else
__victim->_M_sequence = &__lhs;
}
if (__bbegin_its)
{
if (__rhs_iterators)
{
__rhs_iterators->_M_prior = __last_bbegin;
__last_bbegin->_M_next = __rhs_iterators;
}
__rhs_iterators = __bbegin_its;
}
}
template<typename _SafeSequence>
void
_Safe_forward_list<_SafeSequence>::
_M_swap_single(_Safe_sequence_base& __other) noexcept
{
std::swap(_M_this()._M_iterators, __other._M_iterators);
std::swap(_M_this()._M_const_iterators, __other._M_const_iterators);
// Useless, always 1 on forward_list
//std::swap(_M_this()_M_version, __other._M_version);
_Safe_iterator_base* __this_its = _M_this()._M_iterators;
_M_swap_aux(__other, __other._M_iterators,
_M_this(), _M_this()._M_iterators);
_Safe_iterator_base* __this_const_its = _M_this()._M_const_iterators;
_M_swap_aux(__other, __other._M_const_iterators,
_M_this(), _M_this()._M_const_iterators);
_M_swap_aux(_M_this(), __this_its,
__other, __other._M_iterators);
_M_swap_aux(_M_this(), __this_const_its,
__other, __other._M_const_iterators);
}
/* Special forward_list _M_swap version that does not swap the
* before-begin ownership.*/
template<typename _SafeSequence>
void
_Safe_forward_list<_SafeSequence>::
_M_swap(_Safe_sequence_base& __other) noexcept
{
// We need to lock both sequences to swap
using namespace __gnu_cxx;
__mutex *__this_mutex = &_M_this()._M_get_mutex();
__mutex *__other_mutex =
&static_cast<_SafeSequence&>(__other)._M_get_mutex();
if (__this_mutex == __other_mutex)
{
__scoped_lock __lock(*__this_mutex);
_M_swap_single(__other);
}
else
{
__scoped_lock __l1(__this_mutex < __other_mutex
? *__this_mutex : *__other_mutex);
__scoped_lock __l2(__this_mutex < __other_mutex
? *__other_mutex : *__this_mutex);
_M_swap_single(__other);
}
}
}
namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __debug
......@@ -42,119 +173,88 @@ namespace __debug
/// Class std::forward_list with safety/checking/debug instrumentation.
template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
class forward_list
: public _GLIBCXX_STD_C::forward_list<_Tp, _Alloc>,
public __gnu_debug::_Safe_sequence<forward_list<_Tp, _Alloc> >
: public __gnu_debug::_Safe_container<
forward_list<_Tp, _Alloc>, _Alloc, __gnu_debug::_Safe_forward_list>,
public _GLIBCXX_STD_C::forward_list<_Tp, _Alloc>
{
typedef _GLIBCXX_STD_C::forward_list<_Tp, _Alloc> _Base;
typedef __gnu_debug::_Safe_container<
forward_list, _Alloc, __gnu_debug::_Safe_forward_list> _Safe;
typedef typename _Base::iterator _Base_iterator;
typedef typename _Base::const_iterator _Base_const_iterator;
typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
rebind<_GLIBCXX_STD_C::_Fwd_list_node<_Tp>>::other _Node_alloc_type;
typedef __gnu_cxx::__alloc_traits<_Node_alloc_type> _Node_alloc_traits;
public:
typedef typename _Base::reference reference;
typedef typename _Base::const_reference const_reference;
typedef __gnu_debug::_Safe_iterator<_Base_iterator,
forward_list> iterator;
typedef __gnu_debug::_Safe_iterator<_Base_const_iterator,
forward_list> const_iterator;
typedef __gnu_debug::_Safe_iterator<
_Base_iterator, forward_list> iterator;
typedef __gnu_debug::_Safe_iterator<
_Base_const_iterator, forward_list> const_iterator;
typedef typename _Base::size_type size_type;
typedef typename _Base::difference_type difference_type;
typedef _Tp value_type;
typedef _Alloc allocator_type;
typedef typename _Base::allocator_type allocator_type;
typedef typename _Base::pointer pointer;
typedef typename _Base::const_pointer const_pointer;
// 23.2.3.1 construct/copy/destroy:
explicit
forward_list(const _Alloc& __al = _Alloc())
forward_list(const allocator_type& __al = allocator_type())
: _Base(__al) { }
forward_list(const forward_list& __list, const _Alloc& __al)
forward_list(const forward_list& __list, const allocator_type& __al)
: _Base(__list, __al)
{ }
forward_list(forward_list&& __list, const _Alloc& __al)
: _Base(std::move(__list._M_base()), __al)
{
if (__list.get_allocator() == __al)
this->_M_swap(__list);
else
__list._M_invalidate_all();
}
forward_list(forward_list&& __list, const allocator_type& __al)
: _Safe(std::move(__list._M_safe()), __al),
_Base(std::move(__list._M_base()), __al)
{ }
explicit
forward_list(size_type __n, const _Alloc& __al = _Alloc())
forward_list(size_type __n, const allocator_type& __al = allocator_type())
: _Base(__n, __al)
{ }
forward_list(size_type __n, const _Tp& __value,
const _Alloc& __al = _Alloc())
const allocator_type& __al = allocator_type())
: _Base(__n, __value, __al)
{ }
template<typename _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
forward_list(_InputIterator __first, _InputIterator __last,
const _Alloc& __al = _Alloc())
const allocator_type& __al = allocator_type())
: _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first,
__last)),
__gnu_debug::__base(__last), __al)
{ }
forward_list(const forward_list& __list)
: _Base(__list)
{ }
forward_list(const forward_list&) = default;
forward_list(forward_list&& __list) noexcept
: _Base(std::move(__list._M_base()))
{
this->_M_swap(__list);
}
forward_list(forward_list&&) = default;
forward_list(std::initializer_list<_Tp> __il,
const _Alloc& __al = _Alloc())
const allocator_type& __al = allocator_type())
: _Base(__il, __al)
{ }
~forward_list() noexcept
{ }
~forward_list() = default;
forward_list&
operator=(const forward_list& __list)
{
static_cast<_Base&>(*this) = __list;
this->_M_invalidate_all();
return *this;
}
operator=(const forward_list&) = default;
forward_list&
operator=(forward_list&& __list)
noexcept(_Node_alloc_traits::_S_nothrow_move())
{
__glibcxx_check_self_move_assign(__list);
bool __xfer_memory = _Node_alloc_traits::_S_propagate_on_move_assign()
|| __list.get_allocator() == this->get_allocator();
static_cast<_Base&>(*this) = std::move(__list);
if (__xfer_memory)
this->_M_swap(__list);
else
this->_M_invalidate_all();
__list._M_invalidate_all();
return *this;
}
operator=(forward_list&&) = default;
forward_list&
operator=(std::initializer_list<_Tp> __il)
{
static_cast<_Base&>(*this) = __il;
_M_base() = __il;
this->_M_invalidate_all();
return *this;
}
......@@ -347,12 +447,10 @@ namespace __debug
void
swap(forward_list& __list)
noexcept(_Node_alloc_traits::_S_nothrow_swap())
noexcept( noexcept(declval<_Base>().swap(__list)) )
{
if (!_Node_alloc_traits::_S_propagate_on_swap())
__glibcxx_check_equal_allocs(__list);
_Safe::_M_swap(__list);
_Base::swap(__list);
this->_M_swap(__list);
}
void
......@@ -644,93 +742,9 @@ namespace __debug
const _Base&
_M_base() const noexcept { return *this; }
private:
void
_M_invalidate_all()
{
this->_M_invalidate_if([this](_Base_const_iterator __it)
{
return __it != this->_M_base().cbefore_begin()
&& __it != this->_M_base().cend();
});
}
typedef __gnu_debug::_Safe_iterator_base _Safe_iterator_base;
static void
_M_swap_aux(forward_list& __lhs,
_Safe_iterator_base*& __lhs_iterators,
forward_list& __rhs,
_Safe_iterator_base*& __rhs_iterators);
void _M_swap(forward_list& __list);
};
template<typename _Tp, typename _Alloc>
void
forward_list<_Tp, _Alloc>::
_M_swap_aux(forward_list<_Tp, _Alloc>& __lhs,
__gnu_debug::_Safe_iterator_base*& __lhs_iterators,
forward_list<_Tp, _Alloc>& __rhs,
__gnu_debug::_Safe_iterator_base*& __rhs_iterators)
{
using __gnu_debug::_Safe_iterator_base;
_Safe_iterator_base* __bbegin_its = 0;
_Safe_iterator_base* __last_bbegin = 0;
for (_Safe_iterator_base* __iter = __lhs_iterators; __iter;)
{
// Even iterator are casted to const_iterator, not a problem.
const_iterator* __victim = static_cast<const_iterator*>(__iter);
__iter = __iter->_M_next;
if (__victim->base() == __rhs._M_base().cbefore_begin())
{
__victim->_M_unlink();
if (__lhs_iterators == __victim)
__lhs_iterators = __victim->_M_next;
if (__bbegin_its)
{
__victim->_M_next = __bbegin_its;
__bbegin_its->_M_prior = __victim;
}
else
__last_bbegin = __victim;
__bbegin_its = __victim;
}
else
__victim->_M_sequence = &__lhs;
}
if (__bbegin_its)
{
if (__rhs_iterators)
{
__rhs_iterators->_M_prior = __last_bbegin;
__last_bbegin->_M_next = __rhs_iterators;
}
__rhs_iterators = __bbegin_its;
}
}
/* Special forward_list _M_swap version that do not swap the
* before-begin ownership.*/
template<typename _Tp, typename _Alloc>
void
forward_list<_Tp, _Alloc>::
_M_swap(forward_list<_Tp, _Alloc>& __list)
{
__gnu_cxx::__scoped_lock sentry(this->_M_get_mutex());
std::swap(this->_M_iterators, __list._M_iterators);
std::swap(this->_M_const_iterators, __list._M_const_iterators);
// Useless, always 1 on forward_list
//std::swap(this->_M_version, __list._M_version);
_Safe_iterator_base* __this_its = this->_M_iterators;
_M_swap_aux(__list, __list._M_iterators, *this, this->_M_iterators);
_Safe_iterator_base* __this_const_its = this->_M_const_iterators;
_M_swap_aux(__list, __list._M_const_iterators, *this,
this->_M_const_iterators);
_M_swap_aux(*this, __this_its, __list, __list._M_iterators);
_M_swap_aux(*this, __this_const_its, __list, __list._M_const_iterators);
}
template<typename _Tp, typename _Alloc>
bool
operator==(const forward_list<_Tp, _Alloc>& __lx,
const forward_list<_Tp, _Alloc>& __ly)
......
libstdc++-v3/include/debug/list
......@@ -31,6 +31,7 @@
#include <list>
#include <debug/safe_sequence.h>
#include <debug/safe_container.h>
#include <debug/safe_iterator.h>
namespace std _GLIBCXX_VISIBILITY(default)
......@@ -40,15 +41,20 @@ namespace __debug
/// Class std::list with safety/checking/debug instrumentation.
template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
class list
: public _GLIBCXX_STD_C::list<_Tp, _Allocator>,
public __gnu_debug::_Safe_sequence<list<_Tp, _Allocator> >
: public __gnu_debug::_Safe_container<
list<_Tp, _Allocator>, _Allocator,
__gnu_debug::_Safe_node_sequence, false>,
public _GLIBCXX_STD_C::list<_Tp, _Allocator>
{
typedef _GLIBCXX_STD_C::list<_Tp, _Allocator> _Base;
typedef __gnu_debug::_Safe_container<
list, _Allocator, __gnu_debug::_Safe_node_sequence, false> _Safe;
typedef typename _Base::iterator _Base_iterator;
typedef typename _Base::const_iterator _Base_const_iterator;
typedef __gnu_debug::_Equal_to<_Base_const_iterator> _Equal;
typedef __gnu_debug::_Not_equal_to<_Base_const_iterator> _Not_equal;
public:
typedef typename _Base::reference reference;
typedef typename _Base::const_reference const_reference;
......@@ -70,9 +76,26 @@ namespace __debug
// 23.2.2.1 construct/copy/destroy:
list() _GLIBCXX_NOEXCEPT
#if __cplusplus < 201103L
list()
: _Base() { }
list(const list& __x)
: _Base(__x) { }
~list() { }
#else
list() = default;
list(const list&) = default;
list(list&&) = default;
list(initializer_list<value_type> __l,
const allocator_type& __a = allocator_type())
: _Base(__l, __a) { }
~list() = default;
#endif
explicit
list(const _Allocator& __a) _GLIBCXX_NOEXCEPT
: _Base(__a) { }
......@@ -105,49 +128,29 @@ namespace __debug
__gnu_debug::__base(__last), __a)
{ }
list(const list& __x)
: _Base(__x) { }
list(const _Base& __x)
: _Base(__x) { }
#if __cplusplus >= 201103L
list(list&& __x) noexcept
: _Base(std::move(__x))
{ this->_M_swap(__x); }
list(initializer_list<value_type> __l,
const allocator_type& __a = allocator_type())
: _Base(__l, __a) { }
#endif
~list() _GLIBCXX_NOEXCEPT { }
#if __cplusplus < 201103L
list&
operator=(const list& __x)
{
static_cast<_Base&>(*this) = __x;
this->_M_invalidate_all();
this->_M_safe() = __x;
_M_base() = __x;
return *this;
}
#else
list&
operator=(const list&) = default;
#if __cplusplus >= 201103L
list&
operator=(list&& __x)
{
// NB: DR 1204.
// NB: DR 675.
__glibcxx_check_self_move_assign(__x);
clear();
swap(__x);
return *this;
}
operator=(list&&) = default;
list&
operator=(initializer_list<value_type> __l)
{
static_cast<_Base&>(*this) = __l;
this->_M_invalidate_all();
_M_base() = __l;
return *this;
}
......@@ -245,16 +248,14 @@ namespace __debug
{
this->_M_detach_singular();
// if __sz < size(), invalidate all iterators in [begin+__sz, end())
// if __sz < size(), invalidate all iterators in [begin + __sz, end())
_Base_iterator __victim = _Base::begin();
_Base_iterator __end = _Base::end();
for (size_type __i = __sz; __victim != __end && __i > 0; --__i)
++__victim;
for (; __victim != __end; ++__victim)
{
this->_M_invalidate_if(_Equal(__victim));
}
__try
{
......@@ -272,16 +273,14 @@ namespace __debug
{
this->_M_detach_singular();
// if __sz < size(), invalidate all iterators in [begin+__sz, end())
// if __sz < size(), invalidate all iterators in [begin + __sz, end())
_Base_iterator __victim = _Base::begin();
_Base_iterator __end = _Base::end();
for (size_type __i = __sz; __victim != __end && __i > 0; --__i)
++__victim;
for (; __victim != __end; ++__victim)
{
this->_M_invalidate_if(_Equal(__victim));
}
__try
{
......@@ -299,16 +298,14 @@ namespace __debug
{
this->_M_detach_singular();
// if __sz < size(), invalidate all iterators in [begin+__sz, end())
// if __sz < size(), invalidate all iterators in [begin + __sz, end())
_Base_iterator __victim = _Base::begin();
_Base_iterator __end = _Base::end();
for (size_type __i = __sz; __victim != __end && __i > 0; --__i)
++__victim;
for (; __victim != __end; ++__victim)
{
this->_M_invalidate_if(_Equal(__victim));
}
__try
{
......@@ -504,9 +501,12 @@ namespace __debug
void
swap(list& __x)
#if __cplusplus >= 201103L
noexcept( noexcept(declval<_Base>().swap(__x)) )
#endif
{
_Safe::_M_swap(__x);
_Base::swap(__x);
this->_M_swap(__x);
}
void
......@@ -742,13 +742,6 @@ namespace __debug
const _Base&
_M_base() const _GLIBCXX_NOEXCEPT { return *this; }
private:
void
_M_invalidate_all()
{
this->_M_invalidate_if(_Not_equal(_Base::end()));
}
};
template<typename _Tp, typename _Alloc>
......
libstdc++-v3/include/debug/macros.h
......@@ -347,10 +347,10 @@ _GLIBCXX_DEBUG_VERIFY(_F > 0.0f, \
_M_message(__gnu_debug::__msg_valid_load_factor) \
._M_sequence(*this, "this"))
#define __glibcxx_check_equal_allocs(_Other) \
_GLIBCXX_DEBUG_VERIFY(this->get_allocator() == _Other.get_allocator(), \
#define __glibcxx_check_equal_allocs(_This, _Other) \
_GLIBCXX_DEBUG_VERIFY(_This.get_allocator() == _Other.get_allocator(), \
_M_message(__gnu_debug::__msg_equal_allocs) \
._M_sequence(*this, "this"))
._M_sequence(_This, "this"))
#ifdef _GLIBCXX_DEBUG_PEDANTIC
# define __glibcxx_check_string(_String) _GLIBCXX_DEBUG_ASSERT(_String != 0)
......
libstdc++-v3/include/debug/map.h
......@@ -30,6 +30,7 @@
#define _GLIBCXX_DEBUG_MAP_H 1
#include <debug/safe_sequence.h>
#include <debug/safe_container.h>
#include <debug/safe_iterator.h>
#include <utility>
......@@ -41,19 +42,20 @@ namespace __debug
template<typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
typename _Allocator = std::allocator<std::pair<const _Key, _Tp> > >
class map
: public _GLIBCXX_STD_C::map<_Key, _Tp, _Compare, _Allocator>,
public __gnu_debug::_Safe_sequence<map<_Key, _Tp, _Compare, _Allocator> >
: public __gnu_debug::_Safe_container<
map<_Key, _Tp, _Compare, _Allocator>, _Allocator,
__gnu_debug::_Safe_node_sequence>,
public _GLIBCXX_STD_C::map<_Key, _Tp, _Compare, _Allocator>
{
typedef _GLIBCXX_STD_C::map<_Key, _Tp, _Compare, _Allocator> _Base;
typedef _GLIBCXX_STD_C::map<
_Key, _Tp, _Compare, _Allocator> _Base;
typedef __gnu_debug::_Safe_container<
map, _Allocator, __gnu_debug::_Safe_node_sequence> _Safe;
typedef typename _Base::const_iterator _Base_const_iterator;
typedef typename _Base::iterator _Base_iterator;
typedef __gnu_debug::_Equal_to<_Base_const_iterator> _Equal;
#if __cplusplus >= 201103L
typedef __gnu_cxx::__alloc_traits<typename
_Base::allocator_type> _Alloc_traits;
#endif
public:
// types:
typedef _Key key_type;
......@@ -78,32 +80,17 @@ namespace __debug
// 23.3.1.1 construct/copy/destroy:
#if __cplusplus < 201103L
map() : _Base() { }
explicit map(const _Compare& __comp,
const _Allocator& __a = _Allocator())
: _Base(__comp, __a) { }
template<typename _InputIterator>
map(_InputIterator __first, _InputIterator __last,
const _Compare& __comp = _Compare(),
const _Allocator& __a = _Allocator())
: _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first,
__last)),
__gnu_debug::__base(__last),
__comp, __a) { }
map(const map& __x)
: _Base(__x) { }
map(const _Base& __x)
: _Base(__x) { }
#if __cplusplus >= 201103L
map(map&& __x)
noexcept(is_nothrow_copy_constructible<_Compare>::value)
: _Base(std::move(__x))
{ this->_M_swap(__x); }
~map() { }
#else
map() = default;
map(const map&) = default;
map(map&&) = default;
map(initializer_list<value_type> __l,
const _Compare& __c = _Compare(),
......@@ -118,7 +105,8 @@ namespace __debug
: _Base(__m, __a) { }
map(map&& __m, const allocator_type& __a)
: _Base(std::move(__m._M_base()), __a) { }
: _Safe(std::move(__m._M_safe()), __a),
_Base(std::move(__m._M_base()), __a) { }
map(initializer_list<value_type> __l, const allocator_type& __a)
: _Base(__l, __a) { }
......@@ -130,34 +118,40 @@ namespace __debug
__last)),
__gnu_debug::__base(__last), __a)
{ }
~map() = default;
#endif
~map() _GLIBCXX_NOEXCEPT { }
map(const _Base& __x)
: _Base(__x) { }
explicit map(const _Compare& __comp,
const _Allocator& __a = _Allocator())
: _Base(__comp, __a) { }
template<typename _InputIterator>
map(_InputIterator __first, _InputIterator __last,
const _Compare& __comp = _Compare(),
const _Allocator& __a = _Allocator())
: _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first,
__last)),
__gnu_debug::__base(__last),
__comp, __a) { }
#if __cplusplus < 201103L
map&
operator=(const map& __x)
{
this->_M_safe() = __x;
_M_base() = __x;
this->_M_invalidate_all();
return *this;
}
#else
map&
operator=(const map&) = default;
#if __cplusplus >= 201103L
map&
operator=(map&& __x)
noexcept(_Alloc_traits::_S_nothrow_move())
{
__glibcxx_check_self_move_assign(__x);
bool __xfer_memory = _Alloc_traits::_S_propagate_on_move_assign()
|| __x.get_allocator() == this->get_allocator();
_M_base() = std::move(__x._M_base());
if (__xfer_memory)
this->_M_swap(__x);
else
this->_M_invalidate_all();
__x._M_invalidate_all();
return *this;
}
operator=(map&&) = default;
map&
operator=(initializer_list<value_type> __l)
......@@ -395,15 +389,11 @@ namespace __debug
void
swap(map& __x)
#if __cplusplus >= 201103L
noexcept(_Alloc_traits::_S_nothrow_swap())
noexcept( noexcept(declval<_Base>().swap(__x)) )
#endif
{
#if __cplusplus >= 201103L
if (!_Alloc_traits::_S_propagate_on_swap())
__glibcxx_check_equal_allocs(__x);
#endif
_Safe::_M_swap(__x);
_Base::swap(__x);
this->_M_swap(__x);
}
void
......@@ -467,14 +457,6 @@ namespace __debug
const _Base&
_M_base() const _GLIBCXX_NOEXCEPT { return *this; }
private:
void
_M_invalidate_all()
{
typedef __gnu_debug::_Not_equal_to<_Base_const_iterator> _Not_equal;
this->_M_invalidate_if(_Not_equal(_M_base().end()));
}
};
template<typename _Key, typename _Tp,
......
libstdc++-v3/include/debug/multimap.h
......@@ -30,6 +30,7 @@
#define _GLIBCXX_DEBUG_MULTIMAP_H 1
#include <debug/safe_sequence.h>
#include <debug/safe_container.h>
#include <debug/safe_iterator.h>
#include <utility>
......@@ -41,20 +42,20 @@ namespace __debug
template<typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
typename _Allocator = std::allocator<std::pair<const _Key, _Tp> > >
class multimap
: public _GLIBCXX_STD_C::multimap<_Key, _Tp, _Compare, _Allocator>,
public __gnu_debug::_Safe_sequence<multimap<_Key, _Tp,
_Compare, _Allocator> >
: public __gnu_debug::_Safe_container<
multimap<_Key, _Tp, _Compare, _Allocator>, _Allocator,
__gnu_debug::_Safe_node_sequence>,
public _GLIBCXX_STD_C::multimap<_Key, _Tp, _Compare, _Allocator>
{
typedef _GLIBCXX_STD_C::multimap<_Key, _Tp, _Compare, _Allocator> _Base;
typedef _GLIBCXX_STD_C::multimap<
_Key, _Tp, _Compare, _Allocator> _Base;
typedef __gnu_debug::_Safe_container<
multimap, _Allocator, __gnu_debug::_Safe_node_sequence> _Safe;
typedef typename _Base::const_iterator _Base_const_iterator;
typedef typename _Base::iterator _Base_iterator;
typedef __gnu_debug::_Equal_to<_Base_const_iterator> _Equal;
#if __cplusplus >= 201103L
typedef __gnu_cxx::__alloc_traits<typename
_Base::allocator_type> _Alloc_traits;
#endif
public:
// types:
typedef _Key key_type;
......@@ -79,32 +80,17 @@ namespace __debug
// 23.3.1.1 construct/copy/destroy:
#if __cplusplus < 201103L
multimap() : _Base() { }
explicit multimap(const _Compare& __comp,
const _Allocator& __a = _Allocator())
: _Base(__comp, __a) { }
template<typename _InputIterator>
multimap(_InputIterator __first, _InputIterator __last,
const _Compare& __comp = _Compare(),
const _Allocator& __a = _Allocator())
: _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first,
__last)),
__gnu_debug::__base(__last),
__comp, __a) { }
multimap(const multimap& __x)
: _Base(__x) { }
multimap(const _Base& __x)
: _Base(__x) { }
#if __cplusplus >= 201103L
multimap(multimap&& __x)
noexcept(is_nothrow_copy_constructible<_Compare>::value)
: _Base(std::move(__x))
{ this->_M_swap(__x); }
~multimap() { }
#else
multimap() = default;
multimap(const multimap&) = default;
multimap(multimap&&) = default;
multimap(initializer_list<value_type> __l,
const _Compare& __c = _Compare(),
......@@ -119,47 +105,52 @@ namespace __debug
: _Base(__m, __a) { }
multimap(multimap&& __m, const allocator_type& __a)
: _Base(std::move(__m._M_base()), __a) { }
: _Safe(std::move(__m._M_safe()), __a),
_Base(std::move(__m._M_base()), __a) { }
multimap(initializer_list<value_type> __l, const allocator_type& __a)
: _Base(__l, __a)
{ }
: _Base(__l, __a) { }
template<typename _InputIterator>
multimap(_InputIterator __first, _InputIterator __last,
const allocator_type& __a)
: _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first,
__last)),
__gnu_debug::__base(__last), __a)
{ }
__gnu_debug::__base(__last), __a) { }
~multimap() = default;
#endif
~multimap() _GLIBCXX_NOEXCEPT { }
explicit multimap(const _Compare& __comp,
const _Allocator& __a = _Allocator())
: _Base(__comp, __a) { }
template<typename _InputIterator>
multimap(_InputIterator __first, _InputIterator __last,
const _Compare& __comp = _Compare(),
const _Allocator& __a = _Allocator())
: _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first,
__last)),
__gnu_debug::__base(__last),
__comp, __a) { }
multimap(const _Base& __x)
: _Base(__x) { }
#if __cplusplus < 201103L
multimap&
operator=(const multimap& __x)
{
this->_M_safe() = __x;
_M_base() = __x;
this->_M_invalidate_all();
return *this;
}
#else
multimap&
operator=(const multimap&) = default;
#if __cplusplus >= 201103L
multimap&
operator=(multimap&& __x)
noexcept(_Alloc_traits::_S_nothrow_move())
{
__glibcxx_check_self_move_assign(__x);
bool __xfer_memory = _Alloc_traits::_S_propagate_on_move_assign()
|| __x.get_allocator() == this->get_allocator();
_M_base() = std::move(__x._M_base());
if (__xfer_memory)
this->_M_swap(__x);
else
this->_M_invalidate_all();
__x._M_invalidate_all();
return *this;
}
operator=(multimap&&) = default;
multimap&
operator=(initializer_list<value_type> __l)
......@@ -379,15 +370,11 @@ namespace __debug
void
swap(multimap& __x)
#if __cplusplus >= 201103L
noexcept(_Alloc_traits::_S_nothrow_swap())
noexcept( noexcept(declval<_Base>().swap(__x)) )
#endif
{
#if __cplusplus >= 201103L
if (!_Alloc_traits::_S_propagate_on_swap())
__glibcxx_check_equal_allocs(__x);
#endif
_Safe::_M_swap(__x);
_Base::swap(__x);
this->_M_swap(__x);
}
void
......@@ -451,14 +438,6 @@ namespace __debug
const _Base&
_M_base() const _GLIBCXX_NOEXCEPT { return *this; }
private:
void
_M_invalidate_all()
{
typedef __gnu_debug::_Not_equal_to<_Base_const_iterator> _Not_equal;
this->_M_invalidate_if(_Not_equal(_Base::end()));
}
};
template<typename _Key, typename _Tp,
......
libstdc++-v3/include/debug/multiset.h
......@@ -30,6 +30,7 @@
#define _GLIBCXX_DEBUG_MULTISET_H 1
#include <debug/safe_sequence.h>
#include <debug/safe_container.h>
#include <debug/safe_iterator.h>
#include <utility>
......@@ -41,19 +42,19 @@ namespace __debug
template<typename _Key, typename _Compare = std::less<_Key>,
typename _Allocator = std::allocator<_Key> >
class multiset
: public _GLIBCXX_STD_C::multiset<_Key, _Compare, _Allocator>,
public __gnu_debug::_Safe_sequence<multiset<_Key, _Compare, _Allocator> >
: public __gnu_debug::_Safe_container<
multiset<_Key, _Compare, _Allocator>, _Allocator,
__gnu_debug::_Safe_node_sequence>,
public _GLIBCXX_STD_C::multiset<_Key, _Compare, _Allocator>
{
typedef _GLIBCXX_STD_C::multiset<_Key, _Compare, _Allocator> _Base;
typedef __gnu_debug::_Safe_container<
multiset, _Allocator, __gnu_debug::_Safe_node_sequence> _Safe;
typedef typename _Base::const_iterator _Base_const_iterator;
typedef typename _Base::iterator _Base_iterator;
typedef __gnu_debug::_Equal_to<_Base_const_iterator> _Equal;
#if __cplusplus >= 201103L
typedef __gnu_cxx::__alloc_traits<typename
_Base::allocator_type> _Alloc_traits;
#endif
public:
// types:
typedef _Key key_type;
......@@ -78,32 +79,17 @@ namespace __debug
// 23.3.3.1 construct/copy/destroy:
#if __cplusplus < 201103L
multiset() : _Base() { }
explicit multiset(const _Compare& __comp,
const _Allocator& __a = _Allocator())
: _Base(__comp, __a) { }
template<typename _InputIterator>
multiset(_InputIterator __first, _InputIterator __last,
const _Compare& __comp = _Compare(),
const _Allocator& __a = _Allocator())
: _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first,
__last)),
__gnu_debug::__base(__last),
__comp, __a) { }
multiset(const multiset& __x)
: _Base(__x) { }
multiset(const _Base& __x)
: _Base(__x) { }
#if __cplusplus >= 201103L
multiset(multiset&& __x)
noexcept(is_nothrow_copy_constructible<_Compare>::value)
: _Base(std::move(__x))
{ this->_M_swap(__x); }
~multiset() { }
#else
multiset() = default;
multiset(const multiset&) = default;
multiset(multiset&&) = default;
multiset(initializer_list<value_type> __l,
const _Compare& __comp = _Compare(),
......@@ -118,7 +104,8 @@ namespace __debug
: _Base(__m, __a) { }
multiset(multiset&& __m, const allocator_type& __a)
: _Base(std::move(__m._M_base()), __a) { }
: _Safe(std::move(__m._M_safe()), __a),
_Base(std::move(__m._M_base()), __a) { }
multiset(initializer_list<value_type> __l, const allocator_type& __a)
: _Base(__l, __a)
......@@ -129,36 +116,41 @@ namespace __debug
const allocator_type& __a)
: _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first,
__last)),
__gnu_debug::__base(__last), __a)
{ }
__gnu_debug::__base(__last), __a) { }
~multiset() = default;
#endif
~multiset() _GLIBCXX_NOEXCEPT { }
explicit multiset(const _Compare& __comp,
const _Allocator& __a = _Allocator())
: _Base(__comp, __a) { }
template<typename _InputIterator>
multiset(_InputIterator __first, _InputIterator __last,
const _Compare& __comp = _Compare(),
const _Allocator& __a = _Allocator())
: _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first,
__last)),
__gnu_debug::__base(__last),
__comp, __a) { }
multiset(const _Base& __x)
: _Base(__x) { }
#if __cplusplus < 201103L
multiset&
operator=(const multiset& __x)
{
this->_M_safe() = __x;
_M_base() = __x;
this->_M_invalidate_all();
return *this;
}
#else
multiset&
operator=(const multiset&) = default;
#if __cplusplus >= 201103L
multiset&
operator=(multiset&& __x)
noexcept(_Alloc_traits::_S_nothrow_move())
{
__glibcxx_check_self_move_assign(__x);
bool __xfer_memory = _Alloc_traits::_S_propagate_on_move_assign()
|| __x.get_allocator() == this->get_allocator();
_M_base() = std::move(__x._M_base());
if (__xfer_memory)
this->_M_swap(__x);
else
this->_M_invalidate_all();
__x._M_invalidate_all();
return *this;
}
operator=(multiset&&) = default;
multiset&
operator=(initializer_list<value_type> __l)
......@@ -233,7 +225,8 @@ namespace __debug
iterator
emplace(_Args&&... __args)
{
return iterator(_Base::emplace(std::forward<_Args>(__args)...), this);
return iterator(_Base::emplace(std::forward<_Args>(__args)...),
this);
}
template<typename... _Args>
......@@ -364,15 +357,11 @@ namespace __debug
void
swap(multiset& __x)
#if __cplusplus >= 201103L
noexcept(_Alloc_traits::_S_nothrow_swap())
noexcept( noexcept(declval<_Base>().swap(__x)) )
#endif
{
#if __cplusplus >= 201103L
if (!_Alloc_traits::_S_propagate_on_swap())
__glibcxx_check_equal_allocs(__x);
#endif
_Safe::_M_swap(__x);
_Base::swap(__x);
this->_M_swap(__x);
}
void
......@@ -444,14 +433,6 @@ namespace __debug
const _Base&
_M_base() const _GLIBCXX_NOEXCEPT { return *this; }
private:
void
_M_invalidate_all()
{
typedef __gnu_debug::_Not_equal_to<_Base_const_iterator> _Not_equal;
this->_M_invalidate_if(_Not_equal(_Base::end()));
}
};
template<typename _Key, typename _Compare, typename _Allocator>
......
libstdc++-v3/include/debug/safe_base.h
......@@ -104,7 +104,8 @@ namespace __gnu_debug
~_Safe_iterator_base() { this->_M_detach(); }
/** For use in _Safe_iterator. */
__gnu_cxx::__mutex& _M_get_mutex() throw ();
__gnu_cxx::__mutex&
_M_get_mutex() throw ();
public:
/** Attaches this iterator to the given sequence, detaching it
......@@ -112,30 +113,37 @@ namespace __gnu_debug
* new sequence is the NULL pointer, the iterator is left
* unattached.
*/
void _M_attach(_Safe_sequence_base* __seq, bool __constant);
void
_M_attach(_Safe_sequence_base* __seq, bool __constant);
/** Likewise, but not thread-safe. */
void _M_attach_single(_Safe_sequence_base* __seq, bool __constant) throw ();
void
_M_attach_single(_Safe_sequence_base* __seq, bool __constant) throw ();
/** Detach the iterator for whatever sequence it is attached to,
* if any.
*/
void _M_detach();
void
_M_detach();
/** Likewise, but not thread-safe. */
void _M_detach_single() throw ();
void
_M_detach_single() throw ();
/** Determines if we are attached to the given sequence. */
bool _M_attached_to(const _Safe_sequence_base* __seq) const
bool
_M_attached_to(const _Safe_sequence_base* __seq) const
{ return _M_sequence == __seq; }
/** Is this iterator singular? */
_GLIBCXX_PURE bool _M_singular() const throw ();
_GLIBCXX_PURE bool
_M_singular() const throw ();
/** Can we compare this iterator to the given iterator @p __x?
Returns true if both iterators are nonsingular and reference
the same sequence. */
_GLIBCXX_PURE bool _M_can_compare(const _Safe_iterator_base& __x) const throw ();
_GLIBCXX_PURE bool
_M_can_compare(const _Safe_iterator_base& __x) const throw ();
/** Invalidate the iterator, making it singular. */
void
......@@ -188,17 +196,13 @@ namespace __gnu_debug
protected:
// Initialize with a version number of 1 and no iterators
_Safe_sequence_base()
_Safe_sequence_base() _GLIBCXX_NOEXCEPT
: _M_iterators(0), _M_const_iterators(0), _M_version(1)
{ }
#if __cplusplus >= 201103L
_Safe_sequence_base(const _Safe_sequence_base&) noexcept
: _Safe_sequence_base() { }
_Safe_sequence_base(_Safe_sequence_base&& __x) noexcept
: _Safe_sequence_base()
{ _M_swap(__x); }
#endif
/** Notify all iterators that reference this sequence that the
......@@ -231,10 +235,11 @@ namespace __gnu_debug
* one container now reference the other container.
*/
void
_M_swap(_Safe_sequence_base& __x);
_M_swap(_Safe_sequence_base& __x) _GLIBCXX_USE_NOEXCEPT;
/** For use in _Safe_sequence. */
__gnu_cxx::__mutex& _M_get_mutex() throw ();
__gnu_cxx::__mutex&
_M_get_mutex() throw ();
public:
/** Invalidates all iterators. */
......
libstdc++-v3/include/debug/safe_container.h 0 → 100644
// Safe container implementation -*- C++ -*-
// Copyright (C) 2014 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.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file debug/safe_container.h
* This file is a GNU debug extension to the Standard C++ Library.
*/
#ifndef _GLIBCXX_DEBUG_SAFE_CONTAINER_H
#define _GLIBCXX_DEBUG_SAFE_CONTAINER_H 1
#include <ext/alloc_traits.h>
namespace __gnu_debug
{
/// Safe class dealing with some allocator dependent operations.
template<typename _SafeContainer,
typename _Alloc,
template<typename> class _SafeBase,
bool _IsCxx11AllocatorAware = true>
class _Safe_container
: public _SafeBase<_SafeContainer>
{
typedef _SafeBase<_SafeContainer> _Base;
_SafeContainer&
_M_cont() _GLIBCXX_NOEXCEPT
{ return *static_cast<_SafeContainer*>(this); }
protected:
_Safe_container&
_M_safe() _GLIBCXX_NOEXCEPT
{ return *this; }
#if __cplusplus >= 201103L
_Safe_container() = default;
_Safe_container(const _Safe_container&) = default;
_Safe_container(_Safe_container&& __x) noexcept
: _Safe_container()
{ _Base::_M_swap(__x); }
_Safe_container(_Safe_container&& __x,
const _Alloc& __a)
: _Safe_container()
{
if (__x._M_cont().get_allocator() == __a)
_Base::_M_swap(__x);
else
__x._M_invalidate_all();
}
#endif
public:
// Copy assignment invalidate all iterators.
_Safe_container&
operator=(const _Safe_container&) _GLIBCXX_NOEXCEPT
{
this->_M_invalidate_all();
return *this;
}
#if __cplusplus >= 201103L
_Safe_container&
operator=(_Safe_container&& __x) noexcept
{
__glibcxx_check_self_move_assign(__x);
if (_IsCxx11AllocatorAware)
{
typedef __gnu_cxx::__alloc_traits<_Alloc> _Alloc_traits;
bool __xfer_memory = _Alloc_traits::_S_propagate_on_move_assign()
|| _M_cont().get_allocator() == __x._M_cont().get_allocator();
if (__xfer_memory)
_Base::_M_swap(__x);
else
this->_M_invalidate_all();
}
else
_Base::_M_swap(__x);
__x._M_invalidate_all();
return *this;
}
void
_M_swap(_Safe_container& __x) noexcept
{
if (_IsCxx11AllocatorAware)
{
typedef __gnu_cxx::__alloc_traits<_Alloc> _Alloc_traits;
if (!_Alloc_traits::_S_propagate_on_swap())
__glibcxx_check_equal_allocs(this->_M_cont()._M_base(),
__x._M_cont()._M_base());
}
_Base::_M_swap(__x);
}
#endif
};
} // namespace __gnu_debug
#endif
libstdc++-v3/include/debug/safe_sequence.h
......@@ -127,6 +127,25 @@ namespace __gnu_debug
void
_M_transfer_from_if(_Safe_sequence& __from, _Predicate __pred);
};
/// Like _Safe_sequence but with a special _M_invalidate_all implementation
/// not invalidating past-the-end iterators. Used by node based sequence.
template<typename _Sequence>
class _Safe_node_sequence
: public _Safe_sequence<_Sequence>
{
protected:
void
_M_invalidate_all()
{
typedef typename _Sequence::const_iterator _Const_iterator;
typedef typename _Const_iterator::iterator_type _Base_const_iterator;
typedef __gnu_debug::_Not_equal_to<_Base_const_iterator> _Not_equal;
const _Sequence& __seq = *static_cast<_Sequence*>(this);
this->_M_invalidate_if(_Not_equal(__seq._M_base().end()));
}
};
} // namespace __gnu_debug
#include <debug/safe_sequence.tcc>
......
libstdc++-v3/include/debug/safe_unordered_base.h
......@@ -80,7 +80,7 @@ namespace __gnu_debug
~_Safe_local_iterator_base() { this->_M_detach(); }
_Safe_unordered_container_base*
_M_get_container() const _GLIBCXX_NOEXCEPT;
_M_get_container() const noexcept;
public:
/** Attaches this iterator to the given container, detaching it
......@@ -132,15 +132,16 @@ namespace __gnu_debug
protected:
// Initialize with a version number of 1 and no iterators
_Safe_unordered_container_base()
_Safe_unordered_container_base() noexcept
: _M_local_iterators(nullptr), _M_const_local_iterators(nullptr)
{ }
// Initialize with a version number of 1 and no iterators
// Copy constructor does not copy iterators.
_Safe_unordered_container_base(const _Safe_unordered_container_base&)
noexcept
: _Safe_unordered_container_base() { }
// When moved unordered containers iterators are swapped.
_Safe_unordered_container_base(_Safe_unordered_container_base&& __x)
noexcept
: _Safe_unordered_container_base()
......@@ -148,7 +149,7 @@ namespace __gnu_debug
/** Notify all iterators that reference this container that the
container is being destroyed. */
~_Safe_unordered_container_base()
~_Safe_unordered_container_base() noexcept
{ this->_M_detach_all(); }
/** Detach all iterators, leaving them singular. */
......@@ -161,7 +162,7 @@ namespace __gnu_debug
* one container now reference the other container.
*/
void
_M_swap(_Safe_unordered_container_base& __x);
_M_swap(_Safe_unordered_container_base& __x) noexcept;
public:
/** Attach an iterator to this container. */
......
libstdc++-v3/include/debug/safe_unordered_container.h
......@@ -57,7 +57,31 @@ namespace __gnu_debug
template<typename _Container>
class _Safe_unordered_container : public _Safe_unordered_container_base
{
public:
private:
_Container&
_M_cont() noexcept
{ return *static_cast<_Container*>(this); }
protected:
void
_M_invalidate_locals()
{
auto __local_end = _M_cont()._M_base().end(0);
this->_M_invalidate_local_if(
[__local_end](__decltype(_M_cont()._M_base().cend(0)) __it)
{ return __it != __local_end; });
}
void
_M_invalidate_all()
{
auto __end = _M_cont()._M_base().end();
this->_M_invalidate_if(
[__end](__decltype(_M_cont()._M_base().cend()) __it)
{ return __it != __end; });
_M_invalidate_locals();
}
/** Invalidates all iterators @c x that reference this container,
are not singular, and for which @c __pred(x) returns @c
true. @c __pred will be invoked with the normal iterators nested
......
libstdc++-v3/include/debug/set.h
......@@ -30,6 +30,7 @@
#define _GLIBCXX_DEBUG_SET_H 1
#include <debug/safe_sequence.h>
#include <debug/safe_container.h>
#include <debug/safe_iterator.h>
#include <utility>
......@@ -41,18 +42,19 @@ namespace __debug
template<typename _Key, typename _Compare = std::less<_Key>,
typename _Allocator = std::allocator<_Key> >
class set
: public _GLIBCXX_STD_C::set<_Key,_Compare,_Allocator>,
public __gnu_debug::_Safe_sequence<set<_Key, _Compare, _Allocator> >
: public __gnu_debug::_Safe_container<
set<_Key, _Compare, _Allocator>, _Allocator,
__gnu_debug::_Safe_node_sequence>,
public _GLIBCXX_STD_C::set<_Key,_Compare,_Allocator>
{
typedef _GLIBCXX_STD_C::set<_Key, _Compare, _Allocator> _Base;
typedef __gnu_debug::_Safe_container<
set, _Allocator, __gnu_debug::_Safe_node_sequence> _Safe;
typedef typename _Base::const_iterator _Base_const_iterator;
typedef typename _Base::iterator _Base_iterator;
typedef __gnu_debug::_Equal_to<_Base_const_iterator> _Equal;
#if __cplusplus >= 201103L
typedef __gnu_cxx::__alloc_traits<typename
_Base::allocator_type> _Alloc_traits;
#endif
public:
// types:
typedef _Key key_type;
......@@ -77,32 +79,17 @@ namespace __debug
// 23.3.3.1 construct/copy/destroy:
#if __cplusplus < 201103L
set() : _Base() { }
explicit set(const _Compare& __comp,
const _Allocator& __a = _Allocator())
: _Base(__comp, __a) { }
template<typename _InputIterator>
set(_InputIterator __first, _InputIterator __last,
const _Compare& __comp = _Compare(),
const _Allocator& __a = _Allocator())
: _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first,
__last)),
__gnu_debug::__base(__last),
__comp, __a) { }
set(const set& __x)
: _Base(__x) { }
set(const _Base& __x)
: _Base(__x) { }
#if __cplusplus >= 201103L
set(set&& __x)
noexcept(is_nothrow_copy_constructible<_Compare>::value)
: _Base(std::move(__x))
{ this->_M_swap(__x); }
~set() { }
#else
set() = default;
set(const set&) = default;
set(set&&) = default;
set(initializer_list<value_type> __l,
const _Compare& __comp = _Compare(),
......@@ -117,47 +104,52 @@ namespace __debug
: _Base(__x, __a) { }
set(set&& __x, const allocator_type& __a)
: _Base(std::move(__x._M_base()), __a) { }
: _Safe(std::move(__x._M_safe()), __a),
_Base(std::move(__x._M_base()), __a) { }
set(initializer_list<value_type> __l, const allocator_type& __a)
: _Base(__l, __a)
{ }
: _Base(__l, __a) { }
template<typename _InputIterator>
set(_InputIterator __first, _InputIterator __last,
const allocator_type& __a)
: _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first,
__last)),
__gnu_debug::__base(__last), __a)
{ }
__gnu_debug::__base(__last), __a) { }
~set() = default;
#endif
~set() _GLIBCXX_NOEXCEPT { }
explicit set(const _Compare& __comp,
const _Allocator& __a = _Allocator())
: _Base(__comp, __a) { }
template<typename _InputIterator>
set(_InputIterator __first, _InputIterator __last,
const _Compare& __comp = _Compare(),
const _Allocator& __a = _Allocator())
: _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first,
__last)),
__gnu_debug::__base(__last),
__comp, __a) { }
set(const _Base& __x)
: _Base(__x) { }
#if __cplusplus < 201103L
set&
operator=(const set& __x)
{
this->_M_safe() = __x;
_M_base() = __x;
this->_M_invalidate_all();
return *this;
}
#else
set&
operator=(const set&) = default;
#if __cplusplus >= 201103L
set&
operator=(set&& __x)
noexcept(_Alloc_traits::_S_nothrow_move())
{
__glibcxx_check_self_move_assign(__x);
bool __xfer_memory = _Alloc_traits::_S_propagate_on_move_assign()
|| __x.get_allocator() == this->get_allocator();
_M_base() = std::move(__x._M_base());
if (__xfer_memory)
this->_M_swap(__x);
else
this->_M_invalidate_all();
__x._M_invalidate_all();
return *this;
}
operator=(set&&) = default;
set&
operator=(initializer_list<value_type> __l)
......@@ -372,15 +364,11 @@ namespace __debug
void
swap(set& __x)
#if __cplusplus >= 201103L
noexcept(_Alloc_traits::_S_nothrow_swap())
noexcept( noexcept(declval<_Base>().swap(__x)) )
#endif
{
#if __cplusplus >= 201103L
if (!_Alloc_traits::_S_propagate_on_swap())
__glibcxx_check_equal_allocs(__x);
#endif
_Safe::_M_swap(__x);
_Base::swap(__x);
this->_M_swap(__x);
}
void
......@@ -452,14 +440,6 @@ namespace __debug
const _Base&
_M_base() const _GLIBCXX_NOEXCEPT { return *this; }
private:
void
_M_invalidate_all()
{
typedef __gnu_debug::_Not_equal_to<_Base_const_iterator> _Not_equal;
this->_M_invalidate_if(_Not_equal(_M_base().end()));
}
};
template<typename _Key, typename _Compare, typename _Allocator>
......
libstdc++-v3/include/debug/string
......@@ -31,6 +31,7 @@
#include <string>
#include <debug/safe_sequence.h>
#include <debug/safe_container.h>
#include <debug/safe_iterator.h>
namespace __gnu_debug
......@@ -39,12 +40,14 @@ namespace __gnu_debug
template<typename _CharT, typename _Traits = std::char_traits<_CharT>,
typename _Allocator = std::allocator<_CharT> >
class basic_string
: public std::basic_string<_CharT, _Traits, _Allocator>,
public __gnu_debug::_Safe_sequence<basic_string<_CharT, _Traits,
_Allocator> >
: public __gnu_debug::_Safe_container<
basic_string<_CharT, _Traits, _Allocator>,
_Allocator, _Safe_sequence, false>,
public std::basic_string<_CharT, _Traits, _Allocator>
{
typedef std::basic_string<_CharT, _Traits, _Allocator> _Base;
typedef __gnu_debug::_Safe_sequence<basic_string> _Safe_base;
typedef __gnu_debug::_Safe_container<
basic_string, _Allocator, _Safe_sequence, false> _Safe;
public:
// types:
......@@ -58,10 +61,10 @@ namespace __gnu_debug
typedef typename _Base::pointer pointer;
typedef typename _Base::const_pointer const_pointer;
typedef __gnu_debug::_Safe_iterator<typename _Base::iterator, basic_string>
iterator;
typedef __gnu_debug::_Safe_iterator<typename _Base::const_iterator,
basic_string> const_iterator;
typedef __gnu_debug::_Safe_iterator<
typename _Base::iterator, basic_string> iterator;
typedef __gnu_debug::_Safe_iterator<
typename _Base::const_iterator, basic_string> const_iterator;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
......@@ -71,30 +74,39 @@ namespace __gnu_debug
// 21.3.1 construct/copy/destroy:
explicit basic_string(const _Allocator& __a = _Allocator())
// _GLIBCXX_NOEXCEPT
: _Base(__a)
{ }
// Provides conversion from a release-mode string to a debug-mode string
basic_string(const _Base& __base) : _Base(__base) { }
: _Base(__a) { }
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 42. string ctors specify wrong default allocator
#if __cplusplus < 201103L
basic_string(const basic_string& __str)
: _Base(__str, 0, _Base::npos, __str.get_allocator())
: _Base(__str) { }
~basic_string() { }
#else
basic_string(const basic_string&) = default;
basic_string(basic_string&&) = default;
basic_string(std::initializer_list<_CharT> __l,
const _Allocator& __a = _Allocator())
: _Base(__l, __a)
{ }
~basic_string() = default;
#endif // C++11
// Provides conversion from a normal-mode string to a debug-mode string
basic_string(const _Base& __base)
: _Base(__base) { }
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 42. string ctors specify wrong default allocator
basic_string(const basic_string& __str, size_type __pos,
size_type __n = _Base::npos,
const _Allocator& __a = _Allocator())
: _Base(__str, __pos, __n, __a)
{ }
: _Base(__str, __pos, __n, __a) { }
basic_string(const _CharT* __s, size_type __n,
const _Allocator& __a = _Allocator())
: _Base(__gnu_debug::__check_string(__s, __n), __n, __a)
{ }
: _Base(__gnu_debug::__check_string(__s, __n), __n, __a) { }
basic_string(const _CharT* __s, const _Allocator& __a = _Allocator())
: _Base(__gnu_debug::__check_string(__s), __a)
......@@ -102,43 +114,36 @@ namespace __gnu_debug
basic_string(size_type __n, _CharT __c,
const _Allocator& __a = _Allocator())
: _Base(__n, __c, __a)
{ }
: _Base(__n, __c, __a) { }
template<typename _InputIterator>
basic_string(_InputIterator __begin, _InputIterator __end,
const _Allocator& __a = _Allocator())
: _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__begin,
__end)),
__gnu_debug::__base(__end), __a)
{ }
#if __cplusplus >= 201103L
basic_string(basic_string&& __str) // noexcept
: _Base(std::move(__str))
{ }
basic_string(std::initializer_list<_CharT> __l,
const _Allocator& __a = _Allocator())
: _Base(__l, __a)
{ }
#endif // C++11
~basic_string() _GLIBCXX_NOEXCEPT { }
__gnu_debug::__base(__end), __a) { }
#if __cplusplus < 201103L
basic_string&
operator=(const basic_string& __str)
{
*static_cast<_Base*>(this) = __str;
this->_M_invalidate_all();
this->_M_safe() = __str;
_M_base() = __str;
return *this;
}
#else
basic_string&
operator=(const basic_string&) = default;
basic_string&
operator=(basic_string&&) = default;
#endif
basic_string&
operator=(const _CharT* __s)
{
__glibcxx_check_string(__s);
*static_cast<_Base*>(this) = __s;
_M_base() = __s;
this->_M_invalidate_all();
return *this;
}
......@@ -146,25 +151,16 @@ namespace __gnu_debug
basic_string&
operator=(_CharT __c)
{
*static_cast<_Base*>(this) = __c;
_M_base() = __c;
this->_M_invalidate_all();
return *this;
}
#if __cplusplus >= 201103L
basic_string&
operator=(basic_string&& __str)
{
__glibcxx_check_self_move_assign(__str);
*static_cast<_Base*>(this) = std::move(__str);
this->_M_invalidate_all();
return *this;
}
basic_string&
operator=(std::initializer_list<_CharT> __l)
{
*static_cast<_Base*>(this) = __l;
_M_base() = __l;
this->_M_invalidate_all();
return *this;
}
......@@ -704,12 +700,10 @@ namespace __gnu_debug
}
void
swap(basic_string<_CharT,_Traits,_Allocator>& __x)
swap(basic_string& __x)
{
_Safe::_M_swap(__x);
_Base::swap(__x);
this->_M_swap(__x);
this->_M_invalidate_all();
__x._M_invalidate_all();
}
// 21.3.6 string operations:
......@@ -922,7 +916,7 @@ namespace __gnu_debug
const _Base&
_M_base() const _GLIBCXX_NOEXCEPT { return *this; }
using _Safe_base::_M_invalidate_all;
using _Safe::_M_invalidate_all;
};
template<typename _CharT, typename _Traits, typename _Allocator>
......
libstdc++-v3/include/debug/unordered_map
......@@ -35,6 +35,7 @@
# include <unordered_map>
#include <debug/safe_unordered_container.h>
#include <debug/safe_container.h>
#include <debug/safe_iterator.h>
#include <debug/safe_local_iterator.h>
......@@ -48,21 +49,21 @@ namespace __debug
typename _Pred = std::equal_to<_Key>,
typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
class unordered_map
: public _GLIBCXX_STD_C::unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>,
public __gnu_debug::_Safe_unordered_container<unordered_map<_Key, _Tp,
_Hash, _Pred, _Alloc> >
: public __gnu_debug::_Safe_container<
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>, _Alloc,
__gnu_debug::_Safe_unordered_container>,
public _GLIBCXX_STD_C::unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>
{
typedef _GLIBCXX_STD_C::unordered_map<_Key, _Tp, _Hash,
_Pred, _Alloc> _Base;
typedef __gnu_debug::_Safe_unordered_container<unordered_map> _Safe_base;
typedef __gnu_debug::_Safe_container<unordered_map,
_Alloc, __gnu_debug::_Safe_unordered_container> _Safe;
typedef typename _Base::const_iterator _Base_const_iterator;
typedef typename _Base::iterator _Base_iterator;
typedef typename _Base::const_local_iterator _Base_const_local_iterator;
typedef typename _Base::const_local_iterator
_Base_const_local_iterator;
typedef typename _Base::local_iterator _Base_local_iterator;
typedef __gnu_cxx::__alloc_traits<typename
_Base::allocator_type> _Alloc_traits;
public:
typedef typename _Base::size_type size_type;
typedef typename _Base::hasher hasher;
......@@ -72,14 +73,14 @@ namespace __debug
typedef typename _Base::key_type key_type;
typedef typename _Base::value_type value_type;
typedef __gnu_debug::_Safe_iterator<_Base_iterator,
unordered_map> iterator;
typedef __gnu_debug::_Safe_iterator<_Base_const_iterator,
unordered_map> const_iterator;
typedef __gnu_debug::_Safe_local_iterator<_Base_local_iterator,
unordered_map> local_iterator;
typedef __gnu_debug::_Safe_local_iterator<_Base_const_local_iterator,
unordered_map> const_local_iterator;
typedef __gnu_debug::_Safe_iterator<
_Base_iterator, unordered_map> iterator;
typedef __gnu_debug::_Safe_iterator<
_Base_const_iterator, unordered_map> const_iterator;
typedef __gnu_debug::_Safe_local_iterator<
_Base_local_iterator, unordered_map> local_iterator;
typedef __gnu_debug::_Safe_local_iterator<
_Base_const_local_iterator, unordered_map> const_local_iterator;
explicit
unordered_map(size_type __n = 10,
......@@ -108,18 +109,16 @@ namespace __debug
explicit
unordered_map(const allocator_type& __a)
: _Base(__a)
{ }
: _Base(__a) { }
unordered_map(const unordered_map& __umap,
const allocator_type& __a)
: _Base(__umap._M_base(), __a)
{ }
: _Base(__umap, __a) { }
unordered_map(unordered_map&& __umap,
const allocator_type& __a)
: _Base(std::move(__umap._M_base()), __a)
{ }
: _Safe(std::move(__umap._M_safe()), __a),
_Base(std::move(__umap._M_base()), __a) { }
unordered_map(initializer_list<value_type> __l,
size_type __n = 0,
......@@ -128,31 +127,13 @@ namespace __debug
const allocator_type& __a = allocator_type())
: _Base(__l, __n, __hf, __eql, __a) { }
~unordered_map() noexcept { }
~unordered_map() = default;
unordered_map&
operator=(const unordered_map& __x)
{
_M_base() = __x._M_base();
this->_M_invalidate_all();
return *this;
}
operator=(const unordered_map&) = default;
unordered_map&
operator=(unordered_map&& __x)
noexcept(_Alloc_traits::_S_nothrow_move())
{
__glibcxx_check_self_move_assign(__x);
bool __xfer_memory = _Alloc_traits::_S_propagate_on_move_assign()
|| __x.get_allocator() == this->get_allocator();
_M_base() = std::move(__x._M_base());
if (__xfer_memory)
this->_M_swap(__x);
else
this->_M_invalidate_all();
__x._M_invalidate_all();
return *this;
}
operator=(unordered_map&&) = default;
unordered_map&
operator=(initializer_list<value_type> __l)
......@@ -164,12 +145,10 @@ namespace __debug
void
swap(unordered_map& __x)
noexcept(_Alloc_traits::_S_nothrow_swap())
noexcept( noexcept(declval<_Base>().swap(__x)) )
{
if (!_Alloc_traits::_S_propagate_on_swap())
__glibcxx_check_equal_allocs(__x);
_Safe::_M_swap(__x);
_Base::swap(__x);
_Safe_base::_M_swap(__x);
}
void
......@@ -449,28 +428,10 @@ namespace __debug
private:
void
_M_invalidate_locals()
{
_Base_local_iterator __local_end = _Base::end(0);
this->_M_invalidate_local_if(
[__local_end](_Base_const_local_iterator __it)
{ return __it != __local_end; });
}
void
_M_invalidate_all()
{
_Base_iterator __end = _Base::end();
this->_M_invalidate_if([__end](_Base_const_iterator __it)
{ return __it != __end; });
_M_invalidate_locals();
}
void
_M_check_rehashed(size_type __prev_count)
{
if (__prev_count != this->bucket_count())
_M_invalidate_locals();
this->_M_invalidate_locals();
}
};
......@@ -502,23 +463,20 @@ namespace __debug
typename _Pred = std::equal_to<_Key>,
typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
class unordered_multimap
: public _GLIBCXX_STD_C::unordered_multimap<_Key, _Tp, _Hash,
_Pred, _Alloc>,
public __gnu_debug::_Safe_unordered_container<unordered_multimap<_Key,
_Tp, _Hash, _Pred, _Alloc> >
: public __gnu_debug::_Safe_container<
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>, _Alloc,
__gnu_debug::_Safe_unordered_container>,
public _GLIBCXX_STD_C::unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>
{
typedef _GLIBCXX_STD_C::unordered_multimap<_Key, _Tp, _Hash,
_Pred, _Alloc> _Base;
typedef __gnu_debug::_Safe_unordered_container<unordered_multimap>
_Safe_base;
typedef __gnu_debug::_Safe_container<unordered_multimap,
_Alloc, __gnu_debug::_Safe_unordered_container> _Safe;
typedef typename _Base::const_iterator _Base_const_iterator;
typedef typename _Base::iterator _Base_iterator;
typedef typename _Base::const_local_iterator _Base_const_local_iterator;
typedef typename _Base::local_iterator _Base_local_iterator;
typedef __gnu_cxx::__alloc_traits<typename
_Base::allocator_type> _Alloc_traits;
public:
typedef typename _Base::size_type size_type;
typedef typename _Base::hasher hasher;
......@@ -528,10 +486,10 @@ namespace __debug
typedef typename _Base::key_type key_type;
typedef typename _Base::value_type value_type;
typedef __gnu_debug::_Safe_iterator<_Base_iterator,
unordered_multimap> iterator;
typedef __gnu_debug::_Safe_iterator<_Base_const_iterator,
unordered_multimap> const_iterator;
typedef __gnu_debug::_Safe_iterator<
_Base_iterator, unordered_multimap> iterator;
typedef __gnu_debug::_Safe_iterator<
_Base_const_iterator, unordered_multimap> const_iterator;
typedef __gnu_debug::_Safe_local_iterator<
_Base_local_iterator, unordered_multimap> local_iterator;
typedef __gnu_debug::_Safe_local_iterator<
......@@ -564,18 +522,16 @@ namespace __debug
explicit
unordered_multimap(const allocator_type& __a)
: _Base(__a)
{ }
: _Base(__a) { }
unordered_multimap(const unordered_multimap& __umap,
const allocator_type& __a)
: _Base(__umap._M_base(), __a)
{ }
: _Base(__umap, __a) { }
unordered_multimap(unordered_multimap&& __umap,
const allocator_type& __a)
: _Base(std::move(__umap._M_base()), __a)
{ }
: _Safe(std::move(__umap._M_safe()), __a),
_Base(std::move(__umap._M_base()), __a) { }
unordered_multimap(initializer_list<value_type> __l,
size_type __n = 0,
......@@ -584,48 +540,28 @@ namespace __debug
const allocator_type& __a = allocator_type())
: _Base(__l, __n, __hf, __eql, __a) { }
~unordered_multimap() noexcept { }
~unordered_multimap() = default;
unordered_multimap&
operator=(const unordered_multimap& __x)
{
_M_base() = __x._M_base();
this->_M_invalidate_all();
return *this;
}
operator=(const unordered_multimap&) = default;
unordered_multimap&
operator=(unordered_multimap&& __x)
noexcept(_Alloc_traits::_S_nothrow_move())
{
__glibcxx_check_self_move_assign(__x);
bool __xfer_memory = _Alloc_traits::_S_propagate_on_move_assign()
|| __x.get_allocator() == this->get_allocator();
_M_base() = std::move(__x._M_base());
if (__xfer_memory)
this->_M_swap(__x);
else
this->_M_invalidate_all();
__x._M_invalidate_all();
return *this;
}
operator=(unordered_multimap&&) = default;
unordered_multimap&
operator=(initializer_list<value_type> __l)
{
_M_base() = __l;
this->_M_base() = __l;
this->_M_invalidate_all();
return *this;
}
void
swap(unordered_multimap& __x)
noexcept(_Alloc_traits::_S_nothrow_swap())
noexcept( noexcept(declval<_Base>().swap(__x)) )
{
if (!_Alloc_traits::_S_propagate_on_swap())
__glibcxx_check_equal_allocs(__x);
_Safe::_M_swap(__x);
_Base::swap(__x);
_Safe_base::_M_swap(__x);
}
void
......@@ -901,28 +837,10 @@ namespace __debug
private:
void
_M_invalidate_locals()
{
_Base_local_iterator __local_end = _Base::end(0);
this->_M_invalidate_local_if(
[__local_end](_Base_const_local_iterator __it)
{ return __it != __local_end; });
}
void
_M_invalidate_all()
{
_Base_iterator __end = _Base::end();
this->_M_invalidate_if([__end](_Base_const_iterator __it)
{ return __it != __end; });
_M_invalidate_locals();
}
void
_M_check_rehashed(size_type __prev_count)
{
if (__prev_count != this->bucket_count())
_M_invalidate_locals();
this->_M_invalidate_locals();
}
};
......
libstdc++-v3/include/debug/unordered_set
......@@ -35,6 +35,7 @@
# include <unordered_set>
#include <debug/safe_unordered_container.h>
#include <debug/safe_container.h>
#include <debug/safe_iterator.h>
#include <debug/safe_local_iterator.h>
......@@ -48,20 +49,21 @@ namespace __debug
typename _Pred = std::equal_to<_Value>,
typename _Alloc = std::allocator<_Value> >
class unordered_set
: public _GLIBCXX_STD_C::unordered_set<_Value, _Hash, _Pred, _Alloc>,
public __gnu_debug::_Safe_unordered_container<unordered_set<_Value, _Hash,
_Pred, _Alloc> >
: public __gnu_debug::_Safe_container<
unordered_set<_Value, _Hash, _Pred, _Alloc>, _Alloc,
__gnu_debug::_Safe_unordered_container>,
public _GLIBCXX_STD_C::unordered_set<_Value, _Hash, _Pred, _Alloc>
{
typedef _GLIBCXX_STD_C::unordered_set<_Value, _Hash,
_Pred, _Alloc> _Base;
typedef __gnu_debug::_Safe_unordered_container<unordered_set> _Safe_base;
typedef _GLIBCXX_STD_C::unordered_set<
_Value, _Hash, _Pred, _Alloc> _Base;
typedef __gnu_debug::_Safe_container<
unordered_set, _Alloc, __gnu_debug::_Safe_unordered_container> _Safe;
typedef typename _Base::const_iterator _Base_const_iterator;
typedef typename _Base::iterator _Base_iterator;
typedef typename _Base::const_local_iterator _Base_const_local_iterator;
typedef typename _Base::local_iterator _Base_local_iterator;
typedef __gnu_cxx::__alloc_traits<typename
_Base::allocator_type> _Alloc_traits;
public:
typedef typename _Base::size_type size_type;
typedef typename _Base::hasher hasher;
......@@ -71,14 +73,14 @@ namespace __debug
typedef typename _Base::key_type key_type;
typedef typename _Base::value_type value_type;
typedef __gnu_debug::_Safe_iterator<_Base_iterator,
unordered_set> iterator;
typedef __gnu_debug::_Safe_iterator<_Base_const_iterator,
unordered_set> const_iterator;
typedef __gnu_debug::_Safe_local_iterator<_Base_local_iterator,
unordered_set> local_iterator;
typedef __gnu_debug::_Safe_local_iterator<_Base_const_local_iterator,
unordered_set> const_local_iterator;
typedef __gnu_debug::_Safe_iterator<
_Base_iterator, unordered_set> iterator;
typedef __gnu_debug::_Safe_iterator<
_Base_const_iterator, unordered_set> const_iterator;
typedef __gnu_debug::_Safe_local_iterator<
_Base_local_iterator, unordered_set> local_iterator;
typedef __gnu_debug::_Safe_local_iterator<
_Base_const_local_iterator, unordered_set> const_local_iterator;
explicit
unordered_set(size_type __n = 10,
......@@ -107,18 +109,16 @@ namespace __debug
explicit
unordered_set(const allocator_type& __a)
: _Base(__a)
{ }
: _Base(__a) { }
unordered_set(const unordered_set& __uset,
const allocator_type& __a)
: _Base(__uset._M_base(), __a)
{ }
: _Base(__uset, __a) { }
unordered_set(unordered_set&& __uset,
const allocator_type& __a)
: _Base(std::move(__uset._M_base()), __a)
{ }
: _Safe(std::move(__uset._M_safe()), __a),
_Base(std::move(__uset._M_base()), __a) { }
unordered_set(initializer_list<value_type> __l,
size_type __n = 0,
......@@ -127,31 +127,13 @@ namespace __debug
const allocator_type& __a = allocator_type())
: _Base(__l, __n, __hf, __eql, __a) { }
~unordered_set() noexcept { }
~unordered_set() = default;
unordered_set&
operator=(const unordered_set& __x)
{
_M_base() = __x._M_base();
this->_M_invalidate_all();
return *this;
}
operator=(const unordered_set&) = default;
unordered_set&
operator=(unordered_set&& __x)
noexcept(_Alloc_traits::_S_nothrow_move())
{
__glibcxx_check_self_move_assign(__x);
bool __xfer_memory = _Alloc_traits::_S_propagate_on_move_assign()
|| __x.get_allocator() == this->get_allocator();
_M_base() = std::move(__x._M_base());
if (__xfer_memory)
this->_M_swap(__x);
else
this->_M_invalidate_all();
__x._M_invalidate_all();
return *this;
}
operator=(unordered_set&&) = default;
unordered_set&
operator=(initializer_list<value_type> __l)
......@@ -163,12 +145,10 @@ namespace __debug
void
swap(unordered_set& __x)
noexcept(_Alloc_traits::_S_nothrow_swap())
noexcept( noexcept(declval<_Base>().swap(__x)) )
{
if (!_Alloc_traits::_S_propagate_on_swap())
__glibcxx_check_equal_allocs(__x);
_Safe::_M_swap(__x);
_Base::swap(__x);
_Safe_base::_M_swap(__x);
}
void
......@@ -290,8 +270,8 @@ namespace __debug
insert(const value_type& __obj)
{
size_type __bucket_count = this->bucket_count();
typedef std::pair<_Base_iterator, bool> __pair_type;
__pair_type __res = _Base::insert(__obj);
std::pair<_Base_iterator, bool> __res
= _Base::insert(__obj);
_M_check_rehashed(__bucket_count);
return std::make_pair(iterator(__res.first, this), __res.second);
}
......@@ -310,8 +290,8 @@ namespace __debug
insert(value_type&& __obj)
{
size_type __bucket_count = this->bucket_count();
typedef std::pair<typename _Base::iterator, bool> __pair_type;
__pair_type __res = _Base::insert(std::move(__obj));
std::pair<_Base_iterator, bool> __res
= _Base::insert(std::move(__obj));
_M_check_rehashed(__bucket_count);
return std::make_pair(iterator(__res.first, this), __res.second);
}
......@@ -356,8 +336,8 @@ namespace __debug
std::pair<iterator, iterator>
equal_range(const key_type& __key)
{
typedef std::pair<_Base_iterator, _Base_iterator> __pair_type;
__pair_type __res = _Base::equal_range(__key);
std::pair<_Base_iterator, _Base_iterator> __res
= _Base::equal_range(__key);
return std::make_pair(iterator(__res.first, this),
iterator(__res.second, this));
}
......@@ -446,29 +426,10 @@ namespace __debug
private:
void
_M_invalidate_locals()
{
_Base_local_iterator __local_end = _Base::end(0);
this->_M_invalidate_local_if(
[__local_end](_Base_const_local_iterator __it)
{ return __it != __local_end; });
}
void
_M_invalidate_all()
{
_Base_iterator __end = _Base::end();
this->_M_invalidate_if(
[__end](_Base_const_iterator __it)
{ return __it != __end; });
_M_invalidate_locals();
}
void
_M_check_rehashed(size_type __prev_count)
{
if (__prev_count != this->bucket_count())
_M_invalidate_locals();
this->_M_invalidate_locals();
}
};
......@@ -497,22 +458,21 @@ namespace __debug
typename _Pred = std::equal_to<_Value>,
typename _Alloc = std::allocator<_Value> >
class unordered_multiset
: public _GLIBCXX_STD_C::unordered_multiset<_Value, _Hash, _Pred, _Alloc>,
public __gnu_debug::_Safe_unordered_container<
unordered_multiset<_Value, _Hash, _Pred, _Alloc> >
{
typedef _GLIBCXX_STD_C::unordered_multiset<_Value, _Hash,
_Pred, _Alloc> _Base;
typedef __gnu_debug::_Safe_unordered_container<unordered_multiset>
_Safe_base;
: public __gnu_debug::_Safe_container<
unordered_multiset<_Value, _Hash, _Pred, _Alloc>, _Alloc,
__gnu_debug::_Safe_unordered_container>,
public _GLIBCXX_STD_C::unordered_multiset<_Value, _Hash, _Pred, _Alloc>
{
typedef _GLIBCXX_STD_C::unordered_multiset<
_Value, _Hash, _Pred, _Alloc> _Base;
typedef __gnu_debug::_Safe_container<unordered_multiset,
_Alloc, __gnu_debug::_Safe_unordered_container> _Safe;
typedef typename _Base::const_iterator _Base_const_iterator;
typedef typename _Base::iterator _Base_iterator;
typedef typename _Base::const_local_iterator _Base_const_local_iterator;
typedef typename _Base::const_local_iterator
_Base_const_local_iterator;
typedef typename _Base::local_iterator _Base_local_iterator;
typedef __gnu_cxx::__alloc_traits<typename
_Base::allocator_type> _Alloc_traits;
public:
typedef typename _Base::size_type size_type;
typedef typename _Base::hasher hasher;
......@@ -522,10 +482,10 @@ namespace __debug
typedef typename _Base::key_type key_type;
typedef typename _Base::value_type value_type;
typedef __gnu_debug::_Safe_iterator<_Base_iterator,
unordered_multiset> iterator;
typedef __gnu_debug::_Safe_iterator<_Base_const_iterator,
unordered_multiset> const_iterator;
typedef __gnu_debug::_Safe_iterator<
_Base_iterator, unordered_multiset> iterator;
typedef __gnu_debug::_Safe_iterator<
_Base_const_iterator, unordered_multiset> const_iterator;
typedef __gnu_debug::_Safe_local_iterator<
_Base_local_iterator, unordered_multiset> local_iterator;
typedef __gnu_debug::_Safe_local_iterator<
......@@ -558,18 +518,16 @@ namespace __debug
explicit
unordered_multiset(const allocator_type& __a)
: _Base(__a)
{ }
: _Base(__a) { }
unordered_multiset(const unordered_multiset& __uset,
const allocator_type& __a)
: _Base(__uset._M_base(), __a)
{ }
: _Base(__uset, __a) { }
unordered_multiset(unordered_multiset&& __uset,
const allocator_type& __a)
: _Base(std::move(__uset._M_base()), __a)
{ }
: _Safe(std::move(__uset._M_safe()), __a),
_Base(std::move(__uset._M_base()), __a) { }
unordered_multiset(initializer_list<value_type> __l,
size_type __n = 0,
......@@ -578,48 +536,28 @@ namespace __debug
const allocator_type& __a = allocator_type())
: _Base(__l, __n, __hf, __eql, __a) { }
~unordered_multiset() noexcept { }
~unordered_multiset() = default;
unordered_multiset&
operator=(const unordered_multiset& __x)
{
_M_base() = __x._M_base();
this->_M_invalidate_all();
return *this;
}
operator=(const unordered_multiset&) = default;
unordered_multiset&
operator=(unordered_multiset&& __x)
noexcept(_Alloc_traits::_S_nothrow_move())
{
__glibcxx_check_self_move_assign(__x);
bool __xfer_memory = _Alloc_traits::_S_propagate_on_move_assign()
|| __x.get_allocator() == this->get_allocator();
_M_base() = std::move(__x._M_base());
if (__xfer_memory)
this->_M_swap(__x);
else
this->_M_invalidate_all();
__x._M_invalidate_all();
return *this;
}
operator=(unordered_multiset&&) = default;
unordered_multiset&
operator=(initializer_list<value_type> __l)
{
_M_base() = __l;
this->_M_base() = __l;
this->_M_invalidate_all();
return *this;
}
void
swap(unordered_multiset& __x)
noexcept(_Alloc_traits::_S_nothrow_swap())
noexcept( noexcept(declval<_Base>().swap(__x)) )
{
if (!_Alloc_traits::_S_propagate_on_swap())
__glibcxx_check_equal_allocs(__x);
_Safe::_M_swap(__x);
_Base::swap(__x);
_Safe_base::_M_swap(__x);
}
void
......@@ -805,8 +743,8 @@ namespace __debug
std::pair<iterator, iterator>
equal_range(const key_type& __key)
{
typedef std::pair<_Base_iterator, _Base_iterator> __pair_type;
__pair_type __res = _Base::equal_range(__key);
std::pair<_Base_iterator, _Base_iterator> __res
= _Base::equal_range(__key);
return std::make_pair(iterator(__res.first, this),
iterator(__res.second, this));
}
......@@ -885,28 +823,10 @@ namespace __debug
private:
void
_M_invalidate_locals()
{
_Base_local_iterator __local_end = _Base::end(0);
this->_M_invalidate_local_if(
[__local_end](_Base_const_local_iterator __it)
{ return __it != __local_end; });
}
void
_M_invalidate_all()
{
_Base_iterator __end = _Base::end();
this->_M_invalidate_if([__end](_Base_const_iterator __it)
{ return __it != __end; });
_M_invalidate_locals();
}
void
_M_check_rehashed(size_type __prev_count)
{
if (__prev_count != this->bucket_count())
_M_invalidate_locals();
this->_M_invalidate_locals();
}
};
......
libstdc++-v3/include/debug/vector
......@@ -32,8 +32,68 @@
#include <vector>
#include <utility>
#include <debug/safe_sequence.h>
#include <debug/safe_container.h>
#include <debug/safe_iterator.h>
namespace __gnu_debug
{
/// Special vector safe base class to add a guaranteed capacity information
/// useful to detect code relying on the libstdc++ reallocation management
/// implementation detail.
template<typename _SafeSequence,
typename _BaseSequence>
class _Safe_vector
{
typedef typename _BaseSequence::size_type size_type;
const _SafeSequence&
_M_seq() const { return *static_cast<const _SafeSequence*>(this); }
protected:
_Safe_vector() _GLIBCXX_NOEXCEPT
: _M_guaranteed_capacity(0)
{ _M_update_guaranteed_capacity(); }
_Safe_vector(const _Safe_vector&) _GLIBCXX_NOEXCEPT
: _M_guaranteed_capacity(0)
{ _M_update_guaranteed_capacity(); }
_Safe_vector(size_type __n) _GLIBCXX_NOEXCEPT
: _M_guaranteed_capacity(__n)
{ }
#if __cplusplus >= 201103L
_Safe_vector(_Safe_vector&& __x) noexcept
: _Safe_vector()
{ __x._M_guaranteed_capacity = 0; }
_Safe_vector&
operator=(const _Safe_vector&) noexcept
{ _M_update_guaranteed_capacity(); }
_Safe_vector&
operator=(_Safe_vector&& __x) noexcept
{
_M_update_guaranteed_capacity();
__x._M_guaranteed_capacity = 0;
}
#endif
size_type _M_guaranteed_capacity;
bool
_M_requires_reallocation(size_type __elements) const _GLIBCXX_NOEXCEPT
{ return __elements > _M_seq().capacity(); }
void
_M_update_guaranteed_capacity() _GLIBCXX_NOEXCEPT
{
if (_M_seq().size() > _M_guaranteed_capacity)
_M_guaranteed_capacity = _M_seq().size();
}
};
}
namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __debug
......@@ -42,28 +102,30 @@ namespace __debug
template<typename _Tp,
typename _Allocator = std::allocator<_Tp> >
class vector
: public _GLIBCXX_STD_C::vector<_Tp, _Allocator>,
public __gnu_debug::_Safe_sequence<vector<_Tp, _Allocator> >
: public __gnu_debug::_Safe_container<
vector<_Tp, _Allocator>, _Allocator, __gnu_debug::_Safe_sequence>,
public _GLIBCXX_STD_C::vector<_Tp, _Allocator>,
public __gnu_debug::_Safe_vector<
vector<_Tp, _Allocator>,
_GLIBCXX_STD_C::vector<_Tp, _Allocator> >
{
typedef _GLIBCXX_STD_C::vector<_Tp, _Allocator> _Base;
typedef __gnu_debug::_Safe_container<
vector, _Allocator, __gnu_debug::_Safe_sequence> _Safe;
typedef __gnu_debug::_Safe_vector<vector, _Base> _Safe_vector;
typedef typename _Base::iterator _Base_iterator;
typedef typename _Base::const_iterator _Base_const_iterator;
typedef __gnu_debug::_Equal_to<_Base_const_iterator> _Equal;
#if __cplusplus >= 201103L
typedef __gnu_debug::_Safe_sequence<vector<_Tp, _Allocator> > _Safe_base;
typedef __gnu_cxx::__alloc_traits<_Allocator> _Alloc_traits;
#endif
public:
typedef typename _Base::reference reference;
typedef typename _Base::const_reference const_reference;
typedef __gnu_debug::_Safe_iterator<_Base_iterator,vector>
iterator;
typedef __gnu_debug::_Safe_iterator<_Base_const_iterator,vector>
const_iterator;
typedef __gnu_debug::_Safe_iterator<
_Base_iterator, vector> iterator;
typedef __gnu_debug::_Safe_iterator<
_Base_const_iterator, vector> const_iterator;
typedef typename _Base::size_type size_type;
typedef typename _Base::difference_type difference_type;
......@@ -77,26 +139,30 @@ namespace __debug
// 23.2.4.1 construct/copy/destroy:
#if __cplusplus < 201103L
vector() _GLIBCXX_NOEXCEPT
: _Base(), _M_guaranteed_capacity(0) { }
: _Base() { }
#else
vector() = default;
#endif
explicit
vector(const _Allocator& __a) _GLIBCXX_NOEXCEPT
: _Base(__a), _M_guaranteed_capacity(0) { }
: _Base(__a) { }
#if __cplusplus >= 201103L
explicit
vector(size_type __n, const _Allocator& __a = _Allocator())
: _Base(__n, __a), _M_guaranteed_capacity(__n) { }
: _Base(__n, __a), _Safe_vector(__n) { }
vector(size_type __n, const _Tp& __value,
const _Allocator& __a = _Allocator())
: _Base(__n, __value, __a), _M_guaranteed_capacity(__n) { }
: _Base(__n, __value, __a) { }
#else
explicit
vector(size_type __n, const _Tp& __value = _Tp(),
const _Allocator& __a = _Allocator())
: _Base(__n, __value, __a), _M_guaranteed_capacity(__n) { }
: _Base(__n, __value, __a) { }
#endif
#if __cplusplus >= 201103L
......@@ -109,79 +175,58 @@ namespace __debug
const _Allocator& __a = _Allocator())
: _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first,
__last)),
__gnu_debug::__base(__last), __a),
_M_guaranteed_capacity(0)
{ _M_update_guaranteed_capacity(); }
__gnu_debug::__base(__last), __a) { }
#if __cplusplus < 201103L
vector(const vector& __x)
: _Base(__x), _M_guaranteed_capacity(__x.size()) { }
: _Base(__x) { }
/// Construction from a normal-mode vector
vector(const _Base& __x)
: _Base(__x), _M_guaranteed_capacity(__x.size()) { }
#if __cplusplus >= 201103L
vector(vector&& __x) noexcept
: _Base(std::move(__x)),
_Safe_base(std::move(__x)),
_M_guaranteed_capacity(this->size())
{ __x._M_guaranteed_capacity = 0; }
~vector() _GLIBCXX_NOEXCEPT { }
#else
vector(const vector&) = default;
vector(vector&&) = default;
vector(const vector& __x, const allocator_type& __a)
: _Base(__x, __a), _M_guaranteed_capacity(__x.size()) { }
: _Base(__x, __a) { }
vector(vector&& __x, const allocator_type& __a)
: _Base(std::move(__x), __a),
_M_guaranteed_capacity(this->size())
{
if (__x.get_allocator() == __a)
this->_M_swap(__x);
else
__x._M_invalidate_all();
__x._M_guaranteed_capacity = 0;
}
: _Safe(std::move(__x._M_safe()), __a),
_Base(std::move(__x._M_base()), __a),
_Safe_vector(std::move(__x)) { }
vector(initializer_list<value_type> __l,
const allocator_type& __a = allocator_type())
: _Base(__l, __a),
_M_guaranteed_capacity(__l.size()) { }
: _Base(__l, __a) { }
~vector() = default;
#endif
~vector() _GLIBCXX_NOEXCEPT { }
/// Construction from a normal-mode vector
vector(const _Base& __x)
: _Base(__x) { }
#if __cplusplus < 201103L
vector&
operator=(const vector& __x)
{
this->_M_safe() = __x;
_M_base() = __x;
this->_M_invalidate_all();
_M_update_guaranteed_capacity();
this->_M_update_guaranteed_capacity();
return *this;
}
#else
vector&
operator=(const vector&) = default;
#if __cplusplus >= 201103L
vector&
operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move())
{
__glibcxx_check_self_move_assign(__x);
bool __xfer_memory = _Alloc_traits::_S_propagate_on_move_assign()
|| __x.get_allocator() == this->get_allocator();
_M_base() = std::move(__x._M_base());
if (__xfer_memory)
this->_M_swap(__x);
else
this->_M_invalidate_all();
_M_update_guaranteed_capacity();
__x._M_invalidate_all();
__x._M_guaranteed_capacity = 0;
return *this;
}
operator=(vector&&) = default;
vector&
operator=(initializer_list<value_type> __l)
{
_M_base() = __l;
this->_M_invalidate_all();
_M_update_guaranteed_capacity();
this->_M_update_guaranteed_capacity();
return *this;
}
#endif
......@@ -199,7 +244,7 @@ namespace __debug
_Base::assign(__gnu_debug::__base(__first),
__gnu_debug::__base(__last));
this->_M_invalidate_all();
_M_update_guaranteed_capacity();
this->_M_update_guaranteed_capacity();
}
void
......@@ -207,7 +252,7 @@ namespace __debug
{
_Base::assign(__n, __u);
this->_M_invalidate_all();
_M_update_guaranteed_capacity();
this->_M_update_guaranteed_capacity();
}
#if __cplusplus >= 201103L
......@@ -216,7 +261,7 @@ namespace __debug
{
_Base::assign(__l);
this->_M_invalidate_all();
_M_update_guaranteed_capacity();
this->_M_update_guaranteed_capacity();
}
#endif
......@@ -281,37 +326,37 @@ namespace __debug
void
resize(size_type __sz)
{
bool __realloc = _M_requires_reallocation(__sz);
bool __realloc = this->_M_requires_reallocation(__sz);
if (__sz < this->size())
this->_M_invalidate_after_nth(__sz);
_Base::resize(__sz);
if (__realloc)
this->_M_invalidate_all();
_M_update_guaranteed_capacity();
this->_M_update_guaranteed_capacity();
}
void
resize(size_type __sz, const _Tp& __c)
{
bool __realloc = _M_requires_reallocation(__sz);
bool __realloc = this->_M_requires_reallocation(__sz);
if (__sz < this->size())
this->_M_invalidate_after_nth(__sz);
_Base::resize(__sz, __c);
if (__realloc)
this->_M_invalidate_all();
_M_update_guaranteed_capacity();
this->_M_update_guaranteed_capacity();
}
#else
void
resize(size_type __sz, _Tp __c = _Tp())
{
bool __realloc = _M_requires_reallocation(__sz);
bool __realloc = this->_M_requires_reallocation(__sz);
if (__sz < this->size())
this->_M_invalidate_after_nth(__sz);
_Base::resize(__sz, __c);
if (__realloc)
this->_M_invalidate_all();
_M_update_guaranteed_capacity();
this->_M_update_guaranteed_capacity();
}
#endif
......@@ -321,7 +366,7 @@ namespace __debug
{
if (_Base::_M_shrink_to_fit())
{
_M_guaranteed_capacity = _Base::capacity();
this->_M_guaranteed_capacity = _Base::capacity();
this->_M_invalidate_all();
}
}
......@@ -331,7 +376,7 @@ namespace __debug
capacity() const _GLIBCXX_NOEXCEPT
{
#ifdef _GLIBCXX_DEBUG_PEDANTIC
return _M_guaranteed_capacity;
return this->_M_guaranteed_capacity;
#else
return _Base::capacity();
#endif
......@@ -342,10 +387,10 @@ namespace __debug
void
reserve(size_type __n)
{
bool __realloc = _M_requires_reallocation(__n);
bool __realloc = this->_M_requires_reallocation(__n);
_Base::reserve(__n);
if (__n > _M_guaranteed_capacity)
_M_guaranteed_capacity = __n;
if (__n > this->_M_guaranteed_capacity)
this->_M_guaranteed_capacity = __n;
if (__realloc)
this->_M_invalidate_all();
}
......@@ -403,11 +448,11 @@ namespace __debug
void
push_back(const _Tp& __x)
{
bool __realloc = _M_requires_reallocation(this->size() + 1);
bool __realloc = this->_M_requires_reallocation(this->size() + 1);
_Base::push_back(__x);
if (__realloc)
this->_M_invalidate_all();
_M_update_guaranteed_capacity();
this->_M_update_guaranteed_capacity();
}
#if __cplusplus >= 201103L
......@@ -421,11 +466,11 @@ namespace __debug
void
emplace_back(_Args&&... __args)
{
bool __realloc = _M_requires_reallocation(this->size() + 1);
bool __realloc = this->_M_requires_reallocation(this->size() + 1);
_Base::emplace_back(std::forward<_Args>(__args)...);
if (__realloc)
this->_M_invalidate_all();
_M_update_guaranteed_capacity();
this->_M_update_guaranteed_capacity();
}
#endif
......@@ -443,7 +488,7 @@ namespace __debug
emplace(const_iterator __position, _Args&&... __args)
{
__glibcxx_check_insert(__position);
bool __realloc = _M_requires_reallocation(this->size() + 1);
bool __realloc = this->_M_requires_reallocation(this->size() + 1);
difference_type __offset = __position.base() - _Base::begin();
_Base_iterator __res = _Base::emplace(__position.base(),
std::forward<_Args>(__args)...);
......@@ -451,7 +496,7 @@ namespace __debug
this->_M_invalidate_all();
else
this->_M_invalidate_after_nth(__offset);
_M_update_guaranteed_capacity();
this->_M_update_guaranteed_capacity();
return iterator(__res, this);
}
#endif
......@@ -464,14 +509,14 @@ namespace __debug
#endif
{
__glibcxx_check_insert(__position);
bool __realloc = _M_requires_reallocation(this->size() + 1);
bool __realloc = this->_M_requires_reallocation(this->size() + 1);
difference_type __offset = __position.base() - _Base::begin();
_Base_iterator __res = _Base::insert(__position.base(), __x);
if (__realloc)
this->_M_invalidate_all();
else
this->_M_invalidate_after_nth(__offset);
_M_update_guaranteed_capacity();
this->_M_update_guaranteed_capacity();
return iterator(__res, this);
}
......@@ -492,14 +537,14 @@ namespace __debug
insert(const_iterator __position, size_type __n, const _Tp& __x)
{
__glibcxx_check_insert(__position);
bool __realloc = _M_requires_reallocation(this->size() + __n);
bool __realloc = this->_M_requires_reallocation(this->size() + __n);
difference_type __offset = __position.base() - _Base::cbegin();
_Base_iterator __res = _Base::insert(__position.base(), __n, __x);
if (__realloc)
this->_M_invalidate_all();
else
this->_M_invalidate_after_nth(__offset);
_M_update_guaranteed_capacity();
this->_M_update_guaranteed_capacity();
return iterator(__res, this);
}
#else
......@@ -507,14 +552,14 @@ namespace __debug
insert(iterator __position, size_type __n, const _Tp& __x)
{
__glibcxx_check_insert(__position);
bool __realloc = _M_requires_reallocation(this->size() + __n);
bool __realloc = this->_M_requires_reallocation(this->size() + __n);
difference_type __offset = __position.base() - _Base::begin();
_Base::insert(__position.base(), __n, __x);
if (__realloc)
this->_M_invalidate_all();
else
this->_M_invalidate_after_nth(__offset);
_M_update_guaranteed_capacity();
this->_M_update_guaranteed_capacity();
}
#endif
......@@ -540,7 +585,7 @@ namespace __debug
this->_M_invalidate_all();
else
this->_M_invalidate_after_nth(__offset);
_M_update_guaranteed_capacity();
this->_M_update_guaranteed_capacity();
return iterator(__res, this);
}
#else
......@@ -563,7 +608,7 @@ namespace __debug
this->_M_invalidate_all();
else
this->_M_invalidate_after_nth(__offset);
_M_update_guaranteed_capacity();
this->_M_update_guaranteed_capacity();
}
#endif
......@@ -611,16 +656,12 @@ namespace __debug
void
swap(vector& __x)
#if __cplusplus >= 201103L
noexcept(_Alloc_traits::_S_nothrow_swap())
noexcept( noexcept(declval<_Base>().swap(__x)) )
#endif
{
#if __cplusplus >= 201103L
if (!_Alloc_traits::_S_propagate_on_swap())
__glibcxx_check_equal_allocs(__x);
#endif
_Safe::_M_swap(__x);
_Base::swap(__x);
this->_M_swap(__x);
std::swap(_M_guaranteed_capacity, __x._M_guaranteed_capacity);
std::swap(this->_M_guaranteed_capacity, __x._M_guaranteed_capacity);
}
void
......@@ -628,7 +669,7 @@ namespace __debug
{
_Base::clear();
this->_M_invalidate_all();
_M_guaranteed_capacity = 0;
this->_M_guaranteed_capacity = 0;
}
_Base&
......@@ -638,19 +679,6 @@ namespace __debug
_M_base() const _GLIBCXX_NOEXCEPT { return *this; }
private:
size_type _M_guaranteed_capacity;
bool
_M_requires_reallocation(size_type __elements) _GLIBCXX_NOEXCEPT
{ return __elements > this->capacity(); }
void
_M_update_guaranteed_capacity() _GLIBCXX_NOEXCEPT
{
if (this->size() > _M_guaranteed_capacity)
_M_guaranteed_capacity = this->size();
}
void
_M_invalidate_after_nth(difference_type __n) _GLIBCXX_NOEXCEPT
{
......
libstdc++-v3/src/c++11/debug.cc
......@@ -23,8 +23,8 @@
// <http://www.gnu.org/licenses/>.
#include <debug/debug.h>
#include <debug/safe_sequence.h>
#include <debug/safe_unordered_container.h>
#include <debug/safe_base.h>
#include <debug/safe_unordered_base.h>
#include <debug/safe_iterator.h>
#include <debug/safe_local_iterator.h>
#include <algorithm>
......@@ -235,7 +235,7 @@ namespace __gnu_debug
void
_Safe_sequence_base::
_M_swap(_Safe_sequence_base& __x)
_M_swap(_Safe_sequence_base& __x) noexcept
{
// We need to lock both sequences to swap
using namespace __gnu_cxx;
......@@ -382,7 +382,7 @@ namespace __gnu_debug
_Safe_unordered_container_base*
_Safe_local_iterator_base::
_M_get_container() const _GLIBCXX_NOEXCEPT
_M_get_container() const noexcept
{ return static_cast<_Safe_unordered_container_base*>(_M_sequence); }
void
......@@ -455,7 +455,7 @@ namespace __gnu_debug
void
_Safe_unordered_container_base::
_M_swap(_Safe_unordered_container_base& __x)
_M_swap(_Safe_unordered_container_base& __x) noexcept
{
// We need to lock both containers to swap
using namespace __gnu_cxx;
......
libstdc++-v3/testsuite/23_containers/forward_list/allocator/move.cc
......@@ -32,9 +32,11 @@ void test01()
typedef std::forward_list<T, alloc_type> test_type;
test_type v1(alloc_type(1));
v1 = { T() };
auto it = v1.begin();
test_type v2(std::move(v1));
VERIFY(1 == v1.get_allocator().get_personality());
VERIFY(1 == v2.get_allocator().get_personality());
VERIFY( it == v2.begin() );
}
void test02()
......
libstdc++-v3/testsuite/23_containers/forward_list/allocator/move_assign.cc
......@@ -46,11 +46,13 @@ void test02()
typedef std::forward_list<T, alloc_type> test_type;
test_type v1(alloc_type(1));
v1.push_front(T());
auto it = v1.begin();
test_type v2(alloc_type(2));
v2.push_front(T());
v2 = std::move(v1);
VERIFY(0 == v1.get_allocator().get_personality());
VERIFY(1 == v2.get_allocator().get_personality());
VERIFY( it == v2.begin() );
}
int main()
......
libstdc++-v3/testsuite/23_containers/forward_list/debug/construct1_neg.cc 0 → 100644
// Copyright (C) 2014 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/>.
//
// { dg-require-debug-mode "" }
// { dg-options "-std=gnu++11" }
// { dg-do run { xfail *-*-* } }
#include <forward_list>
#include <debug/checks.h>
void test01()
{
__gnu_test::check_construct1<std::forward_list<int> >();
}
int main()
{
test01();
return 0;
}
libstdc++-v3/testsuite/23_containers/forward_list/debug/construct2_neg.cc 0 → 100644
// Copyright (C) 2014 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/>.
//
// { dg-require-debug-mode "" }
// { dg-options "-std=gnu++11" }
// { dg-do run { xfail *-*-* } }
#include <forward_list>
#include <debug/checks.h>
void test01()
{
__gnu_test::check_construct2<std::forward_list<int> >();
}
int main()
{
test01();
return 0;
}
libstdc++-v3/testsuite/23_containers/forward_list/debug/construct3_neg.cc 0 → 100644
// Copyright (C) 2010-2014 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/>.
//
// { dg-require-debug-mode "" }
// { dg-options "-std=gnu++11" }
// { dg-do run { xfail *-*-* } }
#include <forward_list>
#include <debug/checks.h>
void test01()
{
__gnu_test::check_construct3<std::forward_list<int> >();
}
int main()
{
test01();
return 0;
}
libstdc++-v3/testsuite/23_containers/forward_list/debug/construct4_neg.cc 0 → 100644
// Copyright (C) 2014 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/>.
//
// { dg-options "-std=gnu++11" }
// { dg-do run { xfail *-*-* } }
#include <debug/forward_list>
#include <testsuite_allocator.h>
void test01()
{
bool test __attribute__((unused)) = true;
typedef __gnu_test::uneq_allocator<int> alloc_type;
typedef __gnu_debug::forward_list<int, alloc_type> test_type;
test_type v1(alloc_type(1));
v1.push_front(0);
auto it = v1.begin();
test_type v2(std::move(v1), alloc_type(2));
VERIFY( it == v2.begin() ); // Error, it is singular
}
int main()
{
test01();
return 0;
}
libstdc++-v3/testsuite/23_containers/forward_list/debug/move_assign_neg.cc 0 → 100644
// Copyright (C) 2014 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/>.
//
// { dg-options "-std=gnu++11" }
// { dg-do run { xfail *-*-* } }
#include <debug/forward_list>
#include <testsuite_allocator.h>
void test01()
{
bool test __attribute__((unused)) = true;
typedef __gnu_test::uneq_allocator<int> alloc_type;
typedef __gnu_debug::forward_list<int, alloc_type> test_type;
test_type v1(alloc_type(1));
v1.push_front(0);
auto it = v1.begin();
test_type v2(alloc_type(2));
v2.push_front(1);
v2 = std::move(v1);
VERIFY( *it == 0 ); // Error, it is singular.
}
int main()
{
test01();
return 0;
}
libstdc++-v3/testsuite/23_containers/forward_list/debug/move_neg.cc 0 → 100644
// Copyright (C) 2014 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/>.
// { dg-options "-std=gnu++11" }
// { dg-do run { xfail *-*-* } }
#include <debug/forward_list>
#include <testsuite_hooks.h>
#include <testsuite_allocator.h>
using __gnu_test::uneq_allocator;
void test01()
{
bool test __attribute__((unused)) = true;
typedef uneq_allocator<int> alloc_type;
typedef __gnu_debug::forward_list<int, alloc_type> test_type;
test_type v1(alloc_type(1));
v1 = { 0 };
auto it = v1.begin();
test_type v2(std::move(v1), alloc_type(2));
VERIFY( *it == 0 );
}
int main()
{
test01();
return 0;
}
libstdc++-v3/testsuite/23_containers/map/allocator/move.cc
......@@ -38,9 +38,13 @@ void test01()
typedef std::map<T, U, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
v1 = { test_type::value_type{} };
auto it = v1.begin();
test_type v2(std::move(v1));
VERIFY(1 == v1.get_allocator().get_personality());
VERIFY(1 == v2.get_allocator().get_personality());
VERIFY( it == v2.begin() );
}
void test02()
......
libstdc++-v3/testsuite/23_containers/map/allocator/move_assign.cc
......@@ -38,9 +38,11 @@ void test01()
typedef std::map<T, U, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
v1 = { test_type::value_type{} };
test_type v2(alloc_type(2));
v2 = { test_type::value_type{} };
v2 = std::move(v1);
VERIFY(1 == v1.get_allocator().get_personality());
VERIFY(2 == v2.get_allocator().get_personality());
}
......@@ -52,11 +54,15 @@ void test02()
typedef std::map<T, U, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
v1 = { test_type::value_type{} };
auto it = v1.begin();
test_type v2(alloc_type(2));
v2 = { test_type::value_type{} };
v2 = std::move(v1);
VERIFY(0 == v1.get_allocator().get_personality());
VERIFY(1 == v2.get_allocator().get_personality());
VERIFY( it == v2.begin() );
}
int main()
......
libstdc++-v3/testsuite/23_containers/map/debug/construct5_neg.cc 0 → 100644
// Copyright (C) 2014 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/>.
//
// { dg-options "-std=gnu++11" }
// { dg-do run { xfail *-*-* } }
#include <debug/map>
#include <testsuite_allocator.h>
void test01()
{
bool test __attribute__((unused)) = true;
typedef __gnu_test::uneq_allocator<std::pair<const int, int> > alloc_type;
typedef __gnu_debug::map<int, int, std::less<int>, alloc_type> test_type;
test_type v1(alloc_type(1));
v1.insert(std::make_pair(0, 0));
auto it = v1.begin();
test_type v2(std::move(v1), alloc_type(2));
VERIFY( it->first == 0 ); // Error, it is singular
}
int main()
{
test01();
return 0;
}
libstdc++-v3/testsuite/23_containers/map/debug/move_assign_neg.cc 0 → 100644
// Copyright (C) 2014 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/>.
//
// { dg-options "-std=gnu++11" }
// { dg-do run { xfail *-*-* } }
#include <debug/map>
#include <testsuite_allocator.h>
void test01()
{
bool test __attribute__((unused)) = true;
typedef __gnu_test::uneq_allocator<std::pair<const int, int> > alloc_type;
typedef __gnu_debug::map<int, int, std::less<int>, alloc_type> test_type;
test_type v1(alloc_type(1));
v1.insert(std::make_pair(0, 0));
auto it = v1.begin();
test_type v2(alloc_type(2));
v2.insert(std::make_pair(1, 1));
v2 = std::move(v1);
VERIFY( it == v2.begin() ); // Error, it is singular.
}
int main()
{
test01();
return 0;
}
libstdc++-v3/testsuite/23_containers/map/debug/move_neg.cc 0 → 100644
// Copyright (C) 2014 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/>.
// { dg-options "-std=gnu++11" }
// { dg-do run { xfail *-*-* } }
#include <debug/map>
#include <testsuite_hooks.h>
#include <testsuite_allocator.h>
using __gnu_test::uneq_allocator;
void test01()
{
bool test __attribute__((unused)) = true;
typedef uneq_allocator<std::pair<const int, int> > alloc_type;
typedef __gnu_debug::map<int, int, std::less<int>, alloc_type> test_type;
test_type v1(alloc_type(1));
v1 = { { 0, 0 } };
auto it = v1.begin();
test_type v2(std::move(v1), alloc_type(2));
VERIFY( it->first == 0 );
}
int main()
{
test01();
return 0;
}
libstdc++-v3/testsuite/23_containers/multimap/allocator/move.cc
......@@ -38,9 +38,13 @@ void test01()
typedef std::multimap<T, U, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
v1 = { test_type::value_type{} };
auto it = v1.begin();
test_type v2(std::move(v1));
VERIFY(1 == v1.get_allocator().get_personality());
VERIFY(1 == v2.get_allocator().get_personality());
VERIFY( it == v2.begin() );
}
void test02()
......
libstdc++-v3/testsuite/23_containers/multimap/allocator/move_assign.cc
......@@ -52,11 +52,13 @@ void test02()
typedef std::multimap<T, U, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
v1 = { test_type::value_type{} };
auto it = v1.begin();
test_type v2(alloc_type(2));
v2 = { test_type::value_type{} };
v2 = std::move(v1);
VERIFY(0 == v1.get_allocator().get_personality());
VERIFY(1 == v2.get_allocator().get_personality());
VERIFY( it == v2.begin() );
}
int main()
......
libstdc++-v3/testsuite/23_containers/multimap/debug/construct5_neg.cc 0 → 100644
// Copyright (C) 2014 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/>.
//
// { dg-options "-std=gnu++11" }
// { dg-do run { xfail *-*-* } }
#include <debug/map>
#include <testsuite_allocator.h>
void test01()
{
bool test __attribute__((unused)) = true;
typedef __gnu_test::uneq_allocator<std::pair<const int, int> > alloc_type;
typedef __gnu_debug::multimap<int, int, std::less<int>, alloc_type> test_type;
test_type v1(alloc_type(1));
v1.insert(std::make_pair(0, 0));
auto it = v1.begin();
test_type v2(std::move(v1), alloc_type(2));
VERIFY( it->first == 0 ); // Error, it is singular
}
int main()
{
test01();
return 0;
}
libstdc++-v3/testsuite/23_containers/multimap/debug/move_assign_neg.cc 0 → 100644
// Copyright (C) 2014 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/>.
//
// { dg-options "-std=gnu++11" }
// { dg-do run { xfail *-*-* } }
#include <debug/map>
#include <testsuite_allocator.h>
void test01()
{
bool test __attribute__((unused)) = true;
typedef __gnu_test::uneq_allocator<std::pair<const int, int> > alloc_type;
typedef __gnu_debug::multimap<int, int, std::less<int>, alloc_type> test_type;
test_type v1(alloc_type(1));
v1.insert(std::make_pair(0, 0));
auto it = v1.begin();
test_type v2(alloc_type(2));
v2.insert(std::make_pair(1, 1));
v2 = std::move(v1);
VERIFY( it == v2.begin() ); // Error, it is singular.
}
int main()
{
test01();
return 0;
}
libstdc++-v3/testsuite/23_containers/multimap/debug/move_neg.cc 0 → 100644
// Copyright (C) 2014 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/>.
// { dg-options "-std=gnu++11" }
// { dg-do run { xfail *-*-* } }
#include <debug/map>
#include <testsuite_hooks.h>
#include <testsuite_allocator.h>
using __gnu_test::uneq_allocator;
void test01()
{
bool test __attribute__((unused)) = true;
typedef uneq_allocator<std::pair<const int, int> > alloc_type;
typedef __gnu_debug::multimap<int, int, std::less<int>, alloc_type> test_type;
test_type v1(alloc_type(1));
v1 = { { 0, 0 } };
auto it = v1.begin();
test_type v2(std::move(v1), alloc_type(2));
VERIFY( it->first == 0 );
}
int main()
{
test01();
return 0;
}
libstdc++-v3/testsuite/23_containers/multiset/allocator/move.cc
......@@ -36,9 +36,13 @@ void test01()
typedef std::multiset<T, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
v1 = { test_type::value_type{} };
auto it = v1.begin();
test_type v2(std::move(v1));
VERIFY(1 == v1.get_allocator().get_personality());
VERIFY(1 == v2.get_allocator().get_personality());
VERIFY( it == v2.begin() );
}
void test02()
......
libstdc++-v3/testsuite/23_containers/multiset/allocator/move_assign.cc
......@@ -50,11 +50,13 @@ void test02()
typedef std::multiset<T, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
v1 = { test_type::value_type{} };
auto it = v1.begin();
test_type v2(alloc_type(2));
v2 = { test_type::value_type{} };
v2 = std::move(v1);
VERIFY(0 == v1.get_allocator().get_personality());
VERIFY(1 == v2.get_allocator().get_personality());
VERIFY( it == v2.begin() );
}
int main()
......
libstdc++-v3/testsuite/23_containers/multiset/debug/construct5_neg.cc 0 → 100644
// Copyright (C) 2014 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/>.
//
// { dg-options "-std=gnu++11" }
// { dg-do run { xfail *-*-* } }
#include <debug/set>
#include <testsuite_allocator.h>
void test01()
{
bool test __attribute__((unused)) = true;
typedef __gnu_test::uneq_allocator<int> alloc_type;
typedef __gnu_debug::multiset<int, std::less<int>, alloc_type> test_type;
test_type v1(alloc_type(1));
v1.insert(0);
auto it = v1.begin();
test_type v2(std::move(v1), alloc_type(2));
VERIFY( *it == 0 ); // Error, it is singular
}
int main()
{
test01();
return 0;
}
libstdc++-v3/testsuite/23_containers/multiset/debug/move_assign_neg.cc 0 → 100644
// Copyright (C) 2014 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/>.
//
// { dg-options "-std=gnu++11" }
// { dg-do run { xfail *-*-* } }
#include <debug/set>
#include <testsuite_allocator.h>
void test01()
{
bool test __attribute__((unused)) = true;
typedef __gnu_test::uneq_allocator<int> alloc_type;
typedef __gnu_debug::multiset<int, std::less<int>, alloc_type> test_type;
test_type v1(alloc_type(1));
v1.insert(0);
auto it = v1.begin();
test_type v2(alloc_type(2));
v2.insert(1);
v2 = std::move(v1);
VERIFY( it == v2.begin() ); // Error, it is singular.
}
int main()
{
test01();
return 0;
}
libstdc++-v3/testsuite/23_containers/multiset/debug/move_neg.cc 0 → 100644
// Copyright (C) 2014 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/>.
// { dg-options "-std=gnu++11" }
// { dg-do run { xfail *-*-* } }
#include <debug/set>
#include <testsuite_hooks.h>
#include <testsuite_allocator.h>
using __gnu_test::uneq_allocator;
void test01()
{
bool test __attribute__((unused)) = true;
typedef uneq_allocator<int> alloc_type;
typedef __gnu_debug::multiset<int, std::less<int>, alloc_type> test_type;
test_type v1(alloc_type(1));
v1 = { 0 };
auto it = v1.begin();
test_type v2(std::move(v1), alloc_type(2));
VERIFY( *it == 0 );
}
int main()
{
test01();
return 0;
}
libstdc++-v3/testsuite/23_containers/set/allocator/move.cc
......@@ -38,9 +38,13 @@ void test01()
typedef std::set<T, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
v1 = { test_type::value_type{} };
auto it = v1.begin();
test_type v2(std::move(v1));
VERIFY(1 == v1.get_allocator().get_personality());
VERIFY(1 == v2.get_allocator().get_personality());
VERIFY( it == v2.begin() );
}
void test02()
......
libstdc++-v3/testsuite/23_containers/set/allocator/move_assign.cc
......@@ -50,11 +50,13 @@ void test02()
typedef std::set<T, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
v1 = { test_type::value_type{} };
auto it = v1.begin();
test_type v2(alloc_type(2));
v2 = { test_type::value_type{} };
v2 = std::move(v1);
VERIFY(0 == v1.get_allocator().get_personality());
VERIFY(1 == v2.get_allocator().get_personality());
VERIFY( it == v2.begin() );
}
int main()
......
libstdc++-v3/testsuite/23_containers/set/debug/construct5_neg.cc 0 → 100644
// Copyright (C) 2014 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/>.
//
// { dg-options "-std=gnu++11" }
// { dg-do run { xfail *-*-* } }
#include <debug/set>
#include <testsuite_allocator.h>
void test01()
{
bool test __attribute__((unused)) = true;
typedef __gnu_test::uneq_allocator<int> alloc_type;
typedef __gnu_debug::set<int, std::less<int>, alloc_type> test_type;
test_type v1(alloc_type(1));
v1.insert(0);
auto it = v1.begin();
test_type v2(std::move(v1), alloc_type(2));
VERIFY( *it == 0 ); // Error, it is singular
}
int main()
{
test01();
return 0;
}
libstdc++-v3/testsuite/23_containers/set/debug/move_assign_neg.cc 0 → 100644
// Copyright (C) 2014 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/>.
//
// { dg-options "-std=gnu++11" }
// { dg-do run { xfail *-*-* } }
#include <debug/set>
#include <testsuite_allocator.h>
void test01()
{
bool test __attribute__((unused)) = true;
typedef __gnu_test::uneq_allocator<int> alloc_type;
typedef __gnu_debug::set<int, std::less<int>, alloc_type> test_type;
test_type v1(alloc_type(1));
v1.insert(0);
auto it = v1.begin();
test_type v2(alloc_type(2));
v2.insert(1);
v2 = std::move(v1);
VERIFY( it == v2.begin() ); // Error, it is singular.
}
int main()
{
test01();
return 0;
}
libstdc++-v3/testsuite/23_containers/set/debug/move_neg.cc 0 → 100644
// Copyright (C) 2014 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/>.
// { dg-options "-std=gnu++11" }
// { dg-do run { xfail *-*-* } }
#include <debug/set>
#include <testsuite_hooks.h>
#include <testsuite_allocator.h>
using __gnu_test::uneq_allocator;
void test01()
{
bool test __attribute__((unused)) = true;
typedef uneq_allocator<int> alloc_type;
typedef __gnu_debug::set<int, std::less<int>, alloc_type> test_type;
test_type v1(alloc_type(1));
v1 = { 0 };
auto it = v1.begin();
test_type v2(std::move(v1), alloc_type(2));
VERIFY( *it == 0 );
}
int main()
{
test01();
return 0;
}
libstdc++-v3/testsuite/23_containers/unordered_map/allocator/move.cc
......@@ -45,9 +45,11 @@ void test01()
test_type v1(alloc_type(1));
v1.emplace(std::piecewise_construct,
std::make_tuple(T()), std::make_tuple(T()));
auto it = v1.begin();
test_type v2(std::move(v1));
VERIFY(1 == v1.get_allocator().get_personality());
VERIFY(1 == v2.get_allocator().get_personality());
VERIFY( it == v2.begin() );
}
void test02()
......
libstdc++-v3/testsuite/23_containers/unordered_map/allocator/move_assign.cc
......@@ -66,6 +66,8 @@ void test02()
v1.emplace(std::piecewise_construct,
std::make_tuple(1), std::make_tuple(1));
auto it = v1.begin();
test_type v2(alloc_type(2));
v2.emplace(std::piecewise_construct,
std::make_tuple(2), std::make_tuple(2));
......@@ -79,6 +81,8 @@ void test02()
VERIFY( counter_type::move_assign_count == 0 );
VERIFY( counter_type::destructor_count == 2 );
VERIFY( it == v2.begin() );
}
int main()
......
libstdc++-v3/testsuite/23_containers/unordered_map/debug/construct5_neg.cc 0 → 100644
// Copyright (C) 2014 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/>.
//
// { dg-options "-std=gnu++11" }
// { dg-do run { xfail *-*-* } }
#include <debug/unordered_map>
#include <testsuite_allocator.h>
void test01()
{
bool test __attribute__((unused)) = true;
typedef __gnu_test::uneq_allocator<std::pair<const int, int>> alloc_type;
typedef __gnu_debug::unordered_map<int, int, std::hash<int>,
std::equal_to<int>,
alloc_type> test_type;
test_type v1(alloc_type(1));
v1.insert(std::make_pair(0, 0));
auto it = v1.begin();
test_type v2(std::move(v1), alloc_type(2));
VERIFY( it == v2.begin() ); // Error, it is singular.
}
int main()
{
test01();
return 0;
}
libstdc++-v3/testsuite/23_containers/unordered_map/debug/move_assign_neg.cc 0 → 100644
// Copyright (C) 2014 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/>.
//
// { dg-options "-std=gnu++11" }
// { dg-do run { xfail *-*-* } }
#include <debug/unordered_map>
#include <testsuite_allocator.h>
void test01()
{
bool test __attribute__((unused)) = true;
typedef __gnu_test::uneq_allocator<std::pair<const int, int> > alloc_type;
typedef __gnu_debug::unordered_map<int, int,
std::hash<int>, std::equal_to<int>,
alloc_type> test_type;
test_type v1(alloc_type(1));
v1.insert(std::make_pair(0, 0));
auto it = v1.begin();
test_type v2(alloc_type(2));
v2 = std::move(v1);
VERIFY( it == v2.begin() ); // Error, it is singular.
}
int main()
{
test01();
return 0;
}
libstdc++-v3/testsuite/23_containers/unordered_map/debug/move_neg.cc 0 → 100644
// Copyright (C) 2014 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/>.
// { dg-options "-std=gnu++11" }
// { dg-do run { xfail *-*-* } }
#include <debug/unordered_map>
#include <testsuite_hooks.h>
#include <testsuite_allocator.h>
using __gnu_test::uneq_allocator;
void test01()
{
bool test __attribute__((unused)) = true;
typedef uneq_allocator<std::pair<const int, int> > alloc_type;
typedef __gnu_debug::unordered_map<
int, int, std::hash<int>, std::equal_to<int>, alloc_type> test_type;
test_type v1(alloc_type(1));
v1 = { { 0, 0 } };
auto it = v1.begin();
test_type v2(std::move(v1), alloc_type(2));
VERIFY( it->first == 0 );
}
int main()
{
test01();
return 0;
}
libstdc++-v3/testsuite/23_containers/unordered_multimap/allocator/move.cc
......@@ -45,9 +45,11 @@ void test01()
test_type v1(alloc_type(1));
v1.emplace(std::piecewise_construct,
std::make_tuple(T()), std::make_tuple(T()));
auto it = v1.begin();
test_type v2(std::move(v1));
VERIFY(1 == v1.get_allocator().get_personality());
VERIFY(1 == v2.get_allocator().get_personality());
VERIFY( it == v2.begin() );
}
void test02()
......
libstdc++-v3/testsuite/23_containers/unordered_multimap/allocator/move_assign.cc
......@@ -66,6 +66,8 @@ void test02()
v1.emplace(std::piecewise_construct,
std::make_tuple(1), std::make_tuple(1));
auto it = v1.begin();
test_type v2(alloc_type(2));
v2.emplace(std::piecewise_construct,
std::make_tuple(2), std::make_tuple(2));
......@@ -79,6 +81,8 @@ void test02()
VERIFY( counter_type::move_assign_count == 0 );
VERIFY( counter_type::destructor_count == 2 );
VERIFY( it == v2.begin() );
}
int main()
......
libstdc++-v3/testsuite/23_containers/unordered_multimap/debug/construct5_neg.cc 0 → 100644
// Copyright (C) 2014 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/>.
//
// { dg-options "-std=gnu++11" }
// { dg-do run { xfail *-*-* } }
#include <debug/unordered_map>
#include <testsuite_allocator.h>
void test01()
{
bool test __attribute__((unused)) = true;
typedef __gnu_test::uneq_allocator<std::pair<const int, int>> alloc_type;
typedef __gnu_debug::unordered_multimap<int, int,
std::hash<int>, std::equal_to<int>,
alloc_type> test_type;
test_type v1(alloc_type(1));
v1.insert(std::make_pair(0, 0));
auto it = v1.begin();
test_type v2(std::move(v1), alloc_type(2));
VERIFY( it == v2.begin() ); // Error, it is singular.
}
int main()
{
test01();
return 0;
}
libstdc++-v3/testsuite/23_containers/unordered_multimap/debug/move_assign_neg.cc 0 → 100644
// Copyright (C) 2014 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/>.
//
// { dg-options "-std=gnu++11" }
// { dg-do run { xfail *-*-* } }
#include <debug/unordered_map>
#include <testsuite_allocator.h>
void test01()
{
bool test __attribute__((unused)) = true;
typedef __gnu_test::uneq_allocator<std::pair<const int, int>> alloc_type;
typedef __gnu_debug::unordered_multimap<int, int, std::hash<int>,
std::equal_to<int>,
alloc_type> test_type;
test_type v1(alloc_type(1));
v1.insert(std::make_pair(0, 0));
auto it = v1.begin();
test_type v2(alloc_type(2));
v2 = std::move(v1);
VERIFY( it == v2.begin() ); // Error, it is singular.
}
int main()
{
test01();
return 0;
}
libstdc++-v3/testsuite/23_containers/unordered_multimap/debug/move_neg.cc 0 → 100644
// Copyright (C) 2014 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/>.
// { dg-options "-std=gnu++11" }
// { dg-do run { xfail *-*-* } }
#include <debug/unordered_map>
#include <testsuite_hooks.h>
#include <testsuite_allocator.h>
using __gnu_test::uneq_allocator;
void test01()
{
bool test __attribute__((unused)) = true;
typedef uneq_allocator<std::pair<const int, int> > alloc_type;
typedef __gnu_debug::unordered_multimap<
int, int, std::hash<int>, std::equal_to<int>, alloc_type> test_type;
test_type v1(alloc_type(1));
v1 = { { 0, 0 } };
auto it = v1.begin();
test_type v2(std::move(v1), alloc_type(2));
VERIFY( it->first == 0 );
}
int main()
{
test01();
return 0;
}
libstdc++-v3/testsuite/23_containers/unordered_multiset/allocator/move.cc
......@@ -44,9 +44,11 @@ void test01()
typedef std::unordered_multiset<T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
v1.insert(T());
auto it = v1.begin();
test_type v2(std::move(v1));
VERIFY(1 == v1.get_allocator().get_personality());
VERIFY(1 == v2.get_allocator().get_personality());
VERIFY( it == v2.begin() );
}
void test02()
......
libstdc++-v3/testsuite/23_containers/unordered_multiset/allocator/move_assign.cc
......@@ -63,6 +63,8 @@ void test02()
test_type v1(alloc_type(1));
v1.emplace(0);
auto it = v1.begin();
test_type v2(alloc_type(2));
v2.emplace(0);
......@@ -76,6 +78,8 @@ void test02()
VERIFY( counter_type::move_count == 0 );
VERIFY( counter_type::copy_count == 0 );
VERIFY( counter_type::destructor_count == 1 );
VERIFY( it == v2.begin() );
}
int main()
......
libstdc++-v3/testsuite/23_containers/unordered_multiset/debug/construct5_neg.cc 0 → 100644
// Copyright (C) 2014 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/>.
//
// { dg-options "-std=gnu++11" }
// { dg-do run { xfail *-*-* } }
#include <debug/unordered_set>
#include <testsuite_allocator.h>
void test01()
{
bool test __attribute__((unused)) = true;
typedef __gnu_test::uneq_allocator<int> alloc_type;
typedef __gnu_debug::unordered_multiset<int, std::hash<int>,
std::equal_to<int>,
alloc_type> test_type;
test_type v1(alloc_type(1));
v1.insert(0);
auto it = v1.begin();
test_type v2(std::move(v1), alloc_type(2));
VERIFY( it == v2.begin() ); // Error, it is singular
}
int main()
{
test01();
return 0;
}
libstdc++-v3/testsuite/23_containers/unordered_multiset/debug/move_assign_neg.cc 0 → 100644
// Copyright (C) 2014 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/>.
//
// { dg-options "-std=gnu++11" }
// { dg-do run { xfail *-*-* } }
#include <debug/unordered_set>
#include <testsuite_allocator.h>
void test01()
{
bool test __attribute__((unused)) = true;
typedef __gnu_test::uneq_allocator<int> alloc_type;
typedef __gnu_debug::unordered_multiset<int, std::hash<int>,
std::equal_to<int>,
alloc_type> test_type;
test_type v1(alloc_type(1));
v1.emplace(0);
auto it = v1.begin();
test_type v2(alloc_type(2));
v2.emplace(1);
v2 = std::move(v1);
VERIFY( it == v2.begin() ); // Error, it is singular.
}
int main()
{
test01();
return 0;
}
libstdc++-v3/testsuite/23_containers/unordered_multiset/debug/move_neg.cc 0 → 100644
// Copyright (C) 2014 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/>.
// { dg-options "-std=gnu++11" }
// { dg-do run { xfail *-*-* } }
#include <debug/unordered_set>
#include <testsuite_hooks.h>
#include <testsuite_allocator.h>
using __gnu_test::uneq_allocator;
void test01()
{
bool test __attribute__((unused)) = true;
typedef uneq_allocator<int> alloc_type;
typedef __gnu_debug::unordered_multiset<
int, std::hash<int>, std::equal_to<int>, alloc_type> test_type;
test_type v1(alloc_type(1));
v1 = { 0 };
auto it = v1.begin();
test_type v2(std::move(v1), alloc_type(2));
VERIFY( *it == 0 );
}
int main()
{
test01();
return 0;
}
libstdc++-v3/testsuite/23_containers/unordered_set/allocator/move.cc
......@@ -44,9 +44,11 @@ void test01()
typedef std::unordered_set<T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
v1.insert(T());
auto it = v1.begin();
test_type v2(std::move(v1));
VERIFY(1 == v1.get_allocator().get_personality());
VERIFY(1 == v2.get_allocator().get_personality());
VERIFY( it == v2.begin() );
}
void test02()
......
libstdc++-v3/testsuite/23_containers/unordered_set/allocator/move_assign.cc
......@@ -63,6 +63,8 @@ void test02()
test_type v1(alloc_type(1));
v1.emplace(0);
auto it = v1.begin();
test_type v2(alloc_type(2));
v2.emplace(0);
......@@ -76,6 +78,8 @@ void test02()
VERIFY( counter_type::move_count == 0 );
VERIFY( counter_type::copy_count == 0 );
VERIFY( counter_type::destructor_count == 1 );
VERIFY( it == v2.begin() );
}
int main()
......
libstdc++-v3/testsuite/23_containers/unordered_set/debug/construct5_neg.cc 0 → 100644
// Copyright (C) 2014 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/>.
//
// { dg-options "-std=gnu++11" }
// { dg-do run { xfail *-*-* } }
#include <debug/unordered_set>
#include <testsuite_allocator.h>
void test01()
{
bool test __attribute__((unused)) = true;
typedef __gnu_test::uneq_allocator<int> alloc_type;
typedef __gnu_debug::unordered_set<int, std::hash<int>,
std::equal_to<int>, alloc_type> test_type;
test_type v1(alloc_type(1));
v1.insert(0);
auto it = v1.begin();
test_type v2(std::move(v1), alloc_type(2));
VERIFY( it == v2.begin() ); // Error, it is singular
}
int main()
{
test01();
return 0;
}
libstdc++-v3/testsuite/23_containers/unordered_set/debug/move_assign_neg.cc 0 → 100644
// Copyright (C) 2014 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/>.
//
// { dg-options "-std=gnu++11" }
// { dg-do run { xfail *-*-* } }
#include <debug/unordered_set>
#include <testsuite_allocator.h>
void test01()
{
bool test __attribute__((unused)) = true;
typedef __gnu_test::uneq_allocator<int> alloc_type;
typedef __gnu_debug::unordered_set<int, std::hash<int>,
std::equal_to<int>,
alloc_type> test_type;
test_type v1(alloc_type(1));
v1.emplace(0);
auto it = v1.begin();
test_type v2(alloc_type(2));
v2.emplace(1);
v2 = std::move(v1);
VERIFY( it == v2.begin() ); // Error, it is singular.
}
int main()
{
test01();
return 0;
}
libstdc++-v3/testsuite/23_containers/unordered_set/debug/move_neg.cc 0 → 100644
// Copyright (C) 2014 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/>.
// { dg-options "-std=gnu++11" }
// { dg-do run { xfail *-*-* } }
#include <debug/unordered_set>
#include <testsuite_hooks.h>
#include <testsuite_allocator.h>
using __gnu_test::uneq_allocator;
void test01()
{
bool test __attribute__((unused)) = true;
typedef uneq_allocator<int> alloc_type;
typedef __gnu_debug::unordered_set<
int, std::hash<int>, std::equal_to<int>, alloc_type> test_type;
test_type v1(alloc_type(1));
v1 = { 0 };
auto it = v1.begin();
test_type v2(std::move(v1), alloc_type(2));
VERIFY( *it == 0 );
}
int main()
{
test01();
return 0;
}
libstdc++-v3/testsuite/23_containers/vector/debug/move_neg.cc 0 → 100644
// Copyright (C) 2014 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/>.
// { dg-options "-std=gnu++11" }
// { dg-do run { xfail *-*-* } }
#include <debug/vector>
#include <testsuite_hooks.h>
#include <testsuite_allocator.h>
using __gnu_test::uneq_allocator;
void test01()
{
bool test __attribute__((unused)) = true;
typedef uneq_allocator<int> alloc_type;
typedef __gnu_debug::vector<int, alloc_type> test_type;
test_type v1(alloc_type(1));
v1 = { 0 };
auto it = v1.begin();
test_type v2(std::move(v1), alloc_type(2));
VERIFY( *it == 0 );
}
int main()
{
test01();
return 0;
}
libstdc++-v3/testsuite/util/debug/checks.h
......@@ -179,10 +179,8 @@ namespace __gnu_test
val_type *first = &v.front() + 1;
val_type *last = first + 2;
cont_type c1(first, last);
VERIFY(c1.size() == 2);
cont_type c2(last, first); // Expected failure
cont_type c(last, first); // Expected failure
}
// Check that invalid range of debug random iterators is detected
......@@ -206,10 +204,8 @@ namespace __gnu_test
typename vector_type::iterator first = v.begin() + 1;
typename vector_type::iterator last = first + 2;
cont_type c1(first, last);
VERIFY(c1.size() == 2);
cont_type c2(last, first); // Expected failure
cont_type c(last, first); // Expected failure
}
// Check that invalid range of debug not random iterators is detected
......@@ -233,10 +229,8 @@ namespace __gnu_test
typename list_type::iterator first = l.begin(); ++first;
typename list_type::iterator last = first; ++last; ++last;
cont_type c1(first, last);
VERIFY(c1.size() == 2);
cont_type c2(last, first); // Expected failure
cont_type c(last, first); // Expected failure
}
template <typename _Cont>
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment