unordered_map (class __unordered_map, [...]): New.

2007-02-22  Paolo Carlini  <pcarlini@suse.de>

	* include/tr1/unordered_map (class __unordered_map,
	class __unordered_multimap): New.
	(class unordered_map, class unordered_multimap): Forward to
	the latter.
	* include/tr1/unordered_set: Likewise for unordered_set and
	unordered_multiset.
	* testsuite/tr1/6_containers/headers/unordered_set/synopsis.cc:
	Remove xfail.
	* testsuite/tr1/6_containers/headers/unordered_map/synopsis.cc:
	Likewise.
	* testsuite/tr1/6_containers/unordered_multimap/requirements/
	explicit_instantiation.cc: Adjust.
	* testsuite/tr1/6_containers/unordered_set/requirements/
	explicit_instantiation.cc: Likewise.
	* testsuite/tr1/6_containers/unordered_map/requirements/
	explicit_instantiation.cc: Likewise.
	* testsuite/tr1/6_containers/unordered_multiset/requirements/
	explicit_instantiation.cc: Likewise.
	* testsuite/tr1/6_containers/unordered_map/24064.cc: Likewise.
	* testsuite/util/native_type/assoc/native_hash_set.hpp: Likewise.
	* testsuite/util/native_type/assoc/native_hash_map.hpp: Likewise.

From-SVN: r122223

diff --git a/libstdc++-v3/include/tr1/unordered_map b/libstdc++-v3/include/tr1/unordered_map
index d613d156ef1efad2f3cafa4342f2dfc26db7a51d..50e981ce5000dd3bb94ac046ba4650677bd7964d 100644 (file)
--- a/libstdc++-v3/include/tr1/unordered_map
+++ b/libstdc++-v3/include/tr1/unordered_map
@@ -48,7 +48,7 @@ _GLIBCXX_BEGIN_NAMESPACE(tr1)
           class _Pred = std::equal_to<_Key>,
           class _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
           bool __cache_hash_code = false>
-    class unordered_map
+    class __unordered_map
     : public _Hashtable<_Key, std::pair<const _Key, _Tp>, _Alloc,
                        std::_Select1st<std::pair<const _Key, _Tp> >, _Pred, 
                        _Hash, __detail::_Mod_range_hashing,
@@ -71,21 +71,21 @@ _GLIBCXX_BEGIN_NAMESPACE(tr1)
       typedef typename _Base::allocator_type  allocator_type;
 
       explicit
-      unordered_map(size_type __n = 10,
-                   const hasher& __hf = hasher(),
-                   const key_equal& __eql = key_equal(),
-                   const allocator_type& __a = allocator_type())
+      __unordered_map(size_type __n = 10,
+                     const hasher& __hf = hasher(),
+                     const key_equal& __eql = key_equal(),
+                     const allocator_type& __a = allocator_type())
       : _Base(__n, __hf, __detail::_Mod_range_hashing(),
              __detail::_Default_ranged_hash(),
              __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
       { }
 
       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())
+        __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())
        : _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
                __detail::_Default_ranged_hash(),
                __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
@@ -97,7 +97,7 @@ _GLIBCXX_BEGIN_NAMESPACE(tr1)
           class _Pred = std::equal_to<_Key>,
           class _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
           bool __cache_hash_code = false>
-    class unordered_multimap
+    class __unordered_multimap
     : public _Hashtable<_Key, std::pair<const _Key, _Tp>,
                        _Alloc,
                        std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
@@ -122,10 +122,10 @@ _GLIBCXX_BEGIN_NAMESPACE(tr1)
       typedef typename _Base::allocator_type  allocator_type;
       
       explicit
