[util.smartptr.hash]

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@105393 91177308-0d34-0410-b5e6-96231b3b80d8

include/functional

@@ -1834,16 +1834,7 @@ struct hash<long double>
     }
 };
 
-template<class _Tp>
+// struct hash<T*> in <memory>
-struct hash<_Tp*>
-    : public unary_function<_Tp*, size_t>
-{
-    size_t operator()(_Tp* __v) const
-    {
-        const size_t* const __p = reinterpret_cast<const size_t*>(&__v);
-        return *__p;
-    }
-};
 
 _LIBCPP_END_NAMESPACE_STD
 

include/memory

@@ -2463,6 +2463,31 @@ inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator>=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return !(__x < __y);}
 
+template <class> struct hash;
+
+template<class _Tp>
+struct hash<_Tp*>
+    : public unary_function<_Tp*, size_t>
+{
+    size_t operator()(_Tp* __v) const
+    {
+        const size_t* const __p = reinterpret_cast<const size_t*>(&__v);
+        return *__p;
+    }
+};
+
+template <class _Tp, class _Dp>
+struct hash<unique_ptr<_Tp, _Dp> >
+{
+    typedef unique_ptr<_Tp, _Dp> argument_type;
+    typedef size_t               result_type;
+    result_type operator()(const argument_type& __ptr) const
+    {
+        typedef typename argument_type::pointer pointer;
+        return hash<pointer>()(__ptr.get());
+    }
+};
+
 struct __destruct_n
 {
 private:
@@ -3785,6 +3810,17 @@ public:
     template <class _Up> friend class shared_ptr;
 };
 
+template <class _Tp>
+struct hash<shared_ptr<_Tp> >
+{
+    typedef shared_ptr<_Tp>      argument_type;
+    typedef size_t               result_type;
+    result_type operator()(const argument_type& __ptr) const
+    {
+        return hash<_Tp*>()(__ptr.get());
+    }
+};
+
 //enum class 
 struct pointer_safety
 {

src/mutex.cpp

@@ -235,7 +235,7 @@ __call_once(volatile unsigned long& flag, void* arg, void(*func)(void*))
             pthread_mutex_lock(&mut);
             flag = 0ul;
             pthread_mutex_unlock(&mut);
-            pthread_cond_signal(&cv);
+            pthread_cond_broadcast(&cv);
             throw;
         }
     }

test/utilities/memory/util.smartptr/util.smartptr.hash/hash_shared_ptr.pass.cpp

@@ -0,0 +1 @@
+//===----------------------------------------------------------------------===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

// <memory>

// template <class T>
// struct hash<shared_ptr<T>>
// {
//     typedef shared_ptr<T>    argument_type;
//     typedef size_t           result_type;
//     size_t operator()(const shared_ptr<T>& p) const;
// };

#include <memory>
#include <cassert>

int main()
{
    int* ptr = new int;
    std::shared_ptr<int> p(ptr);
    std::hash<std::shared_ptr<int> > f;
    std::size_t h = f(p);
    assert(h == std::hash<int*>()(ptr));
}

test/utilities/memory/util.smartptr/util.smartptr.hash/hash_unique_ptr.pass.cpp

@@ -0,0 +1 @@
+//===----------------------------------------------------------------------===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

// <memory>

// template <class T, class D>
// struct hash<unique_ptr<T, D>>
// {
//     typedef unique_ptr<T, D> argument_type;
//     typedef size_t           result_type;
//     size_t operator()(const unique_ptr<T, D>& p) const;
// };

#include <memory>
#include <cassert>

int main()
{
    int* ptr = new int;
    std::unique_ptr<int> p(ptr);
    std::hash<std::unique_ptr<int> > f;
    std::size_t h = f(p);
    assert(h == std::hash<int*>()(ptr));
}

test/utilities/tuple/tuple.tuple/tuple.creation/pack_arguments.pass.cpp

@@ -0,0 +1,21 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <tuple>
+
+// template<class... Types>
+//     tuple<ATypes...> pack_arguments(Types&&... t);
+
+
+#include <tuple>
+
+int main()
+{
+#error pack_arguments not implemented
+}