]> git.ipfire.org Git - thirdparty/gcc.git/commitdiff
projects / thirdparty / gcc.git / commitdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: e3f5a69)
hashtable.h (_Hashtable<>::operator=(const _Hashtable&)): Move inline.
authorPaolo Carlini <paolo.carlini@oracle.com>
Sat, 14 Aug 2010 01:00:23 +0000 (01:00 +0000)
committerPaolo Carlini <paolo@gcc.gnu.org>
Sat, 14 Aug 2010 01:00:23 +0000 (01:00 +0000)
2010-08-13  Paolo Carlini  <paolo.carlini@oracle.com>

* include/bits/hashtable.h (_Hashtable<>::operator=(const
_Hashtable&)): Move inline.
(operator=(_Hashtable&&)): Define.
* include/bits/unordered_map.h (unordered_map(unordered_map&&),
unordered_map(const unordered_map&), unordered_multimap
(unordered_multimap&&), unordered_multimap(const unordered_multimap&),
__unordered_map(__unordered_map&&), __unordered_map(const
__unordered_map&), __unordered_multimap(__unordered_multimap&&),
__unordered_multimap(const __unordered_multimap&)): Do not define,
leave implicit.
* include/bits/unordered_set.h (unordered_set(unordered_set&&),
unordered_set(const unordered_set&), unordered_multiset
(unordered_multiset&&), unordered_multiset(const unordered_multiset&),
__unordered_set(__unordered_set&&), __unordered_set(const
__unordered_set&), __unordered_multiset(__unordered_multiset&&),
__unordered_multiset(const __unordered_multiset&)): Likewise.

* include/bits/unordered_map.h (__unordered_map(initializer_list<>),
__unordered_map<>::operator=(initializer_list<>),
__unordered_multimap(initializer_list<>), __unordered_multimap<>::
operator=(initializer_list<>)): Add.
* include/bits/unordered_set.h (__unordered_set(initializer_list<>),
__unordered_set<>::operator=(initializer_list<>),
__unordered_multiset(initializer_list<>), __unordered_multiset<>::
operator=(initializer_list<>)): Likewise.

* include/bits/unordered_map.h (__unordered_map(_InputIterator,
_InputIterator, size_type __n), unordered_map(_InputIterator,
_InputIterator, size_type __n), unordered_map(initializer_list<>,
size_type __n), unordered_multimap(initializer_list<>, size_type __n)):
Fix __n default to 0.
* include/bits/unordered_set.h (__unordered_set(_InputIterator,
_InputIterator, size_type __n), unordered_set(_InputIterator,
_InputIterator, size_type __n), unordered_set(initializer_list<>,
size_type __n), unordered_multiset(initializer_list<>, size_type __n)):
Likewise.
* include/debug/unordered_map (unordered_map(_InputIterator,
_InputIterator, size_type __n), unordered_map(initializer_list<>,
size_type __n), unordered_map(_InputIterator, _InputIterator,
size_type __n), unordered_multimap(initializer_list<>, size_type __n)):
Likewise.
* include/debug/unordered_set (unordered_set(_InputIterator,
_InputIterator, size_type __n), unordered_set(initializer_list<>,
size_type __n), unordered_set(_InputIterator, _InputIterator,
size_type __n), unordered_multiset(initializer_list<>, size_type __n)):
Likewise.
* include/profile/unordered_map (unordered_map(_InputIterator,
_InputIterator, size_type __n), unordered_map(initializer_list<>,
size_type __n), unordered_map(_InputIterator, _InputIterator,
size_type __n), unordered_multimap(initializer_list<>, size_type __n)):
Likewise.
* include/profile/unordered_set (unordered_set(_InputIterator,
_InputIterator, size_type __n), unordered_set(initializer_list<>,
size_type __n), unordered_set(_InputIterator, _InputIterator,
size_type __n), unordered_multiset(initializer_list<>, size_type __n)):
Likewise.

From-SVN: r163236