-      unordered_multimap(size_type __n = 10,
-                        const hasher& __hf = hasher(),
-                        const key_equal& __eql = key_equal(),
-                        const allocator_type& __a = allocator_type())
+      __unordered_multimap(size_type __n = 10,
+                          const hasher& __hf = hasher(),
+                          const key_equal& __eql = key_equal(),
+                          const allocator_type& __a = allocator_type())
       : _Base(__n, __hf, __detail::_Mod_range_hashing(),
              __detail::_Default_ranged_hash(),
              __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
@@ -133,11 +133,11 @@ _GLIBCXX_BEGIN_NAMESPACE(tr1)
 
 
       template<typename _InputIterator>
-        unordered_multimap(_InputIterator __f, _InputIterator __l, 
-                          typename _Base::size_type __n = 0,
-                          const hasher& __hf = hasher(), 
-                          const key_equal& __eql = key_equal(), 
-                          const allocator_type& __a = allocator_type())
+        __unordered_multimap(_InputIterator __f, _InputIterator __l, 
+                            typename _Base::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::_Select1st<std::pair<const _Key, _Tp> >(), __a)
@@ -147,21 +147,89 @@ _GLIBCXX_BEGIN_NAMESPACE(tr1)
   template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc,
           bool __cache_hash_code>
     inline void
-    swap(unordered_map<_Key, _Tp, _Hash, _Pred,
+    swap(__unordered_map<_Key, _Tp, _Hash, _Pred,
         _Alloc, __cache_hash_code>& __x,
-        unordered_map<_Key, _Tp, _Hash, _Pred,
+        __unordered_map<_Key, _Tp, _Hash, _Pred,
         _Alloc, __cache_hash_code>& __y)
     { __x.swap(__y); }
 
   template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc,
           bool __cache_hash_code>
     inline void
-    swap(unordered_multimap<_Key, _Tp, _Hash, _Pred,
+    swap(__unordered_multimap<_Key, _Tp, _Hash, _Pred,
         _Alloc, __cache_hash_code>& __x,
-        unordered_multimap<_Key, _Tp, _Hash, _Pred,
+        __unordered_multimap<_Key, _Tp, _Hash, _Pred,
         _Alloc, __cache_hash_code>& __y)
     { __x.swap(__y); }
 
+
+  template<class _Key, class _Tp,
+          class _Hash = hash<_Key>,
+          class _Pred = std::equal_to<_Key>,
+          class _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
+    class unordered_map
+    : public __unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>
+    {
+      typedef __unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>  _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;
+
+      explicit
+      unordered_map(size_type __n = 10,
+                   const hasher& __hf = hasher(),
+                   const key_equal& __eql = key_equal(),
+                   const allocator_type& __a = allocator_type())
+      : _Base(__n, __hf, __eql, __a)
+      { }
+
+      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())
+       : _Base(__f, __l, __n, __hf, __eql, __a)
+        { }
+    };
+  
+  template<class _Key, class _Tp,
+          class _Hash = hash<_Key>,
+          class _Pred = std::equal_to<_Key>,
+          class _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
+    class unordered_multimap
+    : public __unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>
+    {
+      typedef __unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>  _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;
+      
+      explicit
+      unordered_multimap(size_type __n = 10,
+                        const hasher& __hf = hasher(),
+                        const key_equal& __eql = key_equal(),
+                        const allocator_type& __a = allocator_type())
+      : _Base(__n, __hf, __eql, __a)
+      { }
+
+
+      template<typename _InputIterator>
+        unordered_multimap(_InputIterator __f, _InputIterator __l, 
+                          typename _Base::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)
+        { }
+    };
+
 _GLIBCXX_END_NAMESPACE
 }
 

diff --git a/libstdc++-v3/include/tr1/unordered_set b/libstdc++-v3/include/tr1/unordered_set
index a01b89b3af8fa5b5d5f16f949181d39a1c328c68..84a24f4a9aee27d2801c910d17e2fa575889b0d0 100644 (file)
--- a/libstdc++-v3/include/tr1/unordered_set
+++ b/libstdc++-v3/include/tr1/unordered_set
@@ -48,7 +48,7 @@ _GLIBCXX_BEGIN_NAMESPACE(tr1)
           class _Pred = std::equal_to<_Value>,
           class _Alloc = std::allocator<_Value>,
           bool __cache_hash_code = false>
-    class unordered_set
+    class __unordered_set
     : public _Hashtable<_Value, _Value, _Alloc,
                        std::_Identity<_Value>, _Pred,
                        _Hash, __detail::_Mod_range_hashing,
@@ -71,21 +71,21 @@ _GLIBCXX_BEGIN_NAMESPACE(tr1)
       typedef typename _Base::allocator_type  allocator_type;
       
       explicit
-      unordered_set(size_type __n = 10,
-                   const hasher& __hf = hasher(),
-                   const key_equal& __eql = key_equal(),
-                   const allocator_type& __a = allocator_type())
+      __unordered_set(size_type __n = 10,
+                     const hasher& __hf = hasher(),
+                     const key_equal& __eql = key_equal(),
+                     const allocator_type& __a = allocator_type())
       : _Base(__n, __hf, __detail::_Mod_range_hashing(),
              __detail::_Default_ranged_hash(), __eql,
              std::_Identity<_Value>(), __a)
       { }
 
       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())
