Changed cds_std namespace to std, removed cds/details/std directory, use STL headers...

diff --git a/cds/algo/backoff_strategy.h b/cds/algo/backoff_strategy.h
index fd02f6599e2fcbfb97ed9c69e7a2916619409865..a4f99072b14ef820e88bee3ad11e6644fcc3c556 100644 (file)
--- a/cds/algo/backoff_strategy.h
+++ b/cds/algo/backoff_strategy.h
@@ -17,8 +17,9 @@
 */
 
 #include <thread>
+#include <chrono>
+#include <cds/details/defs.h>
 #include <cds/compiler/backoff.h>
-#include <cds/details/std/chrono.h>
 
 namespace cds {
     /// Different backoff schemes
@@ -341,7 +342,7 @@ namespace cds {
             \endcode
 
         */
-        template <class Duration = cds_std::chrono::milliseconds, typename Tag=void >
+        template <class Duration = cds::chrono::milliseconds, typename Tag=void >
         class delay
         {
         public:
@@ -399,7 +400,7 @@ namespace cds {
             The declaration <tt>cds::backoff::delay_of< 5 > bkoff</tt> is equal for
             <tt>cds::backoff::delay<> bkoff(5)</tt>.
         */
-        template <unsigned int Timeout, class Duration = cds_std::chrono::milliseconds >
+        template <unsigned int Timeout, class Duration = cds::chrono::milliseconds >
         class delay_of: public delay<Duration>
         {
         //@cond

diff --git a/cds/algo/flat_combining.h b/cds/algo/flat_combining.h
index 4c7078166a7ef64d0902e4d42b24467cf2119402..9663d39d427d7fd8021b7a3d30a3b5ac9f264cc6 100644 (file)
--- a/cds/algo/flat_combining.h
+++ b/cds/algo/flat_combining.h
@@ -3,11 +3,11 @@
 #ifndef __CDS_ALGO_FLAT_COMBINING_H
 #define __CDS_ALGO_FLAT_COMBINING_H
 
+#include <mutex>
 #include <cds/cxx11_atomic.h>
 #include <cds/details/allocator.h>
 #include <cds/algo/backoff_strategy.h>
 #include <cds/lock/spinlock.h>
-#include <cds/details/std/mutex.h>  // lock_guard
 #include <cds/opt/options.h>
 #include <cds/algo/int_algo.h>
 #include <boost/thread/tss.hpp>     // thread_specific_ptr
@@ -259,7 +259,7 @@ namespace cds { namespace algo {
         protected:
             //@cond
             typedef cds::details::Allocator< publication_record_type, allocator >   cxx11_allocator; ///< internal helper cds::details::Allocator
-            typedef cds_std::lock_guard<global_lock_type> lock_guard;
+            typedef std::lock_guard<global_lock_type> lock_guard;
             //@endcond
 
         protected:
@@ -596,7 +596,7 @@ namespace cds { namespace algo {
             {
                 if ( m_Mutex.try_lock() ) {
                     // The thread becomes a combiner
-                    lock_guard l( m_Mutex, cds_std::adopt_lock_t() );
+                    lock_guard l( m_Mutex, std::adopt_lock_t() );
 
                     // The record pRec can be excluded from publication list. Re-publish it
                     republish( pRec );
@@ -608,7 +608,7 @@ namespace cds { namespace algo {
                     // There is another combiner, wait while it executes our request
                     if ( !wait_for_combining( pRec ) ) {
                         // The thread becomes a combiner
-                        lock_guard l( m_Mutex, cds_std::adopt_lock_t() );
+                        lock_guard l( m_Mutex, std::adopt_lock_t() );
 
                         // The record pRec can be excluded from publication list. Re-publish it
                         republish( pRec );
@@ -624,7 +624,7 @@ namespace cds { namespace algo {
             {
                 if ( m_Mutex.try_lock() ) {
                     // The thread becomes a combiner
-                    lock_guard l( m_Mutex, cds_std::adopt_lock_t() );
+                    lock_guard l( m_Mutex, std::adopt_lock_t() );
 
                     // The record pRec can be excluded from publication list. Re-publish it
                     republish( pRec );
@@ -636,7 +636,7 @@ namespace cds { namespace algo {
                     // There is another combiner, wait while it executes our request
                     if ( !wait_for_combining( pRec ) ) {
                         // The thread becomes a combiner
-                        lock_guard l( m_Mutex, cds_std::adopt_lock_t() );
+                        lock_guard l( m_Mutex, std::adopt_lock_t() );
 
                         // The record pRec can be excluded from publication list. Re-publish it
                         republish( pRec );

diff --git a/cds/details/defs.h b/cds/details/defs.h
index d6dc4d0cb520e4e0d63312c81fe36e26d9e081e9..7260b893080f2f8d157989a3f815a0c6c0fd22fe 100644 (file)
--- a/cds/details/defs.h
+++ b/cds/details/defs.h
@@ -464,39 +464,6 @@ namespace cds {
 } // namespace cds
 
 
-/// @defgroup cds_cxx11_stdlib_wrapper New C++11 standard library support
-
-/// C++11 standard library wrapper namespace
-/** @ingroup cds_cxx11_stdlib_wrapper
-    libcds needs support from new features defined in C++11 standard library.
-    In case when an old compiler and corresponding \p std library has no required feature
-    the \p boost library is used if possible. The \p %cds_std namespace is a wrapper for new C++11 stdlib classes:
-    - if the compiler supports new feature, this feature places (with \p using directive) into \p %cds_std namespace "as is"
-    - otherwise the \p boost analog is used and it places into \p %cds_std namespace too
-
-    For example, for class \p std::mutex the \p libcds does the following:
-    - for old compiler: \code
-        #include <boost/thread/mutex.hpp>
-        namespace cds_std {
-            using boost::mutex;
-        }
-        \endcode
-    - for C++11-ready compiler: \code
-        #include <mutex>
-        namespace cds_std {
-            using std::mutex;
-        }
-        \endcode
-
-        Everywhere in \p libcds the class \p %cds_std::mutex is used instead of \p std::mutex.
-
-        Note, not all C++11 features are contained in \p %cds_std but only required by \p libcds.
-
-        In future when all compilers will be C++11-ready we can transform the \p libcds
-        to new C++11 standard library changing \p %cds_std namespace to native \p std.
-*/
-namespace cds_std {}
-
 //@cond
 #ifdef _DEBUG
 #   define cds_assert(X)    assert(X)

diff --git a/cds/details/std/chrono.h b/cds/details/std/chrono.h
deleted file mode 100644 (file)
index 3c045aa..0000000
--- a/cds/details/std/chrono.h
+++ /dev/null
@@ -1,24 +0,0 @@
-//$$CDS-header$$
-
-#ifndef __CDS_DETAILS_STD_CHRONO_H
-#define __CDS_DETAILS_STD_CHRONO_H
-
-//@cond
-
-#include <cds/details/defs.h>
-
-#ifdef CDS_CXX11_STDLIB_CHRONO
-#   include <chrono>
-namespace cds_std {
-    namespace chrono = std::chrono;
-}
-#else
-#   include <boost/chrono.hpp>
-namespace cds_std {
-    namespace chrono = boost::chrono;
-}
-#endif
-
-//@endcond
-
-#endif // #ifndef __CDS_DETAILS_STD_CHRONO_H

diff --git a/cds/details/std/condition_variable.h b/cds/details/std/condition_variable.h
deleted file mode 100644 (file)
index 5db1e2f..0000000
--- a/cds/details/std/condition_variable.h
+++ /dev/null
@@ -1,26 +0,0 @@
-//$$CDS-header$$
-
-#ifndef __CDS_DETAILS_STD_CONDITION_VARIABLE_H
-#define __CDS_DETAILS_STD_CONDITION_VARIABLE_H
-
-//@cond
-
-#include <cds/details/defs.h>
-
-#ifdef CDS_CXX11_STDLIB_CONDITION_VARIABLE
-#   include <condition_variable>
-    namespace cds_std {
-        using std::condition_variable;
-        using std::condition_variable_any;
-    }
-#else
-#   include <boost/thread/condition_variable.hpp>
-    namespace cds_std {
-        using boost::condition_variable;
-        using boost::condition_variable_any;
-    }
-#endif
-
-//@endcond
-
-#endif // #ifndef __CDS_DETAILS_STD_CONDITION_VARIABLE_H

diff --git a/cds/details/std/mutex.h b/cds/details/std/mutex.h
deleted file mode 100644 (file)
index 7bd3533..0000000
--- a/cds/details/std/mutex.h
+++ /dev/null
@@ -1,39 +0,0 @@
-//$$CDS-header$$
-
-#ifndef __CDS_DETAILS_STD_MUTEX_H
-#define __CDS_DETAILS_STD_MUTEX_H
-
-//@cond
-
-#include <cds/details/defs.h>
-
-#ifdef CDS_CXX11_STDLIB_MUTEX
-#   include <mutex>
-    namespace cds_std {
-        using std::mutex;
-        using std::recursive_mutex;
-        using std::unique_lock;
-        using std::lock_guard;
-        using std::adopt_lock_t;
-    }
-#else
-#   include <boost/thread/mutex.hpp>
-#   include <boost/thread/recursive_mutex.hpp>
-#   if BOOST_VERSION >= 105300
-#       include <boost/thread/locks.hpp>
-#       include <boost/thread/lock_guard.hpp>
-#   else
-#       include <boost/thread.hpp>
-#   endif
-    namespace cds_std {
-        using boost::mutex;
-        using boost::recursive_mutex;
-        using boost::unique_lock;
-        using boost::lock_guard;
-        using boost::adopt_lock_t;
-    }
-#endif
-
-//@endcond
-
-#endif // #ifndef __CDS_DETAILS_STD_MUTEX_H

diff --git a/cds/intrusive/cuckoo_set.h b/cds/intrusive/cuckoo_set.h
index 3a36a98acb2ed19fe81cce5da646334c77ab19ea..dd07159d3afe90e6eb3a1c709de0cbd76a3dc1b5 100644 (file)
--- a/cds/intrusive/cuckoo_set.h
+++ b/cds/intrusive/cuckoo_set.h
@@ -5,6 +5,7 @@
 
 #include <memory>
 #include <type_traits>
+#include <mutex>
 #include <cds/intrusive/base.h>
 #include <cds/opt/compare.h>
 #include <cds/opt/hash.h>
@@ -14,8 +15,6 @@
 #include <cds/details/functor_wrapper.h>
 #include <cds/lock/spinlock.h>
 
-#include <cds/details/std/mutex.h>
-//#include <boost/thread/recursive_mutex.hpp>
 
 namespace cds { namespace intrusive {
 
@@ -347,7 +346,7 @@ namespace cds { namespace intrusive {
             The policy contains an internal array of \p RecursiveLock locks.
 
             Template arguments:
-            - \p RecursiveLock - the type of recursive mutex. The default is \p cds_std::recursive_mutex. The mutex type should be default-constructible.
+            - \p RecursiveLock - the type of recursive mutex. The default is \p std::recursive_mutex. The mutex type should be default-constructible.
                 Note that a recursive spin-lock is not suitable for lock striping for performance reason.
             - \p Arity - unsigned int constant that specifies an arity. The arity is the count of hash functors, i.e., the
                 count of lock arrays. Default value is 2.
@@ -356,7 +355,7 @@ namespace cds { namespace intrusive {
                 class according to its \p opt::stat option.
         */
         template <
-            class RecursiveLock = cds_std::recursive_mutex,
+            class RecursiveLock = std::recursive_mutex,
             unsigned int Arity = 2,
             class Alloc = CDS_DEFAULT_ALLOCATOR,
             class Stat = empty_striping_stat
@@ -597,7 +596,7 @@ namespace cds { namespace intrusive {
 
             Template arguments:
             - \p RecursiveLock - the type of mutex. Reentrant (recursive) mutex is required.
-                The default is \p cds_std::recursive_mutex. The mutex type should be default-constructible.
+                The default is \p std::recursive_mutex. The mutex type should be default-constructible.
             - \p Arity - unsigned int constant that specifies an arity. The arity is the count of hash functors, i.e., the
                 count of lock arrays. Default value is 2.
             - \p BackOff - back-off strategy. Default is cds::backoff::yield
@@ -606,7 +605,7 @@ namespace cds { namespace intrusive {
                 class according to its \p opt::stat option.
         */
         template <
-            class RecursiveLock = cds_std::recursive_mutex,
+            class RecursiveLock = std::recursive_mutex,
             unsigned int Arity = 2,
             typename BackOff = cds::backoff::yield,
             class Alloc = CDS_DEFAULT_ALLOCATOR,

diff --git a/cds/intrusive/segmented_queue.h b/cds/intrusive/segmented_queue.h
index 18a9d45aa51048039e1fcb3881abc671dcbd4624..05ff51c48697e3cba2839b1736dc5386efa3cfe8 100644 (file)
--- a/cds/intrusive/segmented_queue.h
+++ b/cds/intrusive/segmented_queue.h
@@ -3,10 +3,10 @@
 #ifndef __CDS_INTRUSIVE_SEGMENTED_QUEUE_H
 #define __CDS_INTRUSIVE_SEGMENTED_QUEUE_H
 
+#include <mutex>
 #include <cds/intrusive/base.h>
 #include <cds/details/marked_ptr.h>
 #include <cds/algo/int_algo.h>
-#include <cds/details/std/mutex.h>
 #include <cds/lock/spinlock.h>
 #include <cds/opt/permutation.h>
 
@@ -242,7 +242,7 @@ namespace cds { namespace intrusive {
         class segment_list
         {
             typedef boost::intrusive::slist< segment, boost::intrusive::cache_last< true > > list_impl;
-            typedef cds_std::unique_lock< lock_type > scoped_lock;
+            typedef std::unique_lock< lock_type > scoped_lock;
 
             aligned_segment_ptr m_pHead;
             aligned_segment_ptr m_pTail;

diff --git a/cds/intrusive/striped_set/striping_policy.h b/cds/intrusive/striped_set/striping_policy.h
index 579563c01661d1027bcd6ba68f4f194e08935029..1e3ec4c39b4630d3118fe25838be7ddbfbdef8af 100644 (file)
--- a/cds/intrusive/striped_set/striping_policy.h
+++ b/cds/intrusive/striped_set/striping_policy.h
@@ -4,15 +4,11 @@
 #define __CDS_INTRUSIVE_STRIPED_SET_STRIPING_POLICY_H
 
 #include <memory>
+#include <mutex>
 #include <cds/lock/array.h>
 #include <cds/os/thread.h>
 #include <cds/lock/spinlock.h>
 
-#include <cds/details/std/mutex.h>
-//#include <boost/thread/mutex.hpp>
-//#include <boost/thread/recursive_mutex.hpp>
-
-
 namespace cds { namespace intrusive { namespace striped_set {
 
     /// Lock striping concurrent access policy
@@ -29,11 +25,11 @@ namespace cds { namespace intrusive { namespace striped_set {
         The policy contains an internal array of \p Lock locks.
 
         Template arguments:
-        - \p Lock - the type of mutex. The default is \p cds_std::mutex. The mutex type should be default-constructible.
+        - \p Lock - the type of mutex. The default is \p std::mutex. The mutex type should be default-constructible.
             Note that a spin-lock is not so good suitable for lock striping for performance reason.
         - \p Alloc - allocator type used for lock array memory allocation. Default is \p CDS_DEFAULT_ALLOCATOR.
     */
-    template <class Lock = cds_std::mutex, class Alloc = CDS_DEFAULT_ALLOCATOR >
+    template <class Lock = std::mutex, class Alloc = CDS_DEFAULT_ALLOCATOR >
     class striping
     {
     public:
@@ -113,12 +109,12 @@ namespace cds { namespace intrusive { namespace striped_set {
 
         Template arguments:
         - \p RecursiveLock - the type of mutex. Reentrant (recursive) mutex is required.
-            The default is \p cds_std::recursive_mutex. The mutex type should be default-constructible.
+            The default is \p std::recursive_mutex. The mutex type should be default-constructible.
         - \p BackOff - back-off strategy. Default is cds::backoff::yield
         - \p Alloc - allocator type used for lock array memory allocation. Default is \p CDS_DEFAULT_ALLOCATOR.
     */
     template <
-        class RecursiveLock = cds_std::recursive_mutex,
+        class RecursiveLock = std::recursive_mutex,
         typename BackOff = cds::backoff::yield,
         class Alloc = CDS_DEFAULT_ALLOCATOR>
     class refinable

diff --git a/cds/urcu/details/gpb.h b/cds/urcu/details/gpb.h
index b5d85b49369a227d295b78edcf9becb9ab73a194..e75ada611616583658509f02dca9869f26c37695 100644 (file)
--- a/cds/urcu/details/gpb.h
+++ b/cds/urcu/details/gpb.h
@@ -3,12 +3,11 @@
 #ifndef _CDS_URCU_DETAILS_GPB_H
 #define _CDS_URCU_DETAILS_GPB_H
 
+#include <mutex>
 #include <cds/urcu/details/gp.h>
 #include <cds/algo/backoff_strategy.h>
 #include <cds/container/vyukov_mpmc_cycle_queue.h>
 
-#include <cds/details/std/mutex.h>
-
 namespace cds { namespace urcu {
 
     /// User-space general-purpose RCU with deferred (buffered) reclamation
@@ -44,7 +43,7 @@ namespace cds { namespace urcu {
             epoch_retired_ptr
             ,cds::opt::buffer< cds::opt::v::dynamic_buffer< epoch_retired_ptr > >
         >
-        ,class Lock = cds_std::mutex
+        ,class Lock = std::mutex
         ,class Backoff = cds::backoff::Default
     >
     class general_buffered: public details::gp_singleton< general_buffered_tag >

diff --git a/cds/urcu/details/gpi.h b/cds/urcu/details/gpi.h
index 2ab6553f8a32390fccc4aa3771bfbff8f413a7b0..0f0de150b8876c5b65925c2100c923e363b31af5 100644 (file)
--- a/cds/urcu/details/gpi.h
+++ b/cds/urcu/details/gpi.h
@@ -3,12 +3,11 @@
 #ifndef _CDS_URCU_DETAILS_GPI_H
 #define _CDS_URCU_DETAILS_GPI_H
 
+#include <mutex>
 #include <cds/urcu/details/gp.h>
 #include <cds/algo/backoff_strategy.h>
 #include <cds/lock/scoped_lock.h>
 
-#include <cds/details/std/mutex.h>
-
 namespace cds { namespace urcu {
 
     /// User-space general-purpose RCU with immediate reclamation
@@ -29,7 +28,7 @@ namespace cds { namespace urcu {
         - \p Backoff - back-off schema, default is cds::backoff::Default
     */
     template <
-        class Lock = cds_std::mutex
+        class Lock = std::mutex
        ,class Backoff = cds::backoff::Default
     >
     class general_instant: public details::gp_singleton< general_instant_tag >

diff --git a/cds/urcu/details/gpt.h b/cds/urcu/details/gpt.h
index 994e50a64ce114a5157d905d4e8d96f68f51a458..2fb8e114198bafc0ecad420ffc50117b1a5a0ac4 100644 (file)
--- a/cds/urcu/details/gpt.h
+++ b/cds/urcu/details/gpt.h
@@ -41,7 +41,7 @@ namespace cds { namespace urcu {
             epoch_retired_ptr
             ,cds::opt::buffer< cds::opt::v::dynamic_buffer< epoch_retired_ptr > >
         >
-        ,class Lock = cds_std::mutex
+        ,class Lock = std::mutex
         ,class DisposerThread = dispose_thread<Buffer>
         ,class Backoff = cds::backoff::Default
     >

diff --git a/cds/urcu/details/sig_buffered.h b/cds/urcu/details/sig_buffered.h
index 5ab1ad255e3269e0238ab238babe65ee24b9e215..4f90037b233dd2fd0ce180a1cfb217eaa1c267a2 100644 (file)
--- a/cds/urcu/details/sig_buffered.h
+++ b/cds/urcu/details/sig_buffered.h
@@ -6,11 +6,10 @@
 #include <cds/urcu/details/sh.h>
 #ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
 
+#include <mutex>
 #include <cds/algo/backoff_strategy.h>
 #include <cds/container/vyukov_mpmc_cycle_queue.h>
 
-#include <cds/details/std/mutex.h>
-
 namespace cds { namespace urcu {
 
     /// User-space signal-handled RCU with deferred (buffered) reclamation
@@ -46,7 +45,7 @@ namespace cds { namespace urcu {
             epoch_retired_ptr
             ,cds::opt::buffer< cds::opt::v::dynamic_buffer< epoch_retired_ptr > >
         >
-        ,class Lock = cds_std::mutex
+        ,class Lock = std::mutex
         ,class Backoff = cds::backoff::Default
     >
     class signal_buffered: public details::sh_singleton< signal_buffered_tag >

diff --git a/cds/urcu/details/sig_threaded.h b/cds/urcu/details/sig_threaded.h
index 9056e89443e1d20a9d59189f26c2f088223b3fa8..dddcf595183f2456a4647e1333b44579bb7cc01a 100644 (file)
--- a/cds/urcu/details/sig_threaded.h
+++ b/cds/urcu/details/sig_threaded.h
@@ -43,7 +43,7 @@ namespace cds { namespace urcu {
             epoch_retired_ptr
             ,cds::opt::buffer< cds::opt::v::dynamic_buffer< epoch_retired_ptr > >
         >
-        ,class Lock = cds_std::mutex
+        ,class Lock = std::mutex
         ,class DisposerThread = dispose_thread<Buffer>
         ,class Backoff = cds::backoff::Default
     >

diff --git a/cds/urcu/dispose_thread.h b/cds/urcu/dispose_thread.h
index 9ebb4bd58ed2bf8ad3719251bd7b7c72e69e19a3..da2206612bbb2a75f860ccdf8106335ac3351d15 100644 (file)
--- a/cds/urcu/dispose_thread.h
+++ b/cds/urcu/dispose_thread.h
@@ -5,8 +5,8 @@
 
 #include <memory>
 #include <thread>
-#include <cds/details/std/mutex.h>
-#include <cds/details/std/condition_variable.h>
+#include <mutex>
+#include <condition_variable>
 #include <cds/details/aligned_type.h>
 
 namespace cds { namespace urcu {
@@ -27,9 +27,9 @@ namespace cds { namespace urcu {
     private:
         //@cond
         typedef std::thread                 thread_type;
-        typedef cds_std::mutex              mutex_type;
-        typedef cds_std::condition_variable condvar_type;
-        typedef cds_std::unique_lock< mutex_type >  unique_lock;
+        typedef std::mutex              mutex_type;
+        typedef std::condition_variable condvar_type;
+        typedef std::unique_lock< mutex_type >  unique_lock;
 
         class dispose_thread_starter: public thread_type
         {

diff --git a/cds/urcu/general_buffered.h b/cds/urcu/general_buffered.h
index a68dfce24842b07edb726a2e50cecf91f0d3e0b4..4b042f0ed8bf14c5dafeb4e8de7ef3e6656f289c 100644 (file)
--- a/cds/urcu/general_buffered.h
+++ b/cds/urcu/general_buffered.h
@@ -24,7 +24,7 @@ namespace cds { namespace urcu {
             retired_ptr
             ,cds::opt::buffer< cds::opt::v::dynamic_buffer< retired_ptr > >
         >
-        ,class Lock = cds_std::mutex
+        ,class Lock = std::mutex
         ,class Backoff = cds::backoff::Default
 #else
         class Buffer

diff --git a/cds/urcu/general_instant.h b/cds/urcu/general_instant.h
index 49f5cec3b653f81c02b49ec0355fb2637ddd5f4c..c0c128cdb5b2d1805d6f93919c3be52fd85598a9 100644 (file)
--- a/cds/urcu/general_instant.h
+++ b/cds/urcu/general_instant.h
@@ -18,7 +18,7 @@ namespace cds { namespace urcu {
     */
     template <
 #ifdef CDS_DOXGEN_INVOKED
-        class Lock = cds_std::mutex
+        class Lock = std::mutex
        ,class Backoff = cds::backoff::Default
 #else
         class Lock

diff --git a/cds/urcu/general_threaded.h b/cds/urcu/general_threaded.h
index 324017ff76754833929aeb29107f57ea0605c1ef..57699ce1ef8bd181313cbafacc99a33353b3636f 100644 (file)
--- a/cds/urcu/general_threaded.h
+++ b/cds/urcu/general_threaded.h
@@ -27,7 +27,7 @@ namespace cds { namespace urcu {
             epoch_retired_ptr
             ,cds::opt::buffer< cds::opt::v::dynamic_buffer< epoch_retired_ptr > >
         >
-        ,class Lock = cds_std::mutex
+        ,class Lock = std::mutex
         ,class DisposerThread = dispose_thread<Buffer>
         ,class Backoff = cds::backoff::Default
 #else

diff --git a/cds/urcu/signal_buffered.h b/cds/urcu/signal_buffered.h
index 640606d4d0599bb01491ed06c513771068018dbf..0d26dfe4ecd7a50ae6dc547d7fc45e62ea6bf9eb 100644 (file)
--- a/cds/urcu/signal_buffered.h
+++ b/cds/urcu/signal_buffered.h
@@ -25,7 +25,7 @@ namespace cds { namespace urcu {
             retired_ptr
             ,cds::opt::buffer< cds::opt::v::dynamic_buffer< retired_ptr > >
         >
-        ,class Lock = cds_std::mutex
+        ,class Lock = std::mutex
         ,class Backoff = cds::backoff::Default
 #else
         class Buffer

diff --git a/cds/urcu/signal_threaded.h b/cds/urcu/signal_threaded.h
index 68a3adf6164baf9179b4fbe5f5ef8aeef5bae727..e8546b01653fadf99fea580d751dc77f1e95936c 100644 (file)
--- a/cds/urcu/signal_threaded.h
+++ b/cds/urcu/signal_threaded.h
@@ -29,7 +29,7 @@ namespace cds { namespace urcu {
             epoch_retired_ptr
             ,cds::opt::buffer< cds::opt::v::dynamic_buffer< epoch_retired_ptr > >
         >
-        ,class Lock = cds_std::mutex
+        ,class Lock = std::mutex
         ,class DisposerThread = dispose_thread<Buffer>
         ,class Backoff = cds::backoff::Default
 #else

diff --git a/projects/Win/vc12/cds.vcxproj b/projects/Win/vc12/cds.vcxproj
index 0d665996c4fef4259ca459827e0e3fd1d4b093d0..74b6c0e41215f1a318e51d614bd78ae1489f1592 100644 (file)
--- a/projects/Win/vc12/cds.vcxproj
+++ b/projects/Win/vc12/cds.vcxproj
@@ -729,9 +729,6 @@
     <ClInclude Include="..\..\..\cds\details\lib.h" />\r
     <ClInclude Include="..\..\..\cds\details\numtraits.h" />\r
     <ClInclude Include="..\..\..\cds\details\static_functor.h" />\r
-    <ClInclude Include="..\..\..\cds\details\std\condition_variable.h" />\r
-    <ClInclude Include="..\..\..\cds\details\std\mutex.h" />\r
-    <ClInclude Include="..\..\..\cds\details\std\chrono.h" />\r
     <ClInclude Include="..\..\..\cds\gc\all.h" />\r
     <ClInclude Include="..\..\..\cds\gc\exception.h" />\r
     <ClInclude Include="..\..\..\cds\gc\gc_fwd.h" />\r

diff --git a/projects/Win/vc12/cds.vcxproj.filters b/projects/Win/vc12/cds.vcxproj.filters
index 5d3b62680c903ffcdece8df064125f9c1affe643..d08673978c19383f38a4c49a042372ea4af44ea8 100644 (file)
--- a/projects/Win/vc12/cds.vcxproj.filters
+++ b/projects/Win/vc12/cds.vcxproj.filters
@@ -124,9 +124,6 @@
     <Filter Include="Header Files\cds\compiler\clang">\r
       <UniqueIdentifier>{ae97048d-bd62-4ff2-be28-3c84338e7186}</UniqueIdentifier>\r
     </Filter>\r
-    <Filter Include="Header Files\cds\details\std">\r
-      <UniqueIdentifier>{e6c65d81-ad06-40f3-be4e-ddaab3295bf3}</UniqueIdentifier>\r
-    </Filter>\r
     <Filter Include="Header Files\cds\intrusive\striped_set">\r
       <UniqueIdentifier>{560b4d4c-71e1-443c-942e-dcc5a275c7c2}</UniqueIdentifier>\r
     </Filter>\r
@@ -1055,15 +1052,6 @@
     <ClInclude Include="..\..\..\cds\container\details\make_skip_list_map.h">\r
       <Filter>Header Files\cds\container\details</Filter>\r
     </ClInclude>\r
-    <ClInclude Include="..\..\..\cds\details\std\condition_variable.h">\r
-      <Filter>Header Files\cds\details\std</Filter>\r
-    </ClInclude>\r
-    <ClInclude Include="..\..\..\cds\details\std\mutex.h">\r
-      <Filter>Header Files\cds\details\std</Filter>\r
-    </ClInclude>\r
-    <ClInclude Include="..\..\..\cds\details\std\chrono.h">\r
-      <Filter>Header Files\cds\details\std</Filter>\r
-    </ClInclude>\r
     <ClInclude Include="..\..\..\cds\details\static_functor.h">\r
       <Filter>Header Files\cds\details</Filter>\r
     </ClInclude>\r

diff --git a/tests/test-hdr/deque/hdr_fcdeque.cpp b/tests/test-hdr/deque/hdr_fcdeque.cpp
index 11e72dd3f3092ffbd324ac2d6fe0e4b8576671ca..8d6042c3465421056f7d4a4b5e1ecbb1ddd749a3 100644 (file)
--- a/tests/test-hdr/deque/hdr_fcdeque.cpp
+++ b/tests/test-hdr/deque/hdr_fcdeque.cpp
@@ -115,7 +115,7 @@ namespace deque {
             typedef cds::container::FCDeque<int, std::deque<int>,
                 cds::container::fcdeque::make_traits<
                     cds::opt::enable_elimination< true >
-                    ,cds::opt::lock_type< cds_std::mutex >
+                    ,cds::opt::lock_type< std::mutex >
                 >::type
             > deque_type;
             test<deque_type>();
@@ -152,7 +152,7 @@ namespace deque {
             typedef cds::container::FCDeque<int, boost::container::deque<int>,
                 cds::container::fcdeque::make_traits<
                     cds::opt::enable_elimination< true >
-                    ,cds::opt::lock_type< cds_std::mutex >
+                    ,cds::opt::lock_type< std::mutex >
                 >::type
             > deque_type;
             test<deque_type>();

diff --git a/tests/test-hdr/priority_queue/hdr_fcpqueue_deque.cpp b/tests/test-hdr/priority_queue/hdr_fcpqueue_deque.cpp
index 8370f450ff32c3a537d4b63e2a8660390b2b674c..ea40261b76bc8b2e0e6954adc808283940fae9d6 100644 (file)
--- a/tests/test-hdr/priority_queue/hdr_fcpqueue_deque.cpp
+++ b/tests/test-hdr/priority_queue/hdr_fcpqueue_deque.cpp
@@ -44,7 +44,7 @@ namespace priority_queue {
                 ,std::deque<PQueueHdrTest::value_type>
             >
             ,cds::container::fcpqueue::make_traits<
-                cds::opt::lock_type< cds_std::mutex >
+                cds::opt::lock_type< std::mutex >
             >::type
         > pqueue_type;
         test_fcpqueue<pqueue_type>();

diff --git a/tests/test-hdr/priority_queue/hdr_fcpqueue_vector.cpp b/tests/test-hdr/priority_queue/hdr_fcpqueue_vector.cpp
index 4b860b5e76f237fbf885a7973f58993566f7d6c9..613f2d648f13fb0ebbce9b0cc8d1984977dd7af5 100644 (file)
--- a/tests/test-hdr/priority_queue/hdr_fcpqueue_vector.cpp
+++ b/tests/test-hdr/priority_queue/hdr_fcpqueue_vector.cpp
@@ -33,7 +33,7 @@ namespace priority_queue {
             PQueueHdrTest::value_type
             ,std::priority_queue< PQueueHdrTest::value_type >
             ,cds::container::fcpqueue::make_traits<
-                cds::opt::lock_type< cds_std::mutex >
+                cds::opt::lock_type< std::mutex >
             >::type
         > pqueue_type;
         test_fcpqueue<pqueue_type>();

diff --git a/tests/test-hdr/priority_queue/hdr_intrusive_mspqueue_dyn.cpp b/tests/test-hdr/priority_queue/hdr_intrusive_mspqueue_dyn.cpp
index e588afdcd48446c0514876231315be2d2832eddc..aeafd137ea92a1dc3f6f71e569bd00aee11e9bcf 100644 (file)
--- a/tests/test-hdr/priority_queue/hdr_intrusive_mspqueue_dyn.cpp
+++ b/tests/test-hdr/priority_queue/hdr_intrusive_mspqueue_dyn.cpp
@@ -2,7 +2,7 @@
 
 #include "priority_queue/hdr_intrusive_pqueue.h"
 #include <cds/intrusive/mspriority_queue.h>
-#include <cds/details/std/mutex.h>
+#include <mutex>
 
 namespace priority_queue {
     namespace intrusive_pqueue {
@@ -70,7 +70,7 @@ namespace priority_queue {
             cds::intrusive::mspriority_queue::make_traits<
                 cds::opt::buffer< buffer_type >
                 ,cds::opt::compare< IntrusivePQueueHdrTest::compare >
-                ,cds::opt::lock_type<cds_std::mutex>
+                ,cds::opt::lock_type<std::mutex>
             >::type
         > pqueue;
 

diff --git a/tests/test-hdr/priority_queue/hdr_intrusive_mspqueue_static.cpp b/tests/test-hdr/priority_queue/hdr_intrusive_mspqueue_static.cpp
index 37fcd8ecf7d07fe43f6398517b4800cf67f72c0c..450fbc1e174aad58ed5000c9f3ccbd6725c0ff28 100644 (file)
--- a/tests/test-hdr/priority_queue/hdr_intrusive_mspqueue_static.cpp
+++ b/tests/test-hdr/priority_queue/hdr_intrusive_mspqueue_static.cpp
@@ -2,7 +2,7 @@
 
 #include "priority_queue/hdr_intrusive_pqueue.h"
 #include <cds/intrusive/mspriority_queue.h>
-#include <cds/details/std/mutex.h>
+#include <mutex>
 
 namespace priority_queue {
     namespace intrusive_pqueue {
@@ -70,7 +70,7 @@ namespace priority_queue {
             cds::intrusive::mspriority_queue::make_traits<
                 cds::opt::buffer< buffer_type >
                 ,cds::opt::compare< IntrusivePQueueHdrTest::compare >
-                ,cds::opt::lock_type<cds_std::mutex>
+                ,cds::opt::lock_type<std::mutex>
             >::type
         > pqueue;
 

diff --git a/tests/test-hdr/priority_queue/hdr_mspqueue_dyn.cpp b/tests/test-hdr/priority_queue/hdr_mspqueue_dyn.cpp
index cb6e67490b6d149b39e819f3d13f60cdf268dd8c..7a525cb8ce6a4891d862c0b2bfaec42de2d05d92 100644 (file)
--- a/tests/test-hdr/priority_queue/hdr_mspqueue_dyn.cpp
+++ b/tests/test-hdr/priority_queue/hdr_mspqueue_dyn.cpp
@@ -2,7 +2,7 @@
 
 #include "priority_queue/hdr_pqueue.h"
 #include <cds/container/mspriority_queue.h>
-#include <cds/details/std/mutex.h>
+#include <mutex>
 
 namespace priority_queue {
     namespace pqueue {
@@ -70,7 +70,7 @@ namespace priority_queue {
             cds::container::mspriority_queue::make_traits<
                 cds::opt::buffer< buffer_type >
                 ,cds::opt::compare< PQueueHdrTest::compare >
-                ,cds::opt::lock_type<cds_std::mutex>
+                ,cds::opt::lock_type<std::mutex>
             >::type
         > pqueue;
 

diff --git a/tests/test-hdr/priority_queue/hdr_mspqueue_static.cpp b/tests/test-hdr/priority_queue/hdr_mspqueue_static.cpp
index e8ebbe381f65bab4b7bd93b2cd8babdef6e8199e..726a8950013df00e3453a03677843ebf0991acf1 100644 (file)
--- a/tests/test-hdr/priority_queue/hdr_mspqueue_static.cpp
+++ b/tests/test-hdr/priority_queue/hdr_mspqueue_static.cpp
@@ -2,7 +2,7 @@
 
 #include "priority_queue/hdr_pqueue.h"
 #include <cds/container/mspriority_queue.h>
-#include <cds/details/std/mutex.h>
+#include <mutex>
 
 namespace priority_queue {
     namespace pqueue {
@@ -70,7 +70,7 @@ namespace priority_queue {
             cds::container::mspriority_queue::make_traits<
                 cds::opt::buffer< buffer_type >
                 ,cds::opt::compare< PQueueHdrTest::compare >
-                ,cds::opt::lock_type<cds_std::mutex>
+                ,cds::opt::lock_type<std::mutex>
             >::type
         > pqueue;
 

diff --git a/tests/test-hdr/queue/hdr_fcqueue.cpp b/tests/test-hdr/queue/hdr_fcqueue.cpp
index 4b2009dfc7d3706d0f201ebadc44834868948123..ec76558de1292ee60dc5c55c2b10992fb50417a3 100644 (file)
--- a/tests/test-hdr/queue/hdr_fcqueue.cpp
+++ b/tests/test-hdr/queue/hdr_fcqueue.cpp
@@ -27,7 +27,7 @@ namespace queue {
     {
         typedef cds::container::FCQueue<int, std::queue< int, std::deque<int> >,
             cds::container::fcqueue::make_traits<
-                cds::opt::lock_type< cds_std::mutex >
+                cds::opt::lock_type< std::mutex >
             >::type
         > queue_type;
         testFCQueue<queue_type>();
@@ -64,7 +64,7 @@ namespace queue {
     {
         typedef cds::container::FCQueue<int, std::queue<int, std::list<int> >,
             cds::container::fcqueue::make_traits<
-                cds::opt::lock_type< cds_std::mutex >
+                cds::opt::lock_type< std::mutex >
             >::type
         > queue_type;
         testFCQueue<queue_type>();

diff --git a/tests/test-hdr/queue/hdr_intrusive_fcqueue.cpp b/tests/test-hdr/queue/hdr_intrusive_fcqueue.cpp
index 74bfb20b7218d3cdad0bc4accbce7f2cbf900194..0769363c798a1f2167109a1b39f70ebed66d0df0 100644 (file)
--- a/tests/test-hdr/queue/hdr_intrusive_fcqueue.cpp
+++ b/tests/test-hdr/queue/hdr_intrusive_fcqueue.cpp
@@ -198,7 +198,7 @@ namespace queue {
             cds::intrusive::fcqueue::make_traits<
                 cds::intrusive::opt::disposer< disposer >
                 ,cds::opt::enable_elimination< true >
-                ,cds::opt::lock_type< cds_std::mutex >
+                ,cds::opt::lock_type< std::mutex >
             >::type
         > queue_type;
 
@@ -271,7 +271,7 @@ namespace queue {
             cds::intrusive::fcqueue::make_traits<
                 cds::intrusive::opt::disposer< disposer >
                 ,cds::opt::enable_elimination< true >
-                ,cds::opt::lock_type< cds_std::mutex >
+                ,cds::opt::lock_type< std::mutex >
             >::type
         > queue_type;
 

diff --git a/tests/test-hdr/queue/hdr_intrusive_segmented_queue_hp.cpp b/tests/test-hdr/queue/hdr_intrusive_segmented_queue_hp.cpp
index 5e8388932e12d8893e06a1e111b266844829a090..41264b72c7a93c4a0f8637b0e877177a571aee1f 100644 (file)
--- a/tests/test-hdr/queue/hdr_intrusive_segmented_queue_hp.cpp
+++ b/tests/test-hdr/queue/hdr_intrusive_segmented_queue_hp.cpp
@@ -22,7 +22,7 @@ namespace queue {
         typedef cds::intrusive::SegmentedQueue< cds::gc::HP, item,
             cds::intrusive::segmented_queue::make_traits<
                 cds::intrusive::opt::disposer< Disposer >
-                ,cds::opt::lock_type< cds_std::mutex >
+                ,cds::opt::lock_type< std::mutex >
             >::type
         > queue_type;
 

diff --git a/tests/test-hdr/queue/hdr_intrusive_segmented_queue_ptb.cpp b/tests/test-hdr/queue/hdr_intrusive_segmented_queue_ptb.cpp
index 94166e67fd1fe6ceca168964a3cf3ce090ec3b0d..aa43ae2c9d15afd254a329c4930cc47c6182d759 100644 (file)
--- a/tests/test-hdr/queue/hdr_intrusive_segmented_queue_ptb.cpp
+++ b/tests/test-hdr/queue/hdr_intrusive_segmented_queue_ptb.cpp
@@ -22,7 +22,7 @@ namespace queue {
         typedef cds::intrusive::SegmentedQueue< cds::gc::PTB, item,
             cds::intrusive::segmented_queue::make_traits<
                 cds::intrusive::opt::disposer< Disposer >
-                ,cds::opt::lock_type< cds_std::mutex >
+                ,cds::opt::lock_type< std::mutex >
             >::type
         > queue_type;
 

diff --git a/tests/test-hdr/queue/hdr_segmented_queue_hp.cpp b/tests/test-hdr/queue/hdr_segmented_queue_hp.cpp
index bcecfc01fc57e02c265e921f33303c7bdd9d42f8..b7f411be69989116ab9b53561d2bd021feea6e03 100644 (file)
--- a/tests/test-hdr/queue/hdr_segmented_queue_hp.cpp
+++ b/tests/test-hdr/queue/hdr_segmented_queue_hp.cpp
@@ -17,7 +17,7 @@ namespace queue {
     {
         typedef cds::container::SegmentedQueue< cds::gc::HP, item,
             cds::container::segmented_queue::make_traits<
-                cds::opt::lock_type< cds_std::mutex >
+                cds::opt::lock_type< std::mutex >
             >::type
         > queue_type;
 

diff --git a/tests/test-hdr/queue/hdr_segmented_queue_ptb.cpp b/tests/test-hdr/queue/hdr_segmented_queue_ptb.cpp
index 74788a1563255ada8b9497ea4f04eedee8c90b81..6d8ad498a957f9e631b909ba4bbc656e73700959 100644 (file)
--- a/tests/test-hdr/queue/hdr_segmented_queue_ptb.cpp
+++ b/tests/test-hdr/queue/hdr_segmented_queue_ptb.cpp
@@ -17,7 +17,7 @@ namespace queue {
     {
         typedef cds::container::SegmentedQueue< cds::gc::PTB, item,
             cds::container::segmented_queue::make_traits<
-                cds::opt::lock_type< cds_std::mutex >
+                cds::opt::lock_type< std::mutex >
             >::type
         > queue_type;
 

diff --git a/tests/test-hdr/stack/hdr_intrusive_fcstack.cpp b/tests/test-hdr/stack/hdr_intrusive_fcstack.cpp
index f037411ae3626afd931dee85ebf24e23ed6df993..ebc2d248eb896048cd0e925ab9456b8d1818c716 100644 (file)
--- a/tests/test-hdr/stack/hdr_intrusive_fcstack.cpp
+++ b/tests/test-hdr/stack/hdr_intrusive_fcstack.cpp
@@ -146,7 +146,7 @@ namespace stack {
         typedef base_hook_item< boost::intrusive::slist_base_hook<> > value_type;
         typedef cds::intrusive::FCStack< value_type, boost::intrusive::slist< value_type >,
             cds::intrusive::fcstack::make_traits<
-                cds::opt::lock_type< cds_std::mutex >
+                cds::opt::lock_type< std::mutex >
             >::type
         > stack_type;
         test<stack_type>();
@@ -223,7 +223,7 @@ namespace stack {
         typedef base_hook_item< boost::intrusive::list_base_hook<> > value_type;
         typedef cds::intrusive::FCStack< value_type, boost::intrusive::list< value_type >,
             cds::intrusive::fcstack::make_traits<
-                cds::opt::lock_type< cds_std::mutex >
+                cds::opt::lock_type< std::mutex >
             >::type
         > stack_type;
         test<stack_type>();

diff --git a/tests/unit/pqueue/pqueue_type.h b/tests/unit/pqueue/pqueue_type.h
index 799786163fd42361d1047645808bad70fb4bb94f..4c5572f2137e1276b066776559d4a06680b9812b 100644 (file)
--- a/tests/unit/pqueue/pqueue_type.h
+++ b/tests/unit/pqueue/pqueue_type.h
@@ -14,7 +14,7 @@
 #include <deque>
 #include <boost/container/stable_vector.hpp>
 #include <boost/container/deque.hpp>
-#include <cds/details/std/mutex.h>
+#include <mutex>
 #include <cds/lock/spinlock.h>
 
 #include "print_ellenbintree_stat.h"
@@ -65,7 +65,7 @@ namespace pqueue {
         typedef cc::MSPriorityQueue< Value,
             typename cc::mspriority_queue::make_traits<
                 co::buffer< co::v::static_buffer< char, c_nBoundedCapacity > >
-                ,co::lock_type<cds_std::mutex>
+                ,co::lock_type<std::mutex>
             >::type
         > MSPriorityQueue_static_mutex;
 
@@ -92,7 +92,7 @@ namespace pqueue {
         typedef cc::MSPriorityQueue< Value,
             typename cc::mspriority_queue::make_traits<
                 co::buffer< co::v::dynamic_buffer< char > >
-                ,co::lock_type<cds_std::mutex>
+                ,co::lock_type<std::mutex>
             >::type
         > MSPriorityQueue_dyn_mutex;
 
@@ -444,9 +444,9 @@ namespace pqueue {
 
         /// Standard priority_queue
         typedef StdPQueue< Value, std::vector<Value>, cds::lock::Spin > StdPQueue_vector_spin;
-        typedef StdPQueue< Value, std::vector<Value>, cds_std::mutex >  StdPQueue_vector_mutex;
+        typedef StdPQueue< Value, std::vector<Value>, std::mutex >  StdPQueue_vector_mutex;
         typedef StdPQueue< Value, std::deque<Value>,  cds::lock::Spin > StdPQueue_deque_spin;
-        typedef StdPQueue< Value, std::deque<Value>,  cds_std::mutex >  StdPQueue_deque_mutex;
+        typedef StdPQueue< Value, std::deque<Value>,  std::mutex >  StdPQueue_deque_mutex;
     };
 
 

diff --git a/tests/unit/queue/intrusive_queue_type.h b/tests/unit/queue/intrusive_queue_type.h
index b9aaf981edba7ad680147a1292dda64b6ec995cd..23e9f08b93991c06f2cd7adf28a0f5064fff7f17 100644 (file)
--- a/tests/unit/queue/intrusive_queue_type.h
+++ b/tests/unit/queue/intrusive_queue_type.h
@@ -91,12 +91,12 @@ namespace queue {
             }
         };
 
-        template <typename T, typename Lock=cds_std::mutex>
+        template <typename T, typename Lock=std::mutex>
         class BoostSList
         {
             typedef boost::intrusive::slist< T, boost::intrusive::cache_last<true> >    slist_type;
             typedef Lock lock_type;
-            typedef cds_std::lock_guard<lock_type> lock_guard;
+            typedef std::lock_guard<lock_type> lock_guard;
 
             slist_type  m_List;
             mutable lock_type m_Lock;
@@ -569,12 +569,12 @@ namespace queue {
         class traits_SegmentedQueue_mutex_stat:
             public cds::intrusive::segmented_queue::make_traits<
                 cds::opt::stat< cds::intrusive::segmented_queue::stat<> >
-                ,cds::opt::lock_type< cds_std::mutex >
+                ,cds::opt::lock_type< std::mutex >
             >::type
         {};
         class traits_SegmentedQueue_mutex:
             public cds::intrusive::segmented_queue::make_traits<
-                cds::opt::lock_type< cds_std::mutex >
+                cds::opt::lock_type< std::mutex >
             >::type
         {};
 
@@ -589,7 +589,7 @@ namespace queue {
         typedef cds::intrusive::SegmentedQueue< cds::gc::PTB, T, traits_SegmentedQueue_mutex_stat >  SegmentedQueue_PTB_mutex_stat;
 
         // Boost SList
-        typedef details::BoostSList< T, cds_std::mutex >    BoostSList_mutex;
+        typedef details::BoostSList< T, std::mutex >    BoostSList_mutex;
         typedef details::BoostSList< T, cds::lock::Spin >   BoostSList_spin;
     };
 }

diff --git a/tests/unit/queue/queue_type.h b/tests/unit/queue/queue_type.h
index 7585e5b5538b4ce22baf979215bc31c133faffdb..16dbc16dfc9c9fda6dd4051cdb2a2969dbc77b8c 100644 (file)
--- a/tests/unit/queue/queue_type.h
+++ b/tests/unit/queue/queue_type.h
@@ -703,7 +703,7 @@ namespace queue {
         {};
         struct traits_FCDeque_mutex:
             public cds::container::fcdeque::make_traits<
-                cds::opt::lock_type< cds_std::mutex >
+                cds::opt::lock_type< std::mutex >
             >::type
         {};
 
@@ -731,8 +731,8 @@ namespace queue {
 
         typedef StdQueue_deque<Value>               StdQueue_deque_Spinlock;
         typedef StdQueue_list<Value>                StdQueue_list_Spinlock;
-        typedef StdQueue_deque<Value, cds_std::mutex> StdQueue_deque_BoostMutex;
-        typedef StdQueue_list<Value, cds_std::mutex>  StdQueue_list_BoostMutex;
+        typedef StdQueue_deque<Value, std::mutex>   StdQueue_deque_BoostMutex;
+        typedef StdQueue_list<Value, std::mutex>    StdQueue_list_BoostMutex;
 #ifdef UNIT_LOCK_WIN_CS
         typedef StdQueue_deque<Value, lock::win::CS>    StdQueue_deque_WinCS;
         typedef StdQueue_list<Value, lock::win::CS>     StdQueue_list_WinCS;
@@ -749,12 +749,12 @@ namespace queue {
         class traits_SegmentedQueue_mutex_stat:
             public cds::container::segmented_queue::make_traits<
                 cds::opt::stat< cds::intrusive::segmented_queue::stat<> >
-                ,cds::opt::lock_type< cds_std::mutex >
+                ,cds::opt::lock_type< std::mutex >
             >::type
         {};
         class traits_SegmentedQueue_mutex:
             public cds::container::segmented_queue::make_traits<
-                cds::opt::lock_type< cds_std::mutex >
+                cds::opt::lock_type< std::mutex >
             >::type
         {};
 

diff --git a/tests/unit/stack/intrusive_stack_type.h b/tests/unit/stack/intrusive_stack_type.h
index 485c443c3a0d5e178e0cd730289354c1eb7c4d43..14e40f64c14d4a5eec799b8981d6baa96ce9e3eb 100644 (file)
--- a/tests/unit/stack/intrusive_stack_type.h
+++ b/tests/unit/stack/intrusive_stack_type.h
@@ -11,7 +11,7 @@
 #include <cds/gc/ptb.h>
 #include <cds/gc/hrc.h>
 
-#include <cds/details/std/mutex.h>
+#include <mutex>
 #include <cds/lock/spinlock.h>
 #include <stack>
 #include <list>
@@ -68,7 +68,7 @@ namespace istack {
             mutable Lock    m_Lock;
             cds::intrusive::treiber_stack::empty_stat m_stat;
 
-            typedef cds_std::unique_lock<Lock>  unique_lock;
+            typedef std::unique_lock<Lock>  unique_lock;
 
         public:
             typedef T value_type;
@@ -455,20 +455,20 @@ namespace istack {
         struct traits_FCStack_mutex_stat:
             public cds::intrusive::fcstack::make_traits<
                 cds::opt::stat< cds::intrusive::fcstack::stat<> >
-                ,cds::opt::lock_type< cds_std::mutex >
+                ,cds::opt::lock_type< std::mutex >
             >::type
         {};
         struct traits_FCStack_mutex_elimination:
             public cds::intrusive::fcstack::make_traits<
                 cds::opt::enable_elimination< true >
-                ,cds::opt::lock_type< cds_std::mutex >
+                ,cds::opt::lock_type< std::mutex >
             >::type
         {};
         struct traits_FCStack_mutex_elimination_stat:
             public cds::intrusive::fcstack::make_traits<
                 cds::opt::stat< cds::intrusive::fcstack::stat<> >
                 ,cds::opt::enable_elimination< true >
-                ,cds::opt::lock_type< cds_std::mutex >
+                ,cds::opt::lock_type< std::mutex >
             >::type
         {};
 
@@ -624,11 +624,11 @@ namespace istack {
 
 
         // std::stack
-        typedef details::StdStack< T, std::stack< T* >, cds_std::mutex >  StdStack_Deque_Mutex;
+        typedef details::StdStack< T, std::stack< T* >, std::mutex >  StdStack_Deque_Mutex;
         typedef details::StdStack< T, std::stack< T* >, cds::lock::Spin > StdStack_Deque_Spin;
-        typedef details::StdStack< T, std::stack< T*, std::vector<T*> >, cds_std::mutex >  StdStack_Vector_Mutex;
+        typedef details::StdStack< T, std::stack< T*, std::vector<T*> >, std::mutex >  StdStack_Vector_Mutex;
         typedef details::StdStack< T, std::stack< T*, std::vector<T*> >, cds::lock::Spin > StdStack_Vector_Spin;
-        typedef details::StdStack< T, std::stack< T*, std::list<T*> >, cds_std::mutex >  StdStack_List_Mutex;
+        typedef details::StdStack< T, std::stack< T*, std::list<T*> >, std::mutex >  StdStack_List_Mutex;
         typedef details::StdStack< T, std::stack< T*, std::list<T*> >, cds::lock::Spin > StdStack_List_Spin;
 
     };

diff --git a/tests/unit/stack/stack_type.h b/tests/unit/stack/stack_type.h
index 1183c2fbd571eee0aaec15d3ae8aa6ed39e174d7..7a840a807916962da3c020cf1194240ba01f2617 100644 (file)
--- a/tests/unit/stack/stack_type.h
+++ b/tests/unit/stack/stack_type.h
@@ -12,7 +12,7 @@
 #include <cds/gc/ptb.h>
 #include <cds/gc/hrc.h>
 
-#include <cds/details/std/mutex.h>
+#include <mutex>
 #include <cds/lock/spinlock.h>
 #include <stack>
 #include <list>
@@ -120,7 +120,7 @@ namespace stack {
             mutable Lock    m_Lock;
             cds::container::treiber_stack::empty_stat m_stat;
 
-            typedef cds_std::unique_lock<Lock>  unique_lock;
+            typedef std::unique_lock<Lock>  unique_lock;
 
         public:
             bool push( T const& v )
@@ -448,7 +448,7 @@ namespace stack {
         {};
         struct traits_FCStack_mutex:
             public cds::container::fcstack::make_traits<
-                cds::opt::lock_type< cds_std::mutex >
+                cds::opt::lock_type< std::mutex >
             >::type
         {};
 
@@ -486,7 +486,7 @@ namespace stack {
         {};
         struct traits_FCDeque_mutex:
             public cds::container::fcdeque::make_traits<
-                cds::opt::lock_type< cds_std::mutex >
+                cds::opt::lock_type< std::mutex >
             >::type
         {};
 
@@ -613,11 +613,11 @@ namespace stack {
 
 
         // std::stack
-        typedef details::StdStack< T, std::stack< T >, cds_std::mutex >  StdStack_Deque_Mutex;
+        typedef details::StdStack< T, std::stack< T >, std::mutex >  StdStack_Deque_Mutex;
         typedef details::StdStack< T, std::stack< T >, cds::lock::Spin > StdStack_Deque_Spin;
-        typedef details::StdStack< T, std::stack< T, std::vector<T> >, cds_std::mutex >  StdStack_Vector_Mutex;
+        typedef details::StdStack< T, std::stack< T, std::vector<T> >, std::mutex >  StdStack_Vector_Mutex;
         typedef details::StdStack< T, std::stack< T, std::vector<T> >, cds::lock::Spin > StdStack_Vector_Spin;
-        typedef details::StdStack< T, std::stack< T, std::list<T> >, cds_std::mutex >  StdStack_List_Mutex;
+        typedef details::StdStack< T, std::stack< T, std::list<T> >, std::mutex >  StdStack_List_Mutex;
         typedef details::StdStack< T, std::stack< T, std::list<T> >, cds::lock::Spin > StdStack_List_Spin;
 
     };