libstdc++-v3/ChangeLog patch | blob | blame | history
libstdc++-v3/include/bits/hashtable.h patch | blob | blame | history
libstdc++-v3/include/bits/unordered_map.h patch | blob | blame | history
libstdc++-v3/include/bits/unordered_set.h patch | blob | blame | history
libstdc++-v3/include/debug/unordered_map patch | blob | blame | history
libstdc++-v3/include/debug/unordered_set patch | blob | blame | history
libstdc++-v3/include/profile/unordered_map patch | blob | blame | history
libstdc++-v3/include/profile/unordered_set patch | blob | blame | history

diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog
index f5c99a7f4bf42b54e9a7fe22afdbfe140b4e7ad0..115679e5e4dac15631179c575c20b707f08c1aee 100644 (file)
--- a/libstdc++-v3/ChangeLog
+++ b/libstdc++-v3/ChangeLog
@@ -1,3 +1,62 @@
+2010-08-13  Paolo Carlini  <paolo.carlini@oracle.com>
+
+       * include/bits/hashtable.h (_Hashtable<>::operator=(const
+       _Hashtable&)): Move inline.
+       (operator=(_Hashtable&&)): Define.
+       * include/bits/unordered_map.h (unordered_map(unordered_map&&),
+       unordered_map(const unordered_map&), unordered_multimap
+       (unordered_multimap&&), unordered_multimap(const unordered_multimap&),
+       __unordered_map(__unordered_map&&), __unordered_map(const
+       __unordered_map&), __unordered_multimap(__unordered_multimap&&),
+       __unordered_multimap(const __unordered_multimap&)): Do not define,
+       leave implicit.
+       * include/bits/unordered_set.h (unordered_set(unordered_set&&),
+       unordered_set(const unordered_set&), unordered_multiset
+       (unordered_multiset&&), unordered_multiset(const unordered_multiset&),
+       __unordered_set(__unordered_set&&), __unordered_set(const
+       __unordered_set&), __unordered_multiset(__unordered_multiset&&),
+       __unordered_multiset(const __unordered_multiset&)): Likewise.
+
+       * include/bits/unordered_map.h (__unordered_map(initializer_list<>),
+       __unordered_map<>::operator=(initializer_list<>),
+       __unordered_multimap(initializer_list<>), __unordered_multimap<>::
+       operator=(initializer_list<>)): Add.
+       * include/bits/unordered_set.h (__unordered_set(initializer_list<>),
+       __unordered_set<>::operator=(initializer_list<>),
+       __unordered_multiset(initializer_list<>), __unordered_multiset<>::
+       operator=(initializer_list<>)): Likewise.
+
+       * include/bits/unordered_map.h (__unordered_map(_InputIterator,
+       _InputIterator, size_type __n), unordered_map(_InputIterator,
+       _InputIterator, size_type __n), unordered_map(initializer_list<>,
+       size_type __n), unordered_multimap(initializer_list<>, size_type __n)):
+       Fix __n default to 0.
+       * include/bits/unordered_set.h (__unordered_set(_InputIterator,
+       _InputIterator, size_type __n), unordered_set(_InputIterator,
+       _InputIterator, size_type __n), unordered_set(initializer_list<>,
+       size_type __n), unordered_multiset(initializer_list<>, size_type __n)):
+       Likewise.
+       * include/debug/unordered_map (unordered_map(_InputIterator,
+       _InputIterator, size_type __n), unordered_map(initializer_list<>,
+       size_type __n), unordered_map(_InputIterator, _InputIterator,
+       size_type __n), unordered_multimap(initializer_list<>, size_type __n)):
+       Likewise.
+       * include/debug/unordered_set (unordered_set(_InputIterator,
+       _InputIterator, size_type __n), unordered_set(initializer_list<>,
+       size_type __n), unordered_set(_InputIterator, _InputIterator,
+       size_type __n), unordered_multiset(initializer_list<>, size_type __n)):
+       Likewise.
+       * include/profile/unordered_map (unordered_map(_InputIterator,
+       _InputIterator, size_type __n), unordered_map(initializer_list<>,
+       size_type __n), unordered_map(_InputIterator, _InputIterator,
+       size_type __n), unordered_multimap(initializer_list<>, size_type __n)):
+       Likewise.
+       * include/profile/unordered_set (unordered_set(_InputIterator,
+       _InputIterator, size_type __n), unordered_set(initializer_list<>,
+       size_type __n), unordered_set(_InputIterator, _InputIterator,
+       size_type __n), unordered_multiset(initializer_list<>, size_type __n)):
+       Likewise.
+
 2010-08-13  Paolo Carlini  <paolo.carlini@oracle.com>
 
        PR libstdc++/45281