+        __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())
        : _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
                __detail::_Default_ranged_hash(), __eql,
                std::_Identity<_Value>(), __a)
@@ -97,7 +97,7 @@ _GLIBCXX_BEGIN_NAMESPACE(tr1)
           class _Pred = std::equal_to<_Value>,
           class _Alloc = std::allocator<_Value>,
           bool __cache_hash_code = false>
-    class unordered_multiset
+    class __unordered_multiset
     : public _Hashtable<_Value, _Value, _Alloc,
                        std::_Identity<_Value>, _Pred,
                        _Hash, __detail::_Mod_range_hashing,
@@ -120,10 +120,10 @@ _GLIBCXX_BEGIN_NAMESPACE(tr1)
       typedef typename _Base::allocator_type  allocator_type;
       
       explicit
-      unordered_multiset(size_type __n = 10,
-                        const hasher& __hf = hasher(),
-                        const key_equal& __eql = key_equal(),
-                        const allocator_type& __a = allocator_type())
+      __unordered_multiset(size_type __n = 10,
+                          const hasher& __hf = hasher(),
+                          const key_equal& __eql = key_equal(),
+                          const allocator_type& __a = allocator_type())
       : _Base(__n, __hf, __detail::_Mod_range_hashing(),
              __detail::_Default_ranged_hash(), __eql,
              std::_Identity<_Value>(), __a)
@@ -131,11 +131,11 @@ _GLIBCXX_BEGIN_NAMESPACE(tr1)
 
 
       template<typename _InputIterator>
-        unordered_multiset(_InputIterator __f, _InputIterator __l, 
-                          typename _Base::size_type __n = 0,
-                          const hasher& __hf = hasher(), 
-                          const key_equal& __eql = key_equal(), 
-                          const allocator_type& __a = allocator_type())
+        __unordered_multiset(_InputIterator __f, _InputIterator __l, 
+                            typename _Base::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)
@@ -145,21 +145,89 @@ _GLIBCXX_BEGIN_NAMESPACE(tr1)
   template<class _Value, class _Hash, class _Pred, class _Alloc,
           bool __cache_hash_code>
     inline void
-    swap (unordered_set<_Value, _Hash, _Pred,
+    swap (__unordered_set<_Value, _Hash, _Pred,
          _Alloc, __cache_hash_code>& __x,
-         unordered_set<_Value, _Hash, _Pred,
+         __unordered_set<_Value, _Hash, _Pred,
          _Alloc, __cache_hash_code>& __y)
     { __x.swap(__y); }
 
   template<class _Value, class _Hash, class _Pred, class _Alloc,
           bool __cache_hash_code>
     inline void
-    swap(unordered_multiset<_Value, _Hash, _Pred,
+    swap(__unordered_multiset<_Value, _Hash, _Pred,
         _Alloc, __cache_hash_code>& __x,
-        unordered_multiset<_Value, _Hash, _Pred,
+        __unordered_multiset<_Value, _Hash, _Pred,
         _Alloc, __cache_hash_code>& __y)
     { __x.swap(__y); }
 
+
+  template<class _Value,
+          class _Hash = hash<_Value>,
+          class _Pred = std::equal_to<_Value>,
+          class _Alloc = std::allocator<_Value> >
+    class unordered_set
+    : public __unordered_set<_Value, _Hash, _Pred, _Alloc>
+    {
+      typedef __unordered_set<_Value, _Hash, _Pred, _Alloc>  _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;
+      
+      explicit
+      unordered_set(size_type __n = 10,
+                   const hasher& __hf = hasher(),
+                   const key_equal& __eql = key_equal(),
+                   const allocator_type& __a = allocator_type())
+      : _Base(__n, __hf, __eql, __a)
+      { }
+
+      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())
+       : _Base(__f, __l, __n, __hf, __eql, __a)
+        { }
+    };
+
+  template<class _Value,
+          class _Hash = hash<_Value>,
+          class _Pred = std::equal_to<_Value>,
+          class _Alloc = std::allocator<_Value> >
+    class unordered_multiset
+    : public __unordered_multiset<_Value, _Hash, _Pred, _Alloc>
+    {
+      typedef __unordered_multiset<_Value, _Hash, _Pred, _Alloc>  _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;
+      
+      explicit
+      unordered_multiset(size_type __n = 10,
+                        const hasher& __hf = hasher(),
+                        const key_equal& __eql = key_equal(),
+                        const allocator_type& __a = allocator_type())
+      : _Base(__n, __hf, __eql, __a)
+      { }
+
+
+      template<typename _InputIterator>
+        unordered_multiset(_InputIterator __f, _InputIterator __l, 
+                          typename _Base::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)
+        { }
+    };
+
 _GLIBCXX_END_NAMESPACE
 }
 

