+2003-12-09 Bernardo Innocenti <bernie@develer.com>
+
+ * include/debug/bitset, include/debug/debug.h, include/debug/deque,
+ include/debug/formatter.h, include/debug/hash_map.h,
+ include/debug/hash_multimap.h, include/debug/hash_multiset.h,
+ include/debug/hash_set, include/debug/hash_set.h, include/debug/list,
+ include/debug/map.h, include/debug/multimap.h,
+ include/debug/multiset.h, include/debug/safe_base.h,
+ include/debug/safe_iterator.h, include/debug/safe_iterator.tcc,
+ include/debug/safe_sequence.h, include/debug/set.h,
+ include/debug/string, include/debug/vector: Remove trailing whitespace.
+
2003-12-09 Bernardo Innocenti <bernie@develer.com>
* include/c_compatibility/iso646.h, include/c_compatibility/limits.h,
#include <debug/safe_iterator.h>
namespace __gnu_debug_def
-{
- template<size_t _Nb>
+{
+ template<size_t _Nb>
class bitset
: public __gnu_norm::bitset<_Nb>, public __gnu_debug::_Safe_sequence_base
{
- typedef __gnu_norm::bitset<_Nb> _Base;
+ typedef __gnu_norm::bitset<_Nb> _Base;
typedef __gnu_debug::_Safe_sequence_base _Safe_base;
public:
// bit reference:
- class reference
+ class reference
: private _Base::reference, public __gnu_debug::_Safe_iterator_base
{
typedef typename _Base::reference _Base_ref;
friend class bitset;
reference();
-
- reference(const _Base_ref& __base, bitset* __seq)
+
+ reference(const _Base_ref& __base, bitset* __seq)
: _Base_ref(__base), _Safe_iterator_base(__seq, false)
{ }
: _Base_ref(__x), _Safe_iterator_base(__x, false)
{ }
- reference&
+ reference&
operator=(bool __x)
{
_GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),
return *this;
}
- reference&
+ reference&
operator=(const reference& __x)
{
_GLIBCXX_DEBUG_VERIFY(! __x._M_singular(),
*static_cast<_Base_ref*>(this) = __x;
return *this;
}
-
- bool
+
+ bool
operator~() const
{
_GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),
._M_iterator(*this));
return ~(*static_cast<const _Base_ref*>(this));
}
-
+
operator bool() const
{
_GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),
._M_iterator(*this));
return *static_cast<const _Base_ref*>(this);
}
-
- reference&
+
+ reference&
flip()
{
_GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),
// 23.3.5.1 constructors:
bitset() : _Base() { }
-
+
bitset(unsigned long __val) : _Base(__val) { }
-
+
template<typename _CharT, typename _Traits, typename _Allocator>
- explicit
+ explicit
bitset(const std::basic_string<_CharT,_Traits,_Allocator>& __str,
typename std::basic_string<_CharT,_Traits,_Allocator>::size_type
__pos = 0,
typename std::basic_string<_CharT,_Traits,_Allocator>::size_type
- __n = (std::basic_string<_CharT,_Traits,_Allocator>::npos))
+ __n = (std::basic_string<_CharT,_Traits,_Allocator>::npos))
: _Base(__str, __pos, __n) { }
bitset(const _Base& __x) : _Base(__x), _Safe_base() { }
// 23.3.5.2 bitset operations:
- bitset<_Nb>&
+ bitset<_Nb>&
operator&=(const bitset<_Nb>& __rhs)
{
_M_base() &= __rhs;
return *this;
}
-
- bitset<_Nb>&
+
+ bitset<_Nb>&
operator|=(const bitset<_Nb>& __rhs)
{
_M_base() != __rhs;
return *this;
}
-
- bitset<_Nb>&
+
+ bitset<_Nb>&
operator^=(const bitset<_Nb>& __rhs)
{
_M_base() ^= __rhs;
return *this;
}
-
- bitset<_Nb>&
+
+ bitset<_Nb>&
operator<<=(size_t __pos)
{
_M_base() <<= __pos;
return *this;
}
-
- bitset<_Nb>&
+
+ bitset<_Nb>&
operator>>=(size_t __pos)
{
_M_base() >>= __pos;
return *this;
}
-
- bitset<_Nb>&
+
+ bitset<_Nb>&
set()
{
_Base::set();
return *this;
}
-
+
// _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 186. bitset::set() second parameter should be bool
- bitset<_Nb>&
+ // 186. bitset::set() second parameter should be bool
+ bitset<_Nb>&
set(size_t __pos, bool __val = true)
{
_Base::set(__pos, __val);
return *this;
}
-
- bitset<_Nb>&
+
+ bitset<_Nb>&
reset()
{
_Base::reset();
return *this;
}
-
- bitset<_Nb>&
+
+ bitset<_Nb>&
reset(size_t __pos)
{
_Base::reset(__pos);
return *this;
}
-
+
bitset<_Nb> operator~() const { return bitset(~_M_base()); }
-
- bitset<_Nb>&
+
+ bitset<_Nb>&
flip()
{
_Base::flip();
return *this;
}
-
- bitset<_Nb>&
+
+ bitset<_Nb>&
flip(size_t __pos)
{
_Base::flip(__pos);
return *this;
}
-
+
// element access:
// _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 11. Bitset minor problems
- reference
+ // 11. Bitset minor problems
+ reference
operator[](size_t __pos)
- {
+ {
__glibcxx_check_subscript(__pos);
- return reference(_M_base()[__pos], this);
+ return reference(_M_base()[__pos], this);
}
-
+
// _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 11. Bitset minor problems
- bool
- operator[](size_t __pos) const
- {
+ // 11. Bitset minor problems
+ bool
+ operator[](size_t __pos) const
+ {
__glibcxx_check_subscript(__pos);
- return _M_base()[__pos];
+ return _M_base()[__pos];
}
-
+
using _Base::to_ulong;
-
+
template <typename _CharT, typename _Traits, typename _Allocator>
- std::basic_string<_CharT, _Traits, _Allocator>
+ std::basic_string<_CharT, _Traits, _Allocator>
to_string() const
{ return _M_base().template to_string<_CharT, _Traits, _Allocator>(); }
-
+
using _Base::count;
using _Base::size;
-
- bool
+
+ bool
operator==(const bitset<_Nb>& __rhs) const
{ return _M_base() == __rhs; }
- bool
+ bool
operator!=(const bitset<_Nb>& __rhs) const
{ return _M_base() != __rhs; }
-
+
using _Base::test;
using _Base::any;
using _Base::none;
-
- bitset<_Nb>
+
+ bitset<_Nb>
operator<<(size_t __pos) const
{ return bitset<_Nb>(_M_base() << __pos); }
-
- bitset<_Nb>
+
+ bitset<_Nb>
operator>>(size_t __pos) const
{ return bitset<_Nb>(_M_base() >> __pos); }
-
- _Base&
+
+ _Base&
_M_base() { return *this; }
- const _Base&
+ const _Base&
_M_base() const { return *this; }
};
-
+
template<size_t _Nb>
- bitset<_Nb>
+ bitset<_Nb>
operator&(const bitset<_Nb>& __x, const bitset<_Nb>& __y)
{ return bitset<_Nb>(__x) &= __y; }
-
+
template<size_t _Nb>
- bitset<_Nb>
+ bitset<_Nb>
operator|(const bitset<_Nb>& __x, const bitset<_Nb>& __y)
{ return bitset<_Nb>(__x) |= __y; }
template<size_t _Nb>
- bitset<_Nb>
+ bitset<_Nb>
operator^(const bitset<_Nb>& __x, const bitset<_Nb>& __y)
{ return bitset<_Nb>(__x) ^= __y; }
template<typename _CharT, typename _Traits, size_t _Nb>
std::basic_ostream<_CharT, _Traits>&
- operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+ operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const bitset<_Nb>& __x)
{ return __os << __x._M_base(); }
} // namespace __gnu_debug_def
_Value), \
_M_message(::__gnu_debug::__msg_unpartitioned) \
._M_iterator(_First, #_First) \
- ._M_iterator(_Last, #_Last) \
+ ._M_iterator(_Last, #_Last) \
._M_string(#_Value))
/** Verify that the iterator range [_First, _Last) is partitioned
_Value, _Pred), \
_M_message(::__gnu_debug::__msg_unpartitioned_pred) \
._M_iterator(_First, #_First) \
- ._M_iterator(_Last, #_Last) \
+ ._M_iterator(_Last, #_Last) \
._M_string(#_Pred) \
._M_string(#_Value))
# define __glibcxx_requires_string(_String)
# define __glibcxx_requires_string_len(_String,_Len)
# define __glibcxx_requires_subscript(_N)
-#endif
+#endif
#include <cassert> // TBD: temporary
namespace __gnu_debug
{
- template<typename _Iterator, typename _Sequence>
+ template<typename _Iterator, typename _Sequence>
class _Safe_iterator;
// An arbitrary iterator pointer is not singular.
- inline bool
+ inline bool
__check_singular_aux(const void*) { return false; }
// We may have an iterator that derives from _Safe_iterator_base but isn't
{ return __x._M_dereferenceable(); }
/** If the distance between two random access iterators is
- * nonnegative, assume the range is valid.
+ * nonnegative, assume the range is valid.
*/
template<typename _RandomAccessIterator>
inline bool
- __valid_range_aux2(const _RandomAccessIterator& __first,
+ __valid_range_aux2(const _RandomAccessIterator& __first,
const _RandomAccessIterator& __last,
std::random_access_iterator_tag)
{ return __last - __first >= 0; }
/** We say that integral types for a valid range, and defer to other
* routines to realize what to do with integral types instead of
- * iterators.
+ * iterators.
*/
template<typename _Integral>
inline bool
*/
template<typename _InputIterator>
inline bool
- __valid_range_aux(const _InputIterator& __first,
+ __valid_range_aux(const _InputIterator& __first,
const _InputIterator& __last, __false_type)
{
typedef typename std::iterator_traits<_InputIterator>::iterator_category
_Category;
- return __gnu_debug::__valid_range_aux2(__first, __last, _Category());
+ return __gnu_debug::__valid_range_aux2(__first, __last, _Category());
}
/** Don't know what these iterators are, or if they are even
template<typename _InputIterator>
inline bool
__valid_range(const _InputIterator& __first, const _InputIterator& __last)
- {
+ {
typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
return __gnu_debug::__valid_range_aux(__first, __last, _Integral());
}
/** Safe iterators know how to check if they form a valid range. */
template<typename _Iterator, typename _Sequence>
- inline bool
+ inline bool
__valid_range(const _Safe_iterator<_Iterator, _Sequence>& __first,
const _Safe_iterator<_Iterator, _Sequence>& __last)
{ return __first._M_valid_range(__last); }
/* Checks that [first, last) is a valid range, and then returns
* __first. This routine is useful when we can't use a separate
- * assertion statement because, e.g., we are in a constructor.
+ * assertion statement because, e.g., we are in a constructor.
*/
template<typename _InputIterator>
inline _InputIterator
- __check_valid_range(const _InputIterator& __first,
+ __check_valid_range(const _InputIterator& __first,
const _InputIterator& __last)
{
_GLIBCXX_DEBUG_ASSERT(__gnu_debug::__valid_range(__first, __last));
// Can't check if an input iterator sequence is sorted, because we
// can't step through the sequence.
template<typename _InputIterator>
- inline bool
+ inline bool
__check_sorted_aux(const _InputIterator&, const _InputIterator&,
std::input_iterator_tag)
{ return true; }
inline bool
__check_sorted_aux(_ForwardIterator __first, _ForwardIterator __last,
std::forward_iterator_tag)
- {
+ {
if (__first == __last)
return true;
// Can't check if an input iterator sequence is sorted, because we can't step
// through the sequence.
template<typename _InputIterator, typename _Predicate>
- inline bool
+ inline bool
__check_sorted_aux(const _InputIterator&, const _InputIterator&,
_Predicate, std::input_iterator_tag)
{ return true; }
// std::__is_sorted
template<typename _ForwardIterator, typename _Predicate>
inline bool
- __check_sorted_aux(_ForwardIterator __first, _ForwardIterator __last,
+ __check_sorted_aux(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred, std::forward_iterator_tag)
- {
+ {
if (__first == __last)
return true;
template<typename _InputIterator>
inline bool
__check_sorted(const _InputIterator& __first, const _InputIterator& __last)
- {
- typedef typename std::iterator_traits<_InputIterator>::iterator_category
+ {
+ typedef typename std::iterator_traits<_InputIterator>::iterator_category
_Category;
return __gnu_debug::__check_sorted_aux(__first, __last, _Category());
}
inline bool
__check_sorted(const _InputIterator& __first, const _InputIterator& __last,
_Predicate __pred)
- {
- typedef typename std::iterator_traits<_InputIterator>::iterator_category
+ {
+ typedef typename std::iterator_traits<_InputIterator>::iterator_category
_Category;
return __gnu_debug::__check_sorted_aux(__first, __last, __pred,
_Category());
}
// _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 270. Binary search requirements overly strict
+ // 270. Binary search requirements overly strict
// Determine if a sequence is partitioned w.r.t. this element.
template<typename _ForwardIterator, typename _Tp>
inline bool
# include <debug/formatter.h>
#endif
-#endif
+#endif
namespace __gnu_debug_def
{
template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
- class deque
+ class deque
: public __gnu_norm::deque<_Tp, _Allocator>,
public __gnu_debug::_Safe_sequence<deque<_Tp, _Allocator> >
{
public:
typedef typename _Allocator::reference reference;
typedef typename _Allocator::const_reference const_reference;
-
- typedef __gnu_debug::_Safe_iterator<typename _Base::iterator,deque>
- iterator;
+
+ typedef __gnu_debug::_Safe_iterator<typename _Base::iterator,deque>
+ iterator;
typedef __gnu_debug::_Safe_iterator<typename _Base::const_iterator,deque>
const_iterator;
-
+
typedef typename _Base::size_type size_type;
typedef typename _Base::difference_type difference_type;
-
- typedef _Tp value_type;
- typedef _Allocator allocator_type;
+
+ typedef _Tp value_type;
+ typedef _Allocator allocator_type;
typedef typename _Allocator::pointer pointer;
typedef typename _Allocator::const_pointer const_pointer;
typedef std::reverse_iterator<iterator> reverse_iterator;
deque(const deque<_Tp,_Allocator>& __x) : _Base(__x), _Safe_base() { }
deque(const _Base& __x) : _Base(__x), _Safe_base() { }
-
+
~deque() { }
-
- deque<_Tp,_Allocator>&
+
+ deque<_Tp,_Allocator>&
operator=(const deque<_Tp,_Allocator>& __x)
{
*static_cast<_Base*>(this) = __x;
this->_M_invalidate_all();
return *this;
}
-
+
template<class _InputIterator>
- void
+ void
assign(_InputIterator __first, _InputIterator __last)
{
__glibcxx_check_valid_range(__first, __last);
this->_M_invalidate_all();
}
- void
+ void
assign(size_type __n, const _Tp& __t)
{
_Base::assign(__n, __t);
this->_M_invalidate_all();
}
-
+
using _Base::get_allocator;
-
+
// iterators:
- iterator
- begin()
+ iterator
+ begin()
{ return iterator(_Base::begin(), this); }
-
- const_iterator
- begin() const
+
+ const_iterator
+ begin() const
{ return const_iterator(_Base::begin(), this); }
-
- iterator
- end()
+
+ iterator
+ end()
{ return iterator(_Base::end(), this); }
-
- const_iterator
- end() const
+
+ const_iterator
+ end() const
{ return const_iterator(_Base::end(), this); }
-
- reverse_iterator
- rbegin()
+
+ reverse_iterator
+ rbegin()
{ return reverse_iterator(end()); }
-
- const_reverse_iterator
+
+ const_reverse_iterator
rbegin() const
{ return const_reverse_iterator(end()); }
-
- reverse_iterator
- rend()
+
+ reverse_iterator
+ rend()
{ return reverse_iterator(begin()); }
-
- const_reverse_iterator
+
+ const_reverse_iterator
rend() const
{ return const_reverse_iterator(begin()); }
-
+
// 23.2.1.2 capacity:
using _Base::size;
using _Base::max_size;
-
- void
+
+ 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()));
-
+
_Base::resize(__sz, __c);
-
+
if (__invalidate_all)
this->_M_invalidate_all();
}
-
+
using _Base::empty;
-
+
// element access:
- reference
+ reference
operator[](size_type __n)
{
__glibcxx_check_subscript(__n);
return _M_base()[__n];
}
-
- const_reference
+
+ const_reference
operator[](size_type __n) const
{
__glibcxx_check_subscript(__n);
return _M_base()[__n];
}
-
+
using _Base::at;
-
- reference
+
+ reference
front()
{
__glibcxx_check_nonempty();
return _Base::front();
}
-
- const_reference
+
+ const_reference
front() const
{
__glibcxx_check_nonempty();
return _Base::front();
}
-
- reference
+
+ reference
back()
{
__glibcxx_check_nonempty();
return _Base::back();
}
-
- const_reference
+
+ const_reference
back() const
{
__glibcxx_check_nonempty();
return _Base::back();
}
-
+
// 23.2.1.3 modifiers:
- void
+ void
push_front(const _Tp& __x)
{
_Base::push_front(__x);
this->_M_invalidate_all();
}
-
- void
+
+ void
push_back(const _Tp& __x)
{
_Base::push_back(__x);
this->_M_invalidate_all();
}
-
- iterator
+
+ iterator
insert(iterator __position, const _Tp& __x)
{
__glibcxx_check_insert(__position);
this->_M_invalidate_all();
return iterator(__res, this);
}
-
- void
+
+ void
insert(iterator __position, size_type __n, const _Tp& __x)
{
__glibcxx_check_insert(__position);
_Base::insert(__position.base(), __n, __x);
this->_M_invalidate_all();
}
-
+
template<class _InputIterator>
- void
- insert(iterator __position,
+ void
+ insert(iterator __position,
_InputIterator __first, _InputIterator __last)
{
__glibcxx_check_insert_range(__position, __first, __last);
_Base::insert(__position.base(), __first, __last);
this->_M_invalidate_all();
}
-
- void
+
+ void
pop_front()
{
__glibcxx_check_nonempty();
__victim._M_invalidate();
_Base::pop_front();
}
-
- void
+
+ void
pop_back()
{
__glibcxx_check_nonempty();
__victim._M_invalidate();
_Base::pop_back();
}
-
- iterator
+
+ iterator
erase(iterator __position)
{
__glibcxx_check_erase(__position);
return iterator(__res, this);
}
}
-
- iterator
+
+ iterator
erase(iterator __first, iterator __last)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
iterator __victim = __position++;
__victim._M_invalidate();
}
- try
- {
+ try
+ {
return iterator(_Base::erase(__first.base(), __last.base()),
- this);
+ this);
}
catch (...)
{
}
else
{
- typename _Base::iterator __res = _Base::erase(__first.base(),
+ typename _Base::iterator __res = _Base::erase(__first.base(),
__last.base());
this->_M_invalidate_all();
return iterator(__res, this);
}
}
-
- void
+
+ void
swap(deque<_Tp,_Allocator>& __x)
{
_Base::swap(__x);
this->_M_swap(__x);
}
-
- void
+
+ void
clear()
{
_Base::clear();
this->_M_invalidate_all();
}
-
- _Base&
+
+ _Base&
_M_base() { return *this; }
- const _Base&
+ const _Base&
_M_base() const { return *this; }
};
template<typename _Tp, typename _Alloc>
inline bool
- operator==(const deque<_Tp, _Alloc>& __lhs,
+ operator==(const deque<_Tp, _Alloc>& __lhs,
const deque<_Tp, _Alloc>& __rhs)
{ return __lhs._M_base() == __rhs._M_base(); }
template<typename _Tp, typename _Alloc>
inline bool
- operator!=(const deque<_Tp, _Alloc>& __lhs,
+ operator!=(const deque<_Tp, _Alloc>& __lhs,
const deque<_Tp, _Alloc>& __rhs)
{ return __lhs._M_base() != __rhs._M_base(); }
template<typename _Tp, typename _Alloc>
inline bool
- operator<=(const deque<_Tp, _Alloc>& __lhs,
+ operator<=(const deque<_Tp, _Alloc>& __lhs,
const deque<_Tp, _Alloc>& __rhs)
{ return __lhs._M_base() <= __rhs._M_base(); }
template<typename _Tp, typename _Alloc>
inline bool
- operator>=(const deque<_Tp, _Alloc>& __lhs,
+ operator>=(const deque<_Tp, _Alloc>& __lhs,
const deque<_Tp, _Alloc>& __rhs)
{ return __lhs._M_base() >= __rhs._M_base(); }
class _Safe_sequence_base;
- template<typename _Iterator, typename _Sequence>
+ template<typename _Iterator, typename _Sequence>
class _Safe_iterator;
- template<typename _Sequence>
+ template<typename _Sequence>
class _Safe_sequence;
enum _Debug_msg_id
__const_iterator,
__mutable_iterator,
__last_constness
- };
+ };
// The state of the iterator (fine-grained), if we know it.
enum _Iterator_state
// A parameter that may be referenced by an error message
struct _Parameter
{
- enum
- {
- __unused_param,
- __iterator,
- __sequence,
+ enum
+ {
+ __unused_param,
+ __iterator,
+ __sequence,
__integer,
__string
} _M_kind;
-
+
union
{
// When _M_kind == __iterator
- struct
+ struct
{
- const char* _M_name;
- const void* _M_address;
- const type_info* _M_type;
+ const char* _M_name;
+ const void* _M_address;
+ const type_info* _M_type;
_Constness _M_constness;
_Iterator_state _M_state;
- const void* _M_sequence;
+ const void* _M_sequence;
const type_info* _M_seq_type;
} _M_iterator;
-
+
// When _M_kind == __sequence
struct
{
} _M_variant;
_Parameter() : _M_kind(__unused_param) { }
-
+
_Parameter(long __value, const char* __name) : _M_kind(__integer)
- {
+ {
_M_variant._M_integer._M_name = __name;
- _M_variant._M_integer._M_value = __value;
+ _M_variant._M_integer._M_value = __value;
}
_Parameter(const char* __value, const char* __name) : _M_kind(__string)
{
_M_variant._M_string._M_name = __name;
- _M_variant._M_string._M_value = __value;
+ _M_variant._M_string._M_value = __value;
}
template<typename _Iterator, typename _Sequence>
_M_variant._M_iterator._M_name = __name;
_M_variant._M_iterator._M_address = &__it;
_M_variant._M_iterator._M_type = &typeid(__it);
- _M_variant._M_iterator._M_constness =
+ _M_variant._M_iterator._M_constness =
__is_same<_Safe_iterator<_Iterator, _Sequence>,
typename _Sequence::iterator>::
value? __mutable_iterator : __const_iterator;
_M_variant._M_iterator._M_sequence = 0;
_M_variant._M_iterator._M_seq_type = 0;
}
-
+
template<typename _Iterator>
_Parameter(const _Iterator& __it, const char* __name, _Is_iterator)
: _M_kind(__iterator)
_M_variant._M_iterator._M_address = &__it;
_M_variant._M_iterator._M_type = &typeid(__it);
_M_variant._M_iterator._M_constness = __unknown_constness;
- _M_variant._M_iterator._M_state =
+ _M_variant._M_iterator._M_state =
__gnu_debug::__check_singular(__it)? __singular : __unknown_state;
_M_variant._M_iterator._M_sequence = 0;
_M_variant._M_iterator._M_seq_type = 0;
}
template<typename _Sequence>
- _Parameter(const _Safe_sequence<_Sequence>& __seq,
+ _Parameter(const _Safe_sequence<_Sequence>& __seq,
const char* __name, _Is_sequence)
: _M_kind(__sequence)
{
_M_variant._M_sequence._M_name = __name;
- _M_variant._M_sequence._M_address =
+ _M_variant._M_sequence._M_address =
static_cast<const _Sequence*>(&__seq);
_M_variant._M_sequence._M_type = &typeid(_Sequence);
}
_M_variant._M_sequence._M_address = &__seq;
_M_variant._M_sequence._M_type = &typeid(_Sequence);
}
-
+
void
- _M_print_field(const _Error_formatter* __formatter,
+ _M_print_field(const _Error_formatter* __formatter,
const char* __name) const;
-
+
void
_M_print_description(const _Error_formatter* __formatter) const;
};
friend struct _Parameter;
- public:
+ public:
template<typename _Iterator>
const _Error_formatter&
_M_iterator(const _Iterator& __it, const char* __name = 0) const
_M_sequence(const _Sequence& __seq, const char* __name = 0) const
{
if (_M_num_parameters < __max_parameters)
- _M_parameters[_M_num_parameters++] = _Parameter(__seq, __name,
+ _M_parameters[_M_num_parameters++] = _Parameter(__seq, __name,
_Is_sequence());
return *this;
}
const _Error_formatter&
_M_message(_Debug_msg_id __id) const;
- void
+ void
_M_error() const;
private:
void
_M_format_word(char*, int, const char*, _Tp) const;
- void
+ void
_M_print_word(const char* __word) const;
- void
+ void
_M_print_string(const char* __string) const;
enum { __max_parameters = 9 };
};
} // namespace __gnu_debug
-#endif
+#endif
public __gnu_debug::_Safe_sequence<hash_map<_Value, _Tp, _HashFcn,
_EqualKey, _Alloc> >
{
- typedef __gnu_cxx::hash_map<_Value, _Tp, _HashFcn, _EqualKey, _Alloc>
+ typedef __gnu_cxx::hash_map<_Value, _Tp, _HashFcn, _EqualKey, _Alloc>
_Base;
typedef __gnu_debug::_Safe_sequence<hash_map> _Safe_base;
typedef typename _Base::const_pointer const_pointer;
typedef typename _Base::reference reference;
typedef typename _Base::const_reference const_reference;
-
+
typedef __gnu_debug::_Safe_iterator<typename _Base::iterator, hash_map>
- iterator;
- typedef __gnu_debug::_Safe_iterator<typename _Base::const_iterator,
+ iterator;
+ typedef __gnu_debug::_Safe_iterator<typename _Base::const_iterator,
hash_map>
- const_iterator;
-
+ const_iterator;
+
typedef typename _Base::allocator_type allocator_type;
using _Base::hash_funct;
using _Base::key_eq;
using _Base::get_allocator;
-
+
hash_map() { }
-
+
explicit hash_map(size_type __n) : _Base(__n) { }
-
+
hash_map(size_type __n, const hasher& __hf) : _Base(__n, __hf) { }
hash_map(size_type __n, const hasher& __hf, const key_equal& __eql,
const allocator_type& __a = allocator_type())
: _Base(__n, __hf, __eql, __a) { }
-
+
template<typename _InputIterator>
hash_map(_InputIterator __f, _InputIterator __l)
: _Base(__gnu_debug::__check_valid_range(__f, __l), __l) { }
using _Base::size;
using _Base::max_size;
using _Base::empty;
-
- void
+
+ void
swap(hash_map& __x)
{
_Base::swap(__x);
this->_M_swap(__x);
}
-
- iterator
+
+ iterator
begin() { return iterator(_Base::begin(), this); }
- iterator
+ iterator
end() { return iterator(_Base::end(), this); }
-
- const_iterator
- begin() const
+
+ const_iterator
+ begin() const
{ return const_iterator(_Base::begin(), this); }
-
- const_iterator
- end() const
+
+ const_iterator
+ end() const
{ return const_iterator(_Base::end(), this); }
-
- std::pair<iterator, bool>
+
+ std::pair<iterator, bool>
insert(const value_type& __obj)
- {
+ {
std::pair<typename _Base::iterator, bool> __res = _Base::insert(__obj);
return std::make_pair(iterator(__res.first, this), __res.second);
}
-
+
template <typename _InputIterator>
- void
- insert(_InputIterator __first, _InputIterator __last)
+ void
+ insert(_InputIterator __first, _InputIterator __last)
{
__glibcxx_check_valid_range(__first, __last);
_Base::insert(__first.base(), __last.base());
}
- std::pair<iterator, bool>
+ std::pair<iterator, bool>
insert_noresize(const value_type& __obj)
- {
- std::pair<typename _Base::iterator, bool> __res =
+ {
+ std::pair<typename _Base::iterator, bool> __res =
_Base::insert_noresize(__obj);
return std::make_pair(iterator(__res.first, this), __res.second);
}
-
- iterator
+
+ iterator
find(const key_type& __key)
{ return iterator(_Base::find(__key), this); }
-
- const_iterator
- find(const key_type& __key) const
+
+ const_iterator
+ find(const key_type& __key) const
{ return const_iterator(_Base::find(__key), this); }
-
+
using _Base::operator[];
using _Base::count;
-
- std::pair<iterator, iterator>
+
+ std::pair<iterator, iterator>
equal_range(const key_type& __key)
- {
+ {
typedef typename _Base::iterator _Base_iterator;
- std::pair<_Base_iterator, _Base_iterator> __res =
+ 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>
+
+ std::pair<const_iterator, const_iterator>
equal_range(const key_type& __key) const
- {
+ {
typedef typename _Base::const_iterator _Base_iterator;
- std::pair<_Base_iterator, _Base_iterator> __res =
+ std::pair<_Base_iterator, _Base_iterator> __res =
_Base::equal_range(__key);
return std::make_pair(const_iterator(__res.first, this),
const_iterator(__res.second, this));
}
-
- size_type
- erase(const key_type& __key)
+
+ size_type
+ erase(const key_type& __key)
{
iterator __victim(_Base::find(__key), this);
if (__victim != end())
- return this->erase(__victim), 1;
+ return this->erase(__victim), 1;
else
return 0;
}
-
- void
- erase(iterator __it)
+
+ void
+ erase(iterator __it)
{
__glibcxx_check_erase(__it);
__it._M_invalidate();
_Base::erase(__it.base());
}
-
- void
+
+ void
erase(iterator __first, iterator __last)
{
__glibcxx_check_erase_range(__first, __last);
}
_Base::erase(__first.base(), __last.base());
}
-
- void
- clear()
- {
+
+ void
+ clear()
+ {
_Base::clear();
- this->_M_invalidate_all();
+ this->_M_invalidate_all();
}
-
+
using _Base::resize;
using _Base::bucket_count;
using _Base::max_bucket_count;
using _Base::elems_in_bucket;
-
- _Base&
+
+ _Base&
_M_base() { return *this; }
- const _Base&
+ const _Base&
_M_base() const { return *this; }
-
+
private:
- void
+ void
_M_invalidate_all()
{
typedef typename _Base::const_iterator _Base_const_iterator;
this->_M_invalidate_if(_Not_equal(_M_base().end()));
}
};
-
- template<typename _Value, typename _Tp, typename _HashFcn,
+
+ template<typename _Value, typename _Tp, typename _HashFcn,
typename _EqualKey, typename _Alloc>
inline bool
operator==(const hash_map<_Value, _Tp, _HashFcn, _EqualKey, _Alloc>& __x,
const hash_map<_Value, _Tp, _HashFcn, _EqualKey, _Alloc>& __y)
{ return __x._M_base() == __y._M_base(); }
- template<typename _Value, typename _Tp, typename _HashFcn,
+ template<typename _Value, typename _Tp, typename _HashFcn,
typename _EqualKey, typename _Alloc>
inline bool
operator!=(const hash_map<_Value, _Tp, _HashFcn, _EqualKey, _Alloc>& __x,
const hash_map<_Value, _Tp, _HashFcn, _EqualKey, _Alloc>& __y)
{ return __x._M_base() != __y._M_base(); }
- template<typename _Value, typename _Tp, typename _HashFcn,
+ template<typename _Value, typename _Tp, typename _HashFcn,
typename _EqualKey, typename _Alloc>
inline void
swap(hash_map<_Value, _Tp, _HashFcn, _EqualKey, _Alloc>& __x,
{ __x.swap(__y); }
} // namespace __gnu_debug_def
-#endif
+#endif
_EqualKey, _Alloc> >
{
typedef __gnu_cxx::hash_multimap<_Value,_Tp,_HashFcn, _EqualKey,_Alloc>
- _Base;
+ _Base;
typedef __gnu_debug::_Safe_sequence<hash_multimap> _Safe_base;
public:
- typedef typename _Base::key_type key_type;
- typedef typename _Base::data_type data_type;
- typedef typename _Base::mapped_type mapped_type;
- typedef typename _Base::value_type value_type;
- typedef typename _Base::hasher hasher;
- typedef typename _Base::key_equal key_equal;
- typedef typename _Base::size_type size_type;
- typedef typename _Base::difference_type difference_type;
- typedef typename _Base::pointer pointer;
- typedef typename _Base::const_pointer const_pointer;
- typedef typename _Base::reference reference;
- typedef typename _Base::const_reference const_reference;
-
- typedef __gnu_debug::_Safe_iterator<typename _Base::iterator,
+ typedef typename _Base::key_type key_type;
+ typedef typename _Base::data_type data_type;
+ typedef typename _Base::mapped_type mapped_type;
+ typedef typename _Base::value_type value_type;
+ typedef typename _Base::hasher hasher;
+ typedef typename _Base::key_equal key_equal;
+ typedef typename _Base::size_type size_type;
+ typedef typename _Base::difference_type difference_type;
+ typedef typename _Base::pointer pointer;
+ typedef typename _Base::const_pointer const_pointer;
+ typedef typename _Base::reference reference;
+ typedef typename _Base::const_reference const_reference;
+
+ typedef __gnu_debug::_Safe_iterator<typename _Base::iterator,
hash_multimap> iterator;
typedef __gnu_debug::_Safe_iterator<typename _Base::const_iterator,
hash_multimap> const_iterator;
using _Base::hash_funct;
using _Base::key_eq;
using _Base::get_allocator;
-
+
hash_multimap() { }
-
+
explicit hash_multimap(size_type __n) : _Base(__n) { }
-
+
hash_multimap(size_type __n, const hasher& __hf) : _Base(__n, __hf) { }
hash_multimap(size_type __n, const hasher& __hf, const key_equal& __eql,
const allocator_type& __a = allocator_type())
: _Base(__n, __hf, __eql, __a) { }
-
+
template<typename _InputIterator>
hash_multimap(_InputIterator __f, _InputIterator __l)
: _Base(__gnu_debug::__check_valid_range(__f, __l), __l) { }
using _Base::size;
using _Base::max_size;
using _Base::empty;
-
- void
+
+ void
swap(hash_multimap& __x)
{
_Base::swap(__x);
this->_M_swap(__x);
}
-
- iterator
+
+ iterator
begin() { return iterator(_Base::begin(), this); }
- iterator
+ iterator
end() { return iterator(_Base::end(), this); }
-
- const_iterator
- begin() const
+
+ const_iterator
+ begin() const
{ return const_iterator(_Base::begin(), this); }
-
- const_iterator
- end() const
+
+ const_iterator
+ end() const
{ return const_iterator(_Base::end(), this); }
-
+
iterator
insert(const value_type& __obj)
{ return iterator(_Base::insert(__obj), this); }
-
+
template <typename _InputIterator>
- void
- insert(_InputIterator __first, _InputIterator __last)
+ void
+ insert(_InputIterator __first, _InputIterator __last)
{
__glibcxx_check_valid_range(__first, __last);
_Base::insert(__first.base(), __last.base());
}
-
+
iterator
insert_noresize(const value_type& __obj)
{ return iterator(_Base::insert_noresize(__obj), this); }
-
- iterator
+
+ iterator
find(const key_type& __key)
{ return iterator(_Base::find(__key), this); }
-
- const_iterator
- find(const key_type& __key) const
+
+ const_iterator
+ find(const key_type& __key) const
{ return const_iterator(_Base::find(__key), this); }
-
+
using _Base::count;
-
- std::pair<iterator, iterator>
+
+ std::pair<iterator, iterator>
equal_range(const key_type& __key)
- {
+ {
typedef typename _Base::iterator _Base_iterator;
- std::pair<_Base_iterator, _Base_iterator> __res =
+ 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>
+
+ std::pair<const_iterator, const_iterator>
equal_range(const key_type& __key) const
- {
+ {
typedef typename _Base::const_iterator _Base_iterator;
- std::pair<_Base_iterator, _Base_iterator> __res =
+ std::pair<_Base_iterator, _Base_iterator> __res =
_Base::equal_range(__key);
return std::make_pair(const_iterator(__res.first, this),
const_iterator(__res.second, this));
}
-
- size_type
- erase(const key_type& __key)
+
+ size_type
+ erase(const key_type& __key)
{
std::pair<iterator, iterator> __victims = this->equal_range(__key);
size_t __num_victims = 0;
- while (__victims.first != __victims.second)
+ while (__victims.first != __victims.second)
{
this->erase(__victims.first++);
++__num_victims;
}
return __num_victims;
}
-
- void
- erase(iterator __it)
+
+ void
+ erase(iterator __it)
{
__glibcxx_check_erase(__it);
__it._M_invalidate();
_Base::erase(__it.base());
}
-
- void
+
+ void
erase(iterator __first, iterator __last)
{
__glibcxx_check_erase_range(__first, __last);
}
_Base::erase(__first.base(), __last.base());
}
-
- void
- clear()
- {
+
+ void
+ clear()
+ {
_Base::clear();
- this->_M_invalidate_all();
+ this->_M_invalidate_all();
}
-
+
using _Base::resize;
using _Base::bucket_count;
using _Base::max_bucket_count;
using _Base::elems_in_bucket;
-
- _Base&
+
+ _Base&
_M_base() { return *this; }
- const _Base&
+ const _Base&
_M_base() const { return *this; }
-
+
private:
- void
+ void
_M_invalidate_all()
{
typedef typename _Base::const_iterator _Base_const_iterator;
this->_M_invalidate_if(_Not_equal(_M_base().end()));
}
};
-
- template<typename _Value, typename _Tp, typename _HashFcn,
+
+ template<typename _Value, typename _Tp, typename _HashFcn,
typename _EqualKey, typename _Alloc>
inline bool
operator==(const hash_multimap<_Value,_Tp,_HashFcn,_EqualKey,_Alloc>& __x,
const hash_multimap<_Value,_Tp,_HashFcn,_EqualKey,_Alloc>& __y)
{ return __x._M_base() == __y._M_base(); }
- template<typename _Value, typename _Tp, typename _HashFcn,
+ template<typename _Value, typename _Tp, typename _HashFcn,
typename _EqualKey, typename _Alloc>
inline bool
operator!=(const hash_multimap<_Value,_Tp,_HashFcn,_EqualKey,_Alloc>& __x,
const hash_multimap<_Value,_Tp,_HashFcn,_EqualKey,_Alloc>& __y)
{ return __x._M_base() != __y._M_base(); }
-
- template<typename _Value, typename _Tp, typename _HashFcn,
+
+ template<typename _Value, typename _Tp, typename _HashFcn,
typename _EqualKey, typename _Alloc>
inline void
swap(hash_multimap<_Value, _Tp, _HashFcn, _EqualKey, _Alloc>& __x,
_EqualKey, _Alloc> >
{
typedef __gnu_cxx:: hash_multiset<_Value,_HashFcn, _EqualKey,_Alloc>
- _Base;
+ _Base;
typedef __gnu_debug::_Safe_sequence<hash_multiset> _Safe_base;
public:
- typedef typename _Base::key_type key_type;
- typedef typename _Base::value_type value_type;
- typedef typename _Base::hasher hasher;
- typedef typename _Base::key_equal key_equal;
- typedef typename _Base::size_type size_type;
- typedef typename _Base::difference_type difference_type;
- typedef typename _Base::pointer pointer;
- typedef typename _Base::const_pointer const_pointer;
- typedef typename _Base::reference reference;
- typedef typename _Base::const_reference const_reference;
-
- typedef __gnu_debug::_Safe_iterator<typename _Base::iterator,
+ typedef typename _Base::key_type key_type;
+ typedef typename _Base::value_type value_type;
+ typedef typename _Base::hasher hasher;
+ typedef typename _Base::key_equal key_equal;
+ typedef typename _Base::size_type size_type;
+ typedef typename _Base::difference_type difference_type;
+ typedef typename _Base::pointer pointer;
+ typedef typename _Base::const_pointer const_pointer;
+ typedef typename _Base::reference reference;
+ typedef typename _Base::const_reference const_reference;
+
+ typedef __gnu_debug::_Safe_iterator<typename _Base::iterator,
hash_multiset> iterator;
typedef __gnu_debug::_Safe_iterator<typename _Base::const_iterator,
hash_multiset> const_iterator;
const allocator_type& __a = allocator_type())
: _Base(__n, __hf, __eql, __a)
{ }
-
+
template<typename _InputIterator>
hash_multiset(_InputIterator __f, _InputIterator __l)
: _Base(__gnu_debug::__check_valid_range(__f, __l), __l)
using _Base::max_size;
using _Base::empty;
- void
+ void
swap(hash_multiset& __x)
{
_Base::swap(__x);
{ return iterator(_Base::insert(__obj), this); }
template <typename _InputIterator>
- void
- insert(_InputIterator __first, _InputIterator __last)
+ void
+ insert(_InputIterator __first, _InputIterator __last)
{
__glibcxx_check_valid_range(__first, __last);
_Base::insert(__first.base(), __last.base());
insert_noresize(const value_type& __obj)
{ return iterator(_Base::insert_noresize(__obj), this); }
- iterator
- find(const key_type& __key) const
+ iterator
+ find(const key_type& __key) const
{ return iterator(_Base::find(__key), this); }
using _Base::count;
-
- std::pair<iterator, iterator>
+
+ std::pair<iterator, iterator>
equal_range(const key_type& __key) const
- {
+ {
typedef typename _Base::iterator _Base_iterator;
- std::pair<_Base_iterator, _Base_iterator> __res =
+ std::pair<_Base_iterator, _Base_iterator> __res =
_Base::equal_range(__key);
return std::make_pair(iterator(__res.first, this),
iterator(__res.second, this));
}
- size_type
- erase(const key_type& __key)
+ size_type
+ erase(const key_type& __key)
{
size_type __count = 0;
std::pair<iterator, iterator> __victims = this->equal_range(__key);
}
return __count;
}
-
- void
- erase(iterator __it)
+
+ void
+ erase(iterator __it)
{
__glibcxx_check_erase(__it);
__it._M_invalidate();
_Base::erase(__it.base());
}
- void
+ void
erase(iterator __first, iterator __last)
{
__glibcxx_check_erase_range(__first, __last);
_Base::erase(__first.base(), __last.base());
}
- void
- clear()
- {
+ void
+ clear()
+ {
_Base::clear();
- this->_M_invalidate_all();
+ this->_M_invalidate_all();
}
using _Base::resize;
const _Base& _M_base() const { return *this; }
private:
- void
+ void
_M_invalidate_all()
{
typedef typename _Base::const_iterator _Base_const_iterator;
#include <debug/dbg_hash_set.h>
#include <debug/dbg_hash_multiset.h>
-#endif
+#endif
{
typedef __gnu_cxx::hash_set<_Value, _HashFcn, _EqualKey, _Alloc> _Base;
typedef __gnu_debug::_Safe_sequence<hash_set> _Safe_base;
-
+
public:
typedef typename _Base::key_type key_type;
typedef typename _Base::value_type value_type;
const_iterator;
typedef typename _Base::allocator_type allocator_type;
-
+
using _Base::hash_funct;
using _Base::key_eq;
using _Base::get_allocator;
-
+
hash_set() { }
-
+
explicit hash_set(size_type __n) : _Base(__n) { }
-
+
hash_set(size_type __n, const hasher& __hf) : _Base(__n, __hf) { }
-
+
hash_set(size_type __n, const hasher& __hf, const key_equal& __eql,
const allocator_type& __a = allocator_type())
: _Base(__n, __hf, __eql, __a) { }
-
+
template<typename _InputIterator>
hash_set(_InputIterator __f, _InputIterator __l)
: _Base(__gnu_debug::__check_valid_range(__f, __l), __l) { }
__eql, __a) { }
hash_set(const _Base& __x) : _Base(__x), _Safe_base() { }
-
+
using _Base::size;
using _Base::max_size;
using _Base::empty;
-
- void
+
+ void
swap(hash_set& __x)
{
_Base::swap(__x);
this->_M_swap(__x);
}
-
- iterator
+
+ iterator
begin() const { return iterator(_Base::begin(), this); }
- iterator
+ iterator
end() const { return iterator(_Base::end(), this); }
- std::pair<iterator, bool>
+ std::pair<iterator, bool>
insert(const value_type& __obj)
- {
+ {
std::pair<typename _Base::iterator, bool> __res =
_Base::insert(__obj);
return std::make_pair(iterator(__res.first, this), __res.second);
}
-
+
template <typename _InputIterator>
- void
- insert(_InputIterator __first, _InputIterator __last)
+ void
+ insert(_InputIterator __first, _InputIterator __last)
{
__glibcxx_check_valid_range(__first, __last);
_Base::insert(__first.base(), __last.base());
}
-
- std::pair<iterator, bool>
+
+ std::pair<iterator, bool>
insert_noresize(const value_type& __obj)
{
std::pair<typename _Base::iterator, bool> __res =
_Base::insert_noresize(__obj);
return std::make_pair(iterator(__res.first, this), __res.second);
}
-
- iterator
- find(const key_type& __key) const
+
+ iterator
+ find(const key_type& __key) const
{ return iterator(_Base::find(__key), this); }
-
+
using _Base::count;
-
- std::pair<iterator, iterator>
+
+ std::pair<iterator, iterator>
equal_range(const key_type& __key) const
- {
+ {
typedef typename _Base::iterator _Base_iterator;
- std::pair<_Base_iterator, _Base_iterator> __res =
+ std::pair<_Base_iterator, _Base_iterator> __res =
_Base::equal_range(__key);
return std::make_pair(iterator(__res.first, this),
iterator(__res.second, this));
}
-
- size_type
- erase(const key_type& __key)
+
+ size_type
+ erase(const key_type& __key)
{
iterator __victim(_Base::find(__key), this);
if (__victim != end())
else
return 0;
}
-
- void
- erase(iterator __it)
+
+ void
+ erase(iterator __it)
{
__glibcxx_check_erase(__it);
__it._M_invalidate();
_Base::erase(__it.base());
}
-
- void
+
+ void
erase(iterator __first, iterator __last)
{
__glibcxx_check_erase_range(__first, __last);
}
_Base::erase(__first.base(), __last.base());
}
-
- void
- clear()
- {
+
+ void
+ clear()
+ {
_Base::clear();
- this->_M_invalidate_all();
+ this->_M_invalidate_all();
}
-
+
using _Base::resize;
using _Base::bucket_count;
using _Base::max_bucket_count;
using _Base::elems_in_bucket;
-
- _Base&
+
+ _Base&
_M_base() { return *this; }
- const _Base&
+ const _Base&
_M_base() const { return *this; }
private:
- void
+ void
_M_invalidate_all()
{
typedef typename _Base::const_iterator _Base_const_iterator;
}
};
- template<typename _Value, typename _HashFcn, typename _EqualKey,
+ template<typename _Value, typename _HashFcn, typename _EqualKey,
typename _Alloc>
inline bool
operator==(const hash_set<_Value, _HashFcn, _EqualKey, _Alloc>& __x,
const hash_set<_Value, _HashFcn, _EqualKey, _Alloc>& __y)
{ return __x._M_base() == __y._M_base(); }
- template<typename _Value, typename _HashFcn, typename _EqualKey,
+ template<typename _Value, typename _HashFcn, typename _EqualKey,
typename _Alloc>
inline bool
operator!=(const hash_set<_Value, _HashFcn, _EqualKey, _Alloc>& __x,
const hash_set<_Value, _HashFcn, _EqualKey, _Alloc>& __y)
{ return __x._M_base() != __y._M_base(); }
- template<typename _Value, typename _HashFcn, typename _EqualKey,
+ template<typename _Value, typename _HashFcn, typename _EqualKey,
typename _Alloc>
inline void
swap(hash_set<_Value, _HashFcn, _EqualKey, _Alloc>& __x,
public:
typedef typename _Allocator::reference reference;
typedef typename _Allocator::const_reference const_reference;
-
- typedef __gnu_debug::_Safe_iterator<typename _Base::iterator, list>
- iterator;
+
+ typedef __gnu_debug::_Safe_iterator<typename _Base::iterator, list>
+ iterator;
typedef __gnu_debug::_Safe_iterator<typename _Base::const_iterator, list>
const_iterator;
typedef typename _Base::size_type size_type;
typedef typename _Base::difference_type difference_type;
-
- typedef _Tp value_type;
- typedef _Allocator allocator_type;
+
+ typedef _Tp value_type;
+ typedef _Allocator allocator_type;
typedef typename _Allocator::pointer pointer;
typedef typename _Allocator::const_pointer const_pointer;
typedef std::reverse_iterator<iterator> reverse_iterator;
const _Allocator& __a = _Allocator())
: _Base(__gnu_debug::__check_valid_range(__first, __last), __last, __a)
{ }
-
+
list(const list& __x) : _Base(__x), _Safe_base() { }
-
+
list(const _Base& __x) : _Base(__x), _Safe_base() { }
-
+
~list() { }
-
- list&
+
+ list&
operator=(const list& __x)
{
static_cast<_Base&>(*this) = __x;
this->_M_invalidate_all();
return *this;
}
-
+
template<class _InputIterator>
- void
+ void
assign(_InputIterator __first, _InputIterator __last)
{
__glibcxx_check_valid_range(__first, __last);
_Base::assign(__first, __last);
this->_M_invalidate_all();
}
-
- void
+
+ void
assign(size_type __n, const _Tp& __t)
{
_Base::assign(__n, __t);
this->_M_invalidate_all();
}
-
+
using _Base::get_allocator;
-
+
// iterators:
- iterator
- begin()
+ iterator
+ begin()
{ return iterator(_Base::begin(), this); }
-
- const_iterator
- begin() const
+
+ const_iterator
+ begin() const
{ return const_iterator(_Base::begin(), this); }
-
- iterator
- end()
+
+ iterator
+ end()
{ return iterator(_Base::end(), this); }
-
- const_iterator
- end() const
+
+ const_iterator
+ end() const
{ return const_iterator(_Base::end(), this); }
-
- reverse_iterator
- rbegin()
+
+ reverse_iterator
+ rbegin()
{ return reverse_iterator(end()); }
-
- const_reverse_iterator
+
+ const_reverse_iterator
rbegin() const
{ return const_reverse_iterator(end()); }
-
- reverse_iterator
- rend()
+
+ reverse_iterator
+ rend()
{ return reverse_iterator(begin()); }
-
- const_reverse_iterator
- rend() const
+
+ const_reverse_iterator
+ rend() const
{ return const_reverse_iterator(begin()); }
-
+
// 23.2.2.2 capacity:
using _Base::empty;
using _Base::size;
using _Base::max_size;
-
- void
+
+ void
resize(size_type __sz, _Tp __c = _Tp())
{
this->_M_detach_singular();
-
+
// if __sz < size(), invalidate all iterators in [begin+__sz, end())
iterator __victim = begin();
iterator __end = end();
for (size_type __i = __sz; __victim != __end && __i > 0; --__i)
++__victim;
-
+
while (__victim != __end)
{
iterator __real_victim = __victim++;
__real_victim._M_invalidate();
}
-
- try
+
+ try
{
_Base::resize(__sz, __c);
}
__throw_exception_again;
}
}
-
+
// element access:
- reference
+ reference
front()
{
__glibcxx_check_nonempty();
return _Base::front();
}
-
- const_reference
+
+ const_reference
front() const
{
__glibcxx_check_nonempty();
return _Base::front();
}
-
- reference
+
+ reference
back()
{
__glibcxx_check_nonempty();
return _Base::back();
}
-
- const_reference
+
+ const_reference
back() const
{
__glibcxx_check_nonempty();
return _Base::back();
}
-
+
// 23.2.2.3 modifiers:
using _Base::push_front;
-
- void
+
+ void
pop_front()
{
__glibcxx_check_nonempty();
__victim._M_invalidate();
_Base::pop_front();
}
-
+
using _Base::push_back;
-
- void
+
+ void
pop_back()
{
__glibcxx_check_nonempty();
__victim._M_invalidate();
_Base::pop_back();
}
-
- iterator
+
+ iterator
insert(iterator __position, const _Tp& __x)
{
__glibcxx_check_insert(__position);
return iterator(_Base::insert(__position.base(), __x), this);
}
-
- void
+
+ void
insert(iterator __position, size_type __n, const _Tp& __x)
{
__glibcxx_check_insert(__position);
_Base::insert(__position.base(), __n, __x);
}
-
+
template<class _InputIterator>
- void
+ void
insert(iterator __position, _InputIterator __first,
_InputIterator __last)
{
__glibcxx_check_insert_range(__position, __first, __last);
_Base::insert(__position.base(), __first, __last);
}
-
- iterator
+
+ iterator
erase(iterator __position)
{
__glibcxx_check_erase(__position);
__position._M_invalidate();
return iterator(_Base::erase(__position.base()), this);
}
-
- iterator
+
+ iterator
erase(iterator __position, iterator __last)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
}
return iterator(_Base::erase(__position.base(), __last.base()), this);
}
-
- void
+
+ void
swap(list& __x)
{
_Base::swap(__x);
this->_M_swap(__x);
}
-
- void
+
+ void
clear()
{
_Base::clear();
this->_M_invalidate_all();
}
-
+
// 23.2.2.4 list operations:
- void
+ void
splice(iterator __position, list& __x)
{
_GLIBCXX_DEBUG_VERIFY(&__x != this,
._M_sequence(*this, "this"));
this->splice(__position, __x, __x.begin(), __x.end());
}
-
- void
+
+ void
splice(iterator __position, list& __x, iterator __i)
{
__glibcxx_check_insert(__position);
_GLIBCXX_DEBUG_VERIFY(__i._M_attached_to(&__x),
_M_message(::__gnu_debug::__msg_splice_other)
._M_iterator(__i, "__i")._M_sequence(__x, "__x"));
-
+
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 250. splicing invalidates iterators
this->_M_transfer_iter(__i);
_Base::splice(__position.base(), __x._M_base(), __i.base());
}
-
- void
+
+ void
splice(iterator __position, list& __x, iterator __first, iterator __last)
{
__glibcxx_check_insert(__position);
_GLIBCXX_DEBUG_VERIFY(__x.get_allocator() == this->get_allocator(),
_M_message(::__gnu_debug::__msg_splice_alloc)
._M_sequence(*this)._M_sequence(__x));
-
+
for (iterator __tmp = __first; __tmp != __last; )
{
_GLIBCXX_DEBUG_VERIFY(&__x != this || __tmp != __position,
// 250. splicing invalidates iterators
this->_M_transfer_iter(__victim);
}
-
+
_Base::splice(__position.base(), __x._M_base(), __first.base(),
__last.base());
}
-
- void
+
+ void
remove(const _Tp& __value)
{
for (iterator __x = begin(); __x.base() != _Base::end(); )
++__x;
}
}
-
- template<class _Predicate>
- void
+
+ template<class _Predicate>
+ void
remove_if(_Predicate __pred)
{
for (iterator __x = begin(); __x.base() != _Base::end(); )
++__x;
}
}
-
- void
+
+ void
unique()
{
iterator __first = begin();
iterator __last = end();
- if (__first == __last)
+ if (__first == __last)
return;
iterator __next = __first;
while (++__next != __last)
__next = __first;
}
}
-
+
template<class _BinaryPredicate>
- void
+ void
unique(_BinaryPredicate __binary_pred)
{
iterator __first = begin();
iterator __last = end();
- if (__first == __last)
+ if (__first == __last)
return;
iterator __next = __first;
while (++__next != __last)
__next = __first;
}
}
-
- void
+
+ void
merge(list& __x)
{
__glibcxx_check_sorted(_Base::begin(), _Base::end());
}
_Base::merge(__x._M_base());
}
-
- template<class _Compare>
- void
+
+ template<class _Compare>
+ void
merge(list& __x, _Compare __comp)
{
__glibcxx_check_sorted_pred(_Base::begin(), _Base::end(), __comp);
- __glibcxx_check_sorted_pred(__x.begin().base(), __x.end().base(),
+ __glibcxx_check_sorted_pred(__x.begin().base(), __x.end().base(),
__comp);
for (iterator __tmp = __x.begin(); __tmp != __x.end(); )
{
}
_Base::merge(__x._M_base(), __comp);
}
-
- void
+
+ void
sort() { _Base::sort(); }
-
+
template<typename _StrictWeakOrdering>
- void
+ void
sort(_StrictWeakOrdering __pred) { _Base::sort(__pred); }
-
+
using _Base::reverse;
-
- _Base&
+
+ _Base&
_M_base() { return *this; }
- const _Base&
+ const _Base&
_M_base() const { return *this; }
private:
- void
+ void
_M_invalidate_all()
{
typedef typename _Base::const_iterator _Base_const_iterator;
this->_M_invalidate_if(_Not_equal(_M_base().end()));
}
};
-
+
template<typename _Tp, typename _Alloc>
inline bool
operator==(const list<_Tp, _Alloc>& __lhs, const list<_Tp, _Alloc>& __rhs)
inline bool
operator!=(const list<_Tp, _Alloc>& __lhs, const list<_Tp, _Alloc>& __rhs)
{ return __lhs._M_base() != __rhs._M_base(); }
-
+
template<typename _Tp, typename _Alloc>
inline bool
operator<(const list<_Tp, _Alloc>& __lhs, const list<_Tp, _Alloc>& __rhs)
{ return __lhs._M_base() < __rhs._M_base(); }
-
+
template<typename _Tp, typename _Alloc>
inline bool
operator<=(const list<_Tp, _Alloc>& __lhs, const list<_Tp, _Alloc>& __rhs)
inline bool
operator>=(const list<_Tp, _Alloc>& __lhs, const list<_Tp, _Alloc>& __rhs)
{ return __lhs._M_base() >= __rhs._M_base(); }
-
+
template<typename _Tp, typename _Alloc>
inline bool
operator>(const list<_Tp, _Alloc>& __lhs, const list<_Tp, _Alloc>& __rhs)
{ return __lhs._M_base() > __rhs._M_base(); }
-
+
template<typename _Tp, typename _Alloc>
inline void
swap(list<_Tp, _Alloc>& __lhs, list<_Tp, _Alloc>& __rhs)
typedef _Allocator allocator_type;
typedef typename _Allocator::reference reference;
typedef typename _Allocator::const_reference const_reference;
-
- typedef __gnu_debug::_Safe_iterator<typename _Base::iterator, map>
+
+ typedef __gnu_debug::_Safe_iterator<typename _Base::iterator, map>
iterator;
typedef __gnu_debug::_Safe_iterator<typename _Base::const_iterator, map>
const_iterator;
typedef typename _Allocator::const_pointer const_pointer;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-
+
using _Base::value_compare;
-
+
// 23.3.1.1 construct/copy/destroy:
- explicit map(const _Compare& __comp = _Compare(),
+ explicit map(const _Compare& __comp = _Compare(),
const _Allocator& __a = _Allocator())
: _Base(__comp, __a) { }
template<typename _InputIterator>
map(_InputIterator __first, _InputIterator __last,
- const _Compare& __comp = _Compare(),
+ const _Compare& __comp = _Compare(),
const _Allocator& __a = _Allocator())
: _Base(__gnu_debug::__check_valid_range(__first, __last), __last,
__comp, __a), _Safe_base() { }
- map(const map<_Key,_Tp,_Compare,_Allocator>& __x)
- : _Base(__x), _Safe_base() { }
-
+ map(const map<_Key,_Tp,_Compare,_Allocator>& __x)
+ : _Base(__x), _Safe_base() { }
+
map(const _Base& __x) : _Base(__x), _Safe_base() { }
~map() { }
-
+
map<_Key,_Tp,_Compare,_Allocator>&
operator=(const map<_Key,_Tp,_Compare,_Allocator>& __x)
{
this->_M_invalidate_all();
return *this;
}
-
+
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 133. map missing get_allocator()
using _Base::get_allocator;
-
+
// iterators:
- iterator
- begin()
+ iterator
+ begin()
{ return iterator(_Base::begin(), this); }
-
- const_iterator
- begin() const
+
+ const_iterator
+ begin() const
{ return const_iterator(_Base::begin(), this); }
-
- iterator
- end()
+
+ iterator
+ end()
{ return iterator(_Base::end(), this); }
-
- const_iterator
- end() const
+
+ const_iterator
+ end() const
{ return const_iterator(_Base::end(), this); }
-
- reverse_iterator
- rbegin()
+
+ reverse_iterator
+ rbegin()
{ return reverse_iterator(end()); }
-
- const_reverse_iterator
+
+ const_reverse_iterator
rbegin() const
{ return const_reverse_iterator(end()); }
-
- reverse_iterator
- rend()
+
+ reverse_iterator
+ rend()
{ return reverse_iterator(begin()); }
-
- const_reverse_iterator
- rend() const
+
+ const_reverse_iterator
+ rend() const
{ return const_reverse_iterator(begin()); }
-
+
// capacity:
using _Base::empty;
using _Base::size;
using _Base::max_size;
-
+
// 23.3.1.2 element access:
using _Base::operator[];
-
+
// modifiers:
- std::pair<iterator, bool>
+ 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),
+ return std::pair<iterator, bool>(iterator(__res.first, this),
__res.second);
}
-
- iterator
+
+ iterator
insert(iterator __position, const value_type& __x)
{
__glibcxx_check_insert(__position);
return iterator(_Base::insert(__position.base(), __x), this);
}
-
+
template<typename _InputIterator>
- void
+ void
insert(_InputIterator __first, _InputIterator __last)
{
__glibcxx_valid_range(__first, __last);
_Base::insert(__first, __last);
}
-
- void
+
+ void
erase(iterator __position)
{
__glibcxx_check_erase(__position);
__position._M_invalidate();
_Base::erase(__position.base());
}
-
- size_type
+
+ size_type
erase(const key_type& __x)
{
iterator __victim = find(__x);
return 1;
}
}
-
- void
+
+ void
erase(iterator __first, iterator __last)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
while (__first != __last)
this->erase(__first++);
}
-
- void
+
+ void
swap(map<_Key,_Tp,_Compare,_Allocator>& __x)
{
_Base::swap(__x);
this->_M_swap(__x);
}
-
- void
+
+ void
clear()
{ this->erase(begin(), end()); }
-
+
// observers:
using _Base::key_comp;
using _Base::value_comp;
-
+
// 23.3.1.3 map operations:
- iterator
+ iterator
find(const key_type& __x)
{ return iterator(_Base::find(__x), this); }
-
- const_iterator
+
+ const_iterator
find(const key_type& __x) const
{ return const_iterator(_Base::find(__x), this); }
-
+
using _Base::count;
-
- iterator
+
+ iterator
lower_bound(const key_type& __x)
{ return iterator(_Base::lower_bound(__x), this); }
-
- const_iterator
+
+ const_iterator
lower_bound(const key_type& __x) const
{ return const_iterator(_Base::lower_bound(__x), this); }
-
- iterator
+
+ iterator
upper_bound(const key_type& __x)
{ return iterator(_Base::upper_bound(__x), this); }
-
- const_iterator
+
+ const_iterator
upper_bound(const key_type& __x) const
{ return const_iterator(_Base::upper_bound(__x), this); }
-
+
std::pair<iterator,iterator>
equal_range(const key_type& __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
{
return std::make_pair(const_iterator(__res.first, this),
const_iterator(__res.second, this));
}
-
- _Base&
+
+ _Base&
_M_base() { return *this; }
- const _Base&
+ const _Base&
_M_base() const { return *this; }
-
+
private:
- void
+ void
_M_invalidate_all()
{
typedef typename _Base::const_iterator _Base_const_iterator;
}
};
- template<typename _Key,typename _Tp,typename _Compare,typename _Allocator>
+ template<typename _Key,typename _Tp,typename _Compare,typename _Allocator>
inline bool
- operator==(const map<_Key,_Tp,_Compare,_Allocator>& __lhs,
+ operator==(const map<_Key,_Tp,_Compare,_Allocator>& __lhs,
const map<_Key,_Tp,_Compare,_Allocator>& __rhs)
{ return __lhs._M_base() == __rhs._M_base(); }
template<typename _Key,typename _Tp,typename _Compare,typename _Allocator>
inline bool
- operator!=(const map<_Key,_Tp,_Compare,_Allocator>& __lhs,
+ operator!=(const map<_Key,_Tp,_Compare,_Allocator>& __lhs,
const map<_Key,_Tp,_Compare,_Allocator>& __rhs)
{ return __lhs._M_base() != __rhs._M_base(); }
template<typename _Key,typename _Tp,typename _Compare,typename _Allocator>
inline bool
- operator<(const map<_Key,_Tp,_Compare,_Allocator>& __lhs,
+ operator<(const map<_Key,_Tp,_Compare,_Allocator>& __lhs,
const map<_Key,_Tp,_Compare,_Allocator>& __rhs)
{ return __lhs._M_base() < __rhs._M_base(); }
template<typename _Key,typename _Tp,typename _Compare,typename _Allocator>
inline bool
- operator<=(const map<_Key,_Tp,_Compare,_Allocator>& __lhs,
+ operator<=(const map<_Key,_Tp,_Compare,_Allocator>& __lhs,
const map<_Key,_Tp,_Compare,_Allocator>& __rhs)
{ return __lhs._M_base() <= __rhs._M_base(); }
template<typename _Key,typename _Tp,typename _Compare,typename _Allocator>
inline bool
- operator>=(const map<_Key,_Tp,_Compare,_Allocator>& __lhs,
+ operator>=(const map<_Key,_Tp,_Compare,_Allocator>& __lhs,
const map<_Key,_Tp,_Compare,_Allocator>& __rhs)
{ return __lhs._M_base() >= __rhs._M_base(); }
template<typename _Key,typename _Tp,typename _Compare,typename _Allocator>
inline bool
- operator>(const map<_Key,_Tp,_Compare,_Allocator>& __lhs,
+ operator>(const map<_Key,_Tp,_Compare,_Allocator>& __lhs,
const map<_Key,_Tp,_Compare,_Allocator>& __rhs)
{ return __lhs._M_base() > __rhs._M_base(); }
template<typename _Key,typename _Tp,typename _Compare,typename _Allocator>
inline void
- swap(map<_Key,_Tp,_Compare,_Allocator>& __lhs,
+ swap(map<_Key,_Tp,_Compare,_Allocator>& __lhs,
map<_Key,_Tp,_Compare,_Allocator>& __rhs)
{ __lhs.swap(__rhs); }
} // namespace __gnu_debug_def
-#endif
+#endif
{
template<typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
typename _Allocator = std::allocator<std::pair<const _Key, _Tp> > >
- class multimap
+ class multimap
: public __gnu_norm::multimap<_Key, _Tp, _Compare, _Allocator>,
public __gnu_debug::_Safe_sequence<multimap<_Key,_Tp,_Compare,_Allocator> >
{
typedef __gnu_norm::multimap<_Key, _Tp, _Compare, _Allocator> _Base;
typedef __gnu_debug::_Safe_sequence<multimap> _Safe_base;
-
+
public:
// types:
- typedef _Key key_type;
- typedef _Tp mapped_type;
+ typedef _Key key_type;
+ typedef _Tp mapped_type;
typedef std::pair<const _Key, _Tp> value_type;
typedef _Compare key_compare;
typedef _Allocator allocator_type;
typedef typename _Allocator::reference reference;
typedef typename _Allocator::const_reference const_reference;
-
- typedef __gnu_debug::_Safe_iterator<typename _Base::iterator, multimap>
+
+ typedef __gnu_debug::_Safe_iterator<typename _Base::iterator, multimap>
iterator;
typedef __gnu_debug::_Safe_iterator<typename _Base::const_iterator,
multimap> const_iterator;
typedef typename _Allocator::const_pointer const_pointer;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-
+
using _Base::value_compare;
-
+
// 23.3.1.1 construct/copy/destroy:
explicit multimap(const _Compare& __comp = _Compare(),
const _Allocator& __a = _Allocator())
template<typename _InputIterator>
multimap(_InputIterator __first, _InputIterator __last,
- const _Compare& __comp = _Compare(),
+ const _Compare& __comp = _Compare(),
const _Allocator& __a = _Allocator())
: _Base(__gnu_debug::__check_valid_range(__first, __last), __last,
__comp, __a) { }
multimap(const multimap<_Key,_Tp,_Compare,_Allocator>& __x)
- : _Base(__x), _Safe_base() { }
+ : _Base(__x), _Safe_base() { }
multimap(const _Base& __x) : _Base(__x), _Safe_base() { }
using _Base::get_allocator;
// iterators:
- iterator
- begin()
+ iterator
+ begin()
{ return iterator(_Base::begin(), this); }
- const_iterator
- begin() const
+ const_iterator
+ begin() const
{ return const_iterator(_Base::begin(), this); }
- iterator
- end()
+ iterator
+ end()
{ return iterator(_Base::end(), this); }
- const_iterator
- end() const
+ const_iterator
+ end() const
{ return const_iterator(_Base::end(), this); }
- reverse_iterator
- rbegin()
+ reverse_iterator
+ rbegin()
{ return reverse_iterator(end()); }
- const_reverse_iterator
+ const_reverse_iterator
rbegin() const
{ return const_reverse_iterator(end()); }
- reverse_iterator
- rend()
+ reverse_iterator
+ rend()
{ return reverse_iterator(begin()); }
- const_reverse_iterator
- rend() const
+ const_reverse_iterator
+ rend() const
{ return const_reverse_iterator(begin()); }
// capacity:
using _Base::max_size;
// modifiers:
- iterator
+ iterator
insert(const value_type& __x)
{ return iterator(_Base::insert(__x), this); }
- iterator
+ iterator
insert(iterator __position, const value_type& __x)
{
__glibcxx_check_insert(__position);
}
template<typename _InputIterator>
- void
+ void
insert(_InputIterator __first, _InputIterator __last)
{
__glibcxx_check_valid_range(__first, __last);
_Base::insert(__first, __last);
}
- void
+ void
erase(iterator __position)
{
__glibcxx_check_erase(__position);
_Base::erase(__position.base());
}
- size_type
+ size_type
erase(const key_type& __x)
{
std::pair<iterator, iterator> __victims = this->equal_range(__x);
return __count;
}
- void
+ void
erase(iterator __first, iterator __last)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
this->erase(__first++);
}
- void
+ void
swap(multimap<_Key,_Tp,_Compare,_Allocator>& __x)
{
_Base::swap(__x);
this->_M_swap(__x);
}
- void
+ void
clear()
{ this->erase(begin(), end()); }
using _Base::value_comp;
// 23.3.1.3 multimap operations:
- iterator
+ iterator
find(const key_type& __x)
{ return iterator(_Base::find(__x), this); }
- const_iterator
+ const_iterator
find(const key_type& __x) const
{ return const_iterator(_Base::find(__x), this); }
using _Base::count;
- iterator
+ iterator
lower_bound(const key_type& __x)
{ return iterator(_Base::lower_bound(__x), this); }
- const_iterator
+ const_iterator
lower_bound(const key_type& __x) const
{ return const_iterator(_Base::lower_bound(__x), this); }
- iterator
+ iterator
upper_bound(const key_type& __x)
{ return iterator(_Base::upper_bound(__x), this); }
- const_iterator
+ const_iterator
upper_bound(const key_type& __x) const
{ return const_iterator(_Base::upper_bound(__x), this); }
const_iterator(__res.second, this));
}
- _Base&
+ _Base&
_M_base() { return *this; }
- const _Base&
+ const _Base&
_M_base() const { return *this; }
private:
- void
+ void
_M_invalidate_all()
{
typedef typename _Base::const_iterator _Base_const_iterator;
template<typename _Key,typename _Tp,typename _Compare,typename _Allocator>
inline bool
- operator==(const multimap<_Key,_Tp,_Compare,_Allocator>& __lhs,
+ operator==(const multimap<_Key,_Tp,_Compare,_Allocator>& __lhs,
const multimap<_Key,_Tp,_Compare,_Allocator>& __rhs)
{ return __lhs._M_base() == __rhs._M_base(); }
template<typename _Key,typename _Tp,typename _Compare,typename _Allocator>
inline bool
- operator!=(const multimap<_Key,_Tp,_Compare,_Allocator>& __lhs,
+ operator!=(const multimap<_Key,_Tp,_Compare,_Allocator>& __lhs,
const multimap<_Key,_Tp,_Compare,_Allocator>& __rhs)
{ return __lhs._M_base() != __rhs._M_base(); }
template<typename _Key,typename _Tp,typename _Compare,typename _Allocator>
inline bool
- operator<(const multimap<_Key,_Tp,_Compare,_Allocator>& __lhs,
+ operator<(const multimap<_Key,_Tp,_Compare,_Allocator>& __lhs,
const multimap<_Key,_Tp,_Compare,_Allocator>& __rhs)
{ return __lhs._M_base() < __rhs._M_base(); }
template<typename _Key,typename _Tp,typename _Compare,typename _Allocator>
inline bool
- operator<=(const multimap<_Key,_Tp,_Compare,_Allocator>& __lhs,
+ operator<=(const multimap<_Key,_Tp,_Compare,_Allocator>& __lhs,
const multimap<_Key,_Tp,_Compare,_Allocator>& __rhs)
{ return __lhs._M_base() <= __rhs._M_base(); }
template<typename _Key,typename _Tp,typename _Compare,typename _Allocator>
inline bool
- operator>=(const multimap<_Key,_Tp,_Compare,_Allocator>& __lhs,
+ operator>=(const multimap<_Key,_Tp,_Compare,_Allocator>& __lhs,
const multimap<_Key,_Tp,_Compare,_Allocator>& __rhs)
{ return __lhs._M_base() >= __rhs._M_base(); }
template<typename _Key,typename _Tp,typename _Compare,typename _Allocator>
inline bool
- operator>(const multimap<_Key,_Tp,_Compare,_Allocator>& __lhs,
+ operator>(const multimap<_Key,_Tp,_Compare,_Allocator>& __lhs,
const multimap<_Key,_Tp,_Compare,_Allocator>& __rhs)
{ return __lhs._M_base() > __rhs._M_base(); }
template<typename _Key,typename _Tp,typename _Compare,typename _Allocator>
inline void
- swap(multimap<_Key,_Tp,_Compare,_Allocator>& __lhs,
+ swap(multimap<_Key,_Tp,_Compare,_Allocator>& __lhs,
multimap<_Key,_Tp,_Compare,_Allocator>& __rhs)
{ __lhs.swap(__rhs); }
} // namespace __gnu_debug_def
-#endif
+#endif
{
template<typename _Key, typename _Compare = std::less<_Key>,
typename _Allocator = std::allocator<_Key> >
- class multiset
+ class multiset
: public __gnu_norm::multiset<_Key, _Compare, _Allocator>,
public __gnu_debug::_Safe_sequence<multiset<_Key, _Compare, _Allocator> >
{
public:
// types:
- typedef _Key key_type;
- typedef _Key value_type;
- typedef _Compare key_compare;
- typedef _Compare value_compare;
- typedef _Allocator allocator_type;
- typedef typename _Allocator::reference reference;
+ typedef _Key key_type;
+ typedef _Key value_type;
+ typedef _Compare key_compare;
+ typedef _Compare value_compare;
+ typedef _Allocator allocator_type;
+ typedef typename _Allocator::reference reference;
typedef typename _Allocator::const_reference const_reference;
- typedef __gnu_debug::_Safe_iterator<typename _Base::iterator, multiset>
+ typedef __gnu_debug::_Safe_iterator<typename _Base::iterator, multiset>
iterator;
typedef __gnu_debug::_Safe_iterator<typename _Base::const_iterator,
multiset> const_iterator;
: _Base(__gnu_debug::__check_valid_range(__first, __last), __last,
__comp, __a) { }
- multiset(const multiset<_Key,_Compare,_Allocator>& __x)
+ multiset(const multiset<_Key,_Compare,_Allocator>& __x)
: _Base(__x), _Safe_base() { }
-
+
multiset(const _Base& __x) : _Base(__x), _Safe_base() { }
~multiset() { }
- multiset<_Key,_Compare,_Allocator>&
+ multiset<_Key,_Compare,_Allocator>&
operator=(const multiset<_Key,_Compare,_Allocator>& __x)
{
*static_cast<_Base*>(this) = __x;
begin()
{ return iterator(_Base::begin(), this); }
- const_iterator
- begin() const
+ const_iterator
+ begin() const
{ return const_iterator(_Base::begin(), this); }
- iterator
+ iterator
end()
{ return iterator(_Base::end(), this); }
- const_iterator
- end() const
+ const_iterator
+ end() const
{ return const_iterator(_Base::end(), this); }
- reverse_iterator
- rbegin()
+ reverse_iterator
+ rbegin()
{ return reverse_iterator(end()); }
- const_reverse_iterator
+ const_reverse_iterator
rbegin() const
{ return const_reverse_iterator(end()); }
- reverse_iterator
- rend()
+ reverse_iterator
+ rend()
{ return reverse_iterator(begin()); }
- const_reverse_iterator
- rend() const
+ const_reverse_iterator
+ rend() const
{ return const_reverse_iterator(begin()); }
// capacity:
using _Base::max_size;
// modifiers:
- iterator
+ iterator
insert(const value_type& __x)
{ return iterator(_Base::insert(__x), this); }
- iterator
+ iterator
insert(iterator __position, const value_type& __x)
{
__glibcxx_check_insert(__position);
}
template<typename _InputIterator>
- void
+ void
insert(_InputIterator __first, _InputIterator __last)
{
__glibcxx_check_valid_range(__first, __last);
_Base::insert(__first, __last);
}
- void
+ void
erase(iterator __position)
{
__glibcxx_check_erase(__position);
return __count;
}
- void
+ void
erase(iterator __first, iterator __last)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
this->erase(__first++);
}
- void
+ void
swap(multiset<_Key,_Compare,_Allocator>& __x)
{
_Base::swap(__x);
this->_M_swap(__x);
}
- void
+ void
clear()
{ this->erase(begin(), end()); }
using _Base::value_comp;
// multiset operations:
- iterator
+ iterator
find(const key_type& __x)
{ return iterator(_Base::find(__x), this); }
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 214. set::find() missing const overload
- const_iterator
+ const_iterator
find(const key_type& __x) const
{ return const_iterator(_Base::find(__x), this); }
using _Base::count;
- iterator
+ iterator
lower_bound(const key_type& __x)
{ return iterator(_Base::lower_bound(__x), this); }
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 214. set::find() missing const overload
- const_iterator
+ const_iterator
lower_bound(const key_type& __x) const
{ return const_iterator(_Base::lower_bound(__x), this); }
- iterator
+ iterator
upper_bound(const key_type& __x)
{ return iterator(_Base::upper_bound(__x), this); }
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 214. set::find() missing const overload
- const_iterator
+ const_iterator
upper_bound(const key_type& __x) const
{ return const_iterator(_Base::upper_bound(__x), this); }
const_iterator(__res.second, this));
}
- _Base&
+ _Base&
_M_base() { return *this; }
- const _Base&
+ const _Base&
_M_base() const { return *this; }
-
+
private:
- void
+ void
_M_invalidate_all()
{
typedef typename _Base::const_iterator _Base_const_iterator;
};
template<typename _Key, typename _Compare, typename _Allocator>
- inline bool
+ inline bool
operator==(const multiset<_Key,_Compare,_Allocator>& __lhs,
const multiset<_Key,_Compare,_Allocator>& __rhs)
{ return __lhs._M_base() == __rhs._M_base(); }
template<typename _Key, typename _Compare, typename _Allocator>
- inline bool
+ inline bool
operator!=(const multiset<_Key,_Compare,_Allocator>& __lhs,
const multiset<_Key,_Compare,_Allocator>& __rhs)
{ return __lhs._M_base() != __rhs._M_base(); }
template<typename _Key, typename _Compare, typename _Allocator>
- inline bool
+ inline bool
operator<(const multiset<_Key,_Compare,_Allocator>& __lhs,
const multiset<_Key,_Compare,_Allocator>& __rhs)
{ return __lhs._M_base() < __rhs._M_base(); }
template<typename _Key, typename _Compare, typename _Allocator>
- inline bool
+ inline bool
operator<=(const multiset<_Key,_Compare,_Allocator>& __lhs,
const multiset<_Key,_Compare,_Allocator>& __rhs)
{ return __lhs._M_base() <= __rhs._M_base(); }
template<typename _Key, typename _Compare, typename _Allocator>
- inline bool
+ inline bool
operator>=(const multiset<_Key,_Compare,_Allocator>& __lhs,
const multiset<_Key,_Compare,_Allocator>& __rhs)
{ return __lhs._M_base() >= __rhs._M_base(); }
template<typename _Key, typename _Compare, typename _Allocator>
- inline bool
+ inline bool
operator>(const multiset<_Key,_Compare,_Allocator>& __lhs,
const multiset<_Key,_Compare,_Allocator>& __rhs)
{ return __lhs._M_base() > __rhs._M_base(); }
* singular because of an operation on the container). This
* version number must equal the version number in the sequence
* referenced by _M_sequence for the iterator to be
- * non-singular.
+ * non-singular.
*/
unsigned int _M_version;
protected:
/** Initializes the iterator and makes it singular. */
- _Safe_iterator_base()
+ _Safe_iterator_base()
: _M_sequence(0), _M_version(0), _M_prior(0), _M_next(0)
{ }
* constant iterator, and false if it is a mutable iterator. Note
* that @p __seq may be NULL, in which case the iterator will be
* singular. Otherwise, the iterator will reference @p __seq and
- * be nonsingular.
+ * be nonsingular.
*/
_Safe_iterator_base(const _Safe_sequence_base* __seq, bool __constant)
: _M_sequence(0), _M_version(0), _M_prior(0), _M_next(0)
* from whatever sequence it was attached to originally. If the
* new sequence is the NULL pointer, the iterator is left
* unattached.
- */
+ */
void _M_attach(_Safe_sequence_base* __seq, bool __constant);
/** Detach the iterator for whatever sequence it is attached to,
- * if any.
+ * if any.
*/
void _M_detach();
public:
/// The list of mutable iterators that reference this container
_Safe_iterator_base* _M_iterators;
-
+
/// The list of constant iterators that reference this container
_Safe_iterator_base* _M_const_iterators;
-
+
/// The container version number. This number may never be 0.
mutable unsigned int _M_version;
-
+
protected:
// Initialize with a version number of 1 and no iterators
_Safe_sequence_base()
: _M_iterators(0), _M_const_iterators(0), _M_version(1)
{ }
-
+
/** Notify all iterators that reference this sequence that the
sequence is being destroyed. */
~_Safe_sequence_base()
{ this->_M_detach_all(); }
-
+
/** Detach all iterators, leaving them singular. */
- void
+ void
_M_detach_all();
-
- /** Detach all singular iterators.
- * @post for all iterators i attached to this sequence,
+
+ /** Detach all singular iterators.
+ * @post for all iterators i attached to this sequence,
* i->_M_version == _M_version.
*/
void
_M_detach_singular();
-
+
/** Revalidates all attached singular iterators. This method may
* be used to validate iterators that were invalidated before
* (but for some reasion, such as an exception, need to become
*/
void
_M_revalidate_singular();
-
+
/** Swap this sequence with the given sequence. This operation
* also swaps ownership of the iterators, so that when the
* operation is complete all iterators that originally referenced
* one container now reference the other container.
*/
- void
+ void
_M_swap(_Safe_sequence_base& __x);
-
+
public:
/** Invalidates all iterators. */
- void
+ void
_M_invalidate_all() const
{ if (++_M_version == 0) _M_version = 1; }
};
} // namespace __gnu_debug
-#endif
+#endif
{
/** Iterators that derive from _Safe_iterator_base but that aren't
* _Safe_iterators can be determined singular or non-singular via
- * _Safe_iterator_base.
+ * _Safe_iterator_base.
*/
inline bool __check_singular_aux(const _Safe_iterator_base* __x)
{ return __x->_M_singular(); }
-
+
/** \brief Safe iterator wrapper.
- *
+ *
* The class template %_Safe_iterator is a wrapper around an
* iterator that tracks the iterator's movement among sequences and
* checks that operations performed on the "safe" iterator are
__dp_sign, //< Can determine equality and ordering
__dp_exact //< Can determine distance precisely
};
-
+
/// The underlying iterator
_Iterator _M_current;
/// Determine if this is a constant iterator.
- bool
+ bool
_M_constant() const
{
typedef typename _Sequence::const_iterator const_iterator;
*/
_Safe_iterator(const _Iterator& __i, const _Sequence* __seq)
: _Safe_iterator_base(__seq, _M_constant()), _M_current(__i)
- {
+ {
_GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),
_M_message(__msg_init_singular)
._M_iterator(*this, "this"));
*/
_Safe_iterator(const _Safe_iterator& __x)
: _Safe_iterator_base(__x, _M_constant()), _M_current(__x._M_current)
- {
+ {
_GLIBCXX_DEBUG_VERIFY(!__x._M_singular(),
_M_message(__msg_init_copy_singular)
._M_iterator(*this, "this")
._M_iterator(__x, "other"));
}
- /**
+ /**
* @brief Converting constructor from a mutable iterator to a
* constant iterator.
*
template<typename _MutableIterator>
_Safe_iterator(const _Safe_iterator<_MutableIterator, _Sequence>& __x)
: _Safe_iterator_base(__x, _M_constant()), _M_current(__x.base())
- {
+ {
_GLIBCXX_DEBUG_VERIFY(!__x._M_singular(),
_M_message(__msg_init_const_singular)
._M_iterator(*this, "this")
* @brief Copy assignment.
* @pre @p x is not singular
*/
- _Safe_iterator&
+ _Safe_iterator&
operator=(const _Safe_iterator& __x)
{
_GLIBCXX_DEBUG_VERIFY(!__x._M_singular(),
* @brief Iterator dereference.
* @pre iterator is dereferenceable
*/
- reference
- operator*() const
+ reference
+ operator*() const
{
_GLIBCXX_DEBUG_VERIFY(this->_M_dereferenceable(),
* @todo Make this correct w.r.t. iterators that return proxies
* @todo Use addressof() instead of & operator
*/
- pointer
+ pointer
operator->() const
{
_GLIBCXX_DEBUG_VERIFY(this->_M_dereferenceable(),
* @brief Iterator preincrement
* @pre iterator is incrementable
*/
- _Safe_iterator&
+ _Safe_iterator&
operator++()
{
_GLIBCXX_DEBUG_VERIFY(this->_M_incrementable(),
* @brief Iterator postincrement
* @pre iterator is incrementable
*/
- _Safe_iterator
+ _Safe_iterator
operator++(int)
{
_GLIBCXX_DEBUG_VERIFY(this->_M_incrementable(),
* @brief Iterator predecrement
* @pre iterator is decrementable
*/
- _Safe_iterator&
+ _Safe_iterator&
operator--()
{
_GLIBCXX_DEBUG_VERIFY(this->_M_decrementable(),
* @brief Iterator postdecrement
* @pre iterator is decrementable
*/
- _Safe_iterator
+ _Safe_iterator
operator--(int)
{
_GLIBCXX_DEBUG_VERIFY(this->_M_decrementable(),
}
// ------ Random access iterator requirements ------
- reference
+ reference
operator[](const difference_type& __n) const
{
- _GLIBCXX_DEBUG_VERIFY(this->_M_can_advance(__n)
+ _GLIBCXX_DEBUG_VERIFY(this->_M_can_advance(__n)
&& this->_M_can_advance(__n+1),
_M_message(__msg_iter_subscript_oob)
._M_iterator(*this)._M_integer(__n));
return _M_current[__n];
}
- _Safe_iterator&
+ _Safe_iterator&
operator+=(const difference_type& __n)
{
_GLIBCXX_DEBUG_VERIFY(this->_M_can_advance(__n),
return *this;
}
- _Safe_iterator
+ _Safe_iterator
operator+(const difference_type& __n) const
{
_Safe_iterator __tmp(*this);
return __tmp;
}
- _Safe_iterator&
+ _Safe_iterator&
operator-=(const difference_type& __n)
{
_GLIBCXX_DEBUG_VERIFY(this->_M_can_advance(-__n),
return *this;
}
- _Safe_iterator
+ _Safe_iterator
operator-(const difference_type& __n) const
{
_Safe_iterator __tmp(*this);
// ------ Utilities ------
/**
* @brief Return the underlying iterator
- */
- _Iterator
+ */
+ _Iterator
base() const { return _M_current; }
/**
operator _Iterator() const { return _M_current; }
/** Attach iterator to the given sequence. */
- void
+ void
_M_attach(const _Sequence* __seq)
- {
+ {
_Safe_iterator_base::_M_attach(const_cast<_Sequence*>(__seq),
- _M_constant());
+ _M_constant());
}
/** Invalidate the iterator, making it singular. */
- void
+ void
_M_invalidate();
/// Is the iterator dereferenceable?
- bool
+ bool
_M_dereferenceable() const
{ return !this->_M_singular() && !_M_is_end(); }
/// Is the iterator incrementable?
- bool
+ bool
_M_incrementable() const { return this->_M_dereferenceable(); }
// Is the iterator decrementable?
- bool
+ bool
_M_decrementable() const { return !_M_singular() && !_M_is_begin(); }
// Can we advance the iterator @p __n steps (@p __n may be negative)
- bool
+ bool
_M_can_advance(const difference_type& __n) const;
// Is the iterator range [*this, __rhs) valid?
template<typename _Other>
- bool
+ bool
_M_valid_range(const _Safe_iterator<_Other, _Sequence>& __rhs) const;
// The sequence this iterator references.
- const _Sequence*
+ const _Sequence*
_M_get_sequence() const
{ return static_cast<const _Sequence*>(_M_sequence); }
/** Determine the distance between two iterators with some known
- * precision.
+ * precision.
*/
template<typename _Iterator1, typename _Iterator2>
static pair<difference_type, _Distance_precision>
template<typename _Iterator1, typename _Iterator2>
static pair<difference_type, _Distance_precision>
_M_get_distance(const _Iterator1& __lhs, const _Iterator2& __rhs,
- std::forward_iterator_tag)
+ std::forward_iterator_tag)
{
- return std::make_pair(__lhs.base() == __rhs.base()? 0 : 1,
+ return std::make_pair(__lhs.base() == __rhs.base()? 0 : 1,
__dp_equality);
}
template<typename _IteratorL, typename _IteratorR, typename _Sequence>
inline bool
operator==(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
- const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
- {
+ const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
+ {
_GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
_M_message(__msg_iter_compare_bad)
._M_iterator(__lhs, "lhs")
_M_message(__msg_compare_different)
._M_iterator(__lhs, "lhs")
._M_iterator(__rhs, "rhs"));
- return __lhs.base() == __rhs.base();
+ return __lhs.base() == __rhs.base();
}
template<typename _Iterator, typename _Sequence>
inline bool
operator==(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
const _Safe_iterator<_Iterator, _Sequence>& __rhs)
- {
+ {
_GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
_M_message(__msg_iter_compare_bad)
._M_iterator(__lhs, "lhs")
_M_message(__msg_compare_different)
._M_iterator(__lhs, "lhs")
._M_iterator(__rhs, "rhs"));
- return __lhs.base() == __rhs.base();
+ return __lhs.base() == __rhs.base();
}
template<typename _IteratorL, typename _IteratorR, typename _Sequence>
inline bool
operator!=(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
- const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
- {
+ const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
+ {
_GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
_M_message(__msg_iter_compare_bad)
._M_iterator(__lhs, "lhs")
_M_message(__msg_compare_different)
._M_iterator(__lhs, "lhs")
._M_iterator(__rhs, "rhs"));
- return __lhs.base() != __rhs.base();
+ return __lhs.base() != __rhs.base();
}
template<typename _Iterator, typename _Sequence>
inline bool
operator!=(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
const _Safe_iterator<_Iterator, _Sequence>& __rhs)
- {
+ {
_GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
_M_message(__msg_iter_compare_bad)
._M_iterator(__lhs, "lhs")
_M_message(__msg_compare_different)
._M_iterator(__lhs, "lhs")
._M_iterator(__rhs, "rhs"));
- return __lhs.base() != __rhs.base();
+ return __lhs.base() != __rhs.base();
}
template<typename _IteratorL, typename _IteratorR, typename _Sequence>
inline bool
operator<(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
- {
+ {
_GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
_M_message(__msg_iter_order_bad)
._M_iterator(__lhs, "lhs")
_M_message(__msg_order_different)
._M_iterator(__lhs, "lhs")
._M_iterator(__rhs, "rhs"));
- return __lhs.base() < __rhs.base();
+ return __lhs.base() < __rhs.base();
}
template<typename _Iterator, typename _Sequence>
inline bool
operator<(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
const _Safe_iterator<_Iterator, _Sequence>& __rhs)
- {
+ {
_GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
_M_message(__msg_iter_order_bad)
._M_iterator(__lhs, "lhs")
_M_message(__msg_order_different)
._M_iterator(__lhs, "lhs")
._M_iterator(__rhs, "rhs"));
- return __lhs.base() < __rhs.base();
+ return __lhs.base() < __rhs.base();
}
template<typename _IteratorL, typename _IteratorR, typename _Sequence>
inline bool
operator<=(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
- const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
- {
+ const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
+ {
_GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
_M_message(__msg_iter_order_bad)
._M_iterator(__lhs, "lhs")
_M_message(__msg_order_different)
._M_iterator(__lhs, "lhs")
._M_iterator(__rhs, "rhs"));
- return __lhs.base() <= __rhs.base();
+ return __lhs.base() <= __rhs.base();
}
template<typename _Iterator, typename _Sequence>
inline bool
operator<=(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
const _Safe_iterator<_Iterator, _Sequence>& __rhs)
- {
+ {
_GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
_M_message(__msg_iter_order_bad)
._M_iterator(__lhs, "lhs")
_M_message(__msg_order_different)
._M_iterator(__lhs, "lhs")
._M_iterator(__rhs, "rhs"));
- return __lhs.base() <= __rhs.base();
+ return __lhs.base() <= __rhs.base();
}
template<typename _IteratorL, typename _IteratorR, typename _Sequence>
inline bool
operator>(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
- {
+ {
_GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
_M_message(__msg_iter_order_bad)
._M_iterator(__lhs, "lhs")
_M_message(__msg_order_different)
._M_iterator(__lhs, "lhs")
._M_iterator(__rhs, "rhs"));
- return __lhs.base() > __rhs.base();
+ return __lhs.base() > __rhs.base();
}
template<typename _Iterator, typename _Sequence>
inline bool
operator>(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
const _Safe_iterator<_Iterator, _Sequence>& __rhs)
- {
+ {
_GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
_M_message(__msg_iter_order_bad)
._M_iterator(__lhs, "lhs")
_M_message(__msg_order_different)
._M_iterator(__lhs, "lhs")
._M_iterator(__rhs, "rhs"));
- return __lhs.base() > __rhs.base();
+ return __lhs.base() > __rhs.base();
}
template<typename _IteratorL, typename _IteratorR, typename _Sequence>
inline bool
operator>=(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
- const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
- {
+ const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
+ {
_GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
_M_message(__msg_iter_order_bad)
._M_iterator(__lhs, "lhs")
_M_message(__msg_order_different)
._M_iterator(__lhs, "lhs")
._M_iterator(__rhs, "rhs"));
- return __lhs.base() >= __rhs.base();
+ return __lhs.base() >= __rhs.base();
}
template<typename _Iterator, typename _Sequence>
inline bool
operator>=(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
const _Safe_iterator<_Iterator, _Sequence>& __rhs)
- {
+ {
_GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
_M_message(__msg_iter_order_bad)
._M_iterator(__lhs, "lhs")
_M_message(__msg_order_different)
._M_iterator(__lhs, "lhs")
._M_iterator(__rhs, "rhs"));
- return __lhs.base() >= __rhs.base();
+ return __lhs.base() >= __rhs.base();
}
// _GLIBCXX_RESOLVE_LIB_DEFECTS
inline typename _Safe_iterator<_IteratorL, _Sequence>::difference_type
operator-(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
- {
+ {
_GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
_M_message(__msg_distance_bad)
._M_iterator(__lhs, "lhs")
_M_message(__msg_distance_different)
._M_iterator(__lhs, "lhs")
._M_iterator(__rhs, "rhs"));
- return __lhs.base() - __rhs.base();
+ return __lhs.base() - __rhs.base();
}
template<typename _Iterator, typename _Sequence>
#ifndef _GLIBCXX_EXPORT_TEMPLATE
# include <debug/safe_iterator.tcc>
-#endif
+#endif
#endif
namespace __gnu_debug
{
template<typename _Iterator, typename _Sequence>
- bool
+ bool
_Safe_iterator<_Iterator, _Sequence>::
_M_can_advance(const difference_type& __n) const
{
typedef typename _Sequence::const_iterator const_iterator;
-
+
if (this->_M_singular())
return false;
if (__n == 0)
return true;
- if (__n < 0)
+ if (__n < 0)
{
- const_iterator __begin =
+ const_iterator __begin =
static_cast<const _Sequence*>(_M_sequence)->begin();
pair<difference_type, _Distance_precision> __dist =
this->_M_get_distance(__begin, *this);
}
else
{
- const_iterator __end =
+ const_iterator __end =
static_cast<const _Sequence*>(_M_sequence)->end();
- pair<difference_type, _Distance_precision> __dist =
+ pair<difference_type, _Distance_precision> __dist =
this->_M_get_distance(*this, __end);
bool __ok = (__dist.second == __dp_exact && __dist.first >= __n
|| __dist.second != __dp_exact && __dist.first > 0);
return __ok;
}
}
-
+
template<typename _Iterator, typename _Sequence>
template<typename _Other>
- bool
+ bool
_Safe_iterator<_Iterator, _Sequence>::
_M_valid_range(const _Safe_iterator<_Other, _Sequence>& __rhs) const
{
if (!_M_can_compare(__rhs))
return false;
-
+
/* Determine if we can order the iterators without the help of
the container */
- pair<difference_type, _Distance_precision> __dist =
+ pair<difference_type, _Distance_precision> __dist =
this->_M_get_distance(*this, __rhs);
switch (__dist.second) {
case __dp_equality:
if (__dist.first == 0)
return true;
break;
-
+
case __dp_sign:
case __dp_exact:
return __dist.first >= 0;
}
-
+
/* We can only test for equality, but check if one of the
iterators is at an extreme. */
if (_M_is_begin() || __rhs._M_is_end())
return true;
else 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;
}
{
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; )
}
} // namespace __gnu_debug
-#endif
+#endif
namespace __gnu_debug
{
- template<typename _Iterator, typename _Sequence>
+ template<typename _Iterator, typename _Sequence>
class _Safe_iterator;
/** A simple function object that returns true if the passed-in
* value is not equal to the stored value. It saves typing over
- * using both bind1st and not_equal.
+ * using both bind1st and not_equal.
*/
template<typename _Type>
class _Not_equal_to
{
_Type __value;
-
+
public:
explicit _Not_equal_to(const _Type& __v) : __value(__v) { }
-
- bool
- operator()(const _Type& __x) const
+
+ 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>
{
typedef typename std::iterator_traits<_Iterator>::difference_type
difference_type;
-
+
_Iterator _M_base;
difference_type _M_n;
-
+
public:
_After_nth_from(const difference_type& __n, const _Iterator& __base)
: _M_base(__base), _M_n(__n) { }
-
- bool
+
+ bool
operator()(const _Iterator& __x) const
{ return __x - _M_base >= _M_n; }
};
-
+
/**
* @brief Base class for constructing a "safe" sequence type that
* tracks iterators that reference it.
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. */
- template<typename _Predicate>
- void
+ template<typename _Predicate>
+ void
_M_invalidate_if(_Predicate __pred);
/** Transfers all iterators that reference this memory location
};
template<typename _Sequence>
- template<typename _Predicate>
- void
+ template<typename _Predicate>
+ void
_Safe_sequence<_Sequence>::
_M_invalidate_if(_Predicate __pred)
{
typedef typename _Sequence::iterator iterator;
typedef typename _Sequence::const_iterator const_iterator;
-
+
for (_Safe_iterator_base* __iter = _M_iterators; __iter; )
{
iterator* __victim = static_cast<iterator*>(__iter);
__iter = __iter->_M_next;
- if (!__victim->_M_singular())
+ if (!__victim->_M_singular())
{
if (__pred(__victim->base()))
__victim->_M_invalidate();
{
const_iterator* __victim = static_cast<const_iterator*>(__iter);
__iter = __iter->_M_next;
- if (!__victim->_M_singular())
+ if (!__victim->_M_singular())
{
if (__pred(__victim->base()))
__victim->_M_invalidate();
}
- }
+ }
}
template<typename _Sequence>
typedef typename _Sequence::iterator iterator;
typedef typename _Sequence::const_iterator const_iterator;
-
+
for (_Safe_iterator_base* __iter = __from->_M_iterators; __iter; )
{
iterator* __victim = static_cast<iterator*>(__iter);
}
} // namespace __gnu_debug
-#endif
+#endif
{
typedef __gnu_norm::set<_Key,_Compare,_Allocator> _Base;
typedef __gnu_debug::_Safe_sequence<set> _Safe_base;
-
+
public:
// types:
- typedef _Key key_type;
- typedef _Key value_type;
- typedef _Compare key_compare;
- typedef _Compare value_compare;
- typedef _Allocator allocator_type;
+ typedef _Key key_type;
+ typedef _Key value_type;
+ typedef _Compare key_compare;
+ typedef _Compare value_compare;
+ typedef _Allocator allocator_type;
typedef typename _Allocator::reference reference;
typedef typename _Allocator::const_reference const_reference;
-
- typedef __gnu_debug::_Safe_iterator<typename _Base::iterator, set>
+
+ typedef __gnu_debug::_Safe_iterator<typename _Base::iterator, set>
iterator;
typedef __gnu_debug::_Safe_iterator<typename _Base::const_iterator, set>
const_iterator;
typedef typename _Allocator::const_pointer const_pointer;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-
+
// 23.3.3.1 construct/copy/destroy:
explicit set(const _Compare& __comp = _Compare(),
const _Allocator& __a = _Allocator())
: _Base(__comp, __a) { }
-
+
template<typename _InputIterator>
set(_InputIterator __first, _InputIterator __last,
const _Compare& __comp = _Compare(),
: _Base(__gnu_debug::__check_valid_range(__first, __last), __last,
__comp, __a) { }
- set(const set<_Key,_Compare,_Allocator>& __x)
+ set(const set<_Key,_Compare,_Allocator>& __x)
: _Base(__x), _Safe_base() { }
-
+
set(const _Base& __x) : _Base(__x), _Safe_base() { }
-
+
~set() { }
-
- set<_Key,_Compare,_Allocator>&
+
+ set<_Key,_Compare,_Allocator>&
operator=(const set<_Key,_Compare,_Allocator>& __x)
{
*static_cast<_Base*>(this) = __x;
this->_M_invalidate_all();
return *this;
}
-
+
using _Base::get_allocator;
-
+
// iterators:
- iterator
- begin()
+ iterator
+ begin()
{ return iterator(_Base::begin(), this); }
-
- const_iterator
- begin() const
+
+ const_iterator
+ begin() const
{ return const_iterator(_Base::begin(), this); }
-
- iterator
+
+ iterator
end()
{ return iterator(_Base::end(), this); }
-
- const_iterator
- end() const
+
+ const_iterator
+ end() const
{ return const_iterator(_Base::end(), this); }
-
- reverse_iterator
+
+ reverse_iterator
rbegin()
{ return reverse_iterator(end()); }
-
- const_reverse_iterator
+
+ const_reverse_iterator
rbegin() const
{ return const_reverse_iterator(end()); }
-
- reverse_iterator
- rend()
+
+ reverse_iterator
+ rend()
{ return reverse_iterator(begin()); }
-
- const_reverse_iterator
- rend() const
+
+ const_reverse_iterator
+ rend() const
{ return const_reverse_iterator(begin()); }
-
+
// capacity:
using _Base::empty;
using _Base::size;
using _Base::max_size;
-
+
// modifiers:
- std::pair<iterator, bool>
+ std::pair<iterator, bool>
insert(const value_type& __x)
{
typedef typename _Base::iterator _Base_iterator;
return std::pair<iterator, bool>(iterator(__res.first, this),
__res.second);
}
-
- iterator
+
+ iterator
insert(iterator __position, const value_type& __x)
{
__glibcxx_check_insert(__position);
return iterator(_Base::insert(__position.base(), __x), this);
}
-
+
template <typename _InputIterator>
- void
+ void
insert(_InputIterator __first, _InputIterator __last)
{
__glibcxx_check_valid_range(__first, __last);
_Base::insert(__first, __last);
}
-
- void
+
+ void
erase(iterator __position)
{
__glibcxx_check_erase(__position);
__position._M_invalidate();
_Base::erase(__position.base());
}
-
- size_type
+
+ size_type
erase(const key_type& __x)
{
iterator __victim = find(__x);
return 1;
}
}
-
- void
+
+ void
erase(iterator __first, iterator __last)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 151. can't currently clear() empty container
__glibcxx_check_erase_range(__first, __last);
-
+
while (__first != __last)
this->erase(__first++);
}
-
- void
+
+ void
swap(set<_Key,_Compare,_Allocator>& __x)
{
_Base::swap(__x);
this->_M_swap(__x);
}
-
- void
+
+ void
clear()
{ this->erase(begin(), end()); }
-
+
// observers:
using _Base::key_comp;
using _Base::value_comp;
-
+
// set operations:
- iterator
+ iterator
find(const key_type& __x)
{ return iterator(_Base::find(__x), this); }
-
+
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 214. set::find() missing const overload
- const_iterator
+ const_iterator
find(const key_type& __x) const
{ return const_iterator(_Base::find(__x), this); }
-
+
using _Base::count;
-
- iterator
+
+ iterator
lower_bound(const key_type& __x)
{ return iterator(_Base::lower_bound(__x), this); }
-
+
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 214. set::find() missing const overload
- const_iterator
+ const_iterator
lower_bound(const key_type& __x) const
{ return const_iterator(_Base::lower_bound(__x), this); }
-
- iterator
+
+ iterator
upper_bound(const key_type& __x)
{ return iterator(_Base::upper_bound(__x), this); }
-
+
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 214. set::find() missing const overload
- const_iterator
+ const_iterator
upper_bound(const key_type& __x) const
{ return const_iterator(_Base::upper_bound(__x), this); }
-
+
std::pair<iterator,iterator>
equal_range(const key_type& __x)
{
return std::make_pair(iterator(__res.first, this),
iterator(__res.second, this));
}
-
+
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 214. set::find() missing const overload
std::pair<const_iterator,const_iterator>
return std::make_pair(const_iterator(__res.first, this),
const_iterator(__res.second, this));
}
-
- _Base&
+
+ _Base&
_M_base() { return *this; }
- const _Base&
+ const _Base&
_M_base() const { return *this; }
-
+
private:
- void
+ void
_M_invalidate_all()
{
typedef typename _Base::const_iterator _Base_const_iterator;
this->_M_invalidate_if(_Not_equal(_M_base().end()));
}
};
-
+
template<typename _Key, typename _Compare, typename _Allocator>
- inline bool
+ inline bool
operator==(const set<_Key,_Compare,_Allocator>& __lhs,
const set<_Key,_Compare,_Allocator>& __rhs)
{ return __lhs._M_base() == __rhs._M_base(); }
template<typename _Key, typename _Compare, typename _Allocator>
- inline bool
+ inline bool
operator!=(const set<_Key,_Compare,_Allocator>& __lhs,
const set<_Key,_Compare,_Allocator>& __rhs)
{ return __lhs._M_base() != __rhs._M_base(); }
template<typename _Key, typename _Compare, typename _Allocator>
- inline bool
+ inline bool
operator<(const set<_Key,_Compare,_Allocator>& __lhs,
const set<_Key,_Compare,_Allocator>& __rhs)
{ return __lhs._M_base() < __rhs._M_base(); }
template<typename _Key, typename _Compare, typename _Allocator>
- inline bool
+ inline bool
operator<=(const set<_Key,_Compare,_Allocator>& __lhs,
const set<_Key,_Compare,_Allocator>& __rhs)
{ return __lhs._M_base() <= __rhs._M_base(); }
template<typename _Key, typename _Compare, typename _Allocator>
- inline bool
+ inline bool
operator>=(const set<_Key,_Compare,_Allocator>& __lhs,
const set<_Key,_Compare,_Allocator>& __rhs)
{ return __lhs._M_base() >= __rhs._M_base(); }
template<typename _Key, typename _Compare, typename _Allocator>
- inline bool
+ inline bool
operator>(const set<_Key,_Compare,_Allocator>& __lhs,
const set<_Key,_Compare,_Allocator>& __rhs)
{ return __lhs._M_base() > __rhs._M_base(); }
template<typename _Key, typename _Compare, typename _Allocator>
void
- swap(set<_Key,_Compare,_Allocator>& __x,
+ swap(set<_Key,_Compare,_Allocator>& __x,
set<_Key,_Compare,_Allocator>& __y)
{ return __x.swap(__y); }
} // namespace __gnu_debug_def
namespace __gnu_debug
{
template<typename _CharT, typename _Traits, typename _Allocator>
- class basic_string
+ class basic_string
: public std::basic_string<_CharT, _Traits, _Allocator>,
public __gnu_debug::_Safe_sequence<basic_string<_CharT, _Traits,
_Allocator> >
public:
// types:
- typedef _Traits traits_type;
- typedef typename _Traits::char_type value_type;
- typedef _Allocator allocator_type;
+ typedef _Traits traits_type;
+ typedef typename _Traits::char_type value_type;
+ typedef _Allocator allocator_type;
typedef typename _Allocator::size_type size_type;
typedef typename _Allocator::difference_type difference_type;
typedef typename _Allocator::reference reference;
typedef __gnu_debug::_Safe_iterator<typename _Base::iterator, basic_string>
iterator;
- typedef __gnu_debug::_Safe_iterator<typename _Base::const_iterator,
+ typedef __gnu_debug::_Safe_iterator<typename _Base::const_iterator,
basic_string> const_iterator;
typedef std::reverse_iterator<iterator> reverse_iterator;
basic_string(const _Base& __base) : _Base(__base), _Safe_base() { }
// _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 42. string ctors specify wrong default allocator
+ // 42. string ctors specify wrong default allocator
basic_string(const basic_string& __str)
: _Base(__str, 0, _Base::npos, __str.get_allocator()), _Safe_base()
{ }
// _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 42. string ctors specify wrong default allocator
+ // 42. string ctors specify wrong default allocator
basic_string(const basic_string& __str, size_type __pos,
size_type __n = _Base::npos,
const _Allocator& __a = _Allocator())
~basic_string() { }
- basic_string&
+ basic_string&
operator=(const basic_string& __str)
{
*static_cast<_Base*>(this) = __str;
return *this;
}
- basic_string&
+ basic_string&
operator=(const _CharT* __s)
{
__glibcxx_check_string(__s);
return *this;
}
- basic_string&
+ basic_string&
operator=(_CharT __c)
{
*static_cast<_Base*>(this) = __c;
}
// 21.3.2 iterators:
- iterator
- begin()
+ iterator
+ begin()
{ return iterator(_Base::begin(), this); }
- const_iterator
- begin() const
+ const_iterator
+ begin() const
{ return const_iterator(_Base::begin(), this); }
- iterator
- end()
+ iterator
+ end()
{ return iterator(_Base::end(), this); }
- const_iterator
+ const_iterator
end() const
{ return const_iterator(_Base::end(), this); }
- reverse_iterator
- rbegin()
+ reverse_iterator
+ rbegin()
{ return reverse_iterator(end()); }
- const_reverse_iterator
+ const_reverse_iterator
rbegin() const
{ return const_reverse_iterator(end()); }
rend()
{ return reverse_iterator(begin()); }
- const_reverse_iterator
- rend() const
+ const_reverse_iterator
+ rend() const
{ return const_reverse_iterator(begin()); }
// 21.3.3 capacity:
using _Base::length;
using _Base::max_size;
- void
+ void
resize(size_type __n, _CharT __c)
{
_Base::resize(__n, __c);
this->_M_invalidate_all();
}
- void
+ void
resize(size_type __n)
{ this->resize(__n, _CharT()); }
using _Base::capacity;
using _Base::reserve;
- void
+ void
clear()
{
_Base::clear();
using _Base::empty;
// 21.3.4 element access:
- const_reference
+ const_reference
operator[](size_type __pos) const
{
_GLIBCXX_DEBUG_VERIFY(__pos <= this->size(),
return _M_base()[__pos];
}
- reference
+ reference
operator[](size_type __pos)
{
__glibcxx_check_subscript(__pos);
using _Base::at;
// 21.3.5 modifiers:
- basic_string&
+ basic_string&
operator+=(const basic_string& __str)
{
_M_base() += __str;
return *this;
}
- basic_string&
+ basic_string&
operator+=(const _CharT* __s)
{
__glibcxx_check_string(__s);
return *this;
}
- basic_string&
+ basic_string&
operator+=(_CharT __c)
{
_M_base() += __c;
return *this;
}
- basic_string&
+ basic_string&
append(const basic_string& __str)
{
_Base::append(__str);
return *this;
}
- basic_string&
+ basic_string&
append(const basic_string& __str, size_type __pos, size_type __n)
{
_Base::append(__str, __pos, __n);
return *this;
}
- basic_string&
+ basic_string&
append(const _CharT* __s, size_type __n)
{
__glibcxx_check_string_len(__s, __n);
return *this;
}
- basic_string&
+ basic_string&
append(const _CharT* __s)
{
__glibcxx_check_string(__s);
return *this;
}
- basic_string&
+ basic_string&
append(size_type __n, _CharT __c)
{
_Base::append(__n, __c);
}
template<typename _InputIterator>
- basic_string&
+ basic_string&
append(_InputIterator __first, _InputIterator __last)
{
__glibcxx_check_valid_range(__first, __last);
}
// _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 7. string clause minor problems
- void
+ // 7. string clause minor problems
+ void
push_back(_CharT __c)
{
_Base::push_back(__c);
this->_M_invalidate_all();
}
- basic_string&
+ basic_string&
assign(const basic_string& __x)
{
_Base::assign(__x);
return *this;
}
- basic_string&
+ basic_string&
assign(const basic_string& __str, size_type __pos, size_type __n)
{
_Base::assign(__str, __pos, __n);
return *this;
}
- basic_string&
+ basic_string&
assign(const _CharT* __s, size_type __n)
{
__glibcxx_check_string_len(__s, __n);
return *this;
}
- basic_string&
+ basic_string&
assign(const _CharT* __s)
{
__glibcxx_check_string(__s);
return *this;
}
- basic_string&
+ basic_string&
assign(size_type __n, _CharT __c)
{
_Base::assign(__n, __c);
this->_M_invalidate_all();
- return *this;
+ return *this;
}
template<typename _InputIterator>
- basic_string&
+ basic_string&
assign(_InputIterator __first, _InputIterator __last)
{
__glibcxx_check_valid_range(__first, __last);
_Base::assign(__first, __last);
this->_M_invalidate_all();
- return *this;
+ return *this;
}
- basic_string&
+ basic_string&
insert(size_type __pos1, const basic_string& __str)
{
_Base::insert(__pos1, __str);
return *this;
}
- basic_string&
+ basic_string&
insert(size_type __pos1, const basic_string& __str,
size_type __pos2, size_type __n)
{
return *this;
}
- basic_string&
+ basic_string&
insert(size_type __pos, const _CharT* __s, size_type __n)
{
__glibcxx_check_string(__s);
return *this;
}
- basic_string&
+ basic_string&
insert(size_type __pos, const _CharT* __s)
{
__glibcxx_check_string(__s);
_Base::insert(__pos, __s);
this->_M_invalidate_all();
- return *this;
+ return *this;
}
- basic_string&
+ basic_string&
insert(size_type __pos, size_type __n, _CharT __c)
{
_Base::insert(__pos, __n, __c);
return *this;
}
- iterator
+ iterator
insert(iterator __p, _CharT __c)
{
__glibcxx_check_insert(__p);
return iterator(__res, this);
}
- void
+ void
insert(iterator __p, size_type __n, _CharT __c)
{
__glibcxx_check_insert(__p);
}
template<typename _InputIterator>
- void
+ void
insert(iterator __p, _InputIterator __first, _InputIterator __last)
{
__glibcxx_check_insert_range(__p, __first, __last);
this->_M_invalidate_all();
}
- basic_string&
+ basic_string&
erase(size_type __pos = 0, size_type __n = _Base::npos)
{
_Base::erase(__pos, __n);
return *this;
}
- iterator
+ iterator
erase(iterator __position)
{
__glibcxx_check_erase(__position);
return iterator(__res, this);
}
- iterator
+ iterator
erase(iterator __first, iterator __last)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
return iterator(__res, this);
}
- basic_string&
+ basic_string&
replace(size_type __pos1, size_type __n1, const basic_string& __str)
{
_Base::replace(__pos1, __n1, __str);
return *this;
}
- basic_string&
+ basic_string&
replace(size_type __pos1, size_type __n1, const basic_string& __str,
size_type __pos2, size_type __n2)
{
return *this;
}
- basic_string&
- replace(size_type __pos, size_type __n1, const _CharT* __s,
+ basic_string&
+ replace(size_type __pos, size_type __n1, const _CharT* __s,
size_type __n2)
{
__glibcxx_check_string_len(__s, __n2);
return *this;
}
- basic_string&
+ basic_string&
replace(size_type __pos, size_type __n1, const _CharT* __s)
{
__glibcxx_check_string(__s);
return *this;
}
- basic_string&
+ basic_string&
replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
{
_Base::replace(__pos, __n1, __n2, __c);
return *this;
}
- basic_string&
+ basic_string&
replace(iterator __i1, iterator __i2, const basic_string& __str)
{
__glibcxx_check_erase_range(__i1, __i2);
this->_M_invalidate_all();
return *this;
}
-
- basic_string&
+
+ basic_string&
replace(iterator __i1, iterator __i2, const _CharT* __s, size_type __n)
{
__glibcxx_check_erase_range(__i1, __i2);
return *this;
}
- basic_string&
+ basic_string&
replace(iterator __i1, iterator __i2, const _CharT* __s)
{
__glibcxx_check_erase_range(__i1, __i2);
return *this;
}
- basic_string&
+ basic_string&
replace(iterator __i1, iterator __i2, size_type __n, _CharT __c)
{
__glibcxx_check_erase_range(__i1, __i2);
}
template<typename _InputIterator>
- basic_string&
+ basic_string&
replace(iterator __i1, iterator __i2,
_InputIterator __j1, _InputIterator __j2)
{
return *this;
}
- size_type
+ size_type
copy(_CharT* __s, size_type __n, size_type __pos = 0) const
{
__glibcxx_check_string_len(__s, __n);
return _Base::copy(__s, __n, __pos);
}
- void
+ void
swap(basic_string<_CharT,_Traits,_Allocator>& __x)
{
_Base::swap(__x);
}
// 21.3.6 string operations:
- const _CharT*
+ const _CharT*
c_str() const
{
const _CharT* __res = _Base::c_str();
return __res;
}
- const _CharT*
+ const _CharT*
data() const
{
const _CharT* __res = _Base::data();
using _Base::get_allocator;
- size_type
+ size_type
find(const basic_string& __str, size_type __pos = 0) const
{ return _Base::find(__str, __pos); }
- size_type
+ size_type
find(const _CharT* __s, size_type __pos, size_type __n) const
{
__glibcxx_check_string(__s);
return _Base::find(__s, __pos, __n);
}
- size_type
+ size_type
find(const _CharT* __s, size_type __pos = 0) const
{
__glibcxx_check_string(__s);
return _Base::find(__s, __pos);
}
- size_type
+ size_type
find(_CharT __c, size_type __pos = 0) const
{ return _Base::find(__c, __pos); }
- size_type
+ size_type
rfind(const basic_string& __str, size_type __pos = _Base::npos) const
{ return _Base::rfind(__str, __pos); }
- size_type
+ size_type
rfind(const _CharT* __s, size_type __pos, size_type __n) const
- {
+ {
__glibcxx_check_string_len(__s, __n);
return _Base::rfind(__s, __pos, __n);
}
- size_type
+ size_type
rfind(const _CharT* __s, size_type __pos = _Base::npos) const
{
__glibcxx_check_string(__s);
return _Base::rfind(__s, __pos);
}
- size_type
+ size_type
rfind(_CharT __c, size_type __pos = _Base::npos) const
{ return _Base::rfind(__c, __pos); }
-
- size_type
+
+ size_type
find_first_of(const basic_string& __str, size_type __pos = 0) const
{ return _Base::find_first_of(__str, __pos); }
- size_type
+ size_type
find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
- {
+ {
__glibcxx_check_string(__s);
- return _Base::find_first_of(__s, __pos, __n);
+ return _Base::find_first_of(__s, __pos, __n);
}
- size_type
+ size_type
find_first_of(const _CharT* __s, size_type __pos = 0) const
- {
+ {
__glibcxx_check_string(__s);
- return _Base::find_first_of(__s, __pos);
+ return _Base::find_first_of(__s, __pos);
}
- size_type
+ size_type
find_first_of(_CharT __c, size_type __pos = 0) const
{ return _Base::find_first_of(__c, __pos); }
- size_type
+ size_type
find_last_of(const basic_string& __str, size_type __pos = _Base::npos) const
{ return _Base::find_last_of(__str, __pos); }
- size_type
+ size_type
find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
- {
+ {
__glibcxx_check_string(__s);
return _Base::find_last_of(__s, __pos, __n);
}
- size_type
+ size_type
find_last_of(const _CharT* __s, size_type __pos = _Base::npos) const
- {
+ {
__glibcxx_check_string(__s);
return _Base::find_last_of(__s, __pos);
}
- size_type
+ size_type
find_last_of(_CharT __c, size_type __pos = _Base::npos) const
{ return _Base::find_last_of(__c, __pos); }
- size_type
+ size_type
find_first_not_of(const basic_string& __str, size_type __pos = 0) const
{ return _Base::find_first_not_of(__str, __pos); }
- size_type
+ size_type
find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const
{
__glibcxx_check_string_len(__s, __n);
return _Base::find_first_not_of(__s, __pos, __n);
}
- size_type
+ size_type
find_first_not_of(const _CharT* __s, size_type __pos = 0) const
{
__glibcxx_check_string(__s);
return _Base::find_first_not_of(__s, __pos);
}
- size_type
+ size_type
find_first_not_of(_CharT __c, size_type __pos = 0) const
{ return _Base::find_first_not_of(__c, __pos); }
- size_type
+ size_type
find_last_not_of(const basic_string& __str,
size_type __pos = _Base::npos) const
{ return _Base::find_last_not_of(__str, __pos); }
- size_type
+ size_type
find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
{
__glibcxx_check_string(__s);
return _Base::find_last_not_of(__s, __pos, __n);
}
- size_type
+ size_type
find_last_not_of(const _CharT* __s, size_type __pos = _Base::npos) const
{
__glibcxx_check_string(__s);
return _Base::find_last_not_of(__s, __pos);
}
- size_type
+ size_type
find_last_not_of(_CharT __c, size_type __pos = _Base::npos) const
{ return _Base::find_last_not_of(__c, __pos); }
- basic_string
+ basic_string
substr(size_type __pos = 0, size_type __n = _Base::npos) const
{ return basic_string(_Base::substr(__pos, __n)); }
- int
+ int
compare(const basic_string& __str) const
{ return _Base::compare(__str); }
- int
+ int
compare(size_type __pos1, size_type __n1,
const basic_string& __str) const
{ return _Base::compare(__pos1, __n1, __str); }
- int
+ int
compare(size_type __pos1, size_type __n1, const basic_string& __str,
size_type __pos2, size_type __n2) const
{ return _Base::compare(__pos1, __n1, __str, __pos2, __n2); }
- int
+ int
compare(const _CharT* __s) const
{
__glibcxx_check_string(__s);
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 5. string::compare specification questionable
- int
+ int
compare(size_type __pos1, size_type __n1, const _CharT* __s) const
{
__glibcxx_check_string(__s);
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 5. string::compare specification questionable
- int
+ int
compare(size_type __pos1, size_type __n1,const _CharT* __s,
size_type __n2) const
{
return _Base::compare(__pos1, __n1, __s, __n2);
}
- _Base&
+ _Base&
_M_base() { return *this; }
- const _Base&
+ const _Base&
_M_base() const { return *this; }
using _Safe_base::_M_invalidate_all;
inline basic_string<_CharT,_Traits,_Allocator>
operator+(const _CharT* __lhs,
const basic_string<_CharT,_Traits,_Allocator>& __rhs)
- {
+ {
__glibcxx_check_string(__lhs);
return basic_string<_CharT,_Traits,_Allocator>(__lhs) += __rhs;
}
template<typename _CharT, typename _Traits, typename _Allocator>
inline basic_string<_CharT,_Traits,_Allocator>
- operator+(_CharT __lhs,
+ operator+(_CharT __lhs,
const basic_string<_CharT,_Traits,_Allocator>& __rhs)
{ return basic_string<_CharT,_Traits,_Allocator>(1, __lhs) += __rhs; }
inline basic_string<_CharT,_Traits,_Allocator>
operator+(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
const _CharT* __rhs)
- {
+ {
__glibcxx_check_string(__rhs);
- return basic_string<_CharT,_Traits,_Allocator>(__lhs) += __rhs;
+ return basic_string<_CharT,_Traits,_Allocator>(__lhs) += __rhs;
}
template<typename _CharT, typename _Traits, typename _Allocator>
{ return basic_string<_CharT,_Traits,_Allocator>(__lhs) += __rhs; }
template<typename _CharT, typename _Traits, typename _Allocator>
- inline bool
+ inline bool
operator==(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
const basic_string<_CharT,_Traits,_Allocator>& __rhs)
{ return __lhs._M_base() == __rhs._M_base(); }
-
+
template<typename _CharT, typename _Traits, typename _Allocator>
inline bool
operator==(const _CharT* __lhs,
}
template<typename _CharT, typename _Traits, typename _Allocator>
- inline bool
+ inline bool
operator!=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
const basic_string<_CharT,_Traits,_Allocator>& __rhs)
{ return __lhs._M_base() != __rhs._M_base(); }
-
+
template<typename _CharT, typename _Traits, typename _Allocator>
inline bool
operator!=(const _CharT* __lhs,
}
template<typename _CharT, typename _Traits, typename _Allocator>
- inline bool
+ inline bool
operator<(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
const basic_string<_CharT,_Traits,_Allocator>& __rhs)
{ return __lhs._M_base() < __rhs._M_base(); }
-
+
template<typename _CharT, typename _Traits, typename _Allocator>
inline bool
operator<(const _CharT* __lhs,
}
template<typename _CharT, typename _Traits, typename _Allocator>
- inline bool
+ inline bool
operator<=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
const basic_string<_CharT,_Traits,_Allocator>& __rhs)
{ return __lhs._M_base() <= __rhs._M_base(); }
-
+
template<typename _CharT, typename _Traits, typename _Allocator>
inline bool
operator<=(const _CharT* __lhs,
__glibcxx_check_string(__rhs);
return __lhs._M_base() <= __rhs;
}
-
+
template<typename _CharT, typename _Traits, typename _Allocator>
- inline bool
+ inline bool
operator>=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
const basic_string<_CharT,_Traits,_Allocator>& __rhs)
{ return __lhs._M_base() >= __rhs._M_base(); }
-
+
template<typename _CharT, typename _Traits, typename _Allocator>
inline bool
operator>=(const _CharT* __lhs,
__glibcxx_check_string(__lhs);
return __lhs >= __rhs._M_base();
}
-
+
template<typename _CharT, typename _Traits, typename _Allocator>
inline bool
operator>=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
__glibcxx_check_string(__rhs);
return __lhs._M_base() >= __rhs;
}
-
+
template<typename _CharT, typename _Traits, typename _Allocator>
- inline bool
+ inline bool
operator>(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
const basic_string<_CharT,_Traits,_Allocator>& __rhs)
{ return __lhs._M_base() > __rhs._M_base(); }
-
+
template<typename _CharT, typename _Traits, typename _Allocator>
inline bool
operator>(const _CharT* __lhs,
// 21.3.7.8:
template<typename _CharT, typename _Traits, typename _Allocator>
- inline void
+ inline void
swap(basic_string<_CharT,_Traits,_Allocator>& __lhs,
basic_string<_CharT,_Traits,_Allocator>& __rhs)
{ __lhs.swap(__rhs); }
getline(std::basic_istream<_CharT,_Traits>& __is,
basic_string<_CharT,_Traits,_Allocator>& __str, _CharT __delim)
{
- std::basic_istream<_CharT,_Traits>& __res = getline(__is,
+ std::basic_istream<_CharT,_Traits>& __res = getline(__is,
__str._M_base(),
__delim);
__str._M_invalidate_all();
return __res;
}
-
+
template<typename _CharT, typename _Traits, typename _Allocator>
std::basic_istream<_CharT,_Traits>&
getline(std::basic_istream<_CharT,_Traits>& __is,
basic_string<_CharT,_Traits,_Allocator>& __str)
{
- std::basic_istream<_CharT,_Traits>& __res = getline(__is,
+ std::basic_istream<_CharT,_Traits>& __res = getline(__is,
__str._M_base());
__str._M_invalidate_all();
return __res;
}
} // namespace __gnu_debug
-#endif
+#endif
namespace __gnu_debug_def
{
- template<typename _Tp,
+ template<typename _Tp,
typename _Allocator = std::allocator<_Tp> >
class vector
: public __gnu_norm::vector<_Tp, _Allocator>,
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<typename _Base::iterator,vector>
iterator;
typedef __gnu_debug::_Safe_iterator<typename _Base::const_iterator,vector>
const_iterator;
typedef typename _Base::size_type size_type;
typedef typename _Base::difference_type difference_type;
- typedef _Tp value_type;
- typedef _Allocator allocator_type;
+ typedef _Tp value_type;
+ typedef _Allocator allocator_type;
typedef typename _Allocator::pointer pointer;
typedef typename _Allocator::const_pointer const_pointer;
typedef std::reverse_iterator<iterator> reverse_iterator;
template<class _InputIterator>
vector(_InputIterator __first, _InputIterator __last,
const _Allocator& __a = _Allocator())
- : _Base(__gnu_debug::__check_valid_range(__first, __last),
+ : _Base(__gnu_debug::__check_valid_range(__first, __last),
__last, __a),
_M_guaranteed_capacity(0)
{ _M_update_guaranteed_capacity(); }
- vector(const vector<_Tp,_Allocator>& __x)
+ vector(const vector<_Tp,_Allocator>& __x)
: _Base(__x), _Safe_base(), _M_guaranteed_capacity(__x.size()) { }
/// Construction from a release-mode vector
- vector(const _Base& __x)
+ vector(const _Base& __x)
: _Base(__x), _Safe_base(), _M_guaranteed_capacity(__x.size()) { }
~vector() { }
- vector<_Tp,_Allocator>&
+ vector<_Tp,_Allocator>&
operator=(const vector<_Tp,_Allocator>& __x)
{
static_cast<_Base&>(*this) = __x;
}
template<typename _InputIterator>
- void
+ void
assign(_InputIterator __first, _InputIterator __last)
{
__glibcxx_check_valid_range(__first, __last);
_M_update_guaranteed_capacity();
}
- void
+ void
assign(size_type __n, const _Tp& __u)
{
_Base::assign(__n, __u);
using _Base::get_allocator;
// iterators:
- iterator
- begin()
+ iterator
+ begin()
{ return iterator(_Base::begin(), this); }
- const_iterator
- begin() const
+ const_iterator
+ begin() const
{ return const_iterator(_Base::begin(), this); }
- iterator
+ iterator
end()
{ return iterator(_Base::end(), this); }
- const_iterator
+ const_iterator
end() const
{ return const_iterator(_Base::end(), this); }
- reverse_iterator
- rbegin()
+ reverse_iterator
+ rbegin()
{ return reverse_iterator(end()); }
- const_reverse_iterator
+ const_reverse_iterator
rbegin() const
{ return const_reverse_iterator(end()); }
- reverse_iterator
- rend()
+ reverse_iterator
+ rend()
{ return reverse_iterator(begin()); }
- const_reverse_iterator
- rend() const
+ const_reverse_iterator
+ rend() const
{ return const_reverse_iterator(begin()); }
// 23.2.4.2 capacity:
using _Base::size;
using _Base::max_size;
- void
+ void
resize(size_type __sz, _Tp __c = _Tp())
{
bool __realloc = _M_requires_reallocation(__sz);
using _Base::capacity;
using _Base::empty;
- void
+ void
reserve(size_type __n)
{
bool __realloc = _M_requires_reallocation(__n);
}
// element access:
- reference
+ reference
operator[](size_type __n)
{
__glibcxx_check_subscript(__n);
return _M_base()[__n];
}
- const_reference
+ const_reference
operator[](size_type __n) const
{
__glibcxx_check_subscript(__n);
using _Base::at;
- reference
+ reference
front()
{
__glibcxx_check_nonempty();
return _Base::front();
}
- const_reference
+ const_reference
front() const
{
__glibcxx_check_nonempty();
return _Base::front();
}
- reference
+ reference
back()
{
__glibcxx_check_nonempty();
return _Base::back();
}
- const_reference
+ const_reference
back() const
{
__glibcxx_check_nonempty();
}
// 23.2.4.3 modifiers:
- void
+ void
push_back(const _Tp& __x)
{
bool __realloc = _M_requires_reallocation(this->size() + 1);
_M_update_guaranteed_capacity();
}
- void
+ void
pop_back()
{
__glibcxx_check_nonempty();
_Base::pop_back();
}
- iterator
+ iterator
insert(iterator __position, const _Tp& __x)
{
__glibcxx_check_insert(__position);
return iterator(__res, this);
}
- void
+ void
insert(iterator __position, size_type __n, const _Tp& __x)
{
__glibcxx_check_insert(__position);
}
template<class _InputIterator>
- void
- insert(iterator __position,
+ void
+ insert(iterator __position,
_InputIterator __first, _InputIterator __last)
{
__glibcxx_check_insert_range(__position, __first, __last);
-
+
/* 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::insert(__position.base(), __first, __last);
-
+
if (_M_base().begin() != __old_begin)
this->_M_invalidate_all();
else
this->_M_invalidate_if(_After_nth(__offset, _M_base().begin()));
_M_update_guaranteed_capacity();
}
-
- iterator
+
+ iterator
erase(iterator __position)
{
__glibcxx_check_erase(__position);
return iterator(__res, this);
}
- iterator
+ iterator
erase(iterator __first, iterator __last)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 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(),
+ typename _Base::iterator __res = _Base::erase(__first.base(),
__last.base());
this->_M_invalidate_if(_After_nth(__offset, _M_base().begin()));
return iterator(__res, this);
}
- void
+ void
swap(vector<_Tp,_Allocator>& __x)
{
_Base::swap(__x);
std::swap(_M_guaranteed_capacity, __x._M_guaranteed_capacity);
}
- void
+ void
clear()
{
_Base::clear();
_M_guaranteed_capacity = 0;
}
- _Base&
+ _Base&
_M_base() { return *this; }
- const _Base&
+ const _Base&
_M_base() const { return *this; }
private:
size_type _M_guaranteed_capacity;
- bool
+ bool
_M_requires_reallocation(size_type __elements)
{
#ifdef _GLIBCXX_DEBUG_PEDANTIC
return __elements > _M_guaranteed_capacity;
#endif
}
-
- void
+
+ void
_M_update_guaranteed_capacity()
{
if (this->size() > _M_guaranteed_capacity)
template<typename _Tp, typename _Alloc>
inline bool
- operator!=(const vector<_Tp, _Alloc>& __lhs,
+ operator!=(const vector<_Tp, _Alloc>& __lhs,
const vector<_Tp, _Alloc>& __rhs)
{ return __lhs._M_base() != __rhs._M_base(); }
template<typename _Tp, typename _Alloc>
inline bool
- operator<(const vector<_Tp, _Alloc>& __lhs,
+ operator<(const vector<_Tp, _Alloc>& __lhs,
const vector<_Tp, _Alloc>& __rhs)
{ return __lhs._M_base() < __rhs._M_base(); }
template<typename _Tp, typename _Alloc>
inline bool
- operator<=(const vector<_Tp, _Alloc>& __lhs,
+ operator<=(const vector<_Tp, _Alloc>& __lhs,
const vector<_Tp, _Alloc>& __rhs)
{ return __lhs._M_base() <= __rhs._M_base(); }
template<typename _Tp, typename _Alloc>
inline bool
- operator>=(const vector<_Tp, _Alloc>& __lhs,
+ operator>=(const vector<_Tp, _Alloc>& __lhs,
const vector<_Tp, _Alloc>& __rhs)
{ return __lhs._M_base() >= __rhs._M_base(); }
template<typename _Tp, typename _Alloc>
inline bool
- operator>(const vector<_Tp, _Alloc>& __lhs,
+ operator>(const vector<_Tp, _Alloc>& __lhs,
const vector<_Tp, _Alloc>& __rhs)
{ return __lhs._M_base() > __rhs._M_base(); }
{ __lhs.swap(__rhs); }
} // namespace __gnu_debug_def
-#endif
+#endif
projects / thirdparty / gcc.git / commitdiff
