diff options
author | Bernardo Innocenti <bernie@develer.com> | 2003-12-09 05:26:28 +0100 |
---|---|---|
committer | Bernardo Innocenti <bernie@gcc.gnu.org> | 2003-12-09 05:26:28 +0100 |
commit | 526da49cc7dea9f6022612320eb980535b91eecb (patch) | |
tree | ac7c2f2acc6d92bc9cfb2124d2d9ff415962bc49 | |
parent | a6f86b51673a67a9a8f4c1d5232aa9fe81962170 (diff) | |
download | gcc-526da49cc7dea9f6022612320eb980535b91eecb.zip gcc-526da49cc7dea9f6022612320eb980535b91eecb.tar.gz gcc-526da49cc7dea9f6022612320eb980535b91eecb.tar.bz2 |
bitset, [...]: Remove trailing whitespace.
* 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.
From-SVN: r74463
21 files changed, 1159 insertions, 1147 deletions
diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 13a8292..d6aaf44 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,5 +1,17 @@ 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/c_compatibility/locale.h, include/c_compatibility/stdio.h, include/c_compatibility/string.h, include/c_compatibility/time.h, diff --git a/libstdc++-v3/include/debug/bitset b/libstdc++-v3/include/debug/bitset index 3c474cf..8924422 100644 --- a/libstdc++-v3/include/debug/bitset +++ b/libstdc++-v3/include/debug/bitset @@ -36,25 +36,25 @@ #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) { } @@ -63,7 +63,7 @@ namespace __gnu_debug_def : _Base_ref(__x), _Safe_iterator_base(__x, false) { } - reference& + reference& operator=(bool __x) { _GLIBCXX_DEBUG_VERIFY(! this->_M_singular(), @@ -73,7 +73,7 @@ namespace __gnu_debug_def return *this; } - reference& + reference& operator=(const reference& __x) { _GLIBCXX_DEBUG_VERIFY(! __x._M_singular(), @@ -85,8 +85,8 @@ namespace __gnu_debug_def *static_cast<_Base_ref*>(this) = __x; return *this; } - - bool + + bool operator~() const { _GLIBCXX_DEBUG_VERIFY(! this->_M_singular(), @@ -94,7 +94,7 @@ namespace __gnu_debug_def ._M_iterator(*this)); return ~(*static_cast<const _Base_ref*>(this)); } - + operator bool() const { _GLIBCXX_DEBUG_VERIFY(! this->_M_singular(), @@ -102,8 +102,8 @@ namespace __gnu_debug_def ._M_iterator(*this)); return *static_cast<const _Base_ref*>(this); } - - reference& + + reference& flip() { _GLIBCXX_DEBUG_VERIFY(! this->_M_singular(), @@ -116,170 +116,170 @@ namespace __gnu_debug_def // 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; } @@ -290,7 +290,7 @@ namespace __gnu_debug_def 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 diff --git a/libstdc++-v3/include/debug/debug.h b/libstdc++-v3/include/debug/debug.h index edb19aa..87bbcfa 100644 --- a/libstdc++-v3/include/debug/debug.h +++ b/libstdc++-v3/include/debug/debug.h @@ -174,7 +174,7 @@ _GLIBCXX_DEBUG_VERIFY(::__gnu_debug::__check_partitioned(_First, _Last, \ _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 @@ -185,7 +185,7 @@ _GLIBCXX_DEBUG_VERIFY(::__gnu_debug::__check_partitioned(_First, _Last, \ _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)) @@ -267,7 +267,7 @@ _GLIBCXX_DEBUG_VERIFY(::std::__is_heap(_First, _Last, _Pred), \ # define __glibcxx_requires_string(_String) # define __glibcxx_requires_string_len(_String,_Len) # define __glibcxx_requires_subscript(_N) -#endif +#endif #include <cassert> // TBD: temporary @@ -277,11 +277,11 @@ _GLIBCXX_DEBUG_VERIFY(::std::__is_heap(_First, _Last, _Pred), \ 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 @@ -323,11 +323,11 @@ namespace __gnu_debug { 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; } @@ -344,7 +344,7 @@ namespace __gnu_debug /** 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 @@ -356,12 +356,12 @@ namespace __gnu_debug */ 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 @@ -372,25 +372,25 @@ namespace __gnu_debug 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)); @@ -422,7 +422,7 @@ namespace __gnu_debug // 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; } @@ -433,7 +433,7 @@ namespace __gnu_debug inline bool __check_sorted_aux(_ForwardIterator __first, _ForwardIterator __last, std::forward_iterator_tag) - { + { if (__first == __last) return true; @@ -449,7 +449,7 @@ namespace __gnu_debug // 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; } @@ -458,9 +458,9 @@ namespace __gnu_debug // 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; @@ -477,8 +477,8 @@ namespace __gnu_debug 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()); } @@ -487,15 +487,15 @@ namespace __gnu_debug 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 @@ -528,4 +528,4 @@ namespace __gnu_debug # include <debug/formatter.h> #endif -#endif +#endif diff --git a/libstdc++-v3/include/debug/deque b/libstdc++-v3/include/debug/deque index 818d59e..ed68b37 100644 --- a/libstdc++-v3/include/debug/deque +++ b/libstdc++-v3/include/debug/deque @@ -38,7 +38,7 @@ 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> > { @@ -48,17 +48,17 @@ namespace __gnu_debug_def 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; @@ -81,19 +81,19 @@ namespace __gnu_debug_def 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); @@ -101,131 +101,131 @@ namespace __gnu_debug_def 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); @@ -233,26 +233,26 @@ namespace __gnu_debug_def 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(); @@ -260,8 +260,8 @@ namespace __gnu_debug_def __victim._M_invalidate(); _Base::pop_front(); } - - void + + void pop_back() { __glibcxx_check_nonempty(); @@ -270,8 +270,8 @@ namespace __gnu_debug_def __victim._M_invalidate(); _Base::pop_back(); } - - iterator + + iterator erase(iterator __position) { __glibcxx_check_erase(__position); @@ -287,8 +287,8 @@ namespace __gnu_debug_def return iterator(__res, this); } } - - iterator + + iterator erase(iterator __first, iterator __last) { // _GLIBCXX_RESOLVE_LIB_DEFECTS @@ -302,10 +302,10 @@ namespace __gnu_debug_def iterator __victim = __position++; __victim._M_invalidate(); } - try - { + try + { return iterator(_Base::erase(__first.base(), __last.base()), - this); + this); } catch (...) { @@ -315,43 +315,43 @@ namespace __gnu_debug_def } 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(); } @@ -362,13 +362,13 @@ namespace __gnu_debug_def 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(); } diff --git a/libstdc++-v3/include/debug/formatter.h b/libstdc++-v3/include/debug/formatter.h index 1a627a9..6ed00bd 100644 --- a/libstdc++-v3/include/debug/formatter.h +++ b/libstdc++-v3/include/debug/formatter.h @@ -55,10 +55,10 @@ namespace __gnu_debug 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 @@ -123,7 +123,7 @@ namespace __gnu_debug __const_iterator, __mutable_iterator, __last_constness - }; + }; // The state of the iterator (fine-grained), if we know it. enum _Iterator_state @@ -143,29 +143,29 @@ namespace __gnu_debug // 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 { @@ -190,17 +190,17 @@ namespace __gnu_debug } _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> @@ -211,7 +211,7 @@ namespace __gnu_debug _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; @@ -258,7 +258,7 @@ namespace __gnu_debug _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) @@ -267,19 +267,19 @@ namespace __gnu_debug _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); } @@ -292,18 +292,18 @@ namespace __gnu_debug _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 @@ -335,7 +335,7 @@ namespace __gnu_debug _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; } @@ -347,7 +347,7 @@ namespace __gnu_debug const _Error_formatter& _M_message(_Debug_msg_id __id) const; - void + void _M_error() const; private: @@ -360,10 +360,10 @@ namespace __gnu_debug 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 }; @@ -386,4 +386,4 @@ namespace __gnu_debug }; } // namespace __gnu_debug -#endif +#endif diff --git a/libstdc++-v3/include/debug/hash_map.h b/libstdc++-v3/include/debug/hash_map.h index 5ca102a..c2cd7b8 100644 --- a/libstdc++-v3/include/debug/hash_map.h +++ b/libstdc++-v3/include/debug/hash_map.h @@ -45,7 +45,7 @@ namespace __gnu_debug_def 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; @@ -62,29 +62,29 @@ namespace __gnu_debug_def 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) { } @@ -110,102 +110,102 @@ namespace __gnu_debug_def 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); @@ -216,27 +216,27 @@ namespace __gnu_debug_def } _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; @@ -244,22 +244,22 @@ namespace __gnu_debug_def 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, @@ -267,4 +267,4 @@ namespace __gnu_debug_def { __x.swap(__y); } } // namespace __gnu_debug_def -#endif +#endif diff --git a/libstdc++-v3/include/debug/hash_multimap.h b/libstdc++-v3/include/debug/hash_multimap.h index dd453d6..83b4425 100644 --- a/libstdc++-v3/include/debug/hash_multimap.h +++ b/libstdc++-v3/include/debug/hash_multimap.h @@ -46,24 +46,24 @@ namespace __gnu_debug_def _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; @@ -73,17 +73,17 @@ namespace __gnu_debug_def 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) { } @@ -107,96 +107,96 @@ namespace __gnu_debug_def 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); @@ -207,27 +207,27 @@ namespace __gnu_debug_def } _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; @@ -235,22 +235,22 @@ namespace __gnu_debug_def 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, diff --git a/libstdc++-v3/include/debug/hash_multiset.h b/libstdc++-v3/include/debug/hash_multiset.h index cacad03..705d8da 100644 --- a/libstdc++-v3/include/debug/hash_multiset.h +++ b/libstdc++-v3/include/debug/hash_multiset.h @@ -46,22 +46,22 @@ namespace __gnu_debug_def _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; @@ -82,7 +82,7 @@ namespace __gnu_debug_def 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) @@ -113,7 +113,7 @@ namespace __gnu_debug_def using _Base::max_size; using _Base::empty; - void + void swap(hash_multiset& __x) { _Base::swap(__x); @@ -128,8 +128,8 @@ namespace __gnu_debug_def { 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()); @@ -140,24 +140,24 @@ namespace __gnu_debug_def 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); @@ -168,16 +168,16 @@ namespace __gnu_debug_def } 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); @@ -189,11 +189,11 @@ namespace __gnu_debug_def _Base::erase(__first.base(), __last.base()); } - void - clear() - { + void + clear() + { _Base::clear(); - this->_M_invalidate_all(); + this->_M_invalidate_all(); } using _Base::resize; @@ -205,7 +205,7 @@ namespace __gnu_debug_def const _Base& _M_base() const { return *this; } private: - void + void _M_invalidate_all() { typedef typename _Base::const_iterator _Base_const_iterator; diff --git a/libstdc++-v3/include/debug/hash_set b/libstdc++-v3/include/debug/hash_set index 13d879d..282cba2 100644 --- a/libstdc++-v3/include/debug/hash_set +++ b/libstdc++-v3/include/debug/hash_set @@ -35,4 +35,4 @@ #include <debug/dbg_hash_set.h> #include <debug/dbg_hash_multiset.h> -#endif +#endif diff --git a/libstdc++-v3/include/debug/hash_set.h b/libstdc++-v3/include/debug/hash_set.h index 88afb90..0f56d88 100644 --- a/libstdc++-v3/include/debug/hash_set.h +++ b/libstdc++-v3/include/debug/hash_set.h @@ -47,7 +47,7 @@ namespace __gnu_debug_def { 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; @@ -67,21 +67,21 @@ namespace __gnu_debug_def 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) { } @@ -103,67 +103,67 @@ namespace __gnu_debug_def __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()) @@ -171,16 +171,16 @@ namespace __gnu_debug_def 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); @@ -191,27 +191,27 @@ namespace __gnu_debug_def } _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; @@ -220,21 +220,21 @@ namespace __gnu_debug_def } }; - 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, diff --git a/libstdc++-v3/include/debug/list b/libstdc++-v3/include/debug/list index 79dcb1d..f9bb9f9 100644 --- a/libstdc++-v3/include/debug/list +++ b/libstdc++-v3/include/debug/list @@ -49,17 +49,17 @@ namespace __gnu_debug_def 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; @@ -78,96 +78,96 @@ namespace __gnu_debug_def 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); } @@ -177,40 +177,40 @@ namespace __gnu_debug_def __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(); @@ -218,10 +218,10 @@ namespace __gnu_debug_def __victim._M_invalidate(); _Base::pop_front(); } - + using _Base::push_back; - - void + + void pop_back() { __glibcxx_check_nonempty(); @@ -230,39 +230,39 @@ namespace __gnu_debug_def __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 @@ -276,23 +276,23 @@ namespace __gnu_debug_def } 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, @@ -300,8 +300,8 @@ namespace __gnu_debug_def ._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); @@ -314,14 +314,14 @@ namespace __gnu_debug_def _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); @@ -333,7 +333,7 @@ namespace __gnu_debug_def _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, @@ -346,12 +346,12 @@ namespace __gnu_debug_def // 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(); ) @@ -362,9 +362,9 @@ namespace __gnu_debug_def ++__x; } } - - template<class _Predicate> - void + + template<class _Predicate> + void remove_if(_Predicate __pred) { for (iterator __x = begin(); __x.base() != _Base::end(); ) @@ -375,13 +375,13 @@ namespace __gnu_debug_def ++__x; } } - - void + + void unique() { iterator __first = begin(); iterator __last = end(); - if (__first == __last) + if (__first == __last) return; iterator __next = __first; while (++__next != __last) @@ -393,14 +393,14 @@ namespace __gnu_debug_def __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) @@ -412,8 +412,8 @@ namespace __gnu_debug_def __next = __first; } } - - void + + void merge(list& __x) { __glibcxx_check_sorted(_Base::begin(), _Base::end()); @@ -425,13 +425,13 @@ namespace __gnu_debug_def } _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(); ) { @@ -440,24 +440,24 @@ namespace __gnu_debug_def } _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; @@ -465,7 +465,7 @@ namespace __gnu_debug_def 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) @@ -475,12 +475,12 @@ namespace __gnu_debug_def 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) @@ -490,12 +490,12 @@ namespace __gnu_debug_def 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) diff --git a/libstdc++-v3/include/debug/map.h b/libstdc++-v3/include/debug/map.h index d8609bd..9470e66 100644 --- a/libstdc++-v3/include/debug/map.h +++ b/libstdc++-v3/include/debug/map.h @@ -55,8 +55,8 @@ namespace __gnu_debug_def 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; @@ -67,28 +67,28 @@ namespace __gnu_debug_def 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) { @@ -96,86 +96,86 @@ namespace __gnu_debug_def 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); @@ -188,8 +188,8 @@ namespace __gnu_debug_def return 1; } } - - void + + void erase(iterator __first, iterator __last) { // _GLIBCXX_RESOLVE_LIB_DEFECTS @@ -198,49 +198,49 @@ namespace __gnu_debug_def 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) { @@ -250,7 +250,7 @@ namespace __gnu_debug_def 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 { @@ -260,15 +260,15 @@ namespace __gnu_debug_def 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; @@ -277,47 +277,47 @@ namespace __gnu_debug_def } }; - 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 diff --git a/libstdc++-v3/include/debug/multimap.h b/libstdc++-v3/include/debug/multimap.h index 8c3bd31..3772c31 100644 --- a/libstdc++-v3/include/debug/multimap.h +++ b/libstdc++-v3/include/debug/multimap.h @@ -39,24 +39,24 @@ namespace __gnu_debug_def { 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; @@ -67,9 +67,9 @@ namespace __gnu_debug_def 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()) @@ -77,13 +77,13 @@ namespace __gnu_debug_def 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() { } @@ -100,36 +100,36 @@ namespace __gnu_debug_def 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: @@ -138,11 +138,11 @@ namespace __gnu_debug_def 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); @@ -150,14 +150,14 @@ namespace __gnu_debug_def } 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); @@ -165,7 +165,7 @@ namespace __gnu_debug_def _Base::erase(__position.base()); } - size_type + size_type erase(const key_type& __x) { std::pair<iterator, iterator> __victims = this->equal_range(__x); @@ -180,7 +180,7 @@ namespace __gnu_debug_def return __count; } - void + void erase(iterator __first, iterator __last) { // _GLIBCXX_RESOLVE_LIB_DEFECTS @@ -190,14 +190,14 @@ namespace __gnu_debug_def 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()); } @@ -206,29 +206,29 @@ namespace __gnu_debug_def 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); } @@ -252,14 +252,14 @@ namespace __gnu_debug_def 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; @@ -270,45 +270,45 @@ namespace __gnu_debug_def 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 diff --git a/libstdc++-v3/include/debug/multiset.h b/libstdc++-v3/include/debug/multiset.h index 083c8fb..19bc29a 100644 --- a/libstdc++-v3/include/debug/multiset.h +++ b/libstdc++-v3/include/debug/multiset.h @@ -39,7 +39,7 @@ namespace __gnu_debug_def { 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> > { @@ -48,15 +48,15 @@ namespace __gnu_debug_def 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; @@ -80,14 +80,14 @@ namespace __gnu_debug_def : _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; @@ -102,32 +102,32 @@ namespace __gnu_debug_def 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: @@ -136,11 +136,11 @@ namespace __gnu_debug_def 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); @@ -148,14 +148,14 @@ namespace __gnu_debug_def } 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); @@ -178,7 +178,7 @@ namespace __gnu_debug_def return __count; } - void + void erase(iterator __first, iterator __last) { // _GLIBCXX_RESOLVE_LIB_DEFECTS @@ -188,14 +188,14 @@ namespace __gnu_debug_def 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()); } @@ -204,35 +204,35 @@ namespace __gnu_debug_def 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); } @@ -258,14 +258,14 @@ namespace __gnu_debug_def 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; @@ -275,37 +275,37 @@ namespace __gnu_debug_def }; 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(); } diff --git a/libstdc++-v3/include/debug/safe_base.h b/libstdc++-v3/include/debug/safe_base.h index 93b1761..07bc3b3 100644 --- a/libstdc++-v3/include/debug/safe_base.h +++ b/libstdc++-v3/include/debug/safe_base.h @@ -59,7 +59,7 @@ namespace __gnu_debug * 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; @@ -73,7 +73,7 @@ namespace __gnu_debug 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) { } @@ -82,7 +82,7 @@ namespace __gnu_debug * 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) @@ -102,11 +102,11 @@ namespace __gnu_debug * 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(); @@ -145,35 +145,35 @@ namespace __gnu_debug 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 @@ -181,21 +181,21 @@ namespace __gnu_debug */ 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 diff --git a/libstdc++-v3/include/debug/safe_iterator.h b/libstdc++-v3/include/debug/safe_iterator.h index 5d7ee27..72ba3b5 100644 --- a/libstdc++-v3/include/debug/safe_iterator.h +++ b/libstdc++-v3/include/debug/safe_iterator.h @@ -40,13 +40,13 @@ namespace __gnu_debug { /** 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 @@ -70,12 +70,12 @@ namespace __gnu_debug __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; @@ -103,7 +103,7 @@ namespace __gnu_debug */ _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")); @@ -115,14 +115,14 @@ namespace __gnu_debug */ _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. * @@ -131,7 +131,7 @@ namespace __gnu_debug 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") @@ -142,7 +142,7 @@ namespace __gnu_debug * @brief Copy assignment. * @pre @p x is not singular */ - _Safe_iterator& + _Safe_iterator& operator=(const _Safe_iterator& __x) { _GLIBCXX_DEBUG_VERIFY(!__x._M_singular(), @@ -158,8 +158,8 @@ namespace __gnu_debug * @brief Iterator dereference. * @pre iterator is dereferenceable */ - reference - operator*() const + reference + operator*() const { _GLIBCXX_DEBUG_VERIFY(this->_M_dereferenceable(), @@ -174,7 +174,7 @@ namespace __gnu_debug * @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(), @@ -188,7 +188,7 @@ namespace __gnu_debug * @brief Iterator preincrement * @pre iterator is incrementable */ - _Safe_iterator& + _Safe_iterator& operator++() { _GLIBCXX_DEBUG_VERIFY(this->_M_incrementable(), @@ -202,7 +202,7 @@ namespace __gnu_debug * @brief Iterator postincrement * @pre iterator is incrementable */ - _Safe_iterator + _Safe_iterator operator++(int) { _GLIBCXX_DEBUG_VERIFY(this->_M_incrementable(), @@ -218,7 +218,7 @@ namespace __gnu_debug * @brief Iterator predecrement * @pre iterator is decrementable */ - _Safe_iterator& + _Safe_iterator& operator--() { _GLIBCXX_DEBUG_VERIFY(this->_M_decrementable(), @@ -232,7 +232,7 @@ namespace __gnu_debug * @brief Iterator postdecrement * @pre iterator is decrementable */ - _Safe_iterator + _Safe_iterator operator--(int) { _GLIBCXX_DEBUG_VERIFY(this->_M_decrementable(), @@ -244,10 +244,10 @@ namespace __gnu_debug } // ------ 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)); @@ -255,7 +255,7 @@ namespace __gnu_debug return _M_current[__n]; } - _Safe_iterator& + _Safe_iterator& operator+=(const difference_type& __n) { _GLIBCXX_DEBUG_VERIFY(this->_M_can_advance(__n), @@ -265,7 +265,7 @@ namespace __gnu_debug return *this; } - _Safe_iterator + _Safe_iterator operator+(const difference_type& __n) const { _Safe_iterator __tmp(*this); @@ -273,7 +273,7 @@ namespace __gnu_debug return __tmp; } - _Safe_iterator& + _Safe_iterator& operator-=(const difference_type& __n) { _GLIBCXX_DEBUG_VERIFY(this->_M_can_advance(-__n), @@ -283,7 +283,7 @@ namespace __gnu_debug return *this; } - _Safe_iterator + _Safe_iterator operator-(const difference_type& __n) const { _Safe_iterator __tmp(*this); @@ -294,8 +294,8 @@ namespace __gnu_debug // ------ Utilities ------ /** * @brief Return the underlying iterator - */ - _Iterator + */ + _Iterator base() const { return _M_current; } /** @@ -305,46 +305,46 @@ namespace __gnu_debug 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> @@ -366,9 +366,9 @@ namespace __gnu_debug 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); } @@ -384,8 +384,8 @@ namespace __gnu_debug 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") @@ -394,14 +394,14 @@ namespace __gnu_debug _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") @@ -410,14 +410,14 @@ namespace __gnu_debug _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") @@ -426,14 +426,14 @@ namespace __gnu_debug _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") @@ -442,14 +442,14 @@ namespace __gnu_debug _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") @@ -458,14 +458,14 @@ namespace __gnu_debug _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") @@ -474,14 +474,14 @@ namespace __gnu_debug _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") @@ -490,14 +490,14 @@ namespace __gnu_debug _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") @@ -506,14 +506,14 @@ namespace __gnu_debug _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") @@ -522,14 +522,14 @@ namespace __gnu_debug _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") @@ -538,14 +538,14 @@ namespace __gnu_debug _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") @@ -554,14 +554,14 @@ namespace __gnu_debug _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") @@ -570,7 +570,7 @@ namespace __gnu_debug _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 @@ -581,7 +581,7 @@ namespace __gnu_debug 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") @@ -590,7 +590,7 @@ namespace __gnu_debug _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> @@ -602,6 +602,6 @@ namespace __gnu_debug #ifndef _GLIBCXX_EXPORT_TEMPLATE # include <debug/safe_iterator.tcc> -#endif +#endif #endif diff --git a/libstdc++-v3/include/debug/safe_iterator.tcc b/libstdc++-v3/include/debug/safe_iterator.tcc index 0af21b9..29813f4 100644 --- a/libstdc++-v3/include/debug/safe_iterator.tcc +++ b/libstdc++-v3/include/debug/safe_iterator.tcc @@ -39,19 +39,19 @@ 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); @@ -61,47 +61,47 @@ namespace __gnu_debug } 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; } @@ -113,7 +113,7 @@ namespace __gnu_debug { 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; ) @@ -136,5 +136,5 @@ namespace __gnu_debug } } // namespace __gnu_debug -#endif +#endif diff --git a/libstdc++-v3/include/debug/safe_sequence.h b/libstdc++-v3/include/debug/safe_sequence.h index cb2d8ae..0bae943 100644 --- a/libstdc++-v3/include/debug/safe_sequence.h +++ b/libstdc++-v3/include/debug/safe_sequence.h @@ -36,26 +36,26 @@ 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> @@ -63,19 +63,19 @@ namespace __gnu_debug { 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. @@ -101,8 +101,8 @@ namespace __gnu_debug 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 @@ -114,19 +114,19 @@ namespace __gnu_debug }; 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(); @@ -137,12 +137,12 @@ namespace __gnu_debug { 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> @@ -157,7 +157,7 @@ namespace __gnu_debug 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); @@ -176,4 +176,4 @@ namespace __gnu_debug } } // namespace __gnu_debug -#endif +#endif diff --git a/libstdc++-v3/include/debug/set.h b/libstdc++-v3/include/debug/set.h index 861077d..b9200ad 100644 --- a/libstdc++-v3/include/debug/set.h +++ b/libstdc++-v3/include/debug/set.h @@ -45,18 +45,18 @@ namespace __gnu_debug_def { 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; @@ -67,12 +67,12 @@ namespace __gnu_debug_def 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(), @@ -80,63 +80,63 @@ namespace __gnu_debug_def : _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; @@ -144,31 +144,31 @@ namespace __gnu_debug_def 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); @@ -181,66 +181,66 @@ namespace __gnu_debug_def 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) { @@ -250,7 +250,7 @@ namespace __gnu_debug_def 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> @@ -262,15 +262,15 @@ namespace __gnu_debug_def 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; @@ -278,46 +278,46 @@ namespace __gnu_debug_def 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 diff --git a/libstdc++-v3/include/debug/string b/libstdc++-v3/include/debug/string index 5be5da6..a91c004 100644 --- a/libstdc++-v3/include/debug/string +++ b/libstdc++-v3/include/debug/string @@ -38,7 +38,7 @@ 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> > @@ -48,9 +48,9 @@ namespace __gnu_debug 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; @@ -60,7 +60,7 @@ namespace __gnu_debug 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; @@ -77,13 +77,13 @@ namespace __gnu_debug 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()) @@ -112,7 +112,7 @@ namespace __gnu_debug ~basic_string() { } - basic_string& + basic_string& operator=(const basic_string& __str) { *static_cast<_Base*>(this) = __str; @@ -120,7 +120,7 @@ namespace __gnu_debug return *this; } - basic_string& + basic_string& operator=(const _CharT* __s) { __glibcxx_check_string(__s); @@ -129,7 +129,7 @@ namespace __gnu_debug return *this; } - basic_string& + basic_string& operator=(_CharT __c) { *static_cast<_Base*>(this) = __c; @@ -138,27 +138,27 @@ namespace __gnu_debug } // 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()); } @@ -166,8 +166,8 @@ namespace __gnu_debug rend() { return reverse_iterator(begin()); } - const_reverse_iterator - rend() const + const_reverse_iterator + rend() const { return const_reverse_iterator(begin()); } // 21.3.3 capacity: @@ -175,21 +175,21 @@ namespace __gnu_debug 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(); @@ -199,7 +199,7 @@ namespace __gnu_debug using _Base::empty; // 21.3.4 element access: - const_reference + const_reference operator[](size_type __pos) const { _GLIBCXX_DEBUG_VERIFY(__pos <= this->size(), @@ -210,7 +210,7 @@ namespace __gnu_debug return _M_base()[__pos]; } - reference + reference operator[](size_type __pos) { __glibcxx_check_subscript(__pos); @@ -220,7 +220,7 @@ namespace __gnu_debug using _Base::at; // 21.3.5 modifiers: - basic_string& + basic_string& operator+=(const basic_string& __str) { _M_base() += __str; @@ -228,7 +228,7 @@ namespace __gnu_debug return *this; } - basic_string& + basic_string& operator+=(const _CharT* __s) { __glibcxx_check_string(__s); @@ -237,7 +237,7 @@ namespace __gnu_debug return *this; } - basic_string& + basic_string& operator+=(_CharT __c) { _M_base() += __c; @@ -245,7 +245,7 @@ namespace __gnu_debug return *this; } - basic_string& + basic_string& append(const basic_string& __str) { _Base::append(__str); @@ -253,7 +253,7 @@ namespace __gnu_debug return *this; } - basic_string& + basic_string& append(const basic_string& __str, size_type __pos, size_type __n) { _Base::append(__str, __pos, __n); @@ -261,7 +261,7 @@ namespace __gnu_debug return *this; } - basic_string& + basic_string& append(const _CharT* __s, size_type __n) { __glibcxx_check_string_len(__s, __n); @@ -270,7 +270,7 @@ namespace __gnu_debug return *this; } - basic_string& + basic_string& append(const _CharT* __s) { __glibcxx_check_string(__s); @@ -279,7 +279,7 @@ namespace __gnu_debug return *this; } - basic_string& + basic_string& append(size_type __n, _CharT __c) { _Base::append(__n, __c); @@ -288,7 +288,7 @@ namespace __gnu_debug } template<typename _InputIterator> - basic_string& + basic_string& append(_InputIterator __first, _InputIterator __last) { __glibcxx_check_valid_range(__first, __last); @@ -298,15 +298,15 @@ namespace __gnu_debug } // _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); @@ -314,7 +314,7 @@ namespace __gnu_debug return *this; } - basic_string& + basic_string& assign(const basic_string& __str, size_type __pos, size_type __n) { _Base::assign(__str, __pos, __n); @@ -322,7 +322,7 @@ namespace __gnu_debug return *this; } - basic_string& + basic_string& assign(const _CharT* __s, size_type __n) { __glibcxx_check_string_len(__s, __n); @@ -331,7 +331,7 @@ namespace __gnu_debug return *this; } - basic_string& + basic_string& assign(const _CharT* __s) { __glibcxx_check_string(__s); @@ -340,25 +340,25 @@ namespace __gnu_debug 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); @@ -366,7 +366,7 @@ namespace __gnu_debug return *this; } - basic_string& + basic_string& insert(size_type __pos1, const basic_string& __str, size_type __pos2, size_type __n) { @@ -375,7 +375,7 @@ namespace __gnu_debug return *this; } - basic_string& + basic_string& insert(size_type __pos, const _CharT* __s, size_type __n) { __glibcxx_check_string(__s); @@ -384,16 +384,16 @@ namespace __gnu_debug 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); @@ -401,7 +401,7 @@ namespace __gnu_debug return *this; } - iterator + iterator insert(iterator __p, _CharT __c) { __glibcxx_check_insert(__p); @@ -410,7 +410,7 @@ namespace __gnu_debug return iterator(__res, this); } - void + void insert(iterator __p, size_type __n, _CharT __c) { __glibcxx_check_insert(__p); @@ -419,7 +419,7 @@ namespace __gnu_debug } template<typename _InputIterator> - void + void insert(iterator __p, _InputIterator __first, _InputIterator __last) { __glibcxx_check_insert_range(__p, __first, __last); @@ -427,7 +427,7 @@ namespace __gnu_debug this->_M_invalidate_all(); } - basic_string& + basic_string& erase(size_type __pos = 0, size_type __n = _Base::npos) { _Base::erase(__pos, __n); @@ -435,7 +435,7 @@ namespace __gnu_debug return *this; } - iterator + iterator erase(iterator __position) { __glibcxx_check_erase(__position); @@ -444,7 +444,7 @@ namespace __gnu_debug return iterator(__res, this); } - iterator + iterator erase(iterator __first, iterator __last) { // _GLIBCXX_RESOLVE_LIB_DEFECTS @@ -456,7 +456,7 @@ namespace __gnu_debug return iterator(__res, this); } - basic_string& + basic_string& replace(size_type __pos1, size_type __n1, const basic_string& __str) { _Base::replace(__pos1, __n1, __str); @@ -464,7 +464,7 @@ namespace __gnu_debug return *this; } - basic_string& + basic_string& replace(size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, size_type __n2) { @@ -473,8 +473,8 @@ namespace __gnu_debug 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); @@ -483,7 +483,7 @@ namespace __gnu_debug return *this; } - basic_string& + basic_string& replace(size_type __pos, size_type __n1, const _CharT* __s) { __glibcxx_check_string(__s); @@ -492,7 +492,7 @@ namespace __gnu_debug return *this; } - basic_string& + basic_string& replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c) { _Base::replace(__pos, __n1, __n2, __c); @@ -500,7 +500,7 @@ namespace __gnu_debug return *this; } - basic_string& + basic_string& replace(iterator __i1, iterator __i2, const basic_string& __str) { __glibcxx_check_erase_range(__i1, __i2); @@ -508,8 +508,8 @@ namespace __gnu_debug 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); @@ -519,7 +519,7 @@ namespace __gnu_debug return *this; } - basic_string& + basic_string& replace(iterator __i1, iterator __i2, const _CharT* __s) { __glibcxx_check_erase_range(__i1, __i2); @@ -529,7 +529,7 @@ namespace __gnu_debug return *this; } - basic_string& + basic_string& replace(iterator __i1, iterator __i2, size_type __n, _CharT __c) { __glibcxx_check_erase_range(__i1, __i2); @@ -539,7 +539,7 @@ namespace __gnu_debug } template<typename _InputIterator> - basic_string& + basic_string& replace(iterator __i1, iterator __i2, _InputIterator __j1, _InputIterator __j2) { @@ -550,14 +550,14 @@ namespace __gnu_debug 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); @@ -567,7 +567,7 @@ namespace __gnu_debug } // 21.3.6 string operations: - const _CharT* + const _CharT* c_str() const { const _CharT* __res = _Base::c_str(); @@ -575,7 +575,7 @@ namespace __gnu_debug return __res; } - const _CharT* + const _CharT* data() const { const _CharT* __res = _Base::data(); @@ -585,158 +585,158 @@ namespace __gnu_debug 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); @@ -745,7 +745,7 @@ namespace __gnu_debug // _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); @@ -754,7 +754,7 @@ namespace __gnu_debug // _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 { @@ -762,10 +762,10 @@ namespace __gnu_debug 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; @@ -781,14 +781,14 @@ namespace __gnu_debug 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; } @@ -796,9 +796,9 @@ namespace __gnu_debug 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> @@ -808,11 +808,11 @@ namespace __gnu_debug { 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, @@ -832,11 +832,11 @@ namespace __gnu_debug } 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, @@ -856,11 +856,11 @@ namespace __gnu_debug } 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, @@ -880,11 +880,11 @@ namespace __gnu_debug } 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, @@ -902,13 +902,13 @@ namespace __gnu_debug __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, @@ -917,7 +917,7 @@ namespace __gnu_debug __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, @@ -926,13 +926,13 @@ namespace __gnu_debug __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, @@ -953,7 +953,7 @@ namespace __gnu_debug // 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); } @@ -979,23 +979,23 @@ namespace __gnu_debug 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 diff --git a/libstdc++-v3/include/debug/vector b/libstdc++-v3/include/debug/vector index 53e6f0c..f7fa3e8 100644 --- a/libstdc++-v3/include/debug/vector +++ b/libstdc++-v3/include/debug/vector @@ -38,7 +38,7 @@ namespace __gnu_debug_def { - template<typename _Tp, + template<typename _Tp, typename _Allocator = std::allocator<_Tp> > class vector : public __gnu_norm::vector<_Tp, _Allocator>, @@ -54,7 +54,7 @@ namespace __gnu_debug_def 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; @@ -62,8 +62,8 @@ namespace __gnu_debug_def 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; @@ -80,21 +80,21 @@ namespace __gnu_debug_def 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; @@ -104,7 +104,7 @@ namespace __gnu_debug_def } template<typename _InputIterator> - void + void assign(_InputIterator __first, _InputIterator __last) { __glibcxx_check_valid_range(__first, __last); @@ -113,7 +113,7 @@ namespace __gnu_debug_def _M_update_guaranteed_capacity(); } - void + void assign(size_type __n, const _Tp& __u) { _Base::assign(__n, __u); @@ -124,43 +124,43 @@ namespace __gnu_debug_def 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); @@ -174,7 +174,7 @@ namespace __gnu_debug_def using _Base::capacity; using _Base::empty; - void + void reserve(size_type __n) { bool __realloc = _M_requires_reallocation(__n); @@ -186,14 +186,14 @@ namespace __gnu_debug_def } // 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); @@ -202,28 +202,28 @@ namespace __gnu_debug_def 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(); @@ -231,7 +231,7 @@ namespace __gnu_debug_def } // 23.2.4.3 modifiers: - void + void push_back(const _Tp& __x) { bool __realloc = _M_requires_reallocation(this->size() + 1); @@ -241,7 +241,7 @@ namespace __gnu_debug_def _M_update_guaranteed_capacity(); } - void + void pop_back() { __glibcxx_check_nonempty(); @@ -250,7 +250,7 @@ namespace __gnu_debug_def _Base::pop_back(); } - iterator + iterator insert(iterator __position, const _Tp& __x) { __glibcxx_check_insert(__position); @@ -265,7 +265,7 @@ namespace __gnu_debug_def return iterator(__res, this); } - void + void insert(iterator __position, size_type __n, const _Tp& __x) { __glibcxx_check_insert(__position); @@ -280,27 +280,27 @@ namespace __gnu_debug_def } 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); @@ -310,21 +310,21 @@ namespace __gnu_debug_def 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); @@ -332,7 +332,7 @@ namespace __gnu_debug_def std::swap(_M_guaranteed_capacity, __x._M_guaranteed_capacity); } - void + void clear() { _Base::clear(); @@ -340,16 +340,16 @@ namespace __gnu_debug_def _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 @@ -358,8 +358,8 @@ namespace __gnu_debug_def return __elements > _M_guaranteed_capacity; #endif } - - void + + void _M_update_guaranteed_capacity() { if (this->size() > _M_guaranteed_capacity) @@ -375,31 +375,31 @@ namespace __gnu_debug_def 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(); } @@ -409,4 +409,4 @@ namespace __gnu_debug_def { __lhs.swap(__rhs); } } // namespace __gnu_debug_def -#endif +#endif |