set.h (set): Implement C++11 allocator-aware container requirements.

2014-01-17  François Dumont  <fdumont@gcc.gnu.org>

	* include/profile/set.h (set): Implement C++11 allocator-aware
	container requirements.
	* include/profile/map.h (map): Likewise.
	* include/profile/multiset.h (multiset): Likewise.
	* include/profile/multimap.h (multimap): Likewise.
	* include/profile/set.h
	(set::operator=(const set&)): Define as default in C++11 mode.
	(set::operator=(set&&)): Likewise.
	* include/profile/map.h
	(map::operator=(const map&)): Likewise.
	(map::operator=(map&&)): Likewise.
	* include/profile/multiset.h
	(multiset::operator=(const multiset&)): Likewise.
	(multiset::operator=(multiset&&)): Likewise.
	* include/profile/multimap.h
	(multimap::operator=(const multimap&)): Likewise.
	(multimap::operator=(multimap&&)): Likewise.
	* include/profile/set.h (set::operator=(std::initializer_list<>)):
	Rely on the same operator from normal mode.
	* include/profile/map.h (map::operator=(std::initializer_list<>)):
	Likewise.
	* include/profile/multiset.h
	(multiset::operator=(std::initializer_list<>)): Likewise.
	* include/profile/multimap.h
	(multimap::operator=(std::initializer_list<>)): Likewise.
	* include/profile/set.h (set::swap(set&)): Add noexcept
	specification.
	* include/profile/map.h (map::swap(map&)): Likewise.
	* include/profile/multiset.h (multiset::swap(multiset&)): Likewise.
	* include/profile/multimap.h (multimap::swap(multimap&)): Likewise.

From-SVN: r206733

libstdc++-v3/ChangeLog

+2014-01-17  François Dumont  <fdumont@gcc.gnu.org>
+
+	* include/profile/set.h (set): Implement C++11 allocator-aware
+	container requirements.
+	* include/profile/map.h (map): Likewise.
+	* include/profile/multiset.h (multiset): Likewise.
+	* include/profile/multimap.h (multimap): Likewise.
+	* include/profile/set.h
+	(set::operator=(const set&)): Define as default in C++11 mode.
+	(set::operator=(set&&)): Likewise.
+	* include/profile/map.h
+	(map::operator=(const map&)): Likewise.
+	(map::operator=(map&&)): Likewise.
+	* include/profile/multiset.h
+	(multiset::operator=(const multiset&)): Likewise.
+	(multiset::operator=(multiset&&)): Likewise.
+	* include/profile/multimap.h
+	(multimap::operator=(const multimap&)): Likewise.
+	(multimap::operator=(multimap&&)): Likewise.
+	* include/profile/set.h (set::operator=(std::initializer_list<>)):
+	Rely on the same operator from normal mode.
+	* include/profile/map.h (map::operator=(std::initializer_list<>)):
+	Likewise.
+	* include/profile/multiset.h
+	(multiset::operator=(std::initializer_list<>)): Likewise.
+	* include/profile/multimap.h
+	(multimap::operator=(std::initializer_list<>)): Likewise.
+	* include/profile/set.h (set::swap(set&)): Add noexcept
+	specification.
+	* include/profile/map.h (map::swap(map&)): Likewise.
+	* include/profile/multiset.h (multiset::swap(multiset&)): Likewise.
+	* include/profile/multimap.h (multimap::swap(multimap&)): Likewise.
+
 2014-01-17  Tim Shen  <timshen91@gmail.com>
 
 	* include/bits/regex_automaton.tcc (_StateSeq<>::_M_clone()): Do not

libstdc++-v3/include/profile/map.h

