diff --git a/libstdc++-v3/include/Makefile.am b/libstdc++-v3/include/Makefile.am index 7b7e2c59440..82fbe09a561 100644 --- a/libstdc++-v3/include/Makefile.am +++ b/libstdc++-v3/include/Makefile.am @@ -696,7 +696,6 @@ debug_headers = \ ${debug_srcdir}/map.h \ ${debug_srcdir}/multimap.h \ ${debug_srcdir}/multiset.h \ - ${debug_srcdir}/safe_association.h \ ${debug_srcdir}/safe_base.h \ ${debug_srcdir}/safe_iterator.h \ ${debug_srcdir}/safe_iterator.tcc \ diff --git a/libstdc++-v3/include/Makefile.in b/libstdc++-v3/include/Makefile.in index 20da2825999..b26375817f0 100644 --- a/libstdc++-v3/include/Makefile.in +++ b/libstdc++-v3/include/Makefile.in @@ -953,7 +953,6 @@ debug_headers = \ ${debug_srcdir}/map.h \ ${debug_srcdir}/multimap.h \ ${debug_srcdir}/multiset.h \ - ${debug_srcdir}/safe_association.h \ ${debug_srcdir}/safe_base.h \ ${debug_srcdir}/safe_iterator.h \ ${debug_srcdir}/safe_iterator.tcc \ diff --git a/libstdc++-v3/include/debug/safe_association.h b/libstdc++-v3/include/debug/safe_association.h deleted file mode 100644 index de8945301f6..00000000000 --- a/libstdc++-v3/include/debug/safe_association.h +++ /dev/null @@ -1,222 +0,0 @@ -// Safe associated container base class implementation -*- C++ -*- - -// Copyright (C) 2007, 2008 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 2, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License along -// with this library; see the file COPYING. If not, write to the Free -// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, -// USA. - -// As a special exception, you may use this file as part of a free software -// library without restriction. Specifically, if other files instantiate -// templates or use macros or inline functions from this file, or you compile -// this file and link it with other files to produce an executable, this -// file does not by itself cause the resulting executable to be covered by -// the GNU General Public License. This exception does not however -// invalidate any other reasons why the executable file might be covered by -// the GNU General Public License. - -/** @file debug/safe_association.h - * This file is a GNU debug extension to the Standard C++ Library. - */ - -#ifndef _GLIBCXX_DEBUG_SAFE_ASSOCIATION_H -#define _GLIBCXX_DEBUG_SAFE_ASSOCIATION_H 1 - -#include -#include -#include -#include -#include - -namespace __gnu_debug -{ - /** - * @brief Base class for constructing a "safe" associated container type. - * - * The class template %_Safe_association simplifies the construction of - * "safe" associated containers. - */ - template - class _Safe_association - : public _Base - { - public: - typedef typename _Base::size_type size_type; - typedef typename _Base::hasher hasher; - typedef typename _Base::key_equal key_equal; - typedef typename _Base::allocator_type allocator_type; - - typedef typename _Base::key_type key_type; - typedef typename _Base::value_type value_type; - typedef typename _Base::difference_type difference_type; - typedef typename _Base::reference reference; - typedef typename _Base::const_reference const_reference; - - typedef __gnu_debug::_Safe_iterator - iterator; - typedef __gnu_debug::_Safe_iterator - const_iterator; - - _Safe_association() { } - - explicit _Safe_association(size_type __n) : _Base(__n) { } - - _Safe_association(size_type __n, const hasher& __hf) - : _Base(__n, __hf) { } - - _Safe_association(size_type __n, const hasher& __hf, - const key_equal& __eql, - const allocator_type& __a = allocator_type()) - : _Base(__n, __hf, __eql, __a) { } - - template - _Safe_association(_InputIter __f, _InputIter __l) - : _Base(__gnu_debug::__check_valid_range(__f, __l), __l) { } - - template - _Safe_association(_InputIter __f, _InputIter __l, size_type __n) - : _Base(__gnu_debug::__check_valid_range(__f, __l), __l, __n) { } - - template - _Safe_association(_InputIter __f, _InputIter __l, size_type __n, - const hasher& __hf) - : _Base(__gnu_debug::__check_valid_range(__f, __l), __l, __n, __hf) - { } - - template - _Safe_association(_InputIter __f, _InputIter __l, size_type __n, - const hasher& __hf, const key_equal& __eql, - const allocator_type& __a = allocator_type()) - : _Base(__gnu_debug::__check_valid_range(__f, __l), - __l, __n, __hf, __eql, __a) - { } - - _Safe_association(std::initializer_list __l, - size_type __n, - const hasher& __hf, - const key_equal& __eql, - const allocator_type& __a = allocator_type()) - : _Base(__l, __n, __hf, __eql, __a) - { } - - _Safe_association(const _Base& __x) : _Base(__x) { } - - _Safe_association(_Safe_association&& __x) - : _Base(std::forward<_Base>(__x)) { } - - using _Base::size; - using _Base::max_size; - using _Base::empty; - using _Base::get_allocator; - using _Base::key_eq; - - using _Base::count; - using _Base::bucket_count; - using _Base::max_bucket_count; - using _Base::bucket; - using _Base::bucket_size; - using _Base::load_factor; - - const_iterator - begin() const { return const_iterator(_Base::begin(), this); } - - const_iterator - end() const { return const_iterator(_Base::end(), this); } - - std::pair - insert(const value_type& __obj) - { - typedef std::pair __pair_type; - __pair_type __res = _Base::insert(__obj); - return std::make_pair(iterator(__res.first, this), __res.second); - } - - void - insert(const value_type* __first, const value_type* __last) - { - __glibcxx_check_valid_range(__first, __last); - _Base::insert(__first, __last); - } - - template - void - insert(_InputIter __first, _InputIter __last) - { - __glibcxx_check_valid_range(__first, __last); - _Base::insert(__first.base(), __last.base()); - } - - void - insert(std::initializer_list __l) - { _Base::insert(__l); } - - const_iterator - find(const key_type& __key) const - { return const_iterator(_Base::find(__key), this); } - - std::pair - equal_range(const key_type& __key) const - { - typedef typename _Base::const_iterator _Base_iterator; - typedef std::pair<_Base_iterator, _Base_iterator> __pair_type; - __pair_type __res = _Base::equal_range(__key); - return std::make_pair(const_iterator(__res.first, this), - const_iterator(__res.second, this)); - } - - size_type - erase(const key_type& __key) - { - size_type __ret(0); - iterator __victim(_Base::find(__key), this); - if (__victim != end()) - { - this->erase(__victim); - __ret = 1; - } - return __ret; - } - - iterator - erase(iterator __it) - { - __glibcxx_check_erase(__it); - __it._M_invalidate(); - return iterator(_Base::erase(__it.base())); - } - - iterator - erase(iterator __first, iterator __last) - { - __glibcxx_check_erase_range(__first, __last); - for (iterator __tmp = __first; __tmp != __last;) - { - iterator __victim = __tmp++; - __victim._M_invalidate(); - } - return iterator(_Base::erase(__first.base(), __last.base())); - } - - _Base& - _M_base() { return *this; } - - const _Base& - _M_base() const { return *this; } - }; -} // namespace __gnu_debug - -#endif diff --git a/libstdc++-v3/include/debug/unordered_map b/libstdc++-v3/include/debug/unordered_map index 79590f56755..dcd76ad9894 100644 --- a/libstdc++-v3/include/debug/unordered_map +++ b/libstdc++-v3/include/debug/unordered_map @@ -1,6 +1,6 @@ // Debugging unordered_map/unordered_multimap implementation -*- C++ -*- -// Copyright (C) 2003, 2004, 2005, 2006, 2007 +// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 // Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free @@ -40,43 +40,48 @@ #else # include #endif -#include -#include -#include -#define _GLIBCXX_BASE unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc> -#define _GLIBCXX_STD_BASE _GLIBCXX_STD_D::_GLIBCXX_BASE +#include +#include +#include namespace std { namespace __debug { template, + typename _Hash = std::hash<_Key>, typename _Pred = std::equal_to<_Key>, - typename _Alloc = std::allocator<_Key> > + typename _Alloc = std::allocator<_Key> > class unordered_map - : public __gnu_debug::_Safe_association<_GLIBCXX_STD_BASE>, - public __gnu_debug::_Safe_sequence<_GLIBCXX_BASE> + : public _GLIBCXX_STD_D::unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>, + public __gnu_debug::_Safe_sequence > { - typedef typename _GLIBCXX_STD_BASE _Base; - typedef __gnu_debug::_Safe_association<_Base> _Safe_assoc; + typedef _GLIBCXX_STD_D::unordered_map<_Key, _Tp, _Hash, + _Pred, _Alloc> _Base; typedef __gnu_debug::_Safe_sequence _Safe_base; public: - typedef typename _Safe_assoc::size_type size_type; - typedef typename _Safe_assoc::value_type value_type; - typedef typename _Safe_assoc::hasher hasher; - typedef typename _Safe_assoc::key_equal key_equal; - typedef typename _Safe_assoc::allocator_type allocator_type; + typedef typename _Base::size_type size_type; + typedef typename _Base::hasher hasher; + typedef typename _Base::key_equal key_equal; + typedef typename _Base::allocator_type allocator_type; + + typedef typename _Base::key_type key_type; + typedef typename _Base::value_type value_type; + + typedef __gnu_debug::_Safe_iterator iterator; + typedef __gnu_debug::_Safe_iterator const_iterator; explicit unordered_map(size_type __n = 10, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) - : _Safe_assoc(__n, __hf, __eql, __a) - { } + : _Base(__n, __hf, __eql, __a) { } template unordered_map(_InputIterator __f, _InputIterator __l, @@ -84,21 +89,32 @@ namespace __debug const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) - : _Safe_assoc(__f, __l, __n, __hf, __eql, __a) - { } + : _Base(__gnu_debug::__check_valid_range(__f, __l), __l, __n, + __hf, __eql, __a), _Safe_base() { } - unordered_map(const _Safe_assoc& __x) - : _Safe_assoc(__x), _Safe_base() { } + unordered_map(const unordered_map& __x) + : _Base(__x), _Safe_base() { } - unordered_map(unordered_map&& __x) - : _Safe_assoc(std::forward<_Safe_assoc>(__x)), _Safe_base() { } + unordered_map(const _Base& __x) + : _Base(__x), _Safe_base() { } + + unordered_map(unordered_map&& __x) + : _Base(std::forward(__x)), _Safe_base() { } unordered_map(initializer_list __l, size_type __n = 10, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) - : _Safe_assoc(__l, __n, __hf, __eql, __a) { } + : _Base(__l, __n, __hf, __eql, __a), _Safe_base() { } + + unordered_map& + operator=(const unordered_map& __x) + { + *static_cast<_Base*>(this) = __x; + this->_M_invalidate_all(); + return *this; + } unordered_map& operator=(unordered_map&& __x) @@ -120,7 +136,7 @@ namespace __debug void swap(unordered_map&& __x) { - _Safe_assoc::swap(__x); + _Base::swap(__x); _Safe_base::_M_swap(__x); } @@ -131,13 +147,168 @@ namespace __debug this->_M_invalidate_all(); } + iterator + begin() + { return iterator(_Base::begin(), this); } + + const_iterator + begin() const + { return const_iterator(_Base::begin(), this); } + + iterator + end() + { return iterator(_Base::end(), this); } + + const_iterator + end() const + { return const_iterator(_Base::end(), this); } + + const_iterator + cbegin() const + { return const_iterator(_Base::begin(), this); } + + const_iterator + cend() const + { return const_iterator(_Base::end(), this); } + + // local versions + using _Base::begin; + using _Base::end; + using _Base::cbegin; + using _Base::cend; + + std::pair + insert(const value_type& __obj) + { + typedef std::pair __pair_type; + __pair_type __res = _Base::insert(__obj); + return std::make_pair(iterator(__res.first, this), __res.second); + } + + iterator + insert(iterator, const value_type& __obj) + { + typedef std::pair __pair_type; + __pair_type __res = _Base::insert(__obj); + return iterator(__res.first, this); + } + + const_iterator + insert(const_iterator, const value_type& __obj) + { + typedef std::pair __pair_type; + __pair_type __res = _Base::insert(__obj); + return const_iterator(__res.first, this); + } + + void + insert(std::initializer_list __l) + { _Base::insert(__l); } + + template + void + insert(_InputIterator __first, _InputIterator __last) + { + __glibcxx_check_valid_range(__first, __last); + _Base::insert(__first, __last); + } + + iterator + find(const key_type& __key) + { return iterator(_Base::find(__key), this); } + + const_iterator + find(const key_type& __key) const + { return const_iterator(_Base::find(__key), this); } + + std::pair + equal_range(const key_type& __key) + { + typedef typename _Base::iterator _Base_iterator; + typedef std::pair<_Base_iterator, _Base_iterator> __pair_type; + __pair_type __res = _Base::equal_range(__key); + return std::make_pair(iterator(__res.first, this), + iterator(__res.second, this)); + } + + std::pair + equal_range(const key_type& __key) const + { + typedef typename _Base::const_iterator _Base_iterator; + typedef std::pair<_Base_iterator, _Base_iterator> __pair_type; + __pair_type __res = _Base::equal_range(__key); + return std::make_pair(const_iterator(__res.first, this), + const_iterator(__res.second, this)); + } + + size_type + erase(const key_type& __key) + { + size_type __ret(0); + iterator __victim(_Base::find(__key), this); + if (__victim != end()) + { + this->erase(__victim); + __ret = 1; + } + return __ret; + } + + iterator + erase(iterator __it) + { + __glibcxx_check_erase(__it); + __it._M_invalidate(); + return iterator(_Base::erase(__it.base()), this); + } + + const_iterator + erase(const_iterator __it) + { + __glibcxx_check_erase(__it); + __it._M_invalidate(); + return const_iterator(_Base::erase(__it.base()), this); + } + + iterator + erase(iterator __first, iterator __last) + { + __glibcxx_check_erase_range(__first, __last); + for (iterator __tmp = __first; __tmp != __last;) + { + iterator __victim = __tmp++; + __victim._M_invalidate(); + } + return iterator(_Base::erase(__first.base(), + __last.base()), this); + } + + const_iterator + erase(const_iterator __first, const_iterator __last) + { + __glibcxx_check_erase_range(__first, __last); + for (const_iterator __tmp = __first; __tmp != __last;) + { + const_iterator __victim = __tmp++; + __victim._M_invalidate(); + } + return const_iterator(_Base::erase(__first.base(), + __last.base()), this); + } + + _Base& + _M_base() { return *this; } + + const _Base& + _M_base() const { return *this; } + private: void _M_invalidate_all() { typedef typename _Base::const_iterator _Base_const_iterator; typedef __gnu_debug::_Not_equal_to<_Base_const_iterator> _Not_equal; - this->_M_invalidate_if(_Not_equal(this->_M_base().end())); + this->_M_invalidate_if(_Not_equal(_M_base().end())); } }; @@ -162,59 +333,74 @@ namespace __debug unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>&& __y) { __x.swap(__y); } -#undef _GLIBCXX_BASE -#undef _GLIBCXX_STD_BASE -#define _GLIBCXX_STD_BASE _GLIBCXX_STD_D::_GLIBCXX_BASE -#define _GLIBCXX_BASE unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc> template, + typename _Hash = std::hash<_Key>, typename _Pred = std::equal_to<_Key>, - typename _Alloc = std::allocator<_Key> > + typename _Alloc = std::allocator<_Key> > class unordered_multimap - : public __gnu_debug::_Safe_association<_GLIBCXX_STD_BASE>, - public __gnu_debug::_Safe_sequence<_GLIBCXX_BASE> + : public _GLIBCXX_STD_D::unordered_multimap<_Key, _Tp, _Hash, + _Pred, _Alloc>, + public __gnu_debug::_Safe_sequence > { - typedef typename _GLIBCXX_STD_BASE _Base; - typedef __gnu_debug::_Safe_association<_Base> _Safe_assoc; + typedef _GLIBCXX_STD_D::unordered_multimap<_Key, _Tp, _Hash, + _Pred, _Alloc> _Base; typedef __gnu_debug::_Safe_sequence _Safe_base; public: - typedef typename _Safe_assoc::size_type size_type; - typedef typename _Safe_assoc::value_type value_type; - typedef typename _Safe_assoc::hasher hasher; - typedef typename _Safe_assoc::key_equal key_equal; - typedef typename _Safe_assoc::allocator_type allocator_type; + typedef typename _Base::size_type size_type; + typedef typename _Base::hasher hasher; + typedef typename _Base::key_equal key_equal; + typedef typename _Base::allocator_type allocator_type; + + typedef typename _Base::key_type key_type; + typedef typename _Base::value_type value_type; + + typedef __gnu_debug::_Safe_iterator iterator; + typedef __gnu_debug::_Safe_iterator const_iterator; explicit unordered_multimap(size_type __n = 10, - const hasher& __hf = hasher(), - const key_equal& __eql = key_equal(), - const allocator_type& __a = allocator_type()) - : _Safe_assoc(__n, __hf, __eql, __a) - { } + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _Base(__n, __hf, __eql, __a) { } template unordered_multimap(_InputIterator __f, _InputIterator __l, - size_type __n = 10, - const hasher& __hf = hasher(), - const key_equal& __eql = key_equal(), - const allocator_type& __a = allocator_type()) - : _Safe_assoc(__f, __l, __n, __hf, __eql, __a) - { } + size_type __n = 10, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _Base(__gnu_debug::__check_valid_range(__f, __l), __l, __n, + __hf, __eql, __a), _Safe_base() { } + + unordered_multimap(const unordered_multimap& __x) + : _Base(__x), _Safe_base() { } + + unordered_multimap(const _Base& __x) + : _Base(__x), _Safe_base() { } + + unordered_multimap(unordered_multimap&& __x) + : _Base(std::forward(__x)), _Safe_base() { } unordered_multimap(initializer_list __l, size_type __n = 10, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) - : _Safe_assoc(__l, __n, __hf, __eql, __a) { } + : _Base(__l, __n, __hf, __eql, __a), _Safe_base() { } - unordered_multimap(const _Safe_assoc& __x) - : _Safe_assoc(__x), _Safe_base() { } - - unordered_multimap(unordered_multimap&& __x) - : _Safe_assoc(std::forward<_Safe_assoc>(__x)), _Safe_base() { } + unordered_multimap& + operator=(const unordered_multimap& __x) + { + *static_cast<_Base*>(this) = __x; + this->_M_invalidate_all(); + return *this; + } unordered_multimap& operator=(unordered_multimap&& __x) @@ -236,7 +422,7 @@ namespace __debug void swap(unordered_multimap&& __x) { - _Safe_assoc::swap(__x); + _Base::swap(__x); _Safe_base::_M_swap(__x); } @@ -247,13 +433,156 @@ namespace __debug this->_M_invalidate_all(); } + iterator + begin() + { return iterator(_Base::begin(), this); } + + const_iterator + begin() const + { return const_iterator(_Base::begin(), this); } + + iterator + end() + { return iterator(_Base::end(), this); } + + const_iterator + end() const + { return const_iterator(_Base::end(), this); } + + const_iterator + cbegin() const + { return const_iterator(_Base::begin(), this); } + + const_iterator + cend() const + { return const_iterator(_Base::end(), this); } + + // local versions + using _Base::begin; + using _Base::end; + using _Base::cbegin; + using _Base::cend; + + iterator + insert(const value_type& __obj) + { return iterator(_Base::insert(__obj), this); } + + iterator + insert(iterator, const value_type& __obj) + { return iterator(_Base::insert(__obj), this); } + + const_iterator + insert(const_iterator, const value_type& __obj) + { return const_iterator(_Base::insert(__obj), this); } + + void + insert(std::initializer_list __l) + { _Base::insert(__l); } + + template + void + insert(_InputIterator __first, _InputIterator __last) + { + __glibcxx_check_valid_range(__first, __last); + _Base::insert(__first, __last); + } + + iterator + find(const key_type& __key) + { return iterator(_Base::find(__key), this); } + + const_iterator + find(const key_type& __key) const + { return const_iterator(_Base::find(__key), this); } + + std::pair + equal_range(const key_type& __key) + { + typedef typename _Base::iterator _Base_iterator; + typedef std::pair<_Base_iterator, _Base_iterator> __pair_type; + __pair_type __res = _Base::equal_range(__key); + return std::make_pair(iterator(__res.first, this), + iterator(__res.second, this)); + } + + std::pair + equal_range(const key_type& __key) const + { + typedef typename _Base::const_iterator _Base_iterator; + typedef std::pair<_Base_iterator, _Base_iterator> __pair_type; + __pair_type __res = _Base::equal_range(__key); + return std::make_pair(const_iterator(__res.first, this), + const_iterator(__res.second, this)); + } + + size_type + erase(const key_type& __key) + { + size_type __ret(0); + iterator __victim(_Base::find(__key), this); + if (__victim != end()) + { + this->erase(__victim); + __ret = 1; + } + return __ret; + } + + iterator + erase(iterator __it) + { + __glibcxx_check_erase(__it); + __it._M_invalidate(); + return iterator(_Base::erase(__it.base()), this); + } + + const_iterator + erase(const_iterator __it) + { + __glibcxx_check_erase(__it); + __it._M_invalidate(); + return const_iterator(_Base::erase(__it.base()), this); + } + + iterator + erase(iterator __first, iterator __last) + { + __glibcxx_check_erase_range(__first, __last); + for (iterator __tmp = __first; __tmp != __last;) + { + iterator __victim = __tmp++; + __victim._M_invalidate(); + } + return iterator(_Base::erase(__first.base(), + __last.base()), this); + } + + const_iterator + erase(const_iterator __first, const_iterator __last) + { + __glibcxx_check_erase_range(__first, __last); + for (const_iterator __tmp = __first; __tmp != __last;) + { + const_iterator __victim = __tmp++; + __victim._M_invalidate(); + } + return const_iterator(_Base::erase(__first.base(), + __last.base()), this); + } + + _Base& + _M_base() { return *this; } + + const _Base& + _M_base() const { return *this; } + private: void _M_invalidate_all() { typedef typename _Base::const_iterator _Base_const_iterator; typedef __gnu_debug::_Not_equal_to<_Base_const_iterator> _Not_equal; - this->_M_invalidate_if(_Not_equal(this->_M_base().end())); + this->_M_invalidate_if(_Not_equal(_M_base().end())); } }; @@ -281,7 +610,4 @@ namespace __debug } // namespace __debug } // namespace std -#undef _GLIBCXX_BASE -#undef _GLIBCXX_STD_BASE - #endif diff --git a/libstdc++-v3/include/debug/unordered_set b/libstdc++-v3/include/debug/unordered_set index 4c5d4d5ce34..7414cfc6b97 100644 --- a/libstdc++-v3/include/debug/unordered_set +++ b/libstdc++-v3/include/debug/unordered_set @@ -1,6 +1,6 @@ // Debugging unordered_set/unordered_multiset implementation -*- C++ -*- -// Copyright (C) 2003, 2004, 2005, 2006, 2007 +// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 // Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free @@ -41,43 +41,47 @@ # include #endif -#include -#include +#include #include - -#define _GLIBCXX_BASE unordered_set<_Value, _Hash, _Pred, _Alloc> -#define _GLIBCXX_STD_BASE _GLIBCXX_STD_D::_GLIBCXX_BASE +#include namespace std { namespace __debug { template, + typename _Hash = std::hash<_Value>, typename _Pred = std::equal_to<_Value>, - typename _Alloc = std::allocator<_Value> > + typename _Alloc = std::allocator<_Value> > class unordered_set - : public __gnu_debug::_Safe_association<_GLIBCXX_STD_BASE>, - public __gnu_debug::_Safe_sequence<_GLIBCXX_BASE> + : public _GLIBCXX_STD_D::unordered_set<_Value, _Hash, _Pred, _Alloc>, + public __gnu_debug::_Safe_sequence > { - typedef typename _GLIBCXX_STD_BASE _Base; - typedef __gnu_debug::_Safe_association<_Base> _Safe_assoc; + typedef _GLIBCXX_STD_D::unordered_set<_Value, _Hash, + _Pred, _Alloc> _Base; typedef __gnu_debug::_Safe_sequence _Safe_base; public: - typedef typename _Safe_assoc::size_type size_type; - typedef typename _Safe_assoc::value_type value_type; - typedef typename _Safe_assoc::hasher hasher; - typedef typename _Safe_assoc::key_equal key_equal; - typedef typename _Safe_assoc::allocator_type allocator_type; + typedef typename _Base::size_type size_type; + typedef typename _Base::hasher hasher; + typedef typename _Base::key_equal key_equal; + typedef typename _Base::allocator_type allocator_type; + + typedef typename _Base::key_type key_type; + typedef typename _Base::value_type value_type; + + typedef __gnu_debug::_Safe_iterator iterator; + typedef __gnu_debug::_Safe_iterator const_iterator; explicit unordered_set(size_type __n = 10, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) - : _Safe_assoc(__n, __hf, __eql, __a) - { } + : _Base(__n, __hf, __eql, __a) { } template unordered_set(_InputIterator __f, _InputIterator __l, @@ -85,21 +89,32 @@ namespace __debug const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) - : _Safe_assoc(__f, __l, __n, __hf, __eql, __a) - { } + : _Base(__gnu_debug::__check_valid_range(__f, __l), __l, __n, + __hf, __eql, __a), _Safe_base() { } + + unordered_set(const unordered_set& __x) + : _Base(__x), _Safe_base() { } + + unordered_set(const _Base& __x) + : _Base(__x), _Safe_base() { } + + unordered_set(unordered_set&& __x) + : _Base(std::forward(__x)), _Safe_base() { } unordered_set(initializer_list __l, size_type __n = 10, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) - : _Safe_assoc(__l, __n, __hf, __eql, __a) { } + : _Base(__l, __n, __hf, __eql, __a), _Safe_base() { } - unordered_set(const _Safe_assoc& __x) - : _Safe_assoc(__x), _Safe_base() { } - - unordered_set(unordered_set&& __x) - : _Safe_assoc(std::forward<_Safe_assoc>(__x)), _Safe_base() { } + unordered_set& + operator=(const unordered_set& __x) + { + *static_cast<_Base*>(this) = __x; + this->_M_invalidate_all(); + return *this; + } unordered_set& operator=(unordered_set&& __x) @@ -121,7 +136,7 @@ namespace __debug void swap(unordered_set&& __x) { - _Safe_assoc::swap(__x); + _Base::swap(__x); _Safe_base::_M_swap(__x); } @@ -132,13 +147,168 @@ namespace __debug this->_M_invalidate_all(); } + iterator + begin() + { return iterator(_Base::begin(), this); } + + const_iterator + begin() const + { return const_iterator(_Base::begin(), this); } + + iterator + end() + { return iterator(_Base::end(), this); } + + const_iterator + end() const + { return const_iterator(_Base::end(), this); } + + const_iterator + cbegin() const + { return const_iterator(_Base::begin(), this); } + + const_iterator + cend() const + { return const_iterator(_Base::end(), this); } + + // local versions + using _Base::begin; + using _Base::end; + using _Base::cbegin; + using _Base::cend; + + std::pair + insert(const value_type& __obj) + { + typedef std::pair __pair_type; + __pair_type __res = _Base::insert(__obj); + return std::make_pair(iterator(__res.first, this), __res.second); + } + + iterator + insert(iterator, const value_type& __obj) + { + typedef std::pair __pair_type; + __pair_type __res = _Base::insert(__obj); + return iterator(__res.first, this); + } + + const_iterator + insert(const_iterator, const value_type& __obj) + { + typedef std::pair __pair_type; + __pair_type __res = _Base::insert(__obj); + return const_iterator(__res.first, this); + } + + void + insert(std::initializer_list __l) + { _Base::insert(__l); } + + template + void + insert(_InputIterator __first, _InputIterator __last) + { + __glibcxx_check_valid_range(__first, __last); + _Base::insert(__first, __last); + } + + iterator + find(const key_type& __key) + { return iterator(_Base::find(__key), this); } + + const_iterator + find(const key_type& __key) const + { return const_iterator(_Base::find(__key), this); } + + std::pair + equal_range(const key_type& __key) + { + typedef typename _Base::iterator _Base_iterator; + typedef std::pair<_Base_iterator, _Base_iterator> __pair_type; + __pair_type __res = _Base::equal_range(__key); + return std::make_pair(iterator(__res.first, this), + iterator(__res.second, this)); + } + + std::pair + equal_range(const key_type& __key) const + { + typedef typename _Base::const_iterator _Base_iterator; + typedef std::pair<_Base_iterator, _Base_iterator> __pair_type; + __pair_type __res = _Base::equal_range(__key); + return std::make_pair(const_iterator(__res.first, this), + const_iterator(__res.second, this)); + } + + size_type + erase(const key_type& __key) + { + size_type __ret(0); + iterator __victim(_Base::find(__key), this); + if (__victim != end()) + { + this->erase(__victim); + __ret = 1; + } + return __ret; + } + + iterator + erase(iterator __it) + { + __glibcxx_check_erase(__it); + __it._M_invalidate(); + return iterator(_Base::erase(__it.base()), this); + } + + const_iterator + erase(const_iterator __it) + { + __glibcxx_check_erase(__it); + __it._M_invalidate(); + return const_iterator(_Base::erase(__it.base()), this); + } + + iterator + erase(iterator __first, iterator __last) + { + __glibcxx_check_erase_range(__first, __last); + for (iterator __tmp = __first; __tmp != __last;) + { + iterator __victim = __tmp++; + __victim._M_invalidate(); + } + return iterator(_Base::erase(__first.base(), + __last.base()), this); + } + + const_iterator + erase(const_iterator __first, const_iterator __last) + { + __glibcxx_check_erase_range(__first, __last); + for (const_iterator __tmp = __first; __tmp != __last;) + { + const_iterator __victim = __tmp++; + __victim._M_invalidate(); + } + return const_iterator(_Base::erase(__first.base(), + __last.base()), this); + } + + _Base& + _M_base() { return *this; } + + const _Base& + _M_base() const { return *this; } + private: void _M_invalidate_all() { typedef typename _Base::const_iterator _Base_const_iterator; typedef __gnu_debug::_Not_equal_to<_Base_const_iterator> _Not_equal; - this->_M_invalidate_if(_Not_equal(this->_M_base().end())); + this->_M_invalidate_if(_Not_equal(_M_base().end())); } }; @@ -160,59 +330,73 @@ namespace __debug unordered_set<_Value, _Hash, _Pred, _Alloc>&& __y) { __x.swap(__y); } -#undef _GLIBCXX_BASE -#undef _GLIBCXX_STD_BASE -#define _GLIBCXX_STD_BASE _GLIBCXX_STD_D::_GLIBCXX_BASE -#define _GLIBCXX_BASE unordered_multiset<_Value, _Hash, _Pred, _Alloc> template, + typename _Hash = std::hash<_Value>, typename _Pred = std::equal_to<_Value>, - typename _Alloc = std::allocator<_Value> > + typename _Alloc = std::allocator<_Value> > class unordered_multiset - : public __gnu_debug::_Safe_association<_GLIBCXX_STD_BASE>, - public __gnu_debug::_Safe_sequence<_GLIBCXX_BASE> + : public _GLIBCXX_STD_D::unordered_multiset<_Value, _Hash, _Pred, _Alloc>, + public __gnu_debug::_Safe_sequence > { - typedef typename _GLIBCXX_STD_BASE _Base; - typedef __gnu_debug::_Safe_association<_Base> _Safe_assoc; + typedef _GLIBCXX_STD_D::unordered_multiset<_Value, _Hash, + _Pred, _Alloc> _Base; typedef __gnu_debug::_Safe_sequence _Safe_base; public: - typedef typename _Safe_assoc::size_type size_type; - typedef typename _Safe_assoc::value_type value_type; - typedef typename _Safe_assoc::hasher hasher; - typedef typename _Safe_assoc::key_equal key_equal; - typedef typename _Safe_assoc::allocator_type allocator_type; + typedef typename _Base::size_type size_type; + typedef typename _Base::hasher hasher; + typedef typename _Base::key_equal key_equal; + typedef typename _Base::allocator_type allocator_type; + + typedef typename _Base::key_type key_type; + typedef typename _Base::value_type value_type; + + typedef __gnu_debug::_Safe_iterator iterator; + typedef __gnu_debug::_Safe_iterator const_iterator; explicit unordered_multiset(size_type __n = 10, - const hasher& __hf = hasher(), - const key_equal& __eql = key_equal(), - const allocator_type& __a = allocator_type()) - : _Safe_assoc(__n, __hf, __eql, __a) - { } + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _Base(__n, __hf, __eql, __a) { } template unordered_multiset(_InputIterator __f, _InputIterator __l, - size_type __n = 10, - const hasher& __hf = hasher(), - const key_equal& __eql = key_equal(), - const allocator_type& __a = allocator_type()) - : _Safe_assoc(__f, __l, __n, __hf, __eql, __a) - { } + size_type __n = 10, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _Base(__gnu_debug::__check_valid_range(__f, __l), __l, __n, + __hf, __eql, __a), _Safe_base() { } + + unordered_multiset(const unordered_multiset& __x) + : _Base(__x), _Safe_base() { } + + unordered_multiset(const _Base& __x) + : _Base(__x), _Safe_base() { } + + unordered_multiset(unordered_multiset&& __x) + : _Base(std::forward(__x)), _Safe_base() { } unordered_multiset(initializer_list __l, size_type __n = 10, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) - : _Safe_assoc(__l, __n, __hf, __eql, __a) { } + : _Base(__l, __n, __hf, __eql, __a), _Safe_base() { } - unordered_multiset(const _Safe_assoc& __x) - : _Safe_assoc(__x), _Safe_base() { } - - unordered_multiset(unordered_multiset&& __x) - : _Safe_assoc(std::forward<_Safe_assoc>(__x)), _Safe_base() { } + unordered_multiset& + operator=(const unordered_multiset& __x) + { + *static_cast<_Base*>(this) = __x; + this->_M_invalidate_all(); + return *this; + } unordered_multiset& operator=(unordered_multiset&& __x) @@ -234,24 +418,167 @@ namespace __debug void swap(unordered_multiset&& __x) { - _Safe_assoc::swap(__x); + _Base::swap(__x); _Safe_base::_M_swap(__x); } - void + void clear() { _Base::clear(); this->_M_invalidate_all(); } + iterator + begin() + { return iterator(_Base::begin(), this); } + + const_iterator + begin() const + { return const_iterator(_Base::begin(), this); } + + iterator + end() + { return iterator(_Base::end(), this); } + + const_iterator + end() const + { return const_iterator(_Base::end(), this); } + + const_iterator + cbegin() const + { return const_iterator(_Base::begin(), this); } + + const_iterator + cend() const + { return const_iterator(_Base::end(), this); } + + // local versions + using _Base::begin; + using _Base::end; + using _Base::cbegin; + using _Base::cend; + + iterator + insert(const value_type& __obj) + { return iterator(_Base::insert(__obj), this); } + + iterator + insert(iterator, const value_type& __obj) + { return iterator(_Base::insert(__obj), this); } + + const_iterator + insert(const_iterator, const value_type& __obj) + { return const_iterator(_Base::insert(__obj), this); } + + void + insert(std::initializer_list __l) + { _Base::insert(__l); } + + template + void + insert(_InputIterator __first, _InputIterator __last) + { + __glibcxx_check_valid_range(__first, __last); + _Base::insert(__first, __last); + } + + iterator + find(const key_type& __key) + { return iterator(_Base::find(__key), this); } + + const_iterator + find(const key_type& __key) const + { return const_iterator(_Base::find(__key), this); } + + std::pair + equal_range(const key_type& __key) + { + typedef typename _Base::iterator _Base_iterator; + typedef std::pair<_Base_iterator, _Base_iterator> __pair_type; + __pair_type __res = _Base::equal_range(__key); + return std::make_pair(iterator(__res.first, this), + iterator(__res.second, this)); + } + + std::pair + equal_range(const key_type& __key) const + { + typedef typename _Base::const_iterator _Base_iterator; + typedef std::pair<_Base_iterator, _Base_iterator> __pair_type; + __pair_type __res = _Base::equal_range(__key); + return std::make_pair(const_iterator(__res.first, this), + const_iterator(__res.second, this)); + } + + size_type + erase(const key_type& __key) + { + size_type __ret(0); + iterator __victim(_Base::find(__key), this); + if (__victim != end()) + { + this->erase(__victim); + __ret = 1; + } + return __ret; + } + + iterator + erase(iterator __it) + { + __glibcxx_check_erase(__it); + __it._M_invalidate(); + return iterator(_Base::erase(__it.base()), this); + } + + const_iterator + erase(const_iterator __it) + { + __glibcxx_check_erase(__it); + __it._M_invalidate(); + return const_iterator(_Base::erase(__it.base()), this); + } + + iterator + erase(iterator __first, iterator __last) + { + __glibcxx_check_erase_range(__first, __last); + for (iterator __tmp = __first; __tmp != __last;) + { + iterator __victim = __tmp++; + __victim._M_invalidate(); + } + return iterator(_Base::erase(__first.base(), + __last.base()), this); + } + + const_iterator + erase(const_iterator __first, const_iterator __last) + { + __glibcxx_check_erase_range(__first, __last); + for (const_iterator __tmp = __first; __tmp != __last;) + { + const_iterator __victim = __tmp++; + __victim._M_invalidate(); + } + return const_iterator(_Base::erase(__first.base(), + __last.base()), this); + } + + _Base& + _M_base() { return *this; } + + const _Base& + _M_base() const { return *this; } + private: void _M_invalidate_all() { typedef typename _Base::const_iterator _Base_const_iterator; typedef __gnu_debug::_Not_equal_to<_Base_const_iterator> _Not_equal; - this->_M_invalidate_if(_Not_equal(this->_M_base().end())); + this->_M_invalidate_if(_Not_equal(_M_base().end())); } }; @@ -276,7 +603,4 @@ namespace __debug } // namespace __debug } // namespace std -#undef _GLIBCXX_BASE -#undef _GLIBCXX_STD_BASE - #endif diff --git a/libstdc++-v3/testsuite/23_containers/unordered_multimap/init-list.cc b/libstdc++-v3/testsuite/23_containers/unordered_multimap/init-list.cc index ba35b38d85b..5faba7f57f9 100644 --- a/libstdc++-v3/testsuite/23_containers/unordered_multimap/init-list.cc +++ b/libstdc++-v3/testsuite/23_containers/unordered_multimap/init-list.cc @@ -26,8 +26,6 @@ // the GNU General Public License. // { dg-options "-std=gnu++0x" } -// XFAIL this test until debug mode container is fixed. -// { dg-excess-errors "" } #include #include