diff --git a/libstdc++-v3/include/bits/hashtable.h b/libstdc++-v3/include/bits/hashtable.h
index a9876e169afdc6ff0cb764ae02e5a4fd92e78c6e..e62e156e523eb0f791071491dc7205fe586a67b5 100644 (file)
--- a/libstdc++-v3/include/bits/hashtable.h
+++ b/libstdc++-v3/include/bits/hashtable.h
@@ -212,7 +212,22 @@ namespace std
       _Hashtable(_Hashtable&&);
       
       _Hashtable&
-      operator=(const _Hashtable&);
+      operator=(const _Hashtable& __ht)
+      {
+       _Hashtable __tmp(__ht);
+       this->swap(__tmp);
+       return *this;
+      }
+
+      _Hashtable&
+      operator=(_Hashtable&& __ht)
+      {
+       // NB: DR 1204.
+       // NB: DR 675.
+       this->clear();
+       this->swap(__ht);
+       return *this;
+      }
 
       ~_Hashtable();
 
@@ -663,21 +678,6 @@ namespace std
       __ht._M_rehash_policy = _RehashPolicy();
     }
 
-  template<typename _Key, typename _Value, 
-          typename _Allocator, typename _ExtractKey, typename _Equal,
-          typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
-          bool __chc, bool __cit, bool __uk>
-    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-              _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>&
-    _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal,
-              _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::
-    operator=(const _Hashtable& __ht)
-    {
-      _Hashtable __tmp(__ht);
-      this->swap(__tmp);
-      return *this;
-    }
-
   template<typename _Key, typename _Value, 
           typename _Allocator, typename _ExtractKey, typename _Equal,
           typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
diff --git a/libstdc++-v3/include/bits/unordered_map.h b/libstdc++-v3/include/bits/unordered_map.h
index f3a16e0dd01d23880d4200f17be1385c0ed4fbdb..08058c1a94f8df2164ad4184111148220e0698e9 100644 (file)
--- a/libstdc++-v3/include/bits/unordered_map.h
+++ b/libstdc++-v3/include/bits/unordered_map.h
@@ -56,6 +56,7 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
         _Base;
 
     public:
+      typedef typename _Base::value_type      value_type;
       typedef typename _Base::size_type       size_type;
       typedef typename _Base::hasher          hasher;
       typedef typename _Base::key_equal       key_equal;
@@ -73,7 +74,7 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
 
       template<typename _InputIterator>
         __unordered_map(_InputIterator __f, _InputIterator __l, 
-                       size_type __n = 10,
+                       size_type __n = 0,
                        const hasher& __hf = hasher(), 
                        const key_equal& __eql = key_equal(), 
                        const allocator_type& __a = allocator_type())
@@ -82,10 +83,24 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
                __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
        { }
 
-      __unordered_map(const __unordered_map& __x) = default;
+      __unordered_map(initializer_list<value_type> __l,
+                     size_type __n = 0,
+                     const hasher& __hf = hasher(),
+                     const key_equal& __eql = key_equal(),
+                     const allocator_type& __a = allocator_type())
+      : _Base(__l.begin(), __l.end(), __n, __hf,
+             __detail::_Mod_range_hashing(),
+             __detail::_Default_ranged_hash(),
+             __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
+      { }
 
-      __unordered_map(__unordered_map&& __x)
-      : _Base(std::move(__x)) { }
+      __unordered_map&
+      operator=(initializer_list<value_type> __l)
+      {
+       this->clear();
+       this->insert(__l.begin(), __l.end());
+       return *this;
+      }
     };
   
   template<class _Key, class _Tp,
@@ -112,6 +127,7 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
         _Base;
 
     public:
+      typedef typename _Base::value_type      value_type;
       typedef typename _Base::size_type       size_type;
       typedef typename _Base::hasher          hasher;
       typedef typename _Base::key_equal       key_equal;