diff --git a/libstdc++-v3/testsuite/tr1/6_containers/headers/unordered_map/synopsis.cc b/libstdc++-v3/testsuite/tr1/6_containers/headers/unordered_map/synopsis.cc
index 45080fc40f5a1841241585983c4461cab3afba80..d54e2aa482c8aa24dba3382cff0587fca6e341f6 100644 (file)
--- a/libstdc++-v3/testsuite/tr1/6_containers/headers/unordered_map/synopsis.cc
+++ b/libstdc++-v3/testsuite/tr1/6_containers/headers/unordered_map/synopsis.cc
@@ -1,5 +1,4 @@
-// { dg-do compile { xfail *-*-* } }
-// { dg-excess-errors "" }
+// { dg-do compile }
 
 // 2007-02-04  Benjamin Kosnik  <bkoz@redhat.com>
 //

diff --git a/libstdc++-v3/testsuite/tr1/6_containers/headers/unordered_set/synopsis.cc b/libstdc++-v3/testsuite/tr1/6_containers/headers/unordered_set/synopsis.cc
index 29cced09bd2f583f98eba46d188906c72d7bf498..98dfc29957648623b52bc58998f7657d651239d9 100644 (file)
--- a/libstdc++-v3/testsuite/tr1/6_containers/headers/unordered_set/synopsis.cc
+++ b/libstdc++-v3/testsuite/tr1/6_containers/headers/unordered_set/synopsis.cc
@@ -1,5 +1,4 @@
-// { dg-do compile { xfail *-*-* } }
-// { dg-excess-errors "" }
+// { dg-do compile }
 
 // 2007-02-04  Benjamin Kosnik  <bkoz@redhat.com>
 //

diff --git a/libstdc++-v3/testsuite/tr1/6_containers/unordered_map/24064.cc b/libstdc++-v3/testsuite/tr1/6_containers/unordered_map/24064.cc
index 74eabbf53f9b6b7d981d02c667f3ca6d170da996..aaacb70a0f593af1f41d0fddda7f98ffce210d0f 100644 (file)
--- a/libstdc++-v3/testsuite/tr1/6_containers/unordered_map/24064.cc
+++ b/libstdc++-v3/testsuite/tr1/6_containers/unordered_map/24064.cc
@@ -1,4 +1,4 @@
-// Copyright (C) 2005 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2006, 2007 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
@@ -29,7 +29,7 @@ void test01()
   using namespace std;
   using namespace tr1;
 
-  unordered_map<int, char, hash<int>, equal_to<int>,
+  __unordered_map<int, char, hash<int>, equal_to<int>,
     allocator<pair<const int, char> >, true> m;
  
   for (int i = 0; i < 1000; ++i)

