+2010-11-25 François Dumont <francois.cppdevs@free.fr>
+
+ * src/debug.cc: Introduce a mutex pool in get_safe_base_mutex.
+ Move code used to manipulate sequence safe iterators from safe
+ iterator methods to safe sequence ones. Remove usage of safe iterator
+ mutex, keep _Safe_iterator_base::_M_get_mutex for library backward
+ binary compatibility.
+ * src/Makefile.am: Build debug.cc in gnu++0x mode for _Hash_impl usage.
+ * src/Makefile.in: Regenerate
+ * include/debug/safe_base.h: Add _Safe_iterator_base _M_invalidate
+ and _M_reset. Add _Safe_sequence_base _M_attach, _M_attach_single,
+ _M_detach and _M_detach_single.
+ * include/debug.safe_iterator.h, safe_iterator.tcc: Remove
+ _Safe_iterator _M_invalidate and _M_invalidate_single. Implement all
+ methods in terms of normal iterators rather than safe ones.
+ * include/debug/safe_sequence.h: Replace _Safe_sequence
+ _M_transfe_iter with _M_transfer_from_if taking the source sequence
+ and a predicate signaling when a safe iterator shall be transfered.
+ Add _Equal_to predicate.
+ * include/debug/safe_sequence.tcc: New.
+ * include/Makefile.am: Adjust.
+ * include/Makefile.in: Regenerate.
+ * include/debug/forward_list: Swap safe iterators in move constructor.
+ Do not invalidate before begin in _M_invalidate_all method.
+ Reimplement safe methods using normal iterators rather than safe ones.
+ * include/debug/set.h, unordered_map, multiset.h, vector,
+ unordered_set, deque, map.h, list, multimap.h: Reimplement safe method
+ using normal iterators rather than safe ones.
+ * testsuite/23_containers/forward_list/debug/clear.cc, swap.cc,
+ move_constructor.cc, splice_after.cc, splice_after1.cc,
+ splice_after2.cc, splice_after3.cc, splice_after4.cc: New.
+ * testsuite/23_containers/vector/debug/multithreaded_swap.cc: New.
+
2010-11-24 Benjamin Kosnik <bkoz@redhat.com>
* include/std/tuple: Mark more constructors constexpr.
${debug_srcdir}/safe_iterator.h \
${debug_srcdir}/safe_iterator.tcc \
${debug_srcdir}/safe_sequence.h \
+ ${debug_srcdir}/safe_sequence.tcc \
${debug_srcdir}/set \
${debug_srcdir}/set.h \
${debug_srcdir}/string \
${debug_srcdir}/safe_iterator.h \
${debug_srcdir}/safe_iterator.tcc \
${debug_srcdir}/safe_sequence.h \
+ ${debug_srcdir}/safe_sequence.tcc \
${debug_srcdir}/set \
${debug_srcdir}/set.h \
${debug_srcdir}/string \
typedef _GLIBCXX_STD_D::deque<_Tp, _Allocator> _Base;
typedef __gnu_debug::_Safe_sequence<deque> _Safe_base;
+ 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<typename _Base::iterator,deque>
+ typedef __gnu_debug::_Safe_iterator<_Base_iterator,deque>
iterator;
- typedef __gnu_debug::_Safe_iterator<typename _Base::const_iterator,deque>
- const_iterator;
+ typedef __gnu_debug::_Safe_iterator<_Base_const_iterator,deque>
+ const_iterator;
typedef typename _Base::size_type size_type;
typedef typename _Base::difference_type difference_type;
{ return const_reverse_iterator(begin()); }
#endif
+ private:
+ void
+ _M_invalidate_after_nth(difference_type __n)
+ {
+ typedef __gnu_debug::_After_nth_from<_Base_const_iterator> _After_nth;
+ this->_M_invalidate_if(_After_nth(__n, _Base::begin()));
+ }
+
+ public:
// 23.2.1.2 capacity:
using _Base::size;
using _Base::max_size;
void
resize(size_type __sz)
{
- typedef typename _Base::const_iterator _Base_const_iterator;
- typedef __gnu_debug::_After_nth_from<_Base_const_iterator> _After_nth;
-
bool __invalidate_all = __sz > this->size();
if (__sz < this->size())
- this->_M_invalidate_if(_After_nth(__sz, _M_base().begin()));
+ this->_M_invalidate_after_nth(__sz);
_Base::resize(__sz);
void
resize(size_type __sz, const _Tp& __c)
{
- typedef typename _Base::const_iterator _Base_const_iterator;
- typedef __gnu_debug::_After_nth_from<_Base_const_iterator> _After_nth;
-
bool __invalidate_all = __sz > this->size();
if (__sz < this->size())
- this->_M_invalidate_if(_After_nth(__sz, _M_base().begin()));
+ this->_M_invalidate_after_nth(__sz);
_Base::resize(__sz, __c);
void
resize(size_type __sz, _Tp __c = _Tp())
{
- typedef typename _Base::const_iterator _Base_const_iterator;
- typedef __gnu_debug::_After_nth_from<_Base_const_iterator> _After_nth;
-
bool __invalidate_all = __sz > this->size();
if (__sz < this->size())
- this->_M_invalidate_if(_After_nth(__sz, _M_base().begin()));
+ this->_M_invalidate_after_nth(__sz);
_Base::resize(__sz, __c);
emplace(iterator __position, _Args&&... __args)
{
__glibcxx_check_insert(__position);
- typename _Base::iterator __res = _Base::emplace(__position.base(),
- std::forward<_Args>(__args)...);
+ _Base_iterator __res = _Base::emplace(__position.base(),
+ std::forward<_Args>(__args)...);
this->_M_invalidate_all();
return iterator(__res, this);
}
insert(iterator __position, const _Tp& __x)
{
__glibcxx_check_insert(__position);
- typename _Base::iterator __res = _Base::insert(__position.base(), __x);
+ _Base_iterator __res = _Base::insert(__position.base(), __x);
this->_M_invalidate_all();
return iterator(__res, this);
}
pop_front()
{
__glibcxx_check_nonempty();
- iterator __victim = begin();
- __victim._M_invalidate();
+ this->_M_invalidate_if(_Equal(_Base::begin()));
_Base::pop_front();
}
pop_back()
{
__glibcxx_check_nonempty();
- iterator __victim = end();
- --__victim;
- __victim._M_invalidate();
+ this->_M_invalidate_if(_Equal(--_Base::end()));
_Base::pop_back();
}
erase(iterator __position)
{
__glibcxx_check_erase(__position);
- if (__position == begin() || __position == end()-1)
+ _Base_iterator __victim = __position.base();
+ if (__victim == _Base::begin() || __victim == _Base::end()-1)
{
- __position._M_invalidate();
- return iterator(_Base::erase(__position.base()), this);
+ this->_M_invalidate_if(_Equal(__victim));
+ return iterator(_Base::erase(__victim), this);
}
else
{
- typename _Base::iterator __res = _Base::erase(__position.base());
+ _Base_iterator __res = _Base::erase(__victim);
this->_M_invalidate_all();
return iterator(__res, this);
}
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 151. can't currently clear() empty container
__glibcxx_check_erase_range(__first, __last);
- if (__first == begin() || __last == end())
+ if (__first.base() == _Base::begin() || __last.base() == _Base::end())
{
this->_M_detach_singular();
- for (iterator __position = __first; __position != __last; )
+ for (_Base_iterator __position = __first.base();
+ __position != __last.base(); ++__position)
{
- iterator __victim = __position++;
- __victim._M_invalidate();
+ this->_M_invalidate_if(_Equal(__position));
}
__try
{
}
else
{
- typename _Base::iterator __res = _Base::erase(__first.base(),
- __last.base());
+ _Base_iterator __res = _Base::erase(__first.base(),
+ __last.base());
this->_M_invalidate_all();
return iterator(__res, this);
}
typedef _GLIBCXX_STD_D::forward_list<_Tp, _Alloc> _Base;
typedef __gnu_debug::_Safe_sequence<forward_list> _Safe_base;
+ typedef typename _Base::iterator _Base_iterator;
+ typedef typename _Base::const_iterator _Base_const_iterator;
public:
typedef typename _Base::reference reference;
typedef typename _Base::const_reference const_reference;
- typedef __gnu_debug::_Safe_iterator<typename _Base::iterator,
+ typedef __gnu_debug::_Safe_iterator<_Base_iterator,
forward_list> iterator;
- typedef __gnu_debug::_Safe_iterator<typename _Base::const_iterator,
+ typedef __gnu_debug::_Safe_iterator<_Base_const_iterator,
forward_list> const_iterator;
typedef typename _Base::size_type size_type;
{ }
forward_list(forward_list&& __list, const _Alloc& __al)
- : _Base(std::move(__list), __al)
+ : _Base(std::move(__list._M_base()), __al)
{
this->_M_swap(__list);
}
{ }
forward_list(forward_list&& __list)
- : _Base(std::move(__list)) { }
+ : _Base(std::move(__list._M_base()))
+ {
+ this->_M_swap(__list);
+ }
forward_list(std::initializer_list<_Tp> __il,
const _Alloc& __al = _Alloc())
pop_front()
{
__glibcxx_check_nonempty();
- iterator __victim = begin();
- __victim._M_invalidate();
+ this->_M_invalidate_if([this](_Base_const_iterator __it)
+ { return __it == this->_M_base().cbegin(); });
_Base::pop_front();
}
return iterator(_Base::insert_after(__pos.base(), __il), this);
}
+ private:
+ _Base_iterator
+ _M_erase_after(_Base_const_iterator __pos)
+ {
+ _Base_const_iterator __next = std::next(__pos);
+ this->_M_invalidate_if([__next](_Base_const_iterator __it)
+ { return __it == __next; });
+ return _Base::erase_after(__pos);
+ }
+ public:
iterator
erase_after(const_iterator __pos)
{
__glibcxx_check_erase_after(__pos);
- const_iterator __victim = __pos;
- ++__victim;
- __victim._M_invalidate();
- return iterator(_Base::erase_after(__pos.base()), this);
+ return iterator(_M_erase_after(__pos.base()), this);
}
iterator
erase_after(const_iterator __pos, const_iterator __last)
{
__glibcxx_check_erase_range_after(__pos, __last);
- for (const_iterator __victim = std::next(__pos); __victim != __last; )
+ for (_Base_const_iterator __victim = std::next(__pos.base());
+ __victim != __last.base(); ++__victim)
{
- const_iterator __old = __victim;
- ++__victim;
- __old._M_invalidate();
+ _GLIBCXX_DEBUG_VERIFY(__victim != _Base::end(),
+ _M_message(__gnu_debug::__msg_valid_range2)
+ ._M_sequence(*this, "this")
+ ._M_iterator(__pos, "pos")
+ ._M_iterator(__last, "last"));
+ this->_M_invalidate_if([__victim](_Base_const_iterator __it)
+ { return __it == __victim; });
}
return iterator(_Base::erase_after(__pos.base(), __last.base()), this);
}
this->_M_detach_singular();
// if __sz < size(), invalidate all iterators in [begin+__sz, end()
- iterator __victim = begin();
- iterator __end = end();
+ _Base_iterator __victim = _Base::begin();
+ _Base_iterator __end = _Base::end();
for (size_type __i = __sz; __victim != __end && __i > 0; --__i)
++__victim;
- while (__victim != __end)
+ for (; __victim != __end; ++__victim)
{
- iterator __real_victim = __victim++;
- __real_victim._M_invalidate();
+ this->_M_invalidate_if([__victim](_Base_const_iterator __it)
+ { return __it == __victim; });
}
__try
this->_M_detach_singular();
// if __sz < size(), invalidate all iterators in [begin+__sz, end())
- iterator __victim = begin();
- iterator __end = end();
+ _Base_iterator __victim = _Base::begin();
+ _Base_iterator __end = _Base::end();
for (size_type __i = __sz; __victim != __end && __i > 0; --__i)
++__victim;
- while (__victim != __end)
+ for (; __victim != __end; ++__victim)
{
- iterator __real_victim = __victim++;
- __real_victim._M_invalidate();
+ this->_M_invalidate_if([__victim](_Base_const_iterator __it)
+ { return __it == __victim; });
}
__try
}
// 23.2.3.5 forward_list operations:
- private:
- void
- _M_splice_after(const_iterator __pos, forward_list&& __list,
- const_iterator __before, const_iterator __last)
- {
- for (const_iterator __tmp = std::next(__before); __tmp != __last; )
- {
- _GLIBCXX_DEBUG_VERIFY(&__list != this || __tmp != __pos,
- _M_message(__gnu_debug::__msg_splice_overlap)
- ._M_iterator(__tmp, "position")
- ._M_iterator(__before, "before")
- ._M_iterator(__last, "last"));
- const_iterator __victim = __tmp++;
- // _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 250. splicing invalidates iterators
- this->_M_transfer_iter(__victim);
- }
-
- _Base::splice_after(__pos.base(), std::move(__list._M_base()),
- __before.base(), __last.base());
- }
-
- public:
void
splice_after(const_iterator __pos, forward_list&& __list)
{
_GLIBCXX_DEBUG_VERIFY(&__list != this,
_M_message(__gnu_debug::__msg_self_splice)
._M_sequence(*this, "this"));
- _M_splice_after(__pos, std::move(__list),
- __list.before_begin(), __list.end());
+ this->_M_transfer_from_if(__list, [&__list](_Base_const_iterator __it)
+ {
+ return __it != __list._M_base().cbefore_begin()
+ && __it != __list._M_base().end();
+ });
+ _Base::splice_after(__pos.base(), std::move(__list._M_base()));
}
void
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 250. splicing invalidates iterators
- this->_M_transfer_iter(__i);
+ _Base_const_iterator __next = std::next(__i.base());
+ this->_M_transfer_from_if(__list, [__next](_Base_const_iterator __it)
+ { return __it == __next; });
_Base::splice_after(__pos.base(), std::move(__list._M_base()),
__i.base());
}
._M_sequence(__list, "list")
._M_iterator(__before, "before")
._M_iterator(__last, "last"));
- _M_splice_after(__pos, std::move(__list), __before, __last);
+
+ for (_Base_const_iterator __tmp = std::next(__before.base());
+ __tmp != __last.base(); ++__tmp)
+ {
+ _GLIBCXX_DEBUG_VERIFY(__tmp != __list._M_base().end(),
+ _M_message(__gnu_debug::__msg_valid_range2)
+ ._M_sequence(__list, "list")
+ ._M_iterator(__before, "before")
+ ._M_iterator(__last, "last"));
+ _GLIBCXX_DEBUG_VERIFY(&__list != this || __tmp != __pos.base(),
+ _M_message(__gnu_debug::__msg_splice_overlap)
+ ._M_iterator(__tmp, "position")
+ ._M_iterator(__before, "before")
+ ._M_iterator(__last, "last"));
+ // _GLIBCXX_RESOLVE_LIB_DEFECTS
+ // 250. splicing invalidates iterators
+ this->_M_transfer_from_if(__list, [__tmp](_Base_const_iterator __it)
+ { return __it == __tmp; });
+ }
+
+ _Base::splice_after(__pos.base(), std::move(__list._M_base()),
+ __before.base(), __last.base());
}
void
remove(const _Tp& __val)
{
- iterator __x = before_begin();
- iterator __old = __x++;
- while (__x.base() != _Base::end())
+ _Base_iterator __x = _Base::before_begin();
+ _Base_iterator __old = __x++;
+ while (__x != _Base::end())
{
if (*__x == __val)
- {
- erase_after(__old);
- __x = __old; ++__x;
- }
+ __x = _M_erase_after(__old);
else
__old = __x++;
}
void
remove_if(_Pred __pred)
{
- iterator __x = before_begin();
- iterator __old = __x++;
- while (__x.base() != _Base::end())
+ _Base_iterator __x = _Base::before_begin();
+ _Base_iterator __old = __x++;
+ while (__x != _Base::end())
{
if (__pred(*__x))
- {
- erase_after(__old);
- __x = std::next(__old);
- }
+ __x = _M_erase_after(__old);
else
__old = __x++;
}
void
unique()
{
- iterator __first = begin();
- iterator __last = end();
+ _Base_iterator __first = _Base::begin();
+ _Base_iterator __last = _Base::end();
if (__first == __last)
return;
- iterator __next = __first;
- while (++__next != __last)
+ _Base_iterator __next = std::next(__first);
+ while (__next != __last)
{
if (*__first == *__next)
- {
- erase_after(__first);
- __next = __first;
- }
+ __next = _M_erase_after(__first);
else
- __first = __next;
+ __first = __next++;
}
}
void
unique(_BinPred __binary_pred)
{
- iterator __first = begin();
- iterator __last = end();
+ _Base_iterator __first = _Base::begin();
+ _Base_iterator __last = _Base::end();
if (__first == __last)
return;
- iterator __next = __first;
- while (++__next != __last)
+ _Base_iterator __next = std::next(__first);
+ while (__next != __last)
{
if (__binary_pred(*__first, *__next))
- {
- erase_after(__first);
- __next = __first;
- }
+ __next = _M_erase_after(__first);
else
- __first = __next;
+ __first = __next++;
}
}
__glibcxx_check_sorted(_Base::begin(), _Base::end());
__glibcxx_check_sorted(__list._M_base().begin(),
__list._M_base().end());
- for (iterator __tmp = __list.begin(); __tmp != __list.end();)
+ this->_M_transfer_from_if(__list, [&__list](_Base_const_iterator __it)
{
- iterator __victim = __tmp++;
- this->_M_transfer_iter(__victim);
- }
+ return __it != __list._M_base().cbefore_begin()
+ && __it != __list._M_base().cend();
+ });
_Base::merge(std::move(__list._M_base()));
}
}
__glibcxx_check_sorted_pred(_Base::begin(), _Base::end(), __comp);
__glibcxx_check_sorted_pred(__list._M_base().begin(),
__list._M_base().end(), __comp);
- for (iterator __tmp = __list.begin(); __tmp != __list.end();)
+ this->_M_transfer_from_if(__list,
+ [&__list](_Base_const_iterator __it)
{
- iterator __victim = __tmp++;
- this->_M_transfer_iter(__victim);
- }
+ return __it != __list._M_base().cbefore_begin()
+ && __it != __list._M_base().cend();
+ });
_Base::merge(std::move(__list._M_base()), __comp);
}
}
void
_M_invalidate_all()
{
- typedef typename _Base::const_iterator _Base_const_iterator;
- typedef __gnu_debug::_Not_equal_to<_Base_const_iterator> _Not_equal;
- this->_M_invalidate_if(_Not_equal(_M_base().end()));
+ this->_M_invalidate_if([this](_Base_const_iterator __it)
+ {
+ return __it != this->_M_base().cbefore_begin()
+ && __it != this->_M_base().cend();
+ });
}
};
template<class _Tp, class _Alloc>
struct _BeforeBeginHelper<std::__debug::forward_list<_Tp, _Alloc> >
{
- typedef typename forward_list<_Tp, _Alloc>::const_iterator _It;
+ typedef std::__debug::forward_list<_Tp, _Alloc> _Sequence;
+ typedef typename _Sequence::const_iterator _It;
+ typedef typename _It::iterator_type _BaseIt;
static bool
- _M_Is(_It __it, const forward_list<_Tp, _Alloc>* __seq)
- { return __it == __seq->before_begin(); }
+ _M_Is(_BaseIt __it, const _Sequence* __seq)
+ { return __it == __seq->_M_base().cbefore_begin(); }
};
}
typedef _GLIBCXX_STD_D::list<_Tp, _Allocator> _Base;
typedef __gnu_debug::_Safe_sequence<list> _Safe_base;
+ 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;
- typedef __gnu_debug::_Safe_iterator<typename _Base::iterator, list>
+ typedef __gnu_debug::_Safe_iterator<_Base_iterator, list>
iterator;
- typedef __gnu_debug::_Safe_iterator<typename _Base::const_iterator, list>
+ typedef __gnu_debug::_Safe_iterator<_Base_const_iterator, list>
const_iterator;
typedef typename _Base::size_type size_type;
this->_M_detach_singular();
// if __sz < size(), invalidate all iterators in [begin+__sz, end())
- iterator __victim = begin();
- iterator __end = end();
+ _Base_iterator __victim = _Base::begin();
+ _Base_iterator __end = _Base::end();
for (size_type __i = __sz; __victim != __end && __i > 0; --__i)
++__victim;
- while (__victim != __end)
+ for (; __victim != __end; ++__victim)
{
- iterator __real_victim = __victim++;
- __real_victim._M_invalidate();
+ this->_M_invalidate_if(_Equal(__victim));
}
__try
this->_M_detach_singular();
// if __sz < size(), invalidate all iterators in [begin+__sz, end())
- iterator __victim = begin();
- iterator __end = end();
+ _Base_iterator __victim = _Base::begin();
+ _Base_iterator __end = _Base::end();
for (size_type __i = __sz; __victim != __end && __i > 0; --__i)
++__victim;
- while (__victim != __end)
+ for (; __victim != __end; ++__victim)
{
- iterator __real_victim = __victim++;
- __real_victim._M_invalidate();
+ this->_M_invalidate_if(_Equal(__victim));
}
__try
this->_M_detach_singular();
// if __sz < size(), invalidate all iterators in [begin+__sz, end())
- iterator __victim = begin();
- iterator __end = end();
+ _Base_iterator __victim = _Base::begin();
+ _Base_iterator __end = _Base::end();
for (size_type __i = __sz; __victim != __end && __i > 0; --__i)
++__victim;
- while (__victim != __end)
+ for (; __victim != __end; ++__victim)
{
- iterator __real_victim = __victim++;
- __real_victim._M_invalidate();
+ this->_M_invalidate_if(_Equal(__victim));
}
__try
pop_front()
{
__glibcxx_check_nonempty();
- iterator __victim = begin();
- __victim._M_invalidate();
+ this->_M_invalidate_if(_Equal(_Base::begin()));
_Base::pop_front();
}
pop_back()
{
__glibcxx_check_nonempty();
- iterator __victim = end();
- --__victim;
- __victim._M_invalidate();
+ this->_M_invalidate_if(_Equal(--_Base::end()));
_Base::pop_back();
}
__gnu_debug::__base(__last));
}
+ private:
+ _Base_iterator
+ _M_erase(_Base_iterator __position)
+ {
+ this->_M_invalidate_if(_Equal(__position));
+ return _Base::erase(__position);
+ }
+ public:
iterator
erase(iterator __position)
{
__glibcxx_check_erase(__position);
- __position._M_invalidate();
- return iterator(_Base::erase(__position.base()), this);
+ return iterator(_M_erase(__position.base()), this);
}
iterator
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 151. can't currently clear() empty container
__glibcxx_check_erase_range(__position, __last);
- for (iterator __victim = __position; __victim != __last; )
+ for (_Base_iterator __victim = __position.base();
+ __victim != __last.base(); ++__victim)
{
- iterator __old = __victim;
- ++__victim;
- __old._M_invalidate();
+ _GLIBCXX_DEBUG_VERIFY(__victim != _Base::end(),
+ _M_message(__gnu_debug::__msg_valid_range)
+ ._M_iterator(__position, "position")
+ ._M_iterator(__last, "last"));
+ this->_M_invalidate_if(_Equal(__victim));
}
return iterator(_Base::erase(__position.base(), __last.base()), this);
}
_GLIBCXX_DEBUG_VERIFY(&__x != this,
_M_message(__gnu_debug::__msg_self_splice)
._M_sequence(*this, "this"));
- this->splice(__position, _GLIBCXX_MOVE(__x), __x.begin(), __x.end());
+ this->_M_transfer_from_if(__x, _Not_equal(__x._M_base().end()));
+ _Base::splice(__position.base(), _GLIBCXX_MOVE(__x._M_base()));
}
#ifdef __GXX_EXPERIMENTAL_CXX0X__
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 250. splicing invalidates iterators
- this->_M_transfer_iter(__i);
+ this->_M_transfer_from_if(__x, _Equal(__i.base()));
_Base::splice(__position.base(), _GLIBCXX_MOVE(__x._M_base()),
__i.base());
}
// We used to perform the splice_alloc check: not anymore, redundant
// after implementing the relevant bits of N1599.
- for (iterator __tmp = __first; __tmp != __last; )
+ for (_Base_iterator __tmp = __first.base();
+ __tmp != __last.base(); ++__tmp)
{
+ _GLIBCXX_DEBUG_VERIFY(__tmp != _Base::end(),
+ _M_message(__gnu_debug::__msg_valid_range)
+ ._M_iterator(__first, "first")
+ ._M_iterator(__last, "last"));
_GLIBCXX_DEBUG_VERIFY(&__x != this || __tmp != __position,
_M_message(__gnu_debug::__msg_splice_overlap)
._M_iterator(__tmp, "position")
._M_iterator(__first, "first")
._M_iterator(__last, "last"));
- iterator __victim = __tmp++;
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 250. splicing invalidates iterators
- this->_M_transfer_iter(__victim);
+ this->_M_transfer_from_if(__x, _Equal(__tmp));
}
_Base::splice(__position.base(), _GLIBCXX_MOVE(__x._M_base()),
void
remove(const _Tp& __value)
{
- for (iterator __x = begin(); __x.base() != _Base::end(); )
+ for (_Base_iterator __x = _Base::begin(); __x != _Base::end(); )
{
if (*__x == __value)
- __x = erase(__x);
+ __x = _M_erase(__x);
else
++__x;
}
void
remove_if(_Predicate __pred)
{
- for (iterator __x = begin(); __x.base() != _Base::end(); )
+ for (_Base_iterator __x = _Base::begin(); __x != _Base::end(); )
{
if (__pred(*__x))
- __x = erase(__x);
+ __x = _M_erase(__x);
else
++__x;
}
void
unique()
{
- iterator __first = begin();
- iterator __last = end();
+ _Base_iterator __first = _Base::begin();
+ _Base_iterator __last = _Base::end();
if (__first == __last)
return;
- iterator __next = __first;
- while (++__next != __last)
+ _Base_iterator __next = __first; ++__next;
+ while (__next != __last)
{
if (*__first == *__next)
- erase(__next);
+ __next = _M_erase(__next);
else
- __first = __next;
- __next = __first;
+ __first = __next++;
}
}
void
unique(_BinaryPredicate __binary_pred)
{
- iterator __first = begin();
- iterator __last = end();
+ _Base_iterator __first = _Base::begin();
+ _Base_iterator __last = _Base::end();
if (__first == __last)
return;
- iterator __next = __first;
- while (++__next != __last)
+ _Base_iterator __next = __first; ++__next;
+ while (__next != __last)
{
if (__binary_pred(*__first, *__next))
- erase(__next);
+ __next = _M_erase(__next);
else
- __first = __next;
- __next = __first;
+ __first = __next++;
}
}
{
__glibcxx_check_sorted(_Base::begin(), _Base::end());
__glibcxx_check_sorted(__x.begin().base(), __x.end().base());
- for (iterator __tmp = __x.begin(); __tmp != __x.end();)
- {
- iterator __victim = __tmp++;
- this->_M_transfer_iter(__victim);
- }
+ this->_M_transfer_from_if(__x, _Not_equal(__x._M_base().end()));
_Base::merge(_GLIBCXX_MOVE(__x._M_base()));
}
}
__comp);
__glibcxx_check_sorted_pred(__x.begin().base(), __x.end().base(),
__comp);
- for (iterator __tmp = __x.begin(); __tmp != __x.end();)
- {
- iterator __victim = __tmp++;
- this->_M_transfer_iter(__victim);
- }
+ this->_M_transfer_from_if(__x, _Not_equal(__x._M_base().end()));
_Base::merge(_GLIBCXX_MOVE(__x._M_base()), __comp);
}
}
void
_M_invalidate_all()
{
- typedef typename _Base::const_iterator _Base_const_iterator;
- typedef __gnu_debug::_Not_equal_to<_Base_const_iterator> _Not_equal;
- this->_M_invalidate_if(_Not_equal(_M_base().end()));
+ this->_M_invalidate_if(_Not_equal(_Base::end()));
}
};
typedef _GLIBCXX_STD_D::map<_Key, _Tp, _Compare, _Allocator> _Base;
typedef __gnu_debug::_Safe_sequence<map> _Safe_base;
+ typedef typename _Base::const_iterator _Base_const_iterator;
+ typedef typename _Base::iterator _Base_iterator;
+ typedef __gnu_debug::_Equal_to<_Base_const_iterator> _Equal;
public:
// types:
typedef _Key key_type;
erase(const_iterator __position)
{
__glibcxx_check_erase(__position);
- __position._M_invalidate();
+ this->_M_invalidate_if(_Equal(__position.base()));
return iterator(_Base::erase(__position.base()), this);
}
#else
erase(iterator __position)
{
__glibcxx_check_erase(__position);
- __position._M_invalidate();
+ this->_M_invalidate_if(_Equal(__position.base()));
_Base::erase(__position.base());
}
#endif
size_type
erase(const key_type& __x)
{
- iterator __victim = find(__x);
- if (__victim == end())
+ _Base_iterator __victim = _Base::find(__x);
+ if (__victim == _Base::end())
return 0;
else
- {
- __victim._M_invalidate();
- _Base::erase(__victim.base());
- return 1;
- }
+ {
+ this->_M_invalidate_if(_Equal(__victim));
+ _Base::erase(__victim);
+ return 1;
+ }
}
#ifdef __GXX_EXPERIMENTAL_CXX0X__
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 151. can't currently clear() empty container
__glibcxx_check_erase_range(__first, __last);
- while (__first != __last)
- this->erase(__first++);
- return iterator(__last.base()._M_const_cast(), this);
+ for (_Base_const_iterator __victim = __first.base();
+ __victim != __last.base(); ++__victim)
+ {
+ _GLIBCXX_DEBUG_VERIFY(__victim != _Base::end(),
+ _M_message(__gnu_debug::__msg_valid_range)
+ ._M_iterator(__first, "first")
+ ._M_iterator(__last, "last"));
+ this->_M_invalidate_if(_Equal(__victim));
+ }
+ return iterator(_Base::erase(__first.base(), __last.base()), this);
}
#else
void
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 151. can't currently clear() empty container
__glibcxx_check_erase_range(__first, __last);
- while (__first != __last)
- this->erase(__first++);
+ for (_Base_iterator __victim = __first.base();
+ __victim != __last.base(); ++__victim)
+ {
+ _GLIBCXX_DEBUG_VERIFY(__victim != _Base::end(),
+ _M_message(__gnu_debug::__msg_valid_range)
+ ._M_iterator(__first, "first")
+ ._M_iterator(__last, "last"));
+ this->_M_invalidate_if(_Equal(__victim));
+ }
+ _Base::erase(__first.base(), __last.base());
}
#endif
void
clear()
- { this->erase(begin(), end()); }
+ {
+ this->_M_invalidate_all();
+ _Base::clear();
+ }
// observers:
using _Base::key_comp;
typedef _GLIBCXX_STD_D::multimap<_Key, _Tp, _Compare, _Allocator> _Base;
typedef __gnu_debug::_Safe_sequence<multimap> _Safe_base;
+ typedef typename _Base::const_iterator _Base_const_iterator;
+ typedef typename _Base::iterator _Base_iterator;
+ typedef __gnu_debug::_Equal_to<_Base_const_iterator> _Equal;
public:
// types:
typedef _Key key_type;
typedef typename _Base::reference reference;
typedef typename _Base::const_reference const_reference;
- typedef __gnu_debug::_Safe_iterator<typename _Base::iterator, multimap>
+ typedef __gnu_debug::_Safe_iterator<_Base_iterator, multimap>
iterator;
- typedef __gnu_debug::_Safe_iterator<typename _Base::const_iterator,
+ typedef __gnu_debug::_Safe_iterator<_Base_const_iterator,
multimap> const_iterator;
typedef typename _Base::size_type size_type;
#ifdef __GXX_EXPERIMENTAL_CXX0X__
insert(const_iterator __position, const value_type& __x)
#else
- insert(iterator __position, const value_type& __x)
+ insert(iterator __position, const value_type& __x)
#endif
{
__glibcxx_check_insert(__position);
erase(const_iterator __position)
{
__glibcxx_check_erase(__position);
- __position._M_invalidate();
+ this->_M_invalidate_if(_Equal(__position.base()));
return iterator(_Base::erase(__position.base()), this);
}
#else
erase(iterator __position)
{
__glibcxx_check_erase(__position);
- __position._M_invalidate();
+ this->_M_invalidate_if(_Equal(__position.base()));
_Base::erase(__position.base());
}
#endif
size_type
erase(const key_type& __x)
{
- std::pair<iterator, iterator> __victims = this->equal_range(__x);
+ std::pair<_Base_iterator, _Base_iterator> __victims =
+ _Base::equal_range(__x);
size_type __count = 0;
- while (__victims.first != __victims.second)
- {
- iterator __victim = __victims.first++;
- __victim._M_invalidate();
- _Base::erase(__victim.base());
- ++__count;
- }
+ _Base_iterator __victim = __victims.first;
+ while (__victim != __victims.second)
+ {
+ this->_M_invalidate_if(_Equal(__victim));
+ _Base::erase(__victim++);
+ ++__count;
+ }
return __count;
}
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 151. can't currently clear() empty container
__glibcxx_check_erase_range(__first, __last);
- while (__first != __last)
- this->erase(__first++);
- return iterator(__last.base()._M_const_cast(), this);
+ for (_Base_const_iterator __victim = __first.base();
+ __victim != __last.base(); ++__victim)
+ {
+ _GLIBCXX_DEBUG_VERIFY(__victim != _Base::end(),
+ _M_message(__gnu_debug::__msg_valid_range)
+ ._M_iterator(__first, "first")
+ ._M_iterator(__last, "last"));
+ this->_M_invalidate_if(_Equal(__victim));
+ }
+ return iterator(_Base::erase(__first.base(), __last.base()), this);
}
#else
void
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 151. can't currently clear() empty container
__glibcxx_check_erase_range(__first, __last);
- while (__first != __last)
- this->erase(__first++);
+ for (_Base_iterator __victim = __first.base();
+ __victim != __last.base(); ++__victim)
+ {
+ _GLIBCXX_DEBUG_VERIFY(__victim != _Base::end(),
+ _M_message(__gnu_debug::__msg_valid_range)
+ ._M_iterator(__first, "first")
+ ._M_iterator(__last, "last"));
+ this->_M_invalidate_if(_Equal(__victim));
+ }
+ _Base::erase(__first.base(), __last.base());
}
#endif
void
clear()
- { this->erase(begin(), end()); }
+ {
+ this->_M_invalidate_all();
+ _Base::clear();
+ }
// observers:
using _Base::key_comp;
std::pair<iterator,iterator>
equal_range(const key_type& __x)
{
- typedef typename _Base::iterator _Base_iterator;
std::pair<_Base_iterator, _Base_iterator> __res =
_Base::equal_range(__x);
return std::make_pair(iterator(__res.first, this),
std::pair<const_iterator,const_iterator>
equal_range(const key_type& __x) const
{
- typedef typename _Base::const_iterator _Base_const_iterator;
std::pair<_Base_const_iterator, _Base_const_iterator> __res =
- _Base::equal_range(__x);
+ _Base::equal_range(__x);
return std::make_pair(const_iterator(__res.first, this),
const_iterator(__res.second, this));
}
void
_M_invalidate_all()
{
- typedef typename _Base::const_iterator _Base_const_iterator;
typedef __gnu_debug::_Not_equal_to<_Base_const_iterator> _Not_equal;
- this->_M_invalidate_if(_Not_equal(_M_base().end()));
+ this->_M_invalidate_if(_Not_equal(_Base::end()));
}
};
typedef _GLIBCXX_STD_D::multiset<_Key, _Compare, _Allocator> _Base;
typedef __gnu_debug::_Safe_sequence<multiset> _Safe_base;
+ typedef typename _Base::const_iterator _Base_const_iterator;
+ typedef typename _Base::iterator _Base_iterator;
+ typedef __gnu_debug::_Equal_to<_Base_const_iterator> _Equal;
public:
// types:
typedef _Key key_type;
typedef typename _Base::reference reference;
typedef typename _Base::const_reference const_reference;
- typedef __gnu_debug::_Safe_iterator<typename _Base::iterator, multiset>
+ typedef __gnu_debug::_Safe_iterator<_Base_iterator, multiset>
iterator;
- typedef __gnu_debug::_Safe_iterator<typename _Base::const_iterator,
+ typedef __gnu_debug::_Safe_iterator<_Base_const_iterator,
multiset> const_iterator;
typedef typename _Base::size_type size_type;
erase(const_iterator __position)
{
__glibcxx_check_erase(__position);
- __position._M_invalidate();
+ this->_M_invalidate_if(_Equal(__position.base()));
return iterator(_Base::erase(__position.base()), this);
}
#else
erase(iterator __position)
{
__glibcxx_check_erase(__position);
- __position._M_invalidate();
+ this->_M_invalidate_if(_Equal(__position.base()));
_Base::erase(__position.base());
}
#endif
size_type
erase(const key_type& __x)
{
- std::pair<iterator, iterator> __victims = this->equal_range(__x);
+ std::pair<_Base_iterator, _Base_iterator> __victims =
+ _Base::equal_range(__x);
size_type __count = 0;
- while (__victims.first != __victims.second)
- {
- iterator __victim = __victims.first++;
- __victim._M_invalidate();
- _Base::erase(__victim.base());
- ++__count;
- }
+ _Base_iterator __victim = __victims.first;
+ while (__victim != __victims.second)
+ {
+ this->_M_invalidate_if(_Equal(__victim));
+ _Base::erase(__victim++);
+ ++__count;
+ }
return __count;
}
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 151. can't currently clear() empty container
__glibcxx_check_erase_range(__first, __last);
- while (__first != __last)
- this->erase(__first++);
- return __last; // iterator == const_iterator
+ for (_Base_const_iterator __victim = __first.base();
+ __victim != __last.base(); ++__victim)
+ {
+ _GLIBCXX_DEBUG_VERIFY(__victim != _Base::end(),
+ _M_message(__gnu_debug::__msg_valid_range)
+ ._M_iterator(__first, "first")
+ ._M_iterator(__last, "last"));
+ this->_M_invalidate_if(_Equal(__victim));
+ }
+ return iterator(_Base::erase(__first.base(), __last.base()), this);
}
#else
void
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 151. can't currently clear() empty container
__glibcxx_check_erase_range(__first, __last);
- while (__first != __last)
- this->erase(__first++);
+ for (_Base_iterator __victim = __first.base();
+ __victim != __last.base(); ++__victim)
+ {
+ _GLIBCXX_DEBUG_VERIFY(__victim != _Base::end(),
+ _M_message(__gnu_debug::__msg_valid_range)
+ ._M_iterator(__first, "first")
+ ._M_iterator(__last, "last"));
+ this->_M_invalidate_if(_Equal(__victim));
+ }
+ _Base::erase(__first.base(), __last.base());
}
#endif
void
clear()
- { this->erase(begin(), end()); }
+ {
+ this->_M_invalidate_all();
+ _Base::clear();
+ }
// observers:
using _Base::key_comp;
std::pair<iterator,iterator>
equal_range(const key_type& __x)
{
- typedef typename _Base::iterator _Base_iterator;
std::pair<_Base_iterator, _Base_iterator> __res =
- _Base::equal_range(__x);
+ _Base::equal_range(__x);
return std::make_pair(iterator(__res.first, this),
iterator(__res.second, this));
}
std::pair<const_iterator,const_iterator>
equal_range(const key_type& __x) const
{
- typedef typename _Base::const_iterator _Base_iterator;
- std::pair<_Base_iterator, _Base_iterator> __res =
- _Base::equal_range(__x);
+ std::pair<_Base_const_iterator, _Base_const_iterator> __res =
+ _Base::equal_range(__x);
return std::make_pair(const_iterator(__res.first, this),
const_iterator(__res.second, this));
}
void
_M_invalidate_all()
{
- typedef typename _Base::const_iterator _Base_const_iterator;
typedef __gnu_debug::_Not_equal_to<_Base_const_iterator> _Not_equal;
- this->_M_invalidate_if(_Not_equal(_M_base().end()));
+ this->_M_invalidate_if(_Not_equal(_Base::end()));
}
};
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 ();
+
+ /** Invalidate the iterator, making it singular. */
+ void
+ _M_invalidate()
+ { _M_version = 0; }
+
+ /** Reset all member variables */
+ void
+ _M_reset() throw ();
};
/**
void
_M_invalidate_all() const
{ if (++_M_version == 0) _M_version = 1; }
+
+ /** Attach an iterator to this sequence. */
+ void
+ _M_attach(_Safe_iterator_base* __it, bool __constant);
+
+ /** Likewise but not thread safe. */
+ void
+ _M_attach_single(_Safe_iterator_base* __it, bool __constant) throw ();
+
+ /** Detach an iterator from this sequence */
+ void
+ _M_detach(_Safe_iterator_base* __it);
+
+ /** Likewise but not thread safe. */
+ void
+ _M_detach_single(_Safe_iterator_base* __it) throw ();
};
} // namespace __gnu_debug
struct _BeforeBeginHelper
{
typedef typename _Sequence::const_iterator _It;
+ typedef typename _It::iterator_type _BaseIt;
static bool
- _M_Is(_It __it, const _Sequence* __seq)
+ _M_Is(_BaseIt __it, const _Sequence* __seq)
{ return false; }
};
._M_iterator(*this, "this")
._M_iterator(__x, "other"));
_M_current = __x._M_current;
- this->_M_attach(static_cast<_Sequence*>(__x._M_sequence));
+ this->_M_attach(__x._M_sequence);
return *this;
}
/** Attach iterator to the given sequence. */
void
- _M_attach(const _Sequence* __seq)
+ _M_attach(_Safe_sequence_base* __seq)
{
- _Safe_iterator_base::_M_attach(const_cast<_Sequence*>(__seq),
- _M_constant());
+ _Safe_iterator_base::_M_attach(__seq, _M_constant());
}
/** Likewise, but not thread-safe. */
void
- _M_attach_single(const _Sequence* __seq)
+ _M_attach_single(_Safe_sequence_base* __seq)
{
- _Safe_iterator_base::_M_attach_single(const_cast<_Sequence*>(__seq),
- _M_constant());
+ _Safe_iterator_base::_M_attach_single(__seq, _M_constant());
}
- /** Invalidate the iterator, making it singular. */
- void
- _M_invalidate();
-
- /** Likewise, but not thread-safe. */
- void
- _M_invalidate_single();
-
/// Is the iterator dereferenceable?
bool
_M_dereferenceable() const
static std::pair<difference_type, _Distance_precision>
_M_get_distance(const _Iterator1& __lhs, const _Iterator2& __rhs,
std::random_access_iterator_tag)
- {
- return std::make_pair(__rhs.base() - __lhs.base(), __dp_exact);
- }
+ { return std::make_pair(__rhs - __lhs, __dp_exact); }
template<typename _Iterator1, typename _Iterator2>
static std::pair<difference_type, _Distance_precision>
_M_get_distance(const _Iterator1& __lhs, const _Iterator2& __rhs,
std::forward_iterator_tag)
- {
- return std::make_pair(__lhs.base() == __rhs.base()? 0 : 1,
- __dp_equality);
- }
+ { return std::make_pair(__lhs == __rhs? 0 : 1, __dp_equality); }
/// Is this iterator equal to the sequence's begin() iterator?
bool _M_is_begin() const
- { return *this == _M_get_sequence()->begin(); }
+ { return base() == _M_get_sequence()->_M_base().begin(); }
/// Is this iterator equal to the sequence's end() iterator?
bool _M_is_end() const
- { return *this == _M_get_sequence()->end(); }
+ { return base() == _M_get_sequence()->_M_base().end(); }
/// Is this iterator equal to the sequence's before_begin() iterator if
/// any?
bool _M_is_before_begin() const
- { return _BeforeBeginHelper<_Sequence>::_M_Is(*this, _M_get_sequence()); }
+ { return _BeforeBeginHelper<_Sequence>::_M_Is(base(), _M_get_sequence()); }
};
template<typename _IteratorL, typename _IteratorR, typename _Sequence>
_Safe_iterator<_Iterator, _Sequence>::
_M_can_advance(const difference_type& __n) const
{
- typedef typename _Sequence::const_iterator const_iterator;
+ typedef typename _Sequence::const_iterator const_debug_iterator;
+ typedef typename const_debug_iterator::iterator_type const_iterator;
if (this->_M_singular())
return false;
return true;
if (__n < 0)
{
- const_iterator __begin =
- static_cast<const _Sequence*>(_M_sequence)->begin();
+ const_iterator __begin = _M_get_sequence()->_M_base().begin();
std::pair<difference_type, _Distance_precision> __dist =
- this->_M_get_distance(__begin, *this);
+ this->_M_get_distance(__begin, base());
bool __ok = ((__dist.second == __dp_exact && __dist.first >= -__n)
|| (__dist.second != __dp_exact && __dist.first > 0));
return __ok;
}
else
{
- const_iterator __end =
- static_cast<const _Sequence*>(_M_sequence)->end();
+ const_iterator __end = _M_get_sequence()->_M_base().end();
std::pair<difference_type, _Distance_precision> __dist =
- this->_M_get_distance(*this, __end);
+ this->_M_get_distance(base(), __end);
bool __ok = ((__dist.second == __dp_exact && __dist.first >= __n)
|| (__dist.second != __dp_exact && __dist.first > 0));
return __ok;
/* Determine if we can order the iterators without the help of
the container */
std::pair<difference_type, _Distance_precision> __dist =
- this->_M_get_distance(*this, __rhs);
+ this->_M_get_distance(base(), __rhs.base());
switch (__dist.second) {
case __dp_equality:
if (__dist.first == 0)
/* We can only test for equality, but check if one of the
iterators is at an extreme. */
+ /* Optim for classic [begin, it) or [it, end) ranges, limit checks
+ * when code is valid. */
if (_M_is_begin() || __rhs._M_is_end())
return true;
- else if (_M_is_end() || __rhs._M_is_begin())
+ if (_M_is_end() || __rhs._M_is_begin())
return false;
// Assume that this is a valid range; we can't check anything else
return true;
}
-
- template<typename _Iterator, typename _Sequence>
- void
- _Safe_iterator<_Iterator, _Sequence>::
- _M_invalidate()
- {
- __gnu_cxx::__scoped_lock sentry(this->_M_get_mutex());
- _M_invalidate_single();
- }
-
- template<typename _Iterator, typename _Sequence>
- void
- _Safe_iterator<_Iterator, _Sequence>::
- _M_invalidate_single()
- {
- typedef typename _Sequence::iterator iterator;
- typedef typename _Sequence::const_iterator const_iterator;
-
- if (!this->_M_singular())
- {
- for (_Safe_iterator_base* __iter = _M_sequence->_M_iterators;
- __iter; __iter = __iter->_M_next)
- {
- iterator* __victim = static_cast<iterator*>(__iter);
- if (this->base() == __victim->base())
- __victim->_M_version = 0;
- }
-
- for (_Safe_iterator_base* __iter2 = _M_sequence->_M_const_iterators;
- __iter2; __iter2 = __iter2->_M_next)
- {
- const_iterator* __victim = static_cast<const_iterator*>(__iter2);
- if (__victim->base() == this->base())
- __victim->_M_version = 0;
- }
- _M_version = 0;
- }
- }
} // namespace __gnu_debug
#endif
{ return __value != __x; }
};
+ /** A simple function object that returns true if the passed-in
+ * value is equal to the stored value. */
+ template <typename _Type>
+ class _Equal_to
+ {
+ _Type __value;
+
+ public:
+ explicit _Equal_to(const _Type& __v) : __value(__v) { }
+
+ bool
+ operator()(const _Type& __x) const
+ { return __value == __x; }
+ };
+
/** A function object that returns true when the given random access
iterator is at least @c n steps away from the given iterator. */
template<typename _Iterator>
public:
/** Invalidates all iterators @c x that reference this sequence,
are not singular, and for which @c pred(x) returns @c
- true. The user of this routine should be careful not to make
- copies of the iterators passed to @p pred, as the copies may
- interfere with the invalidation. */
+ true. @c pred will be invoked with the normal iterators nested
+ in the safe ones. */
template<typename _Predicate>
void
_M_invalidate_if(_Predicate __pred);
- /** Transfers all iterators that reference this memory location
- to this sequence from whatever sequence they are attached
- to. */
- template<typename _Iterator>
+ /** Transfers all iterators @c x that reference @c from sequence,
+ are not singular, and for which @c pred(x) returns @c
+ true. @c pred will be invoked with the normal iterators nested
+ in the safe ones. */
+ template<typename _Predicate>
void
- _M_transfer_iter(const _Safe_iterator<_Iterator, _Sequence>& __x);
+ _M_transfer_from_if(_Safe_sequence& __from, _Predicate __pred);
};
-
- template<typename _Sequence>
- template<typename _Predicate>
- void
- _Safe_sequence<_Sequence>::
- _M_invalidate_if(_Predicate __pred)
- {
- typedef typename _Sequence::iterator iterator;
- typedef typename _Sequence::const_iterator const_iterator;
-
- __gnu_cxx::__scoped_lock sentry(this->_M_get_mutex());
- for (_Safe_iterator_base* __iter = _M_iterators; __iter;)
- {
- iterator* __victim = static_cast<iterator*>(__iter);
- __iter = __iter->_M_next;
- if (!__victim->_M_singular())
- {
- if (__pred(__victim->base()))
- __victim->_M_invalidate_single();
- }
- }
-
- for (_Safe_iterator_base* __iter2 = _M_const_iterators; __iter2;)
- {
- const_iterator* __victim = static_cast<const_iterator*>(__iter2);
- __iter2 = __iter2->_M_next;
- if (!__victim->_M_singular())
- {
- if (__pred(__victim->base()))
- __victim->_M_invalidate_single();
- }
- }
- }
-
- template<typename _Sequence>
- template<typename _Iterator>
- void
- _Safe_sequence<_Sequence>::
- _M_transfer_iter(const _Safe_iterator<_Iterator, _Sequence>& __x)
- {
- _Safe_sequence_base* __from = __x._M_sequence;
- if (!__from)
- return;
-
- typedef typename _Sequence::iterator iterator;
- typedef typename _Sequence::const_iterator const_iterator;
-
- __gnu_cxx::__scoped_lock sentry(this->_M_get_mutex());
- for (_Safe_iterator_base* __iter = __from->_M_iterators; __iter;)
- {
- iterator* __victim = static_cast<iterator*>(__iter);
- __iter = __iter->_M_next;
- if (!__victim->_M_singular() && __victim->base() == __x.base())
- __victim->_M_attach_single(static_cast<_Sequence*>(this));
- }
-
- for (_Safe_iterator_base* __iter2 = __from->_M_const_iterators;
- __iter2;)
- {
- const_iterator* __victim = static_cast<const_iterator*>(__iter2);
- __iter2 = __iter2->_M_next;
- if (!__victim->_M_singular() && __victim->base() == __x.base())
- __victim->_M_attach_single(static_cast<_Sequence*>(this));
- }
- }
} // namespace __gnu_debug
+#ifndef _GLIBCXX_EXPORT_TEMPLATE
+# include <debug/safe_sequence.tcc>
+#endif
+
#endif
--- /dev/null
+// Safe sequence implementation -*- C++ -*-
+
+// Copyright (C) 2010 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_sequence.tcc
+ * This file is a GNU debug extension to the Standard C++ Library.
+ */
+
+#ifndef _GLIBCXX_DEBUG_SAFE_SEQUENCE_TCC
+#define _GLIBCXX_DEBUG_SAFE_SEQUENCE_TCC 1
+
+namespace __gnu_debug
+{
+ template<typename _Sequence>
+ template<typename _Predicate>
+ void
+ _Safe_sequence<_Sequence>::
+ _M_invalidate_if(_Predicate __pred)
+ {
+ typedef typename _Sequence::iterator iterator;
+ typedef typename _Sequence::const_iterator const_iterator;
+
+ __gnu_cxx::__scoped_lock sentry(this->_M_get_mutex());
+ for (_Safe_iterator_base* __iter = _M_iterators; __iter;)
+ {
+ iterator* __victim = static_cast<iterator*>(__iter);
+ __iter = __iter->_M_next;
+ if (!__victim->_M_singular() && __pred(__victim->base()))
+ {
+ __victim->_M_invalidate();
+ }
+ }
+
+ for (_Safe_iterator_base* __iter2 = _M_const_iterators; __iter2;)
+ {
+ const_iterator* __victim = static_cast<const_iterator*>(__iter2);
+ __iter2 = __iter2->_M_next;
+ if (!__victim->_M_singular() && __pred(__victim->base()))
+ {
+ __victim->_M_invalidate();
+ }
+ }
+ }
+
+ template<typename _Sequence>
+ template<typename _Predicate>
+ void
+ _Safe_sequence<_Sequence>::
+ _M_transfer_from_if(_Safe_sequence& __from, _Predicate __pred)
+ {
+ typedef typename _Sequence::iterator iterator;
+ typedef typename _Sequence::const_iterator const_iterator;
+
+ _Safe_iterator_base* __transfered_iterators = 0;
+ _Safe_iterator_base* __transfered_const_iterators = 0;
+ _Safe_iterator_base* __last_iterator = 0;
+ _Safe_iterator_base* __last_const_iterator = 0;
+ {
+ // We lock __from first and detach iterator(s) to transfer
+ __gnu_cxx::__scoped_lock sentry(__from._M_get_mutex());
+
+ for (_Safe_iterator_base* __iter = __from._M_iterators; __iter;)
+ {
+ iterator* __victim = static_cast<iterator*>(__iter);
+ __iter = __iter->_M_next;
+ if (!__victim->_M_singular() && __pred(__victim->base()))
+ {
+ __victim->_M_detach_single();
+ if (__transfered_iterators)
+ {
+ __victim->_M_next = __transfered_iterators;
+ __transfered_iterators->_M_prior = __victim;
+ }
+ else
+ __last_iterator = __victim;
+ __victim->_M_sequence = this;
+ __victim->_M_version = this->_M_version;
+ __transfered_iterators = __victim;
+ }
+ }
+
+ for (_Safe_iterator_base* __iter2 = __from._M_const_iterators;
+ __iter2;)
+ {
+ const_iterator* __victim = static_cast<const_iterator*>(__iter2);
+ __iter2 = __iter2->_M_next;
+ if (!__victim->_M_singular() && __pred(__victim->base()))
+ {
+ __victim->_M_detach_single();
+ if (__transfered_const_iterators)
+ {
+ __victim->_M_next = __transfered_const_iterators;
+ __transfered_const_iterators->_M_prior = __victim;
+ }
+ else
+ __last_const_iterator = __victim;
+ __victim->_M_sequence = this;
+ __victim->_M_version = this->_M_version;
+ __transfered_const_iterators = __victim;
+ }
+ }
+ }
+
+ // Now we can lock *this and add the transfered iterators if any
+ if (__last_iterator || __last_const_iterator)
+ {
+ __gnu_cxx::__scoped_lock sentry(this->_M_get_mutex());
+ if (__last_iterator)
+ {
+ if (this->_M_iterators)
+ {
+ this->_M_iterators->_M_prior = __last_iterator;
+ __last_iterator->_M_next = this->_M_iterators;
+ }
+ this->_M_iterators = __transfered_iterators;
+ }
+ if (__last_const_iterator)
+ {
+ if (this->_M_const_iterators)
+ {
+ this->_M_const_iterators->_M_prior = __last_const_iterator;
+ __last_const_iterator->_M_next = this->_M_const_iterators;
+ }
+ this->_M_const_iterators = __transfered_const_iterators;
+ }
+ }
+ }
+} // namespace __gnu_debug
+
+#endif
typedef _GLIBCXX_STD_D::set<_Key, _Compare, _Allocator> _Base;
typedef __gnu_debug::_Safe_sequence<set> _Safe_base;
+ typedef typename _Base::const_iterator _Base_const_iterator;
+ typedef typename _Base::iterator _Base_iterator;
+ typedef __gnu_debug::_Equal_to<_Base_const_iterator> _Equal;
public:
// types:
typedef _Key key_type;
typedef typename _Base::reference reference;
typedef typename _Base::const_reference const_reference;
- typedef __gnu_debug::_Safe_iterator<typename _Base::iterator, set>
+ typedef __gnu_debug::_Safe_iterator<_Base_iterator, set>
iterator;
- typedef __gnu_debug::_Safe_iterator<typename _Base::const_iterator, set>
+ typedef __gnu_debug::_Safe_iterator<_Base_const_iterator, set>
const_iterator;
typedef typename _Base::size_type size_type;
std::pair<iterator, bool>
insert(const value_type& __x)
{
- typedef typename _Base::iterator _Base_iterator;
std::pair<_Base_iterator, bool> __res = _Base::insert(__x);
return std::pair<iterator, bool>(iterator(__res.first, this),
__res.second);
erase(const_iterator __position)
{
__glibcxx_check_erase(__position);
- __position._M_invalidate();
+ this->_M_invalidate_if(_Equal(__position.base()));
return iterator(_Base::erase(__position.base()), this);
}
#else
erase(iterator __position)
{
__glibcxx_check_erase(__position);
- __position._M_invalidate();
+ this->_M_invalidate_if(_Equal(__position.base()));
_Base::erase(__position.base());
}
#endif
size_type
erase(const key_type& __x)
{
- iterator __victim = find(__x);
- if (__victim == end())
+ _Base_iterator __victim = _Base::find(__x);
+ if (__victim == _Base::end())
return 0;
else
- {
- __victim._M_invalidate();
- _Base::erase(__victim.base());
- return 1;
- }
+ {
+ this->_M_invalidate_if(_Equal(__victim));
+ _Base::erase(__victim);
+ return 1;
+ }
}
#ifdef __GXX_EXPERIMENTAL_CXX0X__
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 151. can't currently clear() empty container
__glibcxx_check_erase_range(__first, __last);
- while (__first != __last)
- this->erase(__first++);
- return __last; // iterator == const_iterator
+ for (_Base_const_iterator __victim = __first.base();
+ __victim != __last.base(); ++__victim)
+ {
+ _GLIBCXX_DEBUG_VERIFY(__victim != _Base::end(),
+ _M_message(__gnu_debug::__msg_valid_range)
+ ._M_iterator(__first, "first")
+ ._M_iterator(__last, "last"));
+ this->_M_invalidate_if(_Equal(__victim));
+ }
+ return iterator(_Base::erase(__first.base(), __last.base()), this);
}
#else
void
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 151. can't currently clear() empty container
__glibcxx_check_erase_range(__first, __last);
- while (__first != __last)
- this->erase(__first++);
+ for (_Base_iterator __victim = __first.base();
+ __victim != __last.base(); ++__victim)
+ {
+ _GLIBCXX_DEBUG_VERIFY(__victim != _Base::end(),
+ _M_message(__gnu_debug::__msg_valid_range)
+ ._M_iterator(__first, "first")
+ ._M_iterator(__last, "last"));
+ this->_M_invalidate_if(_Equal(__victim));
+ }
+ _Base::erase(__first.base(), __last.base());
}
#endif
void
clear()
- { this->erase(begin(), end()); }
+ {
+ this->_M_invalidate_all();
+ _Base::clear();
+ }
// observers:
using _Base::key_comp;
std::pair<iterator,iterator>
equal_range(const key_type& __x)
{
- typedef typename _Base::iterator _Base_iterator;
std::pair<_Base_iterator, _Base_iterator> __res =
_Base::equal_range(__x);
return std::make_pair(iterator(__res.first, this),
std::pair<const_iterator,const_iterator>
equal_range(const key_type& __x) const
{
- typedef typename _Base::const_iterator _Base_iterator;
std::pair<_Base_iterator, _Base_iterator> __res =
_Base::equal_range(__x);
return std::make_pair(const_iterator(__res.first, this),
void
_M_invalidate_all()
{
- typedef typename _Base::const_iterator _Base_const_iterator;
typedef __gnu_debug::_Not_equal_to<_Base_const_iterator> _Not_equal;
this->_M_invalidate_if(_Not_equal(_M_base().end()));
}
typedef _GLIBCXX_STD_D::unordered_map<_Key, _Tp, _Hash,
_Pred, _Alloc> _Base;
typedef __gnu_debug::_Safe_sequence<unordered_map> _Safe_base;
+ 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::size_type size_type;
typedef typename _Base::key_type key_type;
typedef typename _Base::value_type value_type;
- typedef __gnu_debug::_Safe_iterator<typename _Base::iterator,
+ typedef __gnu_debug::_Safe_iterator<_Base_iterator,
unordered_map> iterator;
- typedef __gnu_debug::_Safe_iterator<typename _Base::const_iterator,
+ typedef __gnu_debug::_Safe_iterator<_Base_const_iterator,
unordered_map> const_iterator;
explicit
std::pair<iterator, bool>
insert(const value_type& __obj)
{
- typedef std::pair<typename _Base::iterator, bool> __pair_type;
- __pair_type __res = _Base::insert(__obj);
+ std::pair<_Base_iterator, bool> __res = _Base::insert(__obj);
return std::make_pair(iterator(__res.first, this), __res.second);
}
iterator
insert(const_iterator, const value_type& __obj)
{
- typedef std::pair<typename _Base::iterator, bool> __pair_type;
- __pair_type __res = _Base::insert(__obj);
- return iterator(__res.first, this);
+ return iterator(_Base::insert(__obj).first, this);
}
template<typename _Pair, typename = typename
std::pair<iterator, bool>
insert(_Pair&& __obj)
{
- typedef std::pair<typename _Base::iterator, bool> __pair_type;
- __pair_type __res = _Base::insert(std::forward<_Pair>(__obj));
+ std::pair<_Base_iterator, bool> __res =
+ _Base::insert(std::forward<_Pair>(__obj));
return std::make_pair(iterator(__res.first, this), __res.second);
}
iterator
insert(const_iterator, _Pair&& __obj)
{
- typedef std::pair<typename _Base::iterator, bool> __pair_type;
- __pair_type __res = _Base::insert(std::forward<_Pair>(__obj));
- return iterator(__res.first, this);
+ return iterator(_Base::insert(std::forward<_Pair>(__obj)).first,
+ this);
}
void
std::pair<iterator, iterator>
equal_range(const key_type& __key)
{
- typedef typename _Base::iterator _Base_iterator;
- 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));
}
std::pair<const_iterator, const_iterator>
equal_range(const key_type& __key) const
{
- typedef typename _Base::const_iterator _Base_iterator;
- typedef std::pair<_Base_iterator, _Base_iterator> __pair_type;
- __pair_type __res = _Base::equal_range(__key);
+ std::pair<_Base_const_iterator, _Base_const_iterator> __res =
+ _Base::equal_range(__key);
return std::make_pair(const_iterator(__res.first, this),
const_iterator(__res.second, this));
}
erase(const key_type& __key)
{
size_type __ret(0);
- iterator __victim(_Base::find(__key), this);
- if (__victim != end())
+ _Base_iterator __victim(_Base::find(__key));
+ if (__victim != _Base::end())
{
- this->erase(__victim);
+ this->_M_invalidate_if(_Equal(__victim));
+ _Base::erase(__victim);
__ret = 1;
}
return __ret;
erase(const_iterator __it)
{
__glibcxx_check_erase(__it);
- __it._M_invalidate();
+ this->_M_invalidate_if(_Equal(__it.base()));
return iterator(_Base::erase(__it.base()), this);
}
erase(const_iterator __first, const_iterator __last)
{
__glibcxx_check_erase_range(__first, __last);
- for (const_iterator __tmp = __first; __tmp != __last;)
- {
- const_iterator __victim = __tmp++;
- __victim._M_invalidate();
- }
+ for (_Base_const_iterator __tmp = __first.base();
+ __tmp != __last.base(); ++__tmp)
+ {
+ _GLIBCXX_DEBUG_VERIFY(__tmp != _Base::end(),
+ _M_message(__gnu_debug::__msg_valid_range)
+ ._M_iterator(__first, "first")
+ ._M_iterator(__last, "last"));
+ this->_M_invalidate_if(_Equal(__tmp));
+ }
return iterator(_Base::erase(__first.base(),
__last.base()), this);
}
void
_M_invalidate_all()
{
- typedef typename _Base::const_iterator _Base_const_iterator;
typedef __gnu_debug::_Not_equal_to<_Base_const_iterator> _Not_equal;
- this->_M_invalidate_if(_Not_equal(_M_base().end()));
+ this->_M_invalidate_if(_Not_equal(_Base::end()));
}
};
typedef _GLIBCXX_STD_D::unordered_multimap<_Key, _Tp, _Hash,
_Pred, _Alloc> _Base;
typedef __gnu_debug::_Safe_sequence<unordered_multimap> _Safe_base;
+ 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::size_type size_type;
typedef typename _Base::key_type key_type;
typedef typename _Base::value_type value_type;
- typedef __gnu_debug::_Safe_iterator<typename _Base::iterator,
+ typedef __gnu_debug::_Safe_iterator<_Base_iterator,
unordered_multimap> iterator;
- typedef __gnu_debug::_Safe_iterator<typename _Base::const_iterator,
+ typedef __gnu_debug::_Safe_iterator<_Base_const_iterator,
unordered_multimap> const_iterator;
explicit
template<typename _Pair, typename = typename
std::enable_if<std::is_convertible<_Pair,
value_type>::value>::type>
- iterator
- insert(const_iterator, _Pair&& __obj)
- { return iterator(_Base::insert(std::forward<_Pair>(__obj)), this); }
+ iterator
+ insert(const_iterator, _Pair&& __obj)
+ { return iterator(_Base::insert(std::forward<_Pair>(__obj)), this); }
void
insert(std::initializer_list<value_type> __l)
std::pair<iterator, iterator>
equal_range(const key_type& __key)
{
- typedef typename _Base::iterator _Base_iterator;
- 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));
}
std::pair<const_iterator, const_iterator>
equal_range(const key_type& __key) const
{
- typedef typename _Base::const_iterator _Base_iterator;
- typedef std::pair<_Base_iterator, _Base_iterator> __pair_type;
- __pair_type __res = _Base::equal_range(__key);
+ std::pair<_Base_const_iterator, _Base_const_iterator> __res =
+ _Base::equal_range(__key);
return std::make_pair(const_iterator(__res.first, this),
const_iterator(__res.second, this));
}
erase(const key_type& __key)
{
size_type __ret(0);
- iterator __victim(_Base::find(__key), this);
- if (__victim != end())
+ _Base_iterator __victim(_Base::find(__key));
+ if (__victim != _Base::end())
{
- this->erase(__victim);
+ this->_M_invalidate_if(_Equal(__victim));
+ _Base::erase(__victim);
__ret = 1;
}
return __ret;
erase(const_iterator __it)
{
__glibcxx_check_erase(__it);
- __it._M_invalidate();
+ this->_M_invalidate_if(_Equal(__it.base()));
return iterator(_Base::erase(__it.base()), this);
}
erase(const_iterator __first, const_iterator __last)
{
__glibcxx_check_erase_range(__first, __last);
- for (const_iterator __tmp = __first; __tmp != __last;)
- {
- const_iterator __victim = __tmp++;
- __victim._M_invalidate();
- }
+ for (_Base_const_iterator __tmp = __first.base();
+ __tmp != __last.base(); ++__tmp)
+ {
+ _GLIBCXX_DEBUG_VERIFY(__tmp != _Base::end(),
+ _M_message(__gnu_debug::__msg_valid_range)
+ ._M_iterator(__first, "first")
+ ._M_iterator(__last, "last"));
+ this->_M_invalidate_if(_Equal(__tmp));
+ }
return iterator(_Base::erase(__first.base(),
__last.base()), this);
}
void
_M_invalidate_all()
{
- typedef typename _Base::const_iterator _Base_const_iterator;
typedef __gnu_debug::_Not_equal_to<_Base_const_iterator> _Not_equal;
- this->_M_invalidate_if(_Not_equal(_M_base().end()));
+ this->_M_invalidate_if(_Not_equal(_Base::end()));
}
};
typedef _GLIBCXX_STD_D::unordered_set<_Value, _Hash,
_Pred, _Alloc> _Base;
typedef __gnu_debug::_Safe_sequence<unordered_set> _Safe_base;
+ 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::size_type size_type;
typedef typename _Base::key_type key_type;
typedef typename _Base::value_type value_type;
- typedef __gnu_debug::_Safe_iterator<typename _Base::iterator,
+ typedef __gnu_debug::_Safe_iterator<_Base_iterator,
unordered_set> iterator;
- typedef __gnu_debug::_Safe_iterator<typename _Base::const_iterator,
+ typedef __gnu_debug::_Safe_iterator<_Base_const_iterator,
unordered_set> const_iterator;
explicit
std::pair<iterator, bool>
insert(const value_type& __obj)
{
- typedef std::pair<typename _Base::iterator, bool> __pair_type;
+ typedef std::pair<_Base_iterator, bool> __pair_type;
__pair_type __res = _Base::insert(__obj);
return std::make_pair(iterator(__res.first, this), __res.second);
}
iterator
insert(const_iterator, const value_type& __obj)
{
- typedef std::pair<typename _Base::iterator, bool> __pair_type;
+ typedef std::pair<_Base_iterator, bool> __pair_type;
__pair_type __res = _Base::insert(__obj);
return iterator(__res.first, this);
}
std::pair<iterator, iterator>
equal_range(const key_type& __key)
{
- typedef typename _Base::iterator _Base_iterator;
typedef std::pair<_Base_iterator, _Base_iterator> __pair_type;
__pair_type __res = _Base::equal_range(__key);
return std::make_pair(iterator(__res.first, this),
std::pair<const_iterator, const_iterator>
equal_range(const key_type& __key) const
{
- typedef typename _Base::const_iterator _Base_iterator;
- typedef std::pair<_Base_iterator, _Base_iterator> __pair_type;
- __pair_type __res = _Base::equal_range(__key);
+ std::pair<_Base_const_iterator, _Base_const_iterator>
+ __res = _Base::equal_range(__key);
return std::make_pair(const_iterator(__res.first, this),
const_iterator(__res.second, this));
}
erase(const key_type& __key)
{
size_type __ret(0);
- iterator __victim(_Base::find(__key), this);
- if (__victim != end())
+ _Base_iterator __victim(_Base::find(__key));
+ if (__victim != _Base::end())
{
- this->erase(__victim);
+ this->_M_invalidate_if(_Equal(__victim));
+ _Base::erase(__victim);
__ret = 1;
}
return __ret;
erase(const_iterator __it)
{
__glibcxx_check_erase(__it);
- __it._M_invalidate();
+ this->_M_invalidate_if(_Equal(__it.base()));
return iterator(_Base::erase(__it.base()), this);
}
erase(const_iterator __first, const_iterator __last)
{
__glibcxx_check_erase_range(__first, __last);
- for (const_iterator __tmp = __first; __tmp != __last;)
- {
- const_iterator __victim = __tmp++;
- __victim._M_invalidate();
- }
+ for (_Base_const_iterator __tmp = __first.base();
+ __tmp != __last.base(); ++__tmp)
+ {
+ _GLIBCXX_DEBUG_VERIFY(__tmp != _Base::end(),
+ _M_message(__gnu_debug::__msg_valid_range)
+ ._M_iterator(__first, "first")
+ ._M_iterator(__last, "last"));
+ this->_M_invalidate_if(_Equal(__tmp));
+ }
return iterator(_Base::erase(__first.base(),
__last.base()), this);
}
void
_M_invalidate_all()
{
- typedef typename _Base::const_iterator _Base_const_iterator;
typedef __gnu_debug::_Not_equal_to<_Base_const_iterator> _Not_equal;
- this->_M_invalidate_if(_Not_equal(_M_base().end()));
+ this->_M_invalidate_if(_Not_equal(_Base::end()));
}
};
typedef _GLIBCXX_STD_D::unordered_multiset<_Value, _Hash,
_Pred, _Alloc> _Base;
typedef __gnu_debug::_Safe_sequence<unordered_multiset> _Safe_base;
+ 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::size_type size_type;
typedef typename _Base::key_type key_type;
typedef typename _Base::value_type value_type;
- typedef __gnu_debug::_Safe_iterator<typename _Base::iterator,
+ typedef __gnu_debug::_Safe_iterator<_Base_iterator,
unordered_multiset> iterator;
- typedef __gnu_debug::_Safe_iterator<typename _Base::const_iterator,
+ typedef __gnu_debug::_Safe_iterator<_Base_const_iterator,
unordered_multiset> const_iterator;
explicit
std::pair<iterator, iterator>
equal_range(const key_type& __key)
{
- typedef typename _Base::iterator _Base_iterator;
typedef std::pair<_Base_iterator, _Base_iterator> __pair_type;
__pair_type __res = _Base::equal_range(__key);
return std::make_pair(iterator(__res.first, this),
std::pair<const_iterator, const_iterator>
equal_range(const key_type& __key) const
{
- typedef typename _Base::const_iterator _Base_iterator;
- typedef std::pair<_Base_iterator, _Base_iterator> __pair_type;
- __pair_type __res = _Base::equal_range(__key);
+ std::pair<_Base_const_iterator, _Base_const_iterator>
+ __res = _Base::equal_range(__key);
return std::make_pair(const_iterator(__res.first, this),
const_iterator(__res.second, this));
}
erase(const key_type& __key)
{
size_type __ret(0);
- iterator __victim(_Base::find(__key), this);
- if (__victim != end())
+ _Base_iterator __victim(_Base::find(__key));
+ if (__victim != _Base::end())
{
- this->erase(__victim);
+ this->_M_invalidate_if(_Equal(__victim));
+ _Base::erase(__victim);
__ret = 1;
}
return __ret;
erase(const_iterator __it)
{
__glibcxx_check_erase(__it);
- __it._M_invalidate();
+ this->_M_invalidate_if(_Equal(__it.base()));
return iterator(_Base::erase(__it.base()), this);
}
erase(const_iterator __first, const_iterator __last)
{
__glibcxx_check_erase_range(__first, __last);
- for (const_iterator __tmp = __first; __tmp != __last;)
- {
- const_iterator __victim = __tmp++;
- __victim._M_invalidate();
- }
+ for (_Base_const_iterator __tmp = __first.base();
+ __tmp != __last.base(); ++__tmp)
+ {
+ _GLIBCXX_DEBUG_VERIFY(__tmp != _Base::end(),
+ _M_message(__gnu_debug::__msg_valid_range)
+ ._M_iterator(__first, "first")
+ ._M_iterator(__last, "last"));
+ this->_M_invalidate_if(_Equal(__tmp));
+ }
return iterator(_Base::erase(__first.base(),
__last.base()), this);
}
void
_M_invalidate_all()
{
- typedef typename _Base::const_iterator _Base_const_iterator;
typedef __gnu_debug::_Not_equal_to<_Base_const_iterator> _Not_equal;
- this->_M_invalidate_if(_Not_equal(_M_base().end()));
+ this->_M_invalidate_if(_Not_equal(_Base::end()));
}
};
typedef _GLIBCXX_STD_D::vector<_Tp, _Allocator> _Base;
typedef __gnu_debug::_Safe_sequence<vector> _Safe_base;
+ typedef typename _Base::iterator _Base_iterator;
typedef typename _Base::const_iterator _Base_const_iterator;
- typedef __gnu_debug::_After_nth_from<_Base_const_iterator> _After_nth;
+ 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<typename _Base::iterator,vector>
+ typedef __gnu_debug::_Safe_iterator<_Base_iterator,vector>
iterator;
- typedef __gnu_debug::_Safe_iterator<typename _Base::const_iterator,vector>
+ typedef __gnu_debug::_Safe_iterator<_Base_const_iterator,vector>
const_iterator;
typedef typename _Base::size_type size_type;
{
bool __realloc = _M_requires_reallocation(__sz);
if (__sz < this->size())
- this->_M_invalidate_if(_After_nth(__sz, _M_base().begin()));
+ this->_M_invalidate_after_nth(__sz);
_Base::resize(__sz);
if (__realloc)
this->_M_invalidate_all();
{
bool __realloc = _M_requires_reallocation(__sz);
if (__sz < this->size())
- this->_M_invalidate_if(_After_nth(__sz, _M_base().begin()));
+ this->_M_invalidate_after_nth(__sz);
_Base::resize(__sz, __c);
if (__realloc)
this->_M_invalidate_all();
{
bool __realloc = _M_requires_reallocation(__sz);
if (__sz < this->size())
- this->_M_invalidate_if(_After_nth(__sz, _M_base().begin()));
+ this->_M_invalidate_after_nth(__sz);
_Base::resize(__sz, __c);
if (__realloc)
this->_M_invalidate_all();
pop_back()
{
__glibcxx_check_nonempty();
- iterator __victim = end() - 1;
- __victim._M_invalidate();
+ this->_M_invalidate_if(_Equal(--_Base::end()));
_Base::pop_back();
}
{
__glibcxx_check_insert(__position);
bool __realloc = _M_requires_reallocation(this->size() + 1);
- difference_type __offset = __position - begin();
- typename _Base::iterator __res = _Base::emplace(__position.base(),
- std::forward<_Args>(__args)...);
+ difference_type __offset = __position.base() - _Base::begin();
+ _Base_iterator __res = _Base::emplace(__position.base(),
+ std::forward<_Args>(__args)...);
if (__realloc)
this->_M_invalidate_all();
else
- this->_M_invalidate_if(_After_nth(__offset, _M_base().begin()));
+ this->_M_invalidate_after_nth(__offset);
_M_update_guaranteed_capacity();
return iterator(__res, this);
}
{
__glibcxx_check_insert(__position);
bool __realloc = _M_requires_reallocation(this->size() + 1);
- difference_type __offset = __position - begin();
- typename _Base::iterator __res = _Base::insert(__position.base(),__x);
+ 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_if(_After_nth(__offset, _M_base().begin()));
+ this->_M_invalidate_after_nth(__offset);
_M_update_guaranteed_capacity();
return iterator(__res, this);
}
{
__glibcxx_check_insert(__position);
bool __realloc = _M_requires_reallocation(this->size() + __n);
- difference_type __offset = __position - begin();
+ difference_type __offset = __position.base() - _Base::begin();
_Base::insert(__position.base(), __n, __x);
if (__realloc)
this->_M_invalidate_all();
else
- this->_M_invalidate_if(_After_nth(__offset, _M_base().begin()));
+ this->_M_invalidate_after_nth(__offset);
_M_update_guaranteed_capacity();
}
/* Hard to guess if invalidation will occur, because __last
- __first can't be calculated in all cases, so we just
punt here by checking if it did occur. */
- typename _Base::iterator __old_begin = _M_base().begin();
- difference_type __offset = __position - begin();
+ _Base_iterator __old_begin = _M_base().begin();
+ difference_type __offset = __position.base() - _Base::begin();
_Base::insert(__position.base(), __gnu_debug::__base(__first),
__gnu_debug::__base(__last));
if (_M_base().begin() != __old_begin)
this->_M_invalidate_all();
else
- this->_M_invalidate_if(_After_nth(__offset, _M_base().begin()));
+ this->_M_invalidate_after_nth(__offset);
_M_update_guaranteed_capacity();
}
erase(iterator __position)
{
__glibcxx_check_erase(__position);
- difference_type __offset = __position - begin();
- typename _Base::iterator __res = _Base::erase(__position.base());
- this->_M_invalidate_if(_After_nth(__offset, _M_base().begin()));
+ difference_type __offset = __position.base() - _Base::begin();
+ _Base_iterator __res = _Base::erase(__position.base());
+ this->_M_invalidate_after_nth(__offset);
return iterator(__res, this);
}
// 151. can't currently clear() empty container
__glibcxx_check_erase_range(__first, __last);
- difference_type __offset = __first - begin();
- typename _Base::iterator __res = _Base::erase(__first.base(),
- __last.base());
- this->_M_invalidate_if(_After_nth(__offset, _M_base().begin()));
+ difference_type __offset = __first.base() - _Base::begin();
+ _Base_iterator __res = _Base::erase(__first.base(),
+ __last.base());
+ this->_M_invalidate_after_nth(__offset);
return iterator(__res, this);
}
if (this->size() > _M_guaranteed_capacity)
_M_guaranteed_capacity = this->size();
}
+
+ void
+ _M_invalidate_after_nth(difference_type __n)
+ {
+ typedef __gnu_debug::_After_nth_from<_Base_const_iterator> _After_nth;
+ this->_M_invalidate_if(_After_nth(__n, _Base::begin()));
+ }
};
template<typename _Tp, typename _Alloc>
future.o: future.cc
$(CXXCOMPILE) -std=gnu++0x -c $<
+debug.lo: debug.cc
+ $(LTCXXCOMPILE) -std=gnu++0x -c $<
+debug.o: debug.cc
+ $(CXXCOMPILE) -std=gnu++0x -c $<
+
if GLIBCXX_LDBL_COMPAT
# Use special rules for compatibility-ldbl.cc compilation, as we need to
# pass -mlong-double-64.
future.o: future.cc
$(CXXCOMPILE) -std=gnu++0x -c $<
+debug.lo: debug.cc
+ $(LTCXXCOMPILE) -std=gnu++0x -c $<
+debug.o: debug.cc
+ $(CXXCOMPILE) -std=gnu++0x -c $<
+
# Use special rules for compatibility-ldbl.cc compilation, as we need to
# pass -mlong-double-64.
@GLIBCXX_LDBL_COMPAT_TRUE@compatibility-ldbl.lo: compatibility-ldbl.cc
#include <cctype>
#include <cstdio>
#include <cstdlib>
+#include <functional>
using namespace std;
namespace
{
+ /** Returns different instances of __mutex depending on the passed address
+ * in order to limit contention without breaking current library binary
+ * compatibility. */
__gnu_cxx::__mutex&
- get_safe_base_mutex()
+ get_safe_base_mutex(void* __address)
{
- static __gnu_cxx::__mutex safe_base_mutex;
- return safe_base_mutex;
+ const size_t mask = 0xf;
+ static __gnu_cxx::__mutex safe_base_mutex[mask + 1];
+ const size_t index = _Hash_impl::hash(__address) & mask;
+ return safe_base_mutex[index];
+ }
+
+ void
+ swap_seq(__gnu_debug::_Safe_sequence_base& __lhs,
+ __gnu_debug::_Safe_sequence_base& __rhs)
+ {
+ swap(__lhs._M_iterators, __rhs._M_iterators);
+ swap(__lhs._M_const_iterators, __rhs._M_const_iterators);
+ swap(__lhs._M_version, __rhs._M_version);
+ __gnu_debug::_Safe_iterator_base* __iter;
+ for (__iter = __rhs._M_iterators; __iter; __iter = __iter->_M_next)
+ __iter->_M_sequence = &__rhs;
+ for (__iter = __lhs._M_iterators; __iter; __iter = __iter->_M_next)
+ __iter->_M_sequence = &__lhs;
+ for (__iter = __rhs._M_const_iterators; __iter; __iter = __iter->_M_next)
+ __iter->_M_sequence = &__rhs;
+ for (__iter = __lhs._M_const_iterators; __iter; __iter = __iter->_M_next)
+ __iter->_M_sequence = &__lhs;
}
} // anonymous namespace
{
_Safe_iterator_base* __old = __iter;
__iter = __iter->_M_next;
- __old->_M_detach_single();
+ __old->_M_reset();
}
+ _M_iterators = 0;
for (_Safe_iterator_base* __iter2 = _M_const_iterators; __iter2;)
{
_Safe_iterator_base* __old = __iter2;
__iter2 = __iter2->_M_next;
- __old->_M_detach_single();
+ __old->_M_reset();
}
+ _M_const_iterators = 0;
}
void
_Safe_sequence_base::
_M_swap(_Safe_sequence_base& __x)
{
- __gnu_cxx::__scoped_lock sentry(_M_get_mutex());
- swap(_M_iterators, __x._M_iterators);
- swap(_M_const_iterators, __x._M_const_iterators);
- swap(_M_version, __x._M_version);
- _Safe_iterator_base* __iter;
- for (__iter = _M_iterators; __iter; __iter = __iter->_M_next)
- __iter->_M_sequence = this;
- for (__iter = __x._M_iterators; __iter; __iter = __iter->_M_next)
- __iter->_M_sequence = &__x;
- for (__iter = _M_const_iterators; __iter; __iter = __iter->_M_next)
- __iter->_M_sequence = this;
- for (__iter = __x._M_const_iterators; __iter; __iter = __iter->_M_next)
- __iter->_M_sequence = &__x;
+ // We need to lock both sequences to swap
+ using namespace __gnu_cxx;
+ __mutex *__this_mutex = &_M_get_mutex();
+ __mutex *__x_mutex = &__x._M_get_mutex();
+ if (__this_mutex == __x_mutex)
+ {
+ __scoped_lock __lock(*__this_mutex);
+ swap_seq(*this, __x);
+ }
+ else
+ {
+ __scoped_lock __l1(__this_mutex < __x_mutex
+ ? *__this_mutex : *__x_mutex);
+ __scoped_lock __l2(__this_mutex < __x_mutex
+ ? *__x_mutex : *__this_mutex);
+ swap_seq(*this, __x);
+ }
}
__gnu_cxx::__mutex&
_Safe_sequence_base::
_M_get_mutex() throw ()
- { return get_safe_base_mutex(); }
+ { return get_safe_base_mutex(this); }
+
+ void
+ _Safe_sequence_base::
+ _M_attach(_Safe_iterator_base* __it, bool __constant)
+ {
+ __gnu_cxx::__scoped_lock sentry(_M_get_mutex());
+ _M_attach_single(__it, __constant);
+ }
+
+ void
+ _Safe_sequence_base::
+ _M_attach_single(_Safe_iterator_base* __it, bool __constant) throw ()
+ {
+ _Safe_iterator_base*& __its =
+ __constant ? _M_const_iterators : _M_iterators;
+ __it->_M_next = __its;
+ if (__it->_M_next)
+ __it->_M_next->_M_prior = __it;
+ __its = __it;
+ }
+
+ void
+ _Safe_sequence_base::
+ _M_detach(_Safe_iterator_base* __it)
+ {
+ // Remove __it from this sequence's list
+ __gnu_cxx::__scoped_lock sentry(_M_get_mutex());
+ _M_detach_single(__it);
+ }
+
+ void
+ _Safe_sequence_base::
+ _M_detach_single(_Safe_iterator_base* __it) throw ()
+ {
+ // Remove __it from this sequence's list
+ if (__it->_M_prior)
+ __it->_M_prior->_M_next = __it->_M_next;
+ if (__it->_M_next)
+ __it->_M_next->_M_prior = __it->_M_prior;
+
+ if (_M_const_iterators == __it)
+ _M_const_iterators = __it->_M_next;
+ if (_M_iterators == __it)
+ _M_iterators = __it->_M_next;
+ }
void
_Safe_iterator_base::
_M_attach(_Safe_sequence_base* __seq, bool __constant)
{
- __gnu_cxx::__scoped_lock sentry(_M_get_mutex());
- _M_attach_single(__seq, __constant);
+ _M_detach();
+
+ // Attach to the new sequence (if there is one)
+ if (__seq)
+ {
+ _M_sequence = __seq;
+ _M_version = _M_sequence->_M_version;
+ _M_sequence->_M_attach(this, __constant);
+ }
}
void
{
_M_sequence = __seq;
_M_version = _M_sequence->_M_version;
- _M_prior = 0;
- if (__constant)
- {
- _M_next = _M_sequence->_M_const_iterators;
- if (_M_next)
- _M_next->_M_prior = this;
- _M_sequence->_M_const_iterators = this;
- }
- else
- {
- _M_next = _M_sequence->_M_iterators;
- if (_M_next)
- _M_next->_M_prior = this;
- _M_sequence->_M_iterators = this;
- }
+ _M_sequence->_M_attach_single(this, __constant);
}
}
_Safe_iterator_base::
_M_detach()
{
- __gnu_cxx::__scoped_lock sentry(_M_get_mutex());
- _M_detach_single();
+ if (_M_sequence)
+ {
+ _M_sequence->_M_detach(this);
+ }
+
+ _M_reset();
}
void
{
if (_M_sequence)
{
- // Remove us from this sequence's list
- if (_M_prior)
- _M_prior->_M_next = _M_next;
- if (_M_next)
- _M_next->_M_prior = _M_prior;
-
- if (_M_sequence->_M_const_iterators == this)
- _M_sequence->_M_const_iterators = _M_next;
- if (_M_sequence->_M_iterators == this)
- _M_sequence->_M_iterators = _M_next;
+ _M_sequence->_M_detach_single(this);
}
+ _M_reset();
+ }
+
+ void
+ _Safe_iterator_base::
+ _M_reset() throw ()
+ {
_M_sequence = 0;
_M_version = 0;
_M_prior = 0;
__gnu_cxx::__mutex&
_Safe_iterator_base::
_M_get_mutex() throw ()
- { return get_safe_base_mutex(); }
+ { return get_safe_base_mutex(_M_sequence); }
void
_Error_formatter::_Parameter::
--- /dev/null
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2010 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 Pred 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/>.
+
+// Check that iterators ownership is correctly manage on swap.
+#include <forward_list>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+ bool test __attribute__((unused)) = true;
+ std::forward_list<int> fl{1, 2, 3};
+
+ auto before = fl.before_begin();
+ auto end = fl.end();
+ fl.clear();
+
+ VERIFY( end == fl.end() );
+ VERIFY( before == fl.before_begin() );
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2010 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 Pred 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/>.
+
+// Check that iterators ownership is correctly manage on swap.
+#include <forward_list>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+ bool test __attribute__((unused)) = true;
+ std::forward_list<int> fl1{1, 3, 5};
+
+ auto flit = fl1.before_begin();
+ std::forward_list<int> fl2(std::move(fl1));
+
+#if !_GLIBCXX_DEBUG
+ VERIFY( flit == fl1.before_begin() );
+#endif
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2010 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 Pred 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/>.
+
+// Check that iterators ownership is correctly manage on swap.
+#include <forward_list>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+ bool test __attribute__((unused)) = true;
+ std::forward_list<int> fl1{1, 2, 3};
+ std::forward_list<int> fl2{4, 5, 6};
+
+ auto before = fl1.before_begin();
+ auto end = fl1.end();
+ fl2.splice_after(fl2.before_begin(), std::move(fl1));
+
+ VERIFY( before == fl1.before_begin() );
+ VERIFY( end == fl1.end() );
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// { dg-options "-std=gnu++0x" }
+// { dg-require-debug-mode "" }
+// { dg-do run { xfail *-*-* } }
+
+// Copyright (C) 2010 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 Pred the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <forward_list>
+
+void
+test01()
+{
+ std::forward_list<int> fl1{1, 2, 3};
+ fl1.splice_after(fl1.begin(), std::move(fl1));
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// { dg-options "-std=gnu++0x" }
+// { dg-require-debug-mode "" }
+// { dg-do run { xfail *-*-* } }
+
+// Copyright (C) 2010 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 Pred the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <forward_list>
+
+void
+test01()
+{
+ std::forward_list<int> fl1{1, 2, 3};
+ std::forward_list<int> fl2{1, 2, 3};
+
+ fl1.splice_after(fl1.before_begin(), std::move(fl2), fl1.begin());
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// { dg-options "-std=gnu++0x" }
+// { dg-require-debug-mode "" }
+// { dg-do run { xfail *-*-* } }
+
+// Copyright (C) 2010 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 Pred the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <forward_list>
+
+void
+test01()
+{
+ std::forward_list<int> fl1{1, 2, 3};
+ std::forward_list<int> fl2{1, 2, 3};
+
+ fl1.splice_after(fl1.before_begin(), std::move(fl2), fl2.end());
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// { dg-options "-std=gnu++0x" }
+// { dg-require-debug-mode "" }
+// { dg-do run { xfail *-*-* } }
+
+// Copyright (C) 2010 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 Pred the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <forward_list>
+
+void
+test01()
+{
+ std::forward_list<int> fl1{1, 2, 3};
+ std::forward_list<int> fl2{1, 2, 3};
+
+ fl1.splice_after(fl1.before_begin(),
+ std::move(fl2), ++(++fl2.begin()), ++fl2.begin());
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2010 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 Pred 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/>.
+
+// Check that iterators ownership is correctly manage on swap.
+#include <vector>
+#include <forward_list>
+#include <iostream>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+ bool test __attribute__((unused)) = true;
+ std::forward_list<int> fl1{1, 3, 5};
+ std::forward_list<int> fl2{2, 4, 6};
+
+ std::vector<std::forward_list<int>::iterator> fl1_its;
+ fl1_its.push_back(fl1.before_begin());
+ for (std::forward_list<int>::iterator it = fl1.begin();
+ it != fl1.end(); ++it)
+ {
+ fl1_its.push_back(it);
+ }
+ fl1_its.push_back(fl1.end());
+
+ std::vector<std::forward_list<int>::iterator> fl2_its;
+ fl2_its.push_back(fl2.before_begin());
+ for (std::forward_list<int>::iterator it = fl2.begin();
+ it != fl2.end(); ++it)
+ {
+ fl2_its.push_back(it);
+ }
+ fl2_its.push_back(fl2.end());
+
+ fl1.swap(fl2);
+
+ auto fit = fl1.before_begin();
+ // before-begin iterator is not transfered:
+ // TODO: Validate with LWG group how before begin should be
+ // treated.
+#if !_GLIBCXX_DEBUG
+ VERIFY( fit == fl1_its[0] );
+#endif
+ // All others are, even paste-the-end one:
+ for (size_t i = 1; i != fl2_its.size(); ++i)
+ {
+ VERIFY( ++fit == fl2_its[i] );
+ }
+
+ fit = fl2.before_begin();
+ // TODO: Validate with LWG group how before begin should be
+ // treated.
+#if !_GLIBCXX_DEBUG
+ VERIFY( fit == fl2_its[0] );
+#endif
+ for (size_t i = 1; i != fl1_its.size(); ++i)
+ {
+ VERIFY( ++fit == fl1_its[i] );
+ }
+}
+
+int
+main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// { dg-do run { target *-*-freebsd* *-*-netbsd* *-*-linux* *-*-solaris* *-*-cygwin *-*-darwin* alpha*-*-osf* mips-sgi-irix6* } }
+// { dg-options " -std=gnu++0x -pthread" { target *-*-freebsd* *-*-netbsd* *-*-linux* alpha*-*-osf* mips-sgi-irix6* } }
+// { dg-options " -std=gnu++0x -pthreads" { target *-*-solaris* } }
+// { dg-options " -std=gnu++0x " { target *-*-cygwin *-*-darwin* } }
+// { dg-require-cstdint "" }
+// { dg-require-gthreads "" }
+// { dg-require-debug-mode "" }
+// Copyright (C) 2010 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/>.
+//
+
+// This test check for potential deadlock when swaping sequences in debug
+// mode as it requires acquiring 2 locks at the same time.
+
+#include <vector>
+#include <thread>
+#include <functional>
+#include <testsuite_hooks.h>
+
+// The following function mimic the one in src/debug.cc to associate a mutex
+// to a given safe sequence instance.
+size_t
+get_index(std::vector<int>& v)
+{
+ const size_t mask = 0xf;
+ // We have to check the address of the internal safe sequence that starts
+ // after the normal vector memory footprint that is to say a 3 pointers
+ // offset:
+ void* __address = reinterpret_cast<char*>(&v) + 3 * sizeof(void*);
+ return std::_Hash_impl::hash(__address) & mask;
+}
+
+void test01()
+{
+ using namespace std;
+ bool test __attribute__((unused)) = true;
+ vector<int> v1, v2;
+ vector<shared_ptr<vector<int> > > vs;
+ vector<int> *pv3 = 0, *pv4 = 0;
+ const int nb_attempts = 100;
+ for (int i = 0; i != nb_attempts; ++i)
+ {
+ vs.push_back(shared_ptr<vector<int> >(new vector<int>()));
+ if (!pv3)
+ {
+ if (get_index(*vs.back()) == get_index(v1))
+ pv3 = vs.back().get();
+ }
+ else if (!pv4)
+ {
+ if (get_index(*vs.back()) == get_index(v2))
+ {
+ pv4 = vs.back().get();
+ break;
+ }
+ }
+ }
+
+ if (!pv3 || !pv4)
+ // Maybe an other time...
+ return;
+
+ vector<int> &v3 = *pv3, &v4 = *pv4;
+
+ // v1 and v3 shares the same mutex instance, like v2 and v4
+ // thread t1 lock v1 and v2
+ thread t1([&v1, &v2]()
+ {
+ for (int i = 0; i != 1000; ++i)
+ v1.swap(v2);
+ });
+ // thread t2 lock v4 and v3
+ thread t2([&v3, &v4]()
+ {
+ for (int i = 0; i != 1000; ++i)
+ v4.swap(v3);
+ });
+ t2.join();
+ t1.join();
+}
+
+int main()
+{
+ test01();
+ return 0;
+}
projects / platform / upstream / linaro-gcc.git / commitdiff