@@ -130,7 +146,7 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
 
       template<typename _InputIterator>
         __unordered_multimap(_InputIterator __f, _InputIterator __l, 
-                            typename _Base::size_type __n = 0,
+                            size_type __n = 0,
                             const hasher& __hf = hasher(), 
                             const key_equal& __eql = key_equal(), 
                             const allocator_type& __a = allocator_type())
@@ -139,10 +155,24 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
                __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
         { }
 
-      __unordered_multimap(const __unordered_multimap& __x) = default;
+      __unordered_multimap(initializer_list<value_type> __l,
+                          size_type __n = 0,
+                          const hasher& __hf = hasher(),
+                          const key_equal& __eql = key_equal(),
+                          const allocator_type& __a = allocator_type())
+      : _Base(__l.begin(), __l.end(), __n, __hf,
+             __detail::_Mod_range_hashing(),
+             __detail::_Default_ranged_hash(),
+             __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
+      { }
 
-      __unordered_multimap(__unordered_multimap&& __x)
-      : _Base(std::move(__x)) { }
+      __unordered_multimap&
+      operator=(initializer_list<value_type> __l)
+      {
+       this->clear();
+       this->insert(__l.begin(), __l.end());
+       return *this;
+      }
     };
 
   template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc,
@@ -243,39 +273,21 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
 
       template<typename _InputIterator>
         unordered_map(_InputIterator __f, _InputIterator __l, 
-                     size_type __n = 10,
+                     size_type __n = 0,
                      const hasher& __hf = hasher(), 
                      const key_equal& __eql = key_equal(), 
                      const allocator_type& __a = allocator_type())
        : _Base(__f, __l, __n, __hf, __eql, __a)
         { }
 
-      unordered_map(const unordered_map& __x) = default;
-
-      unordered_map(unordered_map&& __x)
-      : _Base(std::move(__x)) { }
-
       unordered_map(initializer_list<value_type> __l,
-                   size_type __n = 10,
+                   size_type __n = 0,
                    const hasher& __hf = hasher(),
                    const key_equal& __eql = key_equal(),
                    const allocator_type& __a = allocator_type())
-       : _Base(__l.begin(), __l.end(), __n, __hf, __eql, __a)
+      : _Base(__l.begin(), __l.end(), __n, __hf, __eql, __a)
       { }
 
-      unordered_map&
-      operator=(const unordered_map& __x) = default;
-
-      unordered_map&
-      operator=(unordered_map&& __x)
-      {
-       // NB: DR 1204.
-       // NB: DR 675.
-       this->clear();
-       this->swap(__x);
-       return *this;   
-      }
-
       unordered_map&
       operator=(initializer_list<value_type> __l)
       {
@@ -327,42 +339,23 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
       : _Base(__n, __hf, __eql, __a)
       { }
 
-
       template<typename _InputIterator>
         unordered_multimap(_InputIterator __f, _InputIterator __l, 
-                          typename _Base::size_type __n = 0,
+                          size_type __n = 0,
                           const hasher& __hf = hasher(), 
                           const key_equal& __eql = key_equal(), 
                           const allocator_type& __a = allocator_type())
        : _Base(__f, __l, __n, __hf, __eql, __a)
         { }
 
-      unordered_multimap(const unordered_multimap& __x) = default;
-
-      unordered_multimap(unordered_multimap&& __x)
-      : _Base(std::move(__x)) { }
-
       unordered_multimap(initializer_list<value_type> __l,
-                        size_type __n = 10,
+                        size_type __n = 0,
                         const hasher& __hf = hasher(),
                         const key_equal& __eql = key_equal(),
                         const allocator_type& __a = allocator_type())
-       : _Base(__l.begin(), __l.end(), __n, __hf, __eql, __a)
+      : _Base(__l.begin(), __l.end(), __n, __hf, __eql, __a)
       { }
 
-      unordered_multimap&
-      operator=(const unordered_multimap& __x) = default;
-
-      unordered_multimap&
-      operator=(unordered_multimap&& __x)
-      {
-       // NB: DR 1204.
-       // NB: DR 675.
-       this->clear();
-       this->swap(__x);
-       return *this;   
-      }
-
       unordered_multimap&
       operator=(initializer_list<value_type> __l)
       {
diff --git a/libstdc++-v3/include/bits/unordered_set.h b/libstdc++-v3/include/bits/unordered_set.h
index f056be57ec0890af475505113842587ce1fa8c83..260ad796c1aa070b603d671c762645ae4e54d494 100644 (file)
--- a/libstdc++-v3/include/bits/unordered_set.h
+++ b/libstdc++-v3/include/bits/unordered_set.h
@@ -56,6 +56,7 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
         _Base;
 
     public:
+      typedef typename _Base::value_type      value_type;
       typedef typename _Base::size_type       size_type;
       typedef typename _Base::hasher          hasher;
       typedef typename _Base::key_equal       key_equal;
@@ -68,24 +69,38 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
                      const allocator_type& __a = allocator_type())
       : _Base(__n, __hf, __detail::_Mod_range_hashing(),
              __detail::_Default_ranged_hash(), __eql,
-             std::_Identity<_Value>(), __a)
+             std::_Identity<value_type>(), __a)
       { }
 
       template<typename _InputIterator>
         __unordered_set(_InputIterator __f, _InputIterator __l, 
-                       size_type __n = 10,
+                       size_type __n = 0,
                        const hasher& __hf = hasher(), 
                        const key_equal& __eql = key_equal(), 
                        const allocator_type& __a = allocator_type())
        : _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
                __detail::_Default_ranged_hash(), __eql,
