Removed unused vars

[libcds.git] / tests / unit / set2 / std_set.h

diff --git a/tests/unit/set2/std_set.h b/tests/unit/set2/std_set.h
index 7ca8660d0a95de85e6a60b59684e32efd8dcb98e..09f8fc0ff8d9615d40617f9edf2dce780410ff29 100644 (file)
--- a/tests/unit/set2/std_set.h
+++ b/tests/unit/set2/std_set.h
@@ -4,7 +4,7 @@
 #define __CDSUNIT_STD_SET_VC_H
 
 #include <set>
-#include <cds/ref.h>
+#include <mutex>    //unique_lock
 
 namespace set2 {
     template <typename Value, typename Less, typename Lock,
@@ -13,35 +13,35 @@ namespace set2 {
     class StdSet: public std::set<Value, Less, Alloc>
     {
         Lock m_lock;
-        typedef cds::lock::scoped_lock<Lock> AutoLock;
+        typedef std::unique_lock<Lock> scoped_lock;
         typedef std::set<Value, Less, Alloc> base_class;
     public:
         typedef typename base_class::key_type value_type;
 
-        StdSet( size_t nMapSize, size_t nLoadFactor )
+        StdSet( size_t /*nMapSize*/, size_t /*nLoadFactor*/ )
         {}
 
         template <typename Key>
         bool find( const Key& key )
         {
             value_type v( key );
-            AutoLock al( m_lock );
+            scoped_lock al( m_lock );
             return base_class::find( v ) != base_class::end();
         }
 
         bool insert( value_type const& v )
         {
-            AutoLock al( m_lock );
+            scoped_lock al( m_lock );
             return base_class::insert( v ).second;
         }
 
         template <typename Key, typename Func>
         bool insert( Key const& key, Func func )
         {
-            AutoLock al( m_lock );
+            scoped_lock al( m_lock );
             std::pair<typename base_class::iterator, bool> pRet = base_class::insert( value_type( key ));
             if ( pRet.second ) {
-                cds::unref(func)( *pRet.first );
+                func( *pRet.first );
                 return true;
             }
             return false;
@@ -50,14 +50,14 @@ namespace set2 {
         template <typename T, typename Func>
         std::pair<bool, bool> ensure( const T& key, Func func )
         {
-            AutoLock al( m_lock );
+            scoped_lock al( m_lock );
             std::pair<typename base_class::iterator, bool> pRet = base_class::insert( value_type( key ));
             if ( pRet.second ) {
-                cds::unref(func)( true, *pRet.first, key );
+                func( true, *pRet.first, key );
                 return std::make_pair( true, true );
             }
             else {
-                cds::unref(func)( false, *pRet.first, key );
+                func( false, *pRet.first, key );
                 return std::make_pair( true, false );
             }
         }
@@ -65,17 +65,17 @@ namespace set2 {
         template <typename Key>
         bool erase( const Key& key )
         {
-            AutoLock al( m_lock );
+            scoped_lock al( m_lock );
             return base_class::erase( value_type(key) ) != 0;
         }
 
         template <typename T, typename Func>
         bool erase( const T& key, Func func )
         {
-            AutoLock al( m_lock );
+            scoped_lock al( m_lock );
             typename base_class::iterator it = base_class::find( value_type(key) );
             if ( it != base_class::end() ) {
-                cds::unref(func)( *it );
+                func( *it );
 
                 base_class::erase( it );
                 return true;