diff --git a/libstdc++-v3/testsuite/tr1/6_containers/unordered_map/requirements/explicit_instantiation.cc b/libstdc++-v3/testsuite/tr1/6_containers/unordered_map/requirements/explicit_instantiation.cc
index 41ce95db89e39d9ba6bb1ece523b14c92c686764..8fb0b9f3b62bb493c14fff5fd2bb1216e1c566dd 100644 (file)
--- a/libstdc++-v3/testsuite/tr1/6_containers/unordered_map/requirements/explicit_instantiation.cc
+++ b/libstdc++-v3/testsuite/tr1/6_containers/unordered_map/requirements/explicit_instantiation.cc
@@ -2,7 +2,7 @@
 
 // 2005-02-17  Matt Austern  <austern@apple.com>
 //
-// Copyright (C) 2004, 2005, 2006 Free Software Foundation, Inc.
+// Copyright (C) 2004, 2005, 2006, 2007 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
@@ -29,9 +29,12 @@ using namespace std;
 using namespace std::tr1;
 
 template class unordered_map<string, float>;
-template class unordered_map<string, float,
+template class unordered_map<string, int,
                             hash<string>, equal_to<string>, 
-                            allocator<pair<const string, float> >, true>;
+                            allocator<pair<const string, int> > >;
 template class unordered_map<string, float,
                             hash<string>, equal_to<string>, 
-                            allocator<char>, false>;
+                            allocator<char> >;
+template class __unordered_map<string, int,
+                              hash<string>, equal_to<string>, 
+                              allocator<pair<const string, int> >, true>;

diff --git a/libstdc++-v3/testsuite/tr1/6_containers/unordered_multimap/requirements/explicit_instantiation.cc b/libstdc++-v3/testsuite/tr1/6_containers/unordered_multimap/requirements/explicit_instantiation.cc
index d48aef831b66cc1495279a8dfd8ab5a5bc231819..5433e0efa916722e778afdf0f35af4f53fa059ba 100644 (file)
--- a/libstdc++-v3/testsuite/tr1/6_containers/unordered_multimap/requirements/explicit_instantiation.cc
+++ b/libstdc++-v3/testsuite/tr1/6_containers/unordered_multimap/requirements/explicit_instantiation.cc
@@ -2,7 +2,7 @@
 
 // 2005-02-17  Matt Austern  <austern@apple.com>
 //
-// Copyright (C) 2005, 2006 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2006, 2007 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
@@ -29,9 +29,12 @@ using namespace std;
 using namespace std::tr1;
 
 template class unordered_multimap<string, float>;
-template class unordered_multimap<string, float,
+template class unordered_multimap<string, int,
                                  hash<string>, equal_to<string>, 
-                                 allocator<pair<const string, float> >, true>;
+                                 allocator<pair<const string, int> > >;
 template class unordered_multimap<string, float,
-                                 hash<string>, equal_to<string>, 
-                                 allocator<char>, false>;
+                                 hash<string>, equal_to<string>,
+                                 allocator<char> >;
+template class __unordered_multimap<string, int,
+                                   hash<string>, equal_to<string>, 
+                                   allocator<pair<const string, int> >, true>;

diff --git a/libstdc++-v3/testsuite/tr1/6_containers/unordered_multiset/requirements/explicit_instantiation.cc b/libstdc++-v3/testsuite/tr1/6_containers/unordered_multiset/requirements/explicit_instantiation.cc
index 5d1e8710b05aac4a66ae8ce784c04072dfc65f3c..4389e1b805e0e6aab47fb31c742e325aceaa0587 100644 (file)
--- a/libstdc++-v3/testsuite/tr1/6_containers/unordered_multiset/requirements/explicit_instantiation.cc
+++ b/libstdc++-v3/testsuite/tr1/6_containers/unordered_multiset/requirements/explicit_instantiation.cc
@@ -2,7 +2,7 @@
 
 // 2005-02-17  Matt Austern  <austern@apple.com>
 //
-// Copyright (C) 2005, 2006 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2006, 2007 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
@@ -28,7 +28,9 @@ using namespace std;
 using namespace std::tr1;
 
 template class unordered_multiset<int>;
+template class unordered_multiset<float, hash<float>, equal_to<float>,
+                                 allocator<float> >;
 template class unordered_multiset<int, hash<int>, equal_to<int>,