-               std::_Identity<_Value>(), __a)
+               std::_Identity<value_type>(), __a)
         { }
 
-      __unordered_set(const __unordered_set& __x) = default;
+      __unordered_set(initializer_list<value_type> __l,
+                     size_type __n = 0,
+                     const hasher& __hf = hasher(),
+                     const key_equal& __eql = key_equal(),
+                     const allocator_type& __a = allocator_type())
+      : _Base(__l.begin(), __l.end(), __n, __hf,
+             __detail::_Mod_range_hashing(),
+             __detail::_Default_ranged_hash(), __eql,
+             std::_Identity<value_type>(), __a)
+      { }
 
-      __unordered_set(__unordered_set&& __x)
-      : _Base(std::move(__x)) { }
+      __unordered_set&
+      operator=(initializer_list<value_type> __l)
+      {
+       this->clear();
+       this->insert(__l.begin(), __l.end());
+       return *this;
+      }
     };
 
   template<class _Value,
@@ -110,6 +125,7 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
         _Base;
 
     public:
+      typedef typename _Base::value_type      value_type;
       typedef typename _Base::size_type       size_type;
       typedef typename _Base::hasher          hasher;
       typedef typename _Base::key_equal       key_equal;
@@ -122,25 +138,39 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
                           const allocator_type& __a = allocator_type())
       : _Base(__n, __hf, __detail::_Mod_range_hashing(),
              __detail::_Default_ranged_hash(), __eql,
-             std::_Identity<_Value>(), __a)
+             std::_Identity<value_type>(), __a)
       { }
 
 
       template<typename _InputIterator>
         __unordered_multiset(_InputIterator __f, _InputIterator __l, 
-                            typename _Base::size_type __n = 0,
+                            size_type __n = 0,
                             const hasher& __hf = hasher(), 
                             const key_equal& __eql = key_equal(), 
                             const allocator_type& __a = allocator_type())
        : _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
                __detail::_Default_ranged_hash(), __eql,
-               std::_Identity<_Value>(), __a)
+               std::_Identity<value_type>(), __a)
         { }
 
-      __unordered_multiset(const __unordered_multiset& __x) = default;
+      __unordered_multiset(initializer_list<value_type> __l,
+                          size_type __n = 0,
+                          const hasher& __hf = hasher(),
+                          const key_equal& __eql = key_equal(),
+                          const allocator_type& __a = allocator_type())
+      : _Base(__l.begin(), __l.end(), __n, __hf,
+             __detail::_Mod_range_hashing(),
+             __detail::_Default_ranged_hash(), __eql,
+             std::_Identity<value_type>(), __a)
+      { }
 
