From c105751c468d9a05fb65ad1a22b8899dc1a1ae51 Mon Sep 17 00:00:00 2001 From: Edward Smith-Rowland <3dw4rd@verizon.net> Date: Fri, 14 Aug 2009 17:54:44 +0000 Subject: [PATCH] stl_tree.h: Make erase return iterator as per DR 130. 2009-08-14 Edward Smith-Rowland <3dw4rd@verizon.net> * include/bits/stl_tree.h: Make erase return iterator as per DR 130. * include/bits/stl_set.h: Same. * include/bits/stl_multiset.h: Same. * include/bits/stl_map.h: Same. * include/bits/stl_multimap.h: Same. * doc/xml/manual/intro.xml: Document. * testsuite/23_containers/set/dr130.cc: New. * testsuite/23_containers/multiset/dr130.cc: New. * testsuite/23_containers/map/dr130.cc: New. * testsuite/23_containers/multimap/dr130.cc: New. From-SVN: r150768 --- libstdc++-v3/ChangeLog | 13 +++ libstdc++-v3/doc/xml/manual/intro.xml | 6 + libstdc++-v3/include/bits/stl_map.h | 41 +++++++ libstdc++-v3/include/bits/stl_multimap.h | 43 +++++++ libstdc++-v3/include/bits/stl_multiset.h | 41 +++++++ libstdc++-v3/include/bits/stl_set.h | 40 +++++++ libstdc++-v3/include/bits/stl_tree.h | 110 +++++++++++++++++- .../testsuite/23_containers/map/dr130.cc | 77 ++++++++++++ .../testsuite/23_containers/multimap/dr130.cc | 87 ++++++++++++++ .../testsuite/23_containers/multiset/dr130.cc | 85 ++++++++++++++ .../testsuite/23_containers/set/dr130.cc | 75 ++++++++++++ 11 files changed, 616 insertions(+), 2 deletions(-) create mode 100644 libstdc++-v3/testsuite/23_containers/map/dr130.cc create mode 100644 libstdc++-v3/testsuite/23_containers/multimap/dr130.cc create mode 100644 libstdc++-v3/testsuite/23_containers/multiset/dr130.cc create mode 100644 libstdc++-v3/testsuite/23_containers/set/dr130.cc diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index c97b588dcdd..a48eb055c7a 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,16 @@ +2009-08-14 Edward Smith-Rowland <3dw4rd@verizon.net> + + * include/bits/stl_tree.h: Make erase return iterator as per DR 130. + * include/bits/stl_set.h: Same. + * include/bits/stl_multiset.h: Same. + * include/bits/stl_map.h: Same. + * include/bits/stl_multimap.h: Same. + * doc/xml/manual/intro.xml: Document. + * testsuite/23_containers/set/dr130.cc: New. + * testsuite/23_containers/multiset/dr130.cc: New. + * testsuite/23_containers/map/dr130.cc: New. + * testsuite/23_containers/multimap/dr130.cc: New. + 2009-08-14 Benjamin Kosnik * include/ext/pointer.h: Add pragma system_header, use diff --git a/libstdc++-v3/doc/xml/manual/intro.xml b/libstdc++-v3/doc/xml/manual/intro.xml index 2bf4dea28bf..28b80c90af0 100644 --- a/libstdc++-v3/doc/xml/manual/intro.xml +++ b/libstdc++-v3/doc/xml/manual/intro.xml @@ -393,6 +393,12 @@ requirements of the license of GCC. These functions set failbit on error now. + 130: + Return type of container::erase(iterator) differs for associative containers + + Make member erase return iterator for set, multiset, map, multimap. + + 136: seekp, seekg setting wrong streams? diff --git a/libstdc++-v3/include/bits/stl_map.h b/libstdc++-v3/include/bits/stl_map.h index 5416d827567..a26e68a01c0 100644 --- a/libstdc++-v3/include/bits/stl_map.h +++ b/libstdc++-v3/include/bits/stl_map.h @@ -552,6 +552,26 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) insert(_InputIterator __first, _InputIterator __last) { _M_t._M_insert_unique(__first, __last); } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 130. Associative erase should return an iterator. + /** + * @brief Erases an element from a %map. + * @param position An iterator pointing to the element to be erased. + * @return An iterator pointing to the element immediately following + * @a position prior to the element being erased. If no such + * element exists, end() is returned. + * + * This function erases an element, pointed to by the given + * iterator, from a %map. Note that this function only erases + * the element, and that if the element is itself a pointer, + * the pointed-to memory is not touched in any way. Managing + * the pointer is the user's responsibility. + */ + iterator + erase(iterator __position) + { return _M_t.erase(__position); } +#else /** * @brief Erases an element from a %map. * @param position An iterator pointing to the element to be erased. @@ -565,6 +585,7 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) void erase(iterator __position) { _M_t.erase(__position); } +#endif /** * @brief Erases elements according to the provided key. @@ -581,6 +602,25 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) erase(const key_type& __x) { return _M_t.erase(__x); } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 130. Associative erase should return an iterator. + /** + * @brief Erases a [first,last) range of elements from a %map. + * @param first Iterator pointing to the start of the range to be + * erased. + * @param last Iterator pointing to the end of the range to be erased. + * @return The iterator @a last. + * + * This function erases a sequence of elements from a %map. + * Note that this function only erases the element, and that if + * the element is itself a pointer, the pointed-to memory is not touched + * in any way. Managing the pointer is the user's responsibility. + */ + iterator + erase(iterator __first, iterator __last) + { return _M_t.erase(__first, __last); } +#else /** * @brief Erases a [first,last) range of elements from a %map. * @param first Iterator pointing to the start of the range to be @@ -595,6 +635,7 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) void erase(iterator __first, iterator __last) { _M_t.erase(__first, __last); } +#endif /** * @brief Swaps data with another %map. diff --git a/libstdc++-v3/include/bits/stl_multimap.h b/libstdc++-v3/include/bits/stl_multimap.h index 91dcfa675f4..fa3f2539018 100644 --- a/libstdc++-v3/include/bits/stl_multimap.h +++ b/libstdc++-v3/include/bits/stl_multimap.h @@ -488,6 +488,26 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) { this->insert(__l.begin(), __l.end()); } #endif +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 130. Associative erase should return an iterator. + /** + * @brief Erases an element from a %multimap. + * @param position An iterator pointing to the element to be erased. + * @return An iterator pointing to the element immediately following + * @a position prior to the element being erased. If no such + * element exists, end() is returned. + * + * This function erases an element, pointed to by the given iterator, + * from a %multimap. Note that this function only erases the element, + * and that if the element is itself a pointer, the pointed-to memory is + * not touched in any way. Managing the pointer is the user's + * responsibility. + */ + iterator + erase(iterator __position) + { return _M_t.erase(__position); } +#else /** * @brief Erases an element from a %multimap. * @param position An iterator pointing to the element to be erased. @@ -501,6 +521,7 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) void erase(iterator __position) { _M_t.erase(__position); } +#endif /** * @brief Erases elements according to the provided key. @@ -517,6 +538,27 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) erase(const key_type& __x) { return _M_t.erase(__x); } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 130. Associative erase should return an iterator. + /** + * @brief Erases a [first,last) range of elements from a %multimap. + * @param first Iterator pointing to the start of the range to be + * erased. + * @param last Iterator pointing to the end of the range to be erased. + * @return The iterator @a last. + * + * This function erases a sequence of elements from a %multimap. + * Note that this function only erases the elements, and that if + * the elements themselves are pointers, the pointed-to memory is not + * touched in any way. Managing the pointer is the user's responsibility. + */ + iterator + erase(iterator __first, iterator __last) + { return _M_t.erase(__first, __last); } +#else + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 130. Associative erase should return an iterator. /** * @brief Erases a [first,last) range of elements from a %multimap. * @param first Iterator pointing to the start of the range to be @@ -531,6 +573,7 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) void erase(iterator __first, iterator __last) { _M_t.erase(__first, __last); } +#endif /** * @brief Swaps data with another %multimap. diff --git a/libstdc++-v3/include/bits/stl_multiset.h b/libstdc++-v3/include/bits/stl_multiset.h index be9e2489ce9..431cbae4302 100644 --- a/libstdc++-v3/include/bits/stl_multiset.h +++ b/libstdc++-v3/include/bits/stl_multiset.h @@ -445,6 +445,26 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) { this->insert(__l.begin(), __l.end()); } #endif +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 130. Associative erase should return an iterator. + /** + * @brief Erases an element from a %multiset. + * @param position An iterator pointing to the element to be erased. + * @return An iterator pointing to the element immediately following + * @a position prior to the element being erased. If no such + * element exists, end() is returned. + * + * This function erases an element, pointed to by the given iterator, + * from a %multiset. Note that this function only erases the element, + * and that if the element is itself a pointer, the pointed-to memory is + * not touched in any way. Managing the pointer is the user's + * responsibility. + */ + iterator + erase(iterator __position) + { return _M_t.erase(__position); } +#else /** * @brief Erases an element from a %multiset. * @param position An iterator pointing to the element to be erased. @@ -458,6 +478,7 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) void erase(iterator __position) { _M_t.erase(__position); } +#endif /** * @brief Erases elements according to the provided key. @@ -474,6 +495,25 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) erase(const key_type& __x) { return _M_t.erase(__x); } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 130. Associative erase should return an iterator. + /** + * @brief Erases a [first,last) range of elements from a %multiset. + * @param first Iterator pointing to the start of the range to be + * erased. + * @param last Iterator pointing to the end of the range to be erased. + * @return The iterator @a last. + * + * This function erases a sequence of elements from a %multiset. + * Note that this function only erases the elements, and that if + * the elements themselves are pointers, the pointed-to memory is not + * touched in any way. Managing the pointer is the user's responsibility. + */ + iterator + erase(iterator __first, iterator __last) + { return _M_t.erase(__first, __last); } +#else /** * @brief Erases a [first,last) range of elements from a %multiset. * @param first Iterator pointing to the start of the range to be @@ -488,6 +528,7 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) void erase(iterator __first, iterator __last) { _M_t.erase(__first, __last); } +#endif /** * Erases all elements in a %multiset. Note that this function only diff --git a/libstdc++-v3/include/bits/stl_set.h b/libstdc++-v3/include/bits/stl_set.h index ccd0bc7b2ff..e87cccbab77 100644 --- a/libstdc++-v3/include/bits/stl_set.h +++ b/libstdc++-v3/include/bits/stl_set.h @@ -458,6 +458,25 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) { this->insert(__l.begin(), __l.end()); } #endif +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 130. Associative erase should return an iterator. + /** + * @brief Erases an element from a %set. + * @param position An iterator pointing to the element to be erased. + * @return An iterator pointing to the element immediately following + * @a position prior to the element being erased. If no such + * element exists, end() is returned. + * + * This function erases an element, pointed to by the given iterator, + * from a %set. Note that this function only erases the element, and + * that if the element is itself a pointer, the pointed-to memory is not + * touched in any way. Managing the pointer is the user's responsibility. + */ + iterator + erase(iterator __position) + { return _M_t.erase(__position); } +#else /** * @brief Erases an element from a %set. * @param position An iterator pointing to the element to be erased. @@ -470,6 +489,7 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) void erase(iterator __position) { _M_t.erase(__position); } +#endif /** * @brief Erases elements according to the provided key. @@ -486,6 +506,25 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) erase(const key_type& __x) { return _M_t.erase(__x); } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 130. Associative erase should return an iterator. + /** + * @brief Erases a [first,last) range of elements from a %set. + * @param first Iterator pointing to the start of the range to be + * erased. + * @param last Iterator pointing to the end of the range to be erased. + * @return The iterator @a last. + * + * This function erases a sequence of elements from a %set. + * Note that this function only erases the element, and that if + * the element is itself a pointer, the pointed-to memory is not touched + * in any way. Managing the pointer is the user's responsibility. + */ + iterator + erase(iterator __first, iterator __last) + { return _M_t.erase(__first, __last); } +#else /** * @brief Erases a [first,last) range of elements from a %set. * @param first Iterator pointing to the start of the range to be @@ -500,6 +539,7 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) void erase(iterator __first, iterator __last) { _M_t.erase(__first, __last); } +#endif /** * Erases all elements in a %set. Note that this function only erases diff --git a/libstdc++-v3/include/bits/stl_tree.h b/libstdc++-v3/include/bits/stl_tree.h index 1a67b563f62..d37dc57246e 100644 --- a/libstdc++-v3/include/bits/stl_tree.h +++ b/libstdc++-v3/include/bits/stl_tree.h @@ -698,21 +698,43 @@ _GLIBCXX_BEGIN_NAMESPACE(std) void _M_insert_equal(_InputIterator __first, _InputIterator __last); +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 130. Associative erase should return an iterator. + iterator + erase(iterator __position); + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 130. Associative erase should return an iterator. + const_iterator + erase(const_iterator __position); +#else void erase(iterator __position); void erase(const_iterator __position); - +#endif size_type erase(const key_type& __x); +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 130. Associative erase should return an iterator. + iterator + erase(iterator __first, iterator __last); + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 130. Associative erase should return an iterator. + const_iterator + erase(const_iterator __first, const_iterator __last); +#else void erase(iterator __first, iterator __last); void erase(const_iterator __first, const_iterator __last); - +#endif void erase(const key_type* __first, const key_type* __last); @@ -1327,6 +1349,45 @@ _GLIBCXX_BEGIN_NAMESPACE(std) _M_insert_equal_(end(), *__first); } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 130. Associative erase should return an iterator. + template + inline typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + erase(iterator __position) + { + iterator __result = __position; + ++__result; + _Link_type __y = + static_cast<_Link_type>(_Rb_tree_rebalance_for_erase + (__position._M_node, + this->_M_impl._M_header)); + _M_destroy_node(__y); + --_M_impl._M_node_count; + return __result; + } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 130. Associative erase should return an iterator. + template + inline typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + erase(const_iterator __position) + { + const_iterator __result = __position; + ++__result; + _Link_type __y = + static_cast<_Link_type>(_Rb_tree_rebalance_for_erase + (const_cast<_Base_ptr>(__position._M_node), + this->_M_impl._M_header)); + _M_destroy_node(__y); + --_M_impl._M_node_count; + return __result; + } +#else template inline void @@ -1354,6 +1415,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) _M_destroy_node(__y); --_M_impl._M_node_count; } +#endif template @@ -1367,6 +1429,49 @@ _GLIBCXX_BEGIN_NAMESPACE(std) return __old_size - size(); } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 130. Associative erase should return an iterator. + template + typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + erase(iterator __first, iterator __last) + { + if (__first == begin() && __last == end()) + { + clear(); + return end(); + } + else + { + while (__first != __last) + erase(__first++); + return __last; + } + } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 130. Associative erase should return an iterator. + template + typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + erase(const_iterator __first, const_iterator __last) + { + if (__first == begin() && __last == end()) + { + clear(); + return end(); + } + else + { + while (__first != __last) + erase(__first++); + return __last; + } + } +#else template void @@ -1392,6 +1497,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) while (__first != __last) erase(__first++); } +#endif template diff --git a/libstdc++-v3/testsuite/23_containers/map/dr130.cc b/libstdc++-v3/testsuite/23_containers/map/dr130.cc new file mode 100644 index 00000000000..d7f3c2b0856 --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/map/dr130.cc @@ -0,0 +1,77 @@ +// { dg-options "-std=gnu++0x" } +// 2008-07-22 Edward Smith-Rowland <3dw4rd@verizon.net> +// +// Copyright (C) 2009 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// . + +#include +#include + +// DR 130. Associative erase should return an iterator. +void +test01() +{ + bool test __attribute__((unused)) = true; + using namespace std; + + map m0; + typedef map::iterator iterator; + typedef map::const_iterator const_iterator; + typedef map::value_type value_type; + typedef pair insert_return_type; + + insert_return_type irt0 = m0.insert(value_type(1, 1)); + insert_return_type irt1 = m0.insert(value_type(2, 2)); + insert_return_type irt2 = m0.insert(value_type(3, 3)); + + iterator pos1 = m0.erase(irt1.first); + VERIFY( pos1 == irt2.first ); + + iterator pos2 = m0.erase(irt2.first); + VERIFY( pos2 == m0.end() ); +} + +void +test02() +{ + bool test __attribute__((unused)) = true; + using namespace std; + + map m0; + typedef map::iterator iterator; + typedef map::const_iterator const_iterator; + typedef map::value_type value_type; + typedef pair insert_return_type; + + insert_return_type irt0 = m0.insert(value_type(1, 1)); + insert_return_type irt1 = m0.insert(value_type(2, 2)); + insert_return_type irt2 = m0.insert(value_type(3, 3)); + insert_return_type irt3 = m0.insert(value_type(4, 4)); + + iterator pos1 = m0.erase(irt0.first, irt2.first); + VERIFY( pos1 == irt2.first ); + + iterator pos2 = m0.erase(irt2.first, ++irt3.first); + VERIFY( pos2 == m0.end() ); +} + +int +main() +{ + test01(); + test02(); +} diff --git a/libstdc++-v3/testsuite/23_containers/multimap/dr130.cc b/libstdc++-v3/testsuite/23_containers/multimap/dr130.cc new file mode 100644 index 00000000000..08684870642 --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/multimap/dr130.cc @@ -0,0 +1,87 @@ +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2009 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// . + + +// NOTE: This makes use of the fact that we know how moveable +// is implemented on multiset (via swap). If the implementation changed +// this test may begin to fail. + +#include +#include +#include + +using namespace std; + +void +test01() +{ + bool test __attribute__((unused)) = true; + using namespace std; + + multimap mm0; + typedef multimap::iterator iterator; + typedef multimap::const_iterator const_iterator; + typedef multimap::value_type value_type; + typedef iterator insert_return_type; + + vector irt; + for (int i = 1; i <= 4; ++i) + for (int j = 1; j <= i; ++j) + irt.push_back( mm0.insert( value_type( i, i ) ) ); + + iterator pos1 = mm0.erase(irt[1]); + VERIFY( pos1 == irt[2] ); + + iterator pos2 = mm0.erase(irt[2]); + VERIFY( pos2 == irt[3] ); + + iterator pos3 = mm0.erase(irt[9]); + VERIFY( pos3 == mm0.end() ); +} + +void +test02() +{ + bool test __attribute__((unused)) = true; + using namespace std; + + multimap mm0; + typedef multimap::iterator iterator; + typedef multimap::const_iterator const_iterator; + typedef multimap::value_type value_type; + typedef iterator insert_return_type; + + vector irt; + for (int i = 1; i <= 4; ++i) + for (int j = 1; j <= i; ++j) + irt.push_back( mm0.insert( value_type( i, i ) ) ); + + iterator pos1 = mm0.erase(irt[3], irt[6]); + VERIFY( pos1 == irt[6] ); + + iterator pos2 = mm0.erase(irt[6], ++irt[9]); + VERIFY( pos2 == mm0.end() ); +} + +int +main() +{ + test01(); + test02(); +} diff --git a/libstdc++-v3/testsuite/23_containers/multiset/dr130.cc b/libstdc++-v3/testsuite/23_containers/multiset/dr130.cc new file mode 100644 index 00000000000..52392fcc153 --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/multiset/dr130.cc @@ -0,0 +1,85 @@ +// { dg-options "-std=gnu++0x" } + +// Copyright (C) 2009 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// . + + +// NOTE: This makes use of the fact that we know how moveable +// is implemented on multiset (via swap). If the implementation changed +// this test may begin to fail. + +#include +#include +#include + +using namespace std; + +void +test01() +{ + bool test __attribute__((unused)) = true; + using namespace std; + + multiset ms0; + typedef multiset::iterator iterator; + typedef multiset::const_iterator const_iterator; + typedef iterator insert_return_type; + + vector irt; + for ( int i = 1; i <= 4; ++i ) + for (int j = 1; j <= i; ++j) + irt.push_back( ms0.insert( i ) ); + + iterator pos1 = ms0.erase(irt[1]); + VERIFY( pos1 == irt[2] ); + + iterator pos2 = ms0.erase(irt[2]); + VERIFY( pos2 == irt[3] ); + + iterator pos3 = ms0.erase(irt[9]); + VERIFY( pos3 == ms0.end() ); +} + +void +test02() +{ + bool test __attribute__((unused)) = true; + using namespace std; + + multiset ms0; + typedef multiset::iterator iterator; + typedef multiset::const_iterator const_iterator; + typedef iterator insert_return_type; + + vector irt; + for ( int i = 1; i <= 4; ++i ) + for (int j = 1; j <= i; ++j) + irt.push_back( ms0.insert( i ) ); + + iterator pos1 = ms0.erase(irt[3], irt[6]); + VERIFY( pos1 == irt[6] ); + + iterator pos2 = ms0.erase(irt[6], ++irt[9]); + VERIFY( pos2 == ms0.end() ); +} + +int +main() +{ + test01(); + test02(); +} diff --git a/libstdc++-v3/testsuite/23_containers/set/dr130.cc b/libstdc++-v3/testsuite/23_containers/set/dr130.cc new file mode 100644 index 00000000000..1904dcdc0bd --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/set/dr130.cc @@ -0,0 +1,75 @@ +// { dg-options "-std=gnu++0x" } +// 2008-07-22 Edward Smith-Rowland <3dw4rd@verizon.net> +// +// Copyright (C) 2009 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// . + +#include +#include + +// DR 130. Associative erase should return an iterator. +void +test01() +{ + bool test __attribute__((unused)) = true; + using namespace std; + + set s0; + typedef set::iterator iterator; + typedef set::const_iterator const_iterator; + typedef pair insert_return_type; + + insert_return_type irt0 = s0.insert(1); + insert_return_type irt1 = s0.insert(2); + insert_return_type irt2 = s0.insert(3); + + iterator pos1 = s0.erase(irt1.first); + VERIFY( pos1 == irt2.first ); + + iterator pos2 = s0.erase(irt2.first); + VERIFY( pos2 == s0.end() ); +} + +void +test02() +{ + bool test __attribute__((unused)) = true; + using namespace std; + + set s0; + typedef set::iterator iterator; + typedef set::const_iterator const_iterator; + typedef pair insert_return_type; + + insert_return_type irt0 = s0.insert(1); + insert_return_type irt1 = s0.insert(2); + insert_return_type irt2 = s0.insert(3); + insert_return_type irt3 = s0.insert(4); + + iterator pos1 = s0.erase(irt0.first, irt2.first); + VERIFY( pos1 == irt2.first ); + + iterator pos2 = s0.erase(irt2.first, ++irt3.first); + VERIFY( pos2 == s0.end() ); +} + +int +main() +{ + test01(); + test02(); +}