-                                 allocator<int>, true>;
-template class unordered_multiset<int, hash<int>, equal_to<int>,
-                                 allocator<char>, false>;
+                                 allocator<char> >;
+template class __unordered_multiset<float, hash<float>, equal_to<float>,
+                                   allocator<float>, true>;

diff --git a/libstdc++-v3/testsuite/tr1/6_containers/unordered_set/requirements/explicit_instantiation.cc b/libstdc++-v3/testsuite/tr1/6_containers/unordered_set/requirements/explicit_instantiation.cc
index ae3214f1bae349c23913374c33429128188debe5..a006abfcbb497e0f6308243709ddbd6b6b0f7f19 100644 (file)
--- a/libstdc++-v3/testsuite/tr1/6_containers/unordered_set/requirements/explicit_instantiation.cc
+++ b/libstdc++-v3/testsuite/tr1/6_containers/unordered_set/requirements/explicit_instantiation.cc
@@ -2,7 +2,7 @@
 
 // 2005-02-17  Matt Austern  <austern@apple.com>
 //
-// Copyright (C) 2005, 2006 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2006, 2007 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
@@ -28,7 +28,9 @@ using namespace std;
 using namespace std::tr1;
 
 template class unordered_set<int>;
+template class unordered_set<float, hash<float>, equal_to<float>,
+                            allocator<float> >;
 template class unordered_set<int, hash<int>, equal_to<int>,
-                            allocator<int>, true>;
-template class unordered_set<int, hash<int>, equal_to<int>,
-                            allocator<char>, false>;
+                            allocator<char> >;
+template class __unordered_set<float, hash<float>, equal_to<float>,
+                              allocator<float>, true>;

diff --git a/libstdc++-v3/testsuite/util/native_type/assoc/native_hash_map.hpp b/libstdc++-v3/testsuite/util/native_type/assoc/native_hash_map.hpp
index d6eb835c483b281b2de5449178d6a787ef4233a2..be0e8f4227cf97f467a14c73036a826de0d15908 100644 (file)
--- a/libstdc++-v3/testsuite/util/native_type/assoc/native_hash_map.hpp
+++ b/libstdc++-v3/testsuite/util/native_type/assoc/native_hash_map.hpp
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2005, 2006 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2006, 2007 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
@@ -68,7 +68,7 @@ namespace pb_ds
   {
 #ifdef PB_DS_USE_TR1
 #define PB_DS_BASE_C_DEC \
-    std::tr1::unordered_map<Key, Data, Hash_Fn, Eq_Fn, \
+    std::tr1::__unordered_map<Key, Data, Hash_Fn, Eq_Fn, \
     typename Allocator::template rebind<std::pair<const Key, Data> >::other, Cache_Hash>
 #else 
 #define PB_DS_BASE_C_DEC \

diff --git a/libstdc++-v3/testsuite/util/native_type/assoc/native_hash_set.hpp b/libstdc++-v3/testsuite/util/native_type/assoc/native_hash_set.hpp
index 7f89392629f92c860e5bfe21bee3f635db5f5527..c78553b73fec0f5cb5a6bdfb88248b0a57a20469 100644 (file)
--- a/libstdc++-v3/testsuite/util/native_type/assoc/native_hash_set.hpp
+++ b/libstdc++-v3/testsuite/util/native_type/assoc/native_hash_set.hpp
@@ -1,6 +1,6 @@
 // -*- C++ -*-
 
-// Copyright (C) 2005, 2006 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2006, 2007 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
@@ -68,12 +68,12 @@ namespace pb_ds
   {
 #ifdef PB_DS_USE_TR1
 #define PB_DS_BASE_C_DEC \
-    std::tr1::unordered_set<Key, Hash_Fn, Eq_Fn, \
-                           typename Allocator::template rebind<Key>::other>
+    std::tr1::__unordered_set<Key, Hash_Fn, Eq_Fn, \
+    typename Allocator::template rebind<Key>::other, Cache_Hash>
 #else
 #define PB_DS_BASE_C_DEC \
     __gnu_cxx::hash_set<Key, Hash_Fn, Eq_Fn, \
-                       typename Allocator::template rebind<Key>::other>
+    typename Allocator::template rebind<Key>::other>
 #endif
 
     template<typename Key,