-      __unordered_multiset(__unordered_multiset&& __x)
-      : _Base(std::move(__x)) { }
+      __unordered_multiset&
+      operator=(initializer_list<value_type> __l)
+      {
+       this->clear();
+       this->insert(__l.begin(), __l.end());
+       return *this;
+      }
     };
 
   template<class _Value, class _Hash, class _Pred, class _Alloc,
@@ -236,39 +266,21 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
 
       template<typename _InputIterator>
         unordered_set(_InputIterator __f, _InputIterator __l, 
-                     size_type __n = 10,
+                     size_type __n = 0,
                      const hasher& __hf = hasher(), 
                      const key_equal& __eql = key_equal(), 
                      const allocator_type& __a = allocator_type())
        : _Base(__f, __l, __n, __hf, __eql, __a)
         { }
 
-      unordered_set(const unordered_set& __x) = default;
-
-      unordered_set(unordered_set&& __x)
-      : _Base(std::move(__x)) { }
-
       unordered_set(initializer_list<value_type> __l,
-                   size_type __n = 10,
+                   size_type __n = 0,
                    const hasher& __hf = hasher(),
                    const key_equal& __eql = key_equal(),
                    const allocator_type& __a = allocator_type())
-       : _Base(__l.begin(), __l.end(), __n, __hf, __eql, __a)
+      : _Base(__l.begin(), __l.end(), __n, __hf, __eql, __a)
       { }
 