@@ -43,6 +43,10 @@ namespace __profile
     {
       typedef _GLIBCXX_STD_C::map<_Key, _Tp, _Compare, _Allocator> _Base;
 
+#if __cplusplus >= 201103L
+      typedef __gnu_cxx::__alloc_traits<_Allocator> _Alloc_traits;
+#endif
+
     public:
       // types:
       typedef _Key                                  key_type;
@@ -93,40 +97,61 @@ namespace __profile
       map(map&& __x)
       noexcept(is_nothrow_copy_constructible<_Compare>::value)
       : _Base(std::move(__x))
-      { }
+      { __profcxx_map_to_unordered_map_construct(this); }
 
       map(initializer_list<value_type> __l,
 	  const _Compare& __c = _Compare(),
 	  const allocator_type& __a = allocator_type())
-      : _Base(__l, __c, __a) { }
+      : _Base(__l, __c, __a)
+      { __profcxx_map_to_unordered_map_construct(this); }
+
+      explicit
+      map(const allocator_type& __a)
+	: _Base(__a)
+      { __profcxx_map_to_unordered_map_construct(this); }
+
+      map(const map& __x, const allocator_type& __a)
+      : _Base(__x, __a)
+      { __profcxx_map_to_unordered_map_construct(this); }
+
+      map(map&& __x, const allocator_type& __a)
+      noexcept(is_nothrow_copy_constructible<_Compare>::value
+	       && _Alloc_traits::_S_always_equal())
+      : _Base(std::move(__x), __a)
+      { __profcxx_map_to_unordered_map_construct(this); }
+
+      map(initializer_list<value_type> __l, const allocator_type& __a)
+      : _Base(__l, __a)
+      { __profcxx_map_to_unordered_map_construct(this); }
+
+      template<typename _InputIterator>
+        map(_InputIterator __first, _InputIterator __last,
+	    const allocator_type& __a)
+	  : _Base(__first, __last, __a)
+      { __profcxx_map_to_unordered_map_construct(this); }
 #endif
 
       ~map() _GLIBCXX_NOEXCEPT
       { __profcxx_map_to_unordered_map_destruct(this); }
 
+#if __cplusplus < 201103L
       map&
       operator=(const map& __x)
       {
-	*static_cast<_Base*>(this) = __x;
+	_M_base() = __x;
 	return *this;
       }
+#else
+      map&
+      operator=(const map&) = default;
 
-#if __cplusplus >= 201103L
       map&
-      operator=(map&& __x)
-      {
-	// NB: DR 1204.
-	// NB: DR 675.
-	this->clear();
-	this->swap(__x);
-	return *this;
-      }
+      operator=(map&&) = default;
 
       map&
       operator=(initializer_list<value_type> __l)
       {
-	this->clear();
-	this->insert(__l);
+	_M_base() = __l;
 	return *this;
       }
 #endif
@@ -393,6 +418,9 @@ namespace __profile
 
       void
       swap(map& __x)
+#if __cplusplus >= 201103L
+      noexcept(_Alloc_traits::_S_nothrow_swap())
+#endif
       { _Base::swap(__x); }
 
       void

libstdc++-v3/include/profile/multimap.h

@@ -43,6 +43,10 @@ namespace __profile
     {
       typedef _GLIBCXX_STD_C::multimap<_Key, _Tp, _Compare, _Allocator> _Base;
 
+#if __cplusplus >= 201103L
+      typedef __gnu_cxx::__alloc_traits<_Allocator> _Alloc_traits;
+#endif
+
     public:
       // types:
       typedef _Key				     key_type;
@@ -79,49 +83,62 @@ namespace __profile
 	       const _Allocator& __a = _Allocator())
       : _Base(__first, __last, __comp, __a) { }
 
+#if __cplusplus < 201103L
       multimap(const multimap& __x)
       : _Base(__x) { }
-
-      multimap(const _Base& __x)
-      : _Base(__x) { }
-
-#if __cplusplus >= 201103L
-      multimap(multimap&& __x)
-      noexcept(is_nothrow_copy_constructible<_Compare>::value)
-      : _Base(std::move(__x))
-      { }
+#else
+      multimap(const multimap&) = default;
+      multimap(multimap&&) = default;
 
       multimap(initializer_list<value_type> __l,
 	       const _Compare& __c = _Compare(),
 	       const allocator_type& __a = allocator_type())
       : _Base(__l, __c, __a) { }
+
+      explicit
+      multimap(const allocator_type& __a)
+	: _Base(__a) { }
+
+      multimap(const multimap& __x, const allocator_type& __a)
+      : _Base(__x, __a) { }
+
+      multimap(multimap&& __x, const allocator_type& __a)
+      noexcept(is_nothrow_copy_constructible<_Compare>::value
+	       && _Alloc_traits::_S_always_equal())
+      : _Base(std::move(__x), __a) { }
+
+      multimap(initializer_list<value_type> __l, const allocator_type& __a)
+      : _Base(__l, __a) { }
+
+      template<typename _InputIterator>
+        multimap(_InputIterator __first, _InputIterator __last,
+	    const allocator_type& __a)
+	  : _Base(__first, __last, __a) { }
 #endif
 
+      multimap(const _Base& __x)
+      : _Base(__x) { }
+
       ~multimap() _GLIBCXX_NOEXCEPT { }
 
+#if __cplusplus < 201103L
       multimap&
       operator=(const multimap& __x)
       {
-	*static_cast<_Base*>(this) = __x;
+	_M_base() = __x;
 	return *this;
       }
+#else
+      multimap&
+      operator=(const multimap&) = default;
 
-#if __cplusplus >= 201103L
       multimap&
-      operator=(multimap&& __x)
-      {
-	// NB: DR 1204.
-	// NB: DR 675.
-	this->clear();
-	this->swap(__x);
-	return *this;
-      }
+      operator=(multimap&&) = default;
 
       multimap&
       operator=(initializer_list<value_type> __l)
       {
-	this->clear();
-	this->insert(__l);
+	_M_base() = __l;
 	return *this;
       }
 #endif
@@ -289,6 +306,9 @@ namespace __profile
 
       void
       swap(multimap& __x)
+#if __cplusplus >= 201103L
+      noexcept(_Alloc_traits::_S_nothrow_swap())
+#endif
       { _Base::swap(__x); }
 
       void

libstdc++-v3/include/profile/multiset.h

@@ -43,6 +43,10 @@ namespace __profile
     {
       typedef _GLIBCXX_STD_C::multiset<_Key, _Compare, _Allocator> _Base;
 
+#if __cplusplus >= 201103L
+      typedef __gnu_cxx::__alloc_traits<_Allocator> _Alloc_traits;
+#endif
+
     public:
       // types:
       typedef _Key				     key_type;
@@ -79,49 +83,62 @@ namespace __profile
 		 const _Allocator& __a = _Allocator())
 	: _Base(__first, __last, __comp, __a) { }
 
+#if __cplusplus < 201103L
       multiset(const multiset& __x)
       : _Base(__x) { }
-
-      multiset(const _Base& __x)
-      : _Base(__x) { }
-
-#if __cplusplus >= 201103L
-      multiset(multiset&& __x)
-      noexcept(is_nothrow_copy_constructible<_Compare>::value)
-      : _Base(std::move(__x))
-      { }
+#else
+      multiset(const multiset&) = default;
+      multiset(multiset&&) = default;
 
       multiset(initializer_list<value_type> __l,
 	       const _Compare& __comp = _Compare(),
 	       const allocator_type& __a = allocator_type())
       : _Base(__l, __comp, __a) { }
+
+      explicit
+      multiset(const allocator_type& __a)
+	: _Base(__a) { }
+
+      multiset(const multiset& __x, const allocator_type& __a)
+      : _Base(__x, __a) { }
+
+      multiset(multiset&& __x, const allocator_type& __a)
+      noexcept(is_nothrow_copy_constructible<_Compare>::value
+	       && _Alloc_traits::_S_always_equal())
+      : _Base(std::move(__x), __a) { }
+
+      multiset(initializer_list<value_type> __l, const allocator_type& __a)
+      : _Base(__l, __a) { }
+
+      template<typename _InputIterator>
+        multiset(_InputIterator __first, _InputIterator __last,
+	    const allocator_type& __a)
+	  : _Base(__first, __last, __a) { }
 #endif
 
+      multiset(const _Base& __x)
+      : _Base(__x) { }
+
       ~multiset() _GLIBCXX_NOEXCEPT { }
 
+#if __cplusplus < 201103L
       multiset&
       operator=(const multiset& __x)
       {
-	*static_cast<_Base*>(this) = __x;
+	_M_base() = __x;
 	return *this;
       }
+#else
+      multiset&
+      operator=(const multiset&) = default;
 
-#if __cplusplus >= 201103L
       multiset&
-      operator=(multiset&& __x)
-      {
-	// NB: DR 1204.
-	// NB: DR 675.
-	this->clear();
-	this->swap(__x);
-	return *this;
-      }
+      operator=(multiset&&) = default;
 
       multiset&
       operator=(initializer_list<value_type> __l)
       {
-	this->clear();
-	this->insert(__l);
+	_M_base() = __l;
 	return *this;
       }
 #endif
@@ -272,6 +289,9 @@ namespace __profile
 
       void
       swap(multiset& __x)
+#if __cplusplus >= 201103L
+      noexcept(_Alloc_traits::_S_nothrow_swap())
+#endif
       { _Base::swap(__x); }
 
       void

libstdc++-v3/include/profile/set.h

@@ -43,6 +43,10 @@ namespace __profile
     {
       typedef _GLIBCXX_STD_C::set<_Key, _Compare, _Allocator> _Base;
 
+#if __cplusplus >= 201103L
+      typedef __gnu_cxx::__alloc_traits<_Allocator> _Alloc_traits;
+#endif
+
     public:
       // types:
       typedef _Key				    key_type;
@@ -79,49 +83,62 @@ namespace __profile
 	    const _Allocator& __a = _Allocator())
 	: _Base(__first, __last, __comp, __a) { }
 
+#if __cplusplus < 201103L
       set(const set& __x)
       : _Base(__x) { }
-
-      set(const _Base& __x)
-      : _Base(__x) { }
-
-#if __cplusplus >= 201103L
-      set(set&& __x)
-      noexcept(is_nothrow_copy_constructible<_Compare>::value)
-      : _Base(std::move(__x))
-      { }
+#else
+      set(const set&) = default;
+      set(set&&) = default;
 
       set(initializer_list<value_type> __l,
 	  const _Compare& __comp = _Compare(),
 	  const allocator_type& __a = allocator_type())
       : _Base(__l, __comp, __a) { }
+
+      explicit
+      set(const allocator_type& __a)
+	: _Base(__a) { }
+
+      set(const set& __x, const allocator_type& __a)
+      : _Base(__x, __a) { }
+
+      set(set&& __x, const allocator_type& __a)
+      noexcept(is_nothrow_copy_constructible<_Compare>::value
+	       && _Alloc_traits::_S_always_equal())
+      : _Base(std::move(__x), __a) { }
+
+      set(initializer_list<value_type> __l, const allocator_type& __a)
+      : _Base(__l, __a) { }
+
+      template<typename _InputIterator>
+        set(_InputIterator __first, _InputIterator __last,
+	    const allocator_type& __a)
+	  : _Base(__first, __last, __a) { }
 #endif
 
+      set(const _Base& __x)
+      : _Base(__x) { }
+
       ~set() _GLIBCXX_NOEXCEPT { }
 
+#if __cplusplus < 201103L
       set&
       operator=(const set& __x)
       {
-	*static_cast<_Base*>(this) = __x;
+	_M_base() = __x;
 	return *this;
       }
+#else
+      set&
+      operator=(const set&) = default;
 
-#if __cplusplus >= 201103L
       set&
-      operator=(set&& __x)
-      {
-	// NB: DR 1204.
-	// NB: DR 675.
-	this->clear();
-	this->swap(__x);
-	return *this;
-      }
+      operator=(set&&) = default;
 
       set&
       operator=(initializer_list<value_type> __l)
       {
-	this->clear();
-	this->insert(__l);
+	_M_base() = __l;
 	return *this;
       }
 #endif
@@ -286,6 +303,9 @@ namespace __profile
 
       void
       swap(set& __x)
+#if __cplusplus >= 201103L
+      noexcept(_Alloc_traits::_S_nothrow_swap())
+#endif
       { _Base::swap(__x); }
 
       void