-      unordered_set&
-      operator=(const unordered_set& __x) = default;
-
-      unordered_set&
-      operator=(unordered_set&& __x)
-      {
-       // NB: DR 1204.
-       // NB: DR 675.
-       this->clear();
-       this->swap(__x);
-       return *this;   
-      }
-
       unordered_set&
       operator=(initializer_list<value_type> __l)
       {
@@ -320,39 +332,21 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
 
       template<typename _InputIterator>
         unordered_multiset(_InputIterator __f, _InputIterator __l, 
-                          typename _Base::size_type __n = 0,
+                          size_type __n = 0,
                           const hasher& __hf = hasher(), 
                           const key_equal& __eql = key_equal(), 
                           const allocator_type& __a = allocator_type())
        : _Base(__f, __l, __n, __hf, __eql, __a)
         { }
 
-      unordered_multiset(const unordered_multiset& __x) = default;
-
-      unordered_multiset(unordered_multiset&& __x)
-      : _Base(std::move(__x)) { }
-
       unordered_multiset(initializer_list<value_type> __l,
-                        size_type __n = 10,
+                        size_type __n = 0,
                         const hasher& __hf = hasher(),
                         const key_equal& __eql = key_equal(),
                         const allocator_type& __a = allocator_type())
-       : _Base(__l.begin(), __l.end(), __n, __hf, __eql, __a)
+      : _Base(__l.begin(), __l.end(), __n, __hf, __eql, __a)
       { }
 
-      unordered_multiset&
-      operator=(const unordered_multiset& __x) = default;
-
-      unordered_multiset&
-      operator=(unordered_multiset&& __x)
-      {
-       // NB: DR 1204.
-       // NB: DR 675.
-       this->clear();
-       this->swap(__x);
-       return *this;   
-      }
-
       unordered_multiset&
       operator=(initializer_list<value_type> __l)
       {
diff --git a/libstdc++-v3/include/debug/unordered_map b/libstdc++-v3/include/debug/unordered_map
index 805e42ee75ec3f1fe0154cb391ce1326f657d5d5..04d311dc408d43375a15b614c4e493c33c10d4a3 100644 (file)
--- a/libstdc++-v3/include/debug/unordered_map
+++ b/libstdc++-v3/include/debug/unordered_map
@@ -79,7 +79,7 @@ namespace __debug
 
       template<typename _InputIterator>
         unordered_map(_InputIterator __f, _InputIterator __l, 
-                     size_type __n = 10,
+                     size_type __n = 0,
                      const hasher& __hf = hasher(), 
                      const key_equal& __eql = key_equal(), 
                      const allocator_type& __a = allocator_type())
@@ -96,7 +96,7 @@ namespace __debug
       : _Base(std::move(__x)), _Safe_base() { }
 
       unordered_map(initializer_list<value_type> __l,
-                   size_type __n = 10,
+                   size_type __n = 0,
                    const hasher& __hf = hasher(),
                    const key_equal& __eql = key_equal(),
                    const allocator_type& __a = allocator_type())
@@ -338,7 +338,7 @@ namespace __debug
 
       template<typename _InputIterator>
         unordered_multimap(_InputIterator __f, _InputIterator __l, 
-                          size_type __n = 10,
+                          size_type __n = 0,
                           const hasher& __hf = hasher(), 
                           const key_equal& __eql = key_equal(), 
                           const allocator_type& __a = allocator_type())
@@ -355,7 +355,7 @@ namespace __debug
       : _Base(std::move(__x)), _Safe_base() { }
 
       unordered_multimap(initializer_list<value_type> __l,
-                        size_type __n = 10,
+                        size_type __n = 0,
                         const hasher& __hf = hasher(),
                         const key_equal& __eql = key_equal(),
                         const allocator_type& __a = allocator_type())
diff --git a/libstdc++-v3/include/debug/unordered_set b/libstdc++-v3/include/debug/unordered_set
index 80ca806f5aa5e0217db7ee2aaca3a1c44a6a3244..13f869813e58ffa46c1e38c53ad056c77cdc31f7 100644 (file)
--- a/libstdc++-v3/include/debug/unordered_set
+++ b/libstdc++-v3/include/debug/unordered_set
@@ -79,7 +79,7 @@ namespace __debug
 
       template<typename _InputIterator>
         unordered_set(_InputIterator __f, _InputIterator __l, 
-                     size_type __n = 10,
+                     size_type __n = 0,
                      const hasher& __hf = hasher(), 
                      const key_equal& __eql = key_equal(), 
                      const allocator_type& __a = allocator_type())
@@ -96,7 +96,7 @@ namespace __debug
       : _Base(std::move(__x)), _Safe_base() { }
 
       unordered_set(initializer_list<value_type> __l,
-                   size_type __n = 10,
+                   size_type __n = 0,
                    const hasher& __hf = hasher(),
                    const key_equal& __eql = key_equal(),
                    const allocator_type& __a = allocator_type())
@@ -334,7 +334,7 @@ namespace __debug
 
       template<typename _InputIterator>
         unordered_multiset(_InputIterator __f, _InputIterator __l, 
-                          size_type __n = 10,
+                          size_type __n = 0,
                           const hasher& __hf = hasher(), 
                           const key_equal& __eql = key_equal(), 
                           const allocator_type& __a = allocator_type())
@@ -351,7 +351,7 @@ namespace __debug
       : _Base(std::move(__x)), _Safe_base() { }
 
       unordered_multiset(initializer_list<value_type> __l,
-                        size_type __n = 10,
+                        size_type __n = 0,
                         const hasher& __hf = hasher(),
                         const key_equal& __eql = key_equal(),
                         const allocator_type& __a = allocator_type())
diff --git a/libstdc++-v3/include/profile/unordered_map b/libstdc++-v3/include/profile/unordered_map
index 203ae97ef8d001beeae294b9a2e8eaf26922a133..2dec1f2a26807bdc7c83c569d8396d251570278c 100644 (file)
--- a/libstdc++-v3/include/profile/unordered_map
+++ b/libstdc++-v3/include/profile/unordered_map
@@ -86,10 +86,10 @@ namespace __profile
 
       template<typename _InputIterator>
         unordered_map(_InputIterator __f, _InputIterator __l,
-              size_type __n = 10,
-              const hasher& __hf = hasher(),
-              const key_equal& __eql = key_equal(),
-              const allocator_type& __a = allocator_type())
+                     size_type __n = 0,
+                     const hasher& __hf = hasher(),
+                     const key_equal& __eql = key_equal(),
+                     const allocator_type& __a = allocator_type())
       : _Base(__f, __l, __n, __hf, __eql, __a)
       {
         __profcxx_hashtable_construct(this, _Base::bucket_count());
@@ -111,7 +111,7 @@ namespace __profile
       }
 
       unordered_map(initializer_list<value_type> __l,
-                   size_type __n = 10,
+                   size_type __n = 0,
                    const hasher& __hf = hasher(),
                    const key_equal& __eql = key_equal(),
                    const allocator_type& __a = allocator_type())
@@ -314,19 +314,19 @@ namespace __profile
 
       explicit
       unordered_multimap(size_type __n = 10,
-                   const hasher& __hf = hasher(),
-                   const key_equal& __eql = key_equal(),
-                   const allocator_type& __a = allocator_type())
+                        const hasher& __hf = hasher(),
+                        const key_equal& __eql = key_equal(),
+                        const allocator_type& __a = allocator_type())
       : _Base(__n, __hf, __eql, __a)
       {
         __profcxx_hashtable_construct(this, _Base::bucket_count());
       }
       template<typename _InputIterator>
         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())
+                          size_type __n = 0,
+                          const hasher& __hf = hasher(),
+                          const key_equal& __eql = key_equal(),
+                          const allocator_type& __a = allocator_type())
       : _Base(__f, __l, __n, __hf, __eql, __a)
       {
         __profcxx_hashtable_construct(this, _Base::bucket_count());
@@ -345,7 +345,7 @@ namespace __profile
       }
 
       unordered_multimap(initializer_list<value_type> __l,
-                        size_type __n = 10,
+                        size_type __n = 0,
                         const hasher& __hf = hasher(),
                         const key_equal& __eql = key_equal(),
                         const allocator_type& __a = allocator_type())
diff --git a/libstdc++-v3/include/profile/unordered_set b/libstdc++-v3/include/profile/unordered_set
index 1a8836a7772fb944e4fe5866e62ceb7b4da5febf..2dade092024cb0987baa3949014200f14af62be6 100644 (file)
--- a/libstdc++-v3/include/profile/unordered_set
+++ b/libstdc++-v3/include/profile/unordered_set
@@ -85,10 +85,10 @@ namespace __profile
 
       template<typename _InputIterator>
         unordered_set(_InputIterator __f, _InputIterator __l,
-              size_type __n = 10,
-              const hasher& __hf = hasher(),
-              const key_equal& __eql = key_equal(),
-              const allocator_type& __a = allocator_type())
+                     size_type __n = 0,
+                     const hasher& __hf = hasher(),
+                     const key_equal& __eql = key_equal(),
+                     const allocator_type& __a = allocator_type())
       : _Base(__f, __l, __n, __hf, __eql, __a)
       {
         __profcxx_hashtable_construct(this, _Base::bucket_count());
@@ -110,7 +110,7 @@ namespace __profile
       }
 
       unordered_set(initializer_list<value_type> __l,
-                   size_type __n = 10,
+                   size_type __n = 0,
                    const hasher& __hf = hasher(),
                    const key_equal& __eql = key_equal(),
                    const allocator_type& __a = allocator_type())
@@ -302,9 +302,9 @@ namespace __profile
 
       explicit
       unordered_multiset(size_type __n = 10,
-                   const hasher& __hf = hasher(),
-                   const key_equal& __eql = key_equal(),
-                   const allocator_type& __a = allocator_type())
+                        const hasher& __hf = hasher(),
+                        const key_equal& __eql = key_equal(),
+                        const allocator_type& __a = allocator_type())
       : _Base(__n, __hf, __eql, __a)
       {
         __profcxx_hashtable_construct(this, _Base::bucket_count());
@@ -312,10 +312,10 @@ namespace __profile
 
       template<typename _InputIterator>
         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())
+                          size_type __n = 0,
+                          const hasher& __hf = hasher(),
+                          const key_equal& __eql = key_equal(),
+                          const allocator_type& __a = allocator_type())
       : _Base(__f, __l, __n, __hf, __eql, __a)
       {
         __profcxx_hashtable_construct(this, _Base::bucket_count());
@@ -334,7 +334,7 @@ namespace __profile
       }
 
       unordered_multiset(initializer_list<value_type> __l,
-                        size_type __n = 10,
+                        size_type __n = 0,
                         const hasher& __hf = hasher(),
                         const key_equal& __eql = key_equal(),
                         const allocator_type& __a = allocator_type())
Mirror of https://gcc.gnu.org/git/gcc.git