Fixed -Wshadow warnings
authorkhizmax <khizmax@gmail.com>
Tue, 12 Sep 2017 18:11:45 +0000 (21:11 +0300)
committerkhizmax <khizmax@gmail.com>
Tue, 12 Sep 2017 18:11:45 +0000 (21:11 +0300)
36 files changed:
cds/container/impl/bronson_avltree_map_rcu.h
cds/container/impl/lazy_list.h
cds/container/impl/skip_list_set.h
cds/container/lazy_list_rcu.h
cds/container/michael_map.h
cds/container/michael_map_nogc.h
cds/container/michael_map_rcu.h
cds/container/michael_set.h
cds/container/michael_set_nogc.h
cds/container/michael_set_rcu.h
cds/container/skip_list_set_rcu.h
cds/container/split_list_set.h
cds/container/split_list_set_rcu.h
cds/intrusive/free_list_cached.h
cds/intrusive/impl/ellen_bintree.h
cds/intrusive/lazy_list_nogc.h
cds/intrusive/michael_set.h
cds/intrusive/michael_set_nogc.h
cds/intrusive/michael_set_rcu.h
cds/intrusive/msqueue.h
cds/intrusive/split_list.h
cds/intrusive/split_list_nogc.h
cds/intrusive/split_list_rcu.h
test/include/cds_test/thread.h
test/stress/framework/city.cpp
test/unit/intrusive-list/test_intrusive_list_nogc.h
test/unit/intrusive-set/test_intrusive_michael_lazy_rcu.h
test/unit/intrusive-set/test_intrusive_michael_michael_rcu.h
test/unit/intrusive-set/test_intrusive_skiplist_rcu.h
test/unit/intrusive-set/test_intrusive_split_lazy_rcu.h
test/unit/intrusive-set/test_intrusive_split_michael_rcu.h
test/unit/misc/cxx11_atomic_class.cpp
test/unit/misc/cxx11_atomic_func.cpp
test/unit/pqueue/intrusive_mspqueue.cpp
test/unit/striped-set/test_striped_set.h
test/unit/tree/test_bronson_avltree_map.h

index f21253b..a855ff2 100644 (file)
@@ -381,9 +381,9 @@ namespace cds { namespace container {
             return do_remove(
                 key,
                 key_comparator(),
-                [&f]( key_type const& key, mapped_type pVal, rcu_disposer& disp ) -> bool {
+                [&f]( key_type const& k, mapped_type pVal, rcu_disposer& disp ) -> bool {
                     assert( pVal );
-                    f( key, *pVal );
+                    f( k, *pVal );
                     disp.dispose_value(pVal);
                     return true;
                 }
@@ -404,9 +404,9 @@ namespace cds { namespace container {
             return do_remove(
                 key,
                 cds::opt::details::make_comparator_from_less<Less>(),
-                [&f]( key_type const& key, mapped_type pVal, rcu_disposer& disp ) -> bool {
+                [&f]( key_type const& k, mapped_type pVal, rcu_disposer& disp ) -> bool {
                     assert( pVal );
-                    f( key, *pVal );
+                    f( k, *pVal );
                     disp.dispose_value(pVal);
                     return true;
                 }
@@ -1410,10 +1410,10 @@ namespace cds { namespace container {
         {
             node_type * pNew;
 
-            auto fnCreateNode = [&funcUpdate]( node_type * pNew ) {
-                mapped_type pVal = funcUpdate( pNew );
+            auto fnCreateNode = [&funcUpdate]( node_type * pNode ) {
+                mapped_type pVal = funcUpdate( pNode );
                 assert( pVal != nullptr );
-                pNew->m_pValue.store( pVal, memory_model::memory_order_release );
+                pNode->m_pValue.store( pVal, memory_model::memory_order_release );
             };
 
             static_if ( c_bRelaxedInsert ) {
index 7d91b0e..96c37b8 100644 (file)
@@ -851,7 +851,7 @@ namespace cds { namespace container {
         template <typename Q, typename Compare, typename Func>
         bool find_at( head_type& refHead, Q& val, Compare cmp, Func f )
         {
-            return base_class::find_at( &refHead, val, cmp, [&f](node_type& node, Q& val){ f( node_to_value(node), val ); });
+            return base_class::find_at( &refHead, val, cmp, [&f](node_type& node, Q& v){ f( node_to_value(node), v ); });
         }
 
         template <typename Q, typename Compare>
index ab075e9..7901f7d 100644 (file)
@@ -313,7 +313,7 @@ namespace cds { namespace container {
         bool insert( Q const& val, Func f )
         {
             scoped_node_ptr sp( node_allocator().New( random_level(), val ));
-            if ( base_class::insert( *sp.get(), [&f]( node_type& val ) { f( val.m_Value ); } )) {
+            if ( base_class::insert( *sp.get(), [&f]( node_type& v ) { f( v.m_Value ); } )) {
                 sp.release();
                 return true;
             }
index 738e504..60c724e 100644 (file)
@@ -821,13 +821,13 @@ namespace cds { namespace container {
         template <typename Q, typename Compare>
         bool find_at( head_type& refHead, Q const& key, Compare cmp ) const
         {
-            return base_class::find_at( &refHead, key, cmp, [](node_type&, Q const &) {} );
+            return base_class::find_at( &refHead, key, cmp, [](node_type&, Q const&) {} );
         }
 
         template <typename Q, typename Compare, typename Func>
         bool find_at( head_type& refHead, Q& val, Compare cmp, Func f ) const
         {
-            return base_class::find_at( &refHead, val, cmp, [&f](node_type& node, Q& val){ f( node_to_value(node), val ); });
+            return base_class::find_at( &refHead, val, cmp, [&f](node_type& node, Q& v){ f( node_to_value(node), v ); });
         }
 
         template <typename Q, typename Compare>
index 912ae81..9947409 100644 (file)
@@ -990,15 +990,15 @@ namespace cds { namespace container {
         }
 
         template <typename Stat>
-        typename std::enable_if< Stat::empty >::type construct_bucket( internal_bucket_type* bucket )
+        typename std::enable_if< Stat::empty >::type construct_bucket( internal_bucket_type* b )
         {
-            new (bucket) internal_bucket_type;
+            new (b) internal_bucket_type;
         }
 
         template <typename Stat>
-        typename std::enable_if< !Stat::empty >::type construct_bucket( internal_bucket_type* bucket )
+        typename std::enable_if< !Stat::empty >::type construct_bucket( internal_bucket_type* b )
         {
-            new (bucket) internal_bucket_type( m_Stat );
+            new (b) internal_bucket_type( m_Stat );
         }
         //@endcond
     };
index 04299da..610eef3 100644 (file)
@@ -590,15 +590,15 @@ namespace cds { namespace container {
         }
 
         template <typename Stat>
-        typename std::enable_if< Stat::empty >::type construct_bucket( internal_bucket_type* bucket )
+        typename std::enable_if< Stat::empty >::type construct_bucket( internal_bucket_type* b )
         {
-            new (bucket) internal_bucket_type;
+            new (b) internal_bucket_type;
         }
 
         template <typename Stat>
-        typename std::enable_if< !Stat::empty >::type construct_bucket( internal_bucket_type* bucket )
+        typename std::enable_if< !Stat::empty >::type construct_bucket( internal_bucket_type* b )
         {
-            new (bucket) internal_bucket_type( m_Stat );
+            new (b) internal_bucket_type( m_Stat );
         }
         //@endcond
     };
index 93198b8..ef44254 100644 (file)
@@ -855,15 +855,15 @@ namespace cds { namespace container {
         }
 
         template <typename Stat>
-        typename std::enable_if< Stat::empty >::type construct_bucket( internal_bucket_type* bucket )
+        typename std::enable_if< Stat::empty >::type construct_bucket( internal_bucket_type* bkt )
         {
-            new (bucket) internal_bucket_type;
+            new (bkt) internal_bucket_type;
         }
 
         template <typename Stat>
-        typename std::enable_if< !Stat::empty >::type construct_bucket( internal_bucket_type* bucket )
+        typename std::enable_if< !Stat::empty >::type construct_bucket( internal_bucket_type* bkt )
         {
-            new (bucket) internal_bucket_type( m_Stat );
+            new (bkt) internal_bucket_type( m_Stat );
         }
         //@endcond
     };
index 32fddca..85ffc53 100644 (file)
@@ -943,15 +943,15 @@ namespace cds { namespace container {
         }
 
         template <typename Stat>
-        typename std::enable_if< Stat::empty >::type construct_bucket( internal_bucket_type* bucket )
+        typename std::enable_if< Stat::empty >::type construct_bucket( internal_bucket_type* b )
         {
-            new (bucket) internal_bucket_type;
+            new (b) internal_bucket_type;
         }
 
         template <typename Stat>
-        typename std::enable_if< !Stat::empty >::type construct_bucket( internal_bucket_type* bucket )
+        typename std::enable_if< !Stat::empty >::type construct_bucket( internal_bucket_type* b )
         {
-            new (bucket) internal_bucket_type( m_Stat );
+            new (b) internal_bucket_type( m_Stat );
         }
 
         template <typename List, typename... Args>
index efb6901..5874dd2 100644 (file)
@@ -430,15 +430,15 @@ namespace cds { namespace container {
     private:
         //@cond
         template <typename Stat>
-        typename std::enable_if< Stat::empty >::type construct_bucket( internal_bucket_type* bucket )
+        typename std::enable_if< Stat::empty >::type construct_bucket( internal_bucket_type* b )
         {
-            new (bucket) internal_bucket_type;
+            new (b) internal_bucket_type;
         }
 
         template <typename Stat>
-        typename std::enable_if< !Stat::empty >::type construct_bucket( internal_bucket_type* bucket )
+        typename std::enable_if< !Stat::empty >::type construct_bucket( internal_bucket_type* b )
         {
-            new (bucket) internal_bucket_type( m_Stat );
+            new (b) internal_bucket_type( m_Stat );
         }
 
         const_iterator get_const_begin() const
index 34bc0c2..54cf068 100644 (file)
@@ -797,15 +797,15 @@ namespace cds { namespace container {
         }
 
         template <typename Stat>
-        typename std::enable_if< Stat::empty >::type construct_bucket( internal_bucket_type* bucket )
+        typename std::enable_if< Stat::empty >::type construct_bucket( internal_bucket_type* bkt )
         {
-            new (bucket) internal_bucket_type;
+            new (bkt) internal_bucket_type;
         }
 
         template <typename Stat>
-        typename std::enable_if< !Stat::empty >::type construct_bucket( internal_bucket_type* bucket )
+        typename std::enable_if< !Stat::empty >::type construct_bucket( internal_bucket_type* bkt )
         {
-            new (bucket) internal_bucket_type( m_Stat );
+            new (bkt) internal_bucket_type( m_Stat );
         }
 
         const_iterator get_const_begin() const
index daf05f2..b34ccba 100644 (file)
@@ -358,7 +358,7 @@ namespace cds { namespace container {
         bool insert( Q const& val, Func f )
         {
             scoped_node_ptr sp( node_allocator().New( random_level(), val ));
-            if ( base_class::insert( *sp.get(), [&f]( node_type& val ) { f( val.m_Value ); } )) {
+            if ( base_class::insert( *sp.get(), [&f]( node_type& v ) { f( v.m_Value ); } )) {
                 sp.release();
                 return true;
             }
index b4af551..47d4886 100644 (file)
@@ -936,7 +936,7 @@ namespace cds { namespace container {
         template <typename Q, typename Func>
         bool find_( Q& val, Func f )
         {
-            return base_class::find( val, [&f]( node_type& item, Q& val ) { f( item.m_Value, val ); } );
+            return base_class::find( val, [&f]( node_type& item, Q& v ) { f( item.m_Value, v ); } );
         }
 
         template <typename Q>
@@ -951,7 +951,7 @@ namespace cds { namespace container {
         {
             CDS_UNUSED( pred );
             return base_class::find_with( val, typename maker::template predicate_wrapper<Less>::type(),
-                [&f]( node_type& item, Q& val ) { f( item.m_Value, val ); } );
+                [&f]( node_type& item, Q& v ) { f( item.m_Value, v ); } );
         }
 
         template <typename Q, typename Less>
index 36f4551..c72295a 100644 (file)
@@ -315,7 +315,7 @@ namespace cds { namespace container {
         template <typename Q, typename Func>
         bool find_( Q& val, Func f )
         {
-            return base_class::find( val, [&f]( node_type& item, Q& val ) { f(item.m_Value, val) ; } );
+            return base_class::find( val, [&f]( node_type& item, Q& v ) { f(item.m_Value, v) ; } );
         }
 
         template <typename Q, typename Less, typename Func>
@@ -323,7 +323,7 @@ namespace cds { namespace container {
         {
             CDS_UNUSED( pred );
             return base_class::find_with( val, typename maker::template predicate_wrapper<Less>::type(),
-                [&f]( node_type& item, Q& val ) { f(item.m_Value, val) ; } );
+                [&f]( node_type& item, Q& v ) { f(item.m_Value, v) ; } );
         }
 
         template <typename Q>
index 9c9adea..3fd3b09 100644 (file)
@@ -121,9 +121,9 @@ namespace cds { namespace intrusive {
                 return p;
 
             // iterate the cache
-            for ( auto& cell : m_cache ) {
-                p = cell.load( atomics::memory_order_relaxed );
-                if ( p && cell.compare_exchange_weak( p, nullptr, atomics::memory_order_acquire, atomics::memory_order_relaxed ))
+            for ( auto& item : m_cache ) {
+                p = item.load( atomics::memory_order_relaxed );
+                if ( p && item.compare_exchange_weak( p, nullptr, atomics::memory_order_acquire, atomics::memory_order_relaxed ))
                     return p;
             }
 
index 974854b..3ab0923 100644 (file)
@@ -918,18 +918,18 @@ namespace cds { namespace intrusive {
         retry:
             tree_node * p = bRight
                 ? res.guards.protect( search_result::Guard_Leaf, pParent->m_pRight,
-                    []( tree_node * p ) -> internal_node* { return static_cast<internal_node *>(p);})
+                    []( tree_node * pn ) -> internal_node* { return static_cast<internal_node *>(pn);})
                 : res.guards.protect( search_result::Guard_Leaf, pParent->m_pLeft,
-                    []( tree_node * p ) -> internal_node* { return static_cast<internal_node *>(p);});
+                    []( tree_node * pn ) -> internal_node* { return static_cast<internal_node *>(pn);});
 
             // If we use member hook, data node pointer != internal node pointer
             // So, we need protect the child twice: as internal node and as data node
             // and then analyze what kind of node we have
             tree_node * pVal = bRight
                 ? res.guards.protect( search_result::Guard_temporary, pParent->m_pRight,
-                    []( tree_node * p ) -> value_type* { return node_traits::to_value_ptr( static_cast<leaf_node *>(p));} )
+                    []( tree_node * pn ) -> value_type* { return node_traits::to_value_ptr( static_cast<leaf_node *>(pn));} )
                 : res.guards.protect( search_result::Guard_temporary, pParent->m_pLeft,
-                    []( tree_node * p ) -> value_type* { return node_traits::to_value_ptr( static_cast<leaf_node *>(p));} );
+                    []( tree_node * pn ) -> value_type* { return node_traits::to_value_ptr( static_cast<leaf_node *>(pn));} );
 
             // child node is guarded
             // See whether pParent->m_pUpdate has not been changed
index 01fc656..2c9761f 100644 (file)
@@ -480,10 +480,10 @@ namespace cds { namespace intrusive {
             \p Equal functor has the interface like \p std::equal_to.
         */
         template <typename Q, typename Equal, typename Func, bool Sort = c_bSort>
-        typename std::enable_if<!Sort, bool>::type find_with( Q& key, Equal equal, Func f )
+        typename std::enable_if<!Sort, bool>::type find_with( Q& key, Equal eq, Func f )
         {
-            CDS_UNUSED( equal );
-            return find_at( &m_Head, key, equal, f );
+            //CDS_UNUSED( eq );
+            return find_at( &m_Head, key, eq, f );
         }
         //@cond
         template <typename Q, typename Less, typename Func, bool Sort = c_bSort>
@@ -494,10 +494,10 @@ namespace cds { namespace intrusive {
         }
 
         template <typename Q, typename Equal, typename Func, bool Sort = c_bSort>
-        typename std::enable_if<!Sort, bool>::type find_with( Q const& key, Equal equal, Func f )
+        typename std::enable_if<!Sort, bool>::type find_with( Q const& key, Equal eq, Func f )
         {
-            CDS_UNUSED( equal );
-            return find_at( &m_Head, key, equal, f );
+            //CDS_UNUSED( eq );
+            return find_at( &m_Head, key, eq, f );
         }
         //@endcond
 
@@ -547,16 +547,16 @@ namespace cds { namespace intrusive {
             \p Equal functor has the interface like \p std::equal_to.
         */
         template <typename Q, typename Equal, bool Sort = c_bSort>
-        typename std::enable_if<!Sort, value_type *>::type contains( Q const& key, Equal equal )
+        typename std::enable_if<!Sort, value_type *>::type contains( Q const& key, Equal eq )
         {
-            return find_at( &m_Head, key, equal );
+            return find_at( &m_Head, key, eq );
         }
         //@cond
         template <typename Q, typename Equal, bool Sort = c_bSort>
         CDS_DEPRECATED("deprecated, use contains()")
-        typename std::enable_if<!Sort, value_type *>::type find_with( Q const& key, Equal equal )
+        typename std::enable_if<!Sort, value_type *>::type find_with( Q const& key, Equal eq )
         {
-            return contains( key, equal );
+            return contains( key, eq );
         }
         //@endcond
 
index fe2c2f9..79b2b8c 100644 (file)
@@ -982,15 +982,15 @@ namespace cds { namespace intrusive {
         }
 
         template <typename Stat>
-        typename std::enable_if< Stat::empty >::type construct_bucket( internal_bucket_type * bucket )
+        typename std::enable_if< Stat::empty >::type construct_bucket( internal_bucket_type * b )
         {
-            new (bucket) internal_bucket_type;
+            new (b) internal_bucket_type;
         }
 
         template <typename Stat>
-        typename std::enable_if< !Stat::empty >::type construct_bucket( internal_bucket_type * bucket )
+        typename std::enable_if< !Stat::empty >::type construct_bucket( internal_bucket_type * b )
         {
-            new (bucket) internal_bucket_type( m_Stat );
+            new (b) internal_bucket_type( m_Stat );
         }
 
         /// Calculates hash value of \p key
index 883e852..dfe01d1 100644 (file)
@@ -455,15 +455,15 @@ namespace cds { namespace intrusive {
     private:
         //@cond
         template <typename Stat>
-        typename std::enable_if< Stat::empty >::type construct_bucket( internal_bucket_type * bucket )
+        typename std::enable_if< Stat::empty >::type construct_bucket( internal_bucket_type * b )
         {
-            new (bucket) internal_bucket_type;
+            new (b) internal_bucket_type;
         }
 
         template <typename Stat>
-        typename std::enable_if< !Stat::empty >::type construct_bucket( internal_bucket_type * bucket )
+        typename std::enable_if< !Stat::empty >::type construct_bucket( internal_bucket_type * b )
         {
-            new (bucket) internal_bucket_type( m_Stat );
+            new (b) internal_bucket_type( m_Stat );
         }
         //@endcond
     };
index 43a2613..2a0d9bd 100644 (file)
@@ -735,15 +735,15 @@ namespace cds { namespace intrusive {
     private:
         //@cond
         template <typename Stat>
-        typename std::enable_if< Stat::empty >::type construct_bucket( internal_bucket_type * bucket )
+        typename std::enable_if< Stat::empty >::type construct_bucket( internal_bucket_type * bkt )
         {
-            new (bucket) internal_bucket_type;
+            new (bkt) internal_bucket_type;
         }
 
         template <typename Stat>
-        typename std::enable_if< !Stat::empty >::type construct_bucket( internal_bucket_type * bucket )
+        typename std::enable_if< !Stat::empty >::type construct_bucket( internal_bucket_type * bkt )
         {
-            new (bucket) internal_bucket_type( m_Stat );
+            new (bkt) internal_bucket_type( m_Stat );
         }
 
         /// Calculates hash value of \p key
index 98d8a64..0313390 100644 (file)
@@ -584,7 +584,7 @@ namespace cds { namespace intrusive {
         bool empty() const
         {
             typename gc::Guard guard;
-            node_type * p = guard.protect( m_pHead, []( node_type * p ) -> value_type * { return node_traits::to_value_ptr( p );});
+            node_type * p = guard.protect( m_pHead, []( node_type * pNode ) -> value_type * { return node_traits::to_value_ptr( pNode );});
             return p->m_pNext.load( memory_model::memory_order_relaxed ) == nullptr;
         }
 
index 691a089..7ef5bfd 100644 (file)
@@ -1325,7 +1325,7 @@ namespace cds { namespace intrusive {
 
             return m_Stat.onFind(
                 m_List.find_at( pHead, sv, cmp,
-                    [&f]( value_type& item, split_list::details::search_value_type<Q>& val ) { f( item, val.val ); } )
+                    [&f]( value_type& item, split_list::details::search_value_type<Q>& v ) { f( item, v.val ); } )
             );
         }
 
index 68c0d25..966f5da 100644 (file)
@@ -582,7 +582,7 @@ namespace cds { namespace intrusive {
             aux_node_type * pHead = get_bucket( nHash );
             assert( pHead != nullptr );
             return m_Stat.onFind( m_List.find_at( pHead, sv, cmp,
-                [&f](value_type& item, split_list::details::search_value_type<Q>& val){ f(item, val.val ); }));
+                [&f](value_type& item, split_list::details::search_value_type<Q>& v){ f(item, v.val ); }));
         }
 
         aux_node_type * alloc_aux_node( size_t nHash )
index 64583fe..48c49a2 100644 (file)
@@ -1019,7 +1019,7 @@ namespace cds { namespace intrusive {
             assert( pHead != nullptr );
 
             return m_Stat.onFind( m_List.find_at( pHead, sv, cmp,
-                [&f](value_type& item, split_list::details::search_value_type<Q>& val){ f(item, val.val ); }));
+                [&f](value_type& item, split_list::details::search_value_type<Q>& v){ f(item, v.val ); }));
         }
 
         template <typename Q, typename Compare>
index 44baffd..51fc399 100644 (file)
@@ -156,8 +156,8 @@ namespace cds_test {
         };
 
     public:
-        explicit thread_pool( ::testing::Test& fixture )
-            : m_fixture( fixture )
+        explicit thread_pool( ::testing::Test& fx )
+            : m_fixture( fx )
             , m_bTimeElapsed( false )
         {}
 
index 1d99557..321cea1 100644 (file)
@@ -200,11 +200,11 @@ uint32 CityHash32(const char *s, size_t len) {
   f = f * 5 + 0xe6546b64;
   size_t iters = (len - 1) / 20;
   do {
-    uint32 a0 = Rotate32(Fetch32(s) * c1, 17) * c2;
-    uint32 a1 = Fetch32(s + 4);
-    uint32 a2 = Rotate32(Fetch32(s + 8) * c1, 17) * c2;
-    uint32 a3 = Rotate32(Fetch32(s + 12) * c1, 17) * c2;
-    uint32 a4 = Fetch32(s + 16);
+    a0 = Rotate32(Fetch32(s) * c1, 17) * c2;
+    a1 = Fetch32(s + 4);
+    a2 = Rotate32(Fetch32(s + 8) * c1, 17) * c2;
+    a3 = Rotate32(Fetch32(s + 12) * c1, 17) * c2;
+    a4 = Fetch32(s + 16);
     h ^= a0;
     h = Rotate32(h, 18);
     h = h * 5 + 0xe6546b64;
index 08274cc..c023d00 100644 (file)
@@ -329,11 +329,11 @@ namespace cds_test {
                 EXPECT_FALSE( ret.second );
                 EXPECT_EQ( i.s.nUpdateExistsCall, 1 );
 
-                ret = l.update( i, []( bool bNew, value_type& i, value_type& arg ) {
+                ret = l.update( i, []( bool bNew, value_type& vi, value_type& arg ) {
                     EXPECT_FALSE( bNew );
-                    EXPECT_EQ( i.s.nUpdateExistsCall, 1 );
-                    EXPECT_TRUE( &i == &arg );
-                    ++i.s.nUpdateExistsCall;
+                    EXPECT_EQ( vi.s.nUpdateExistsCall, 1 );
+                    EXPECT_TRUE( &vi == &arg );
+                    ++vi.s.nUpdateExistsCall;
                 });
                 EXPECT_TRUE( ret.first );
                 EXPECT_FALSE( ret.second );
index d831268..5c03650 100644 (file)
@@ -68,14 +68,14 @@ TYPED_TEST_P( IntrusiveMichaelLazySet, base_cmp )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::base_item_type base_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template cmp<base_item_type> cmp;
+    typedef typename TestFixture::template cmp<base_item_type> item_cmp;
     typedef typename TestFixture::hash_int hash_int;
 
     typedef ci::LazyList< rcu_type
         , base_item_type
         , typename ci::lazy_list::make_traits<
             ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< rcu_type > > >
-            , ci::opt::compare< cmp >
+            , ci::opt::compare< item_cmp >
             , ci::opt::disposer< mock_disposer >
         >::type
     > bucket_type;
@@ -95,14 +95,14 @@ TYPED_TEST_P( IntrusiveMichaelLazySet, base_less )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::base_item_type base_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template less<base_item_type> less;
+    typedef typename TestFixture::template less<base_item_type> item_less;
     typedef typename TestFixture::hash_int hash_int;
 
     typedef ci::LazyList< rcu_type
         , base_item_type
         , typename ci::lazy_list::make_traits<
             ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< rcu_type >>>
-            , ci::opt::less< less >
+            , ci::opt::less< item_less >
             , ci::opt::disposer< mock_disposer >
         >::type
     > bucket_type;
@@ -232,7 +232,7 @@ TYPED_TEST_P( IntrusiveMichaelLazySet, member_cmp )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::member_item_type member_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template cmp<member_item_type> cmp;
+    typedef typename TestFixture::template cmp<member_item_type> item_cmp;
     typedef typename TestFixture::hash_int hash_int;
 
     typedef ci::LazyList< rcu_type
@@ -242,7 +242,7 @@ TYPED_TEST_P( IntrusiveMichaelLazySet, member_cmp )
                 offsetof( member_item_type, hMember ),
                 ci::opt::gc<rcu_type>
             >>
-            , ci::opt::compare< cmp >
+            , ci::opt::compare< item_cmp >
             , ci::opt::disposer< mock_disposer >
         >::type
     >    bucket_type;
@@ -262,7 +262,7 @@ TYPED_TEST_P( IntrusiveMichaelLazySet, member_less )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::member_item_type member_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template less<member_item_type> less;
+    typedef typename TestFixture::template less<member_item_type> item_less;
     typedef typename TestFixture::hash_int hash_int;
 
     typedef ci::LazyList< rcu_type
@@ -272,7 +272,7 @@ TYPED_TEST_P( IntrusiveMichaelLazySet, member_less )
                 offsetof( member_item_type, hMember ),
                 ci::opt::gc<rcu_type>
             > >
-            , ci::opt::less< less >
+            , ci::opt::less< item_less >
             , ci::opt::disposer< mock_disposer >
         >::type
     > bucket_type;
index 1c38731..5d9e3ee 100644 (file)
@@ -66,14 +66,14 @@ TYPED_TEST_P( IntrusiveMichaelSet, base_cmp )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::base_item_type base_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template cmp<base_item_type> cmp;
+    typedef typename TestFixture::template cmp<base_item_type> item_cmp;
     typedef typename TestFixture::hash_int hash_int;
 
     typedef ci::MichaelList< rcu_type
         , base_item_type
         , typename ci::michael_list::make_traits<
             ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< rcu_type > > >
-            , ci::opt::compare< cmp >
+            , ci::opt::compare< item_cmp >
             , ci::opt::disposer< mock_disposer >
         >::type
     > bucket_type;
@@ -93,14 +93,14 @@ TYPED_TEST_P( IntrusiveMichaelSet, base_less )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::base_item_type base_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template less<base_item_type> less;
+    typedef typename TestFixture::template less<base_item_type> item_less;
     typedef typename TestFixture::hash_int hash_int;
 
     typedef ci::MichaelList< rcu_type
         , base_item_type
         , typename ci::michael_list::make_traits<
             ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< rcu_type >>>
-            , ci::opt::less< less >
+            , ci::opt::less< item_less >
             , ci::opt::disposer< mock_disposer >
         >::type
     > bucket_type;
@@ -205,7 +205,7 @@ TYPED_TEST_P( IntrusiveMichaelSet, member_cmp )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::member_item_type member_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template cmp<member_item_type> cmp;
+    typedef typename TestFixture::template cmp<member_item_type> item_cmp;
     typedef typename TestFixture::hash_int hash_int;
 
     typedef ci::MichaelList< rcu_type
@@ -215,7 +215,7 @@ TYPED_TEST_P( IntrusiveMichaelSet, member_cmp )
                 offsetof( member_item_type, hMember ),
                 ci::opt::gc<rcu_type>
             >>
-            , ci::opt::compare< cmp >
+            , ci::opt::compare< item_cmp >
             , ci::opt::disposer< mock_disposer >
         >::type
     >    bucket_type;
@@ -235,7 +235,7 @@ TYPED_TEST_P( IntrusiveMichaelSet, member_less )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::member_item_type member_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template less<member_item_type> less;
+    typedef typename TestFixture::template less<member_item_type> item_less;
     typedef typename TestFixture::hash_int hash_int;
 
     typedef ci::MichaelList< rcu_type
@@ -245,7 +245,7 @@ TYPED_TEST_P( IntrusiveMichaelSet, member_less )
                 offsetof( member_item_type, hMember ),
                 ci::opt::gc<rcu_type>
             > >
-            , ci::opt::less< less >
+            , ci::opt::less< item_less >
             , ci::opt::disposer< mock_disposer >
         >::type
     > bucket_type;
index ee62fc2..63347a8 100644 (file)
@@ -65,13 +65,13 @@ TYPED_TEST_P( IntrusiveSkipListSet, base_cmp )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::base_item_type base_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template cmp<base_item_type> cmp;
+    typedef typename TestFixture::template cmp<base_item_type> item_cmp;
 
     struct traits : public ci::skip_list::traits
     {
         typedef ci::skip_list::base_hook< ci::opt::gc< rcu_type >> hook;
         typedef mock_disposer disposer;
-        typedef cmp compare;
+        typedef item_cmp compare;
     };
 
     typedef ci::SkipListSet< rcu_type, base_item_type, traits > set_type;
@@ -106,14 +106,14 @@ TYPED_TEST_P( IntrusiveSkipListSet, base_cmpmix )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::base_item_type base_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template cmp<base_item_type> cmp;
+    typedef typename TestFixture::template cmp<base_item_type> item_cmp;
     typedef typename TestFixture::template less<base_item_type> less_predicate;
 
     struct traits : public ci::skip_list::traits
     {
         typedef ci::skip_list::base_hook< ci::opt::gc< rcu_type >> hook;
         typedef mock_disposer disposer;
-        typedef cmp compare;
+        typedef item_cmp compare;
         typedef less_predicate less;
         typedef ci::skip_list::stat<> stat;
     };
@@ -129,13 +129,13 @@ TYPED_TEST_P( IntrusiveSkipListSet, base_xorshift32 )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::base_item_type base_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template cmp<base_item_type> cmp;
+    typedef typename TestFixture::template cmp<base_item_type> item_cmp;
 
     struct traits : public ci::skip_list::traits
     {
         typedef ci::skip_list::base_hook< ci::opt::gc< rcu_type >> hook;
         typedef mock_disposer disposer;
-        typedef cmp compare;
+        typedef item_cmp compare;
         typedef ci::skip_list::xorshift32 random_level_generator;
     };
 
@@ -150,13 +150,13 @@ TYPED_TEST_P( IntrusiveSkipListSet, base_xorshift24 )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::base_item_type base_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template cmp<base_item_type> cmp;
+    typedef typename TestFixture::template cmp<base_item_type> item_cmp;
 
     struct traits: public ci::skip_list::traits
     {
         typedef ci::skip_list::base_hook< ci::opt::gc< rcu_type >> hook;
         typedef mock_disposer disposer;
-        typedef cmp compare;
+        typedef item_cmp compare;
         typedef ci::skip_list::xorshift24 random_level_generator;
     };
 
@@ -171,13 +171,13 @@ TYPED_TEST_P( IntrusiveSkipListSet, base_xorshift16 )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::base_item_type base_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template cmp<base_item_type> cmp;
+    typedef typename TestFixture::template cmp<base_item_type> item_cmp;
 
     struct traits: public ci::skip_list::traits
     {
         typedef ci::skip_list::base_hook< ci::opt::gc< rcu_type >> hook;
         typedef mock_disposer disposer;
-        typedef cmp compare;
+        typedef item_cmp compare;
         typedef ci::skip_list::xorshift16 random_level_generator;
     };
 
@@ -192,13 +192,13 @@ TYPED_TEST_P( IntrusiveSkipListSet, base_turbo32 )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::base_item_type base_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template cmp<base_item_type> cmp;
+    typedef typename TestFixture::template cmp<base_item_type> item_cmp;
 
     struct traits: public ci::skip_list::traits
     {
         typedef ci::skip_list::base_hook< ci::opt::gc< rcu_type >> hook;
         typedef mock_disposer disposer;
-        typedef cmp compare;
+        typedef item_cmp compare;
         typedef ci::skip_list::turbo32 random_level_generator;
     };
 
@@ -234,13 +234,13 @@ TYPED_TEST_P( IntrusiveSkipListSet, base_turbo16 )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::base_item_type base_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template cmp<base_item_type> cmp;
+    typedef typename TestFixture::template cmp<base_item_type> item_cmp;
 
     struct traits: public ci::skip_list::traits
     {
         typedef ci::skip_list::base_hook< ci::opt::gc< rcu_type >> hook;
         typedef mock_disposer disposer;
-        typedef cmp compare;
+        typedef item_cmp compare;
         typedef ci::skip_list::turbo16 random_level_generator;
     };
 
@@ -256,13 +256,13 @@ TYPED_TEST_P( IntrusiveSkipListSet, member_cmp )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::member_item_type member_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template cmp<member_item_type> cmp;
+    typedef typename TestFixture::template cmp<member_item_type> item_cmp;
 
     struct traits : public ci::skip_list::traits
     {
         typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< rcu_type >> hook;
         typedef mock_disposer disposer;
-        typedef cmp compare;
+        typedef item_cmp compare;
     };
 
     typedef ci::SkipListSet< rcu_type, member_item_type, traits > set_type;
@@ -300,13 +300,13 @@ TYPED_TEST_P( IntrusiveSkipListSet, member_cmpmix )
     typedef typename TestFixture::member_item_type member_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
     typedef typename TestFixture::template less<member_item_type> less_predicate;
-    typedef typename TestFixture::template cmp<member_item_type> cmp;
+    typedef typename TestFixture::template cmp<member_item_type> item_cmp;
 
     struct traits : public ci::skip_list::traits
     {
         typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< rcu_type >> hook;
         typedef mock_disposer disposer;
-        typedef cmp compare;
+        typedef item_cmp compare;
         typedef less_predicate less;
         typedef ci::skip_list::stat<> stat;
     };
@@ -323,13 +323,13 @@ TYPED_TEST_P( IntrusiveSkipListSet, member_xorshift32 )
     typedef typename TestFixture::member_item_type member_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
     typedef typename TestFixture::template less<member_item_type> less_predicate;
-    typedef typename TestFixture::template cmp<member_item_type> cmp;
+    typedef typename TestFixture::template cmp<member_item_type> item_cmp;
 
     struct traits : public ci::skip_list::traits
     {
         typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< rcu_type >> hook;
         typedef mock_disposer disposer;
-        typedef cmp compare;
+        typedef item_cmp compare;
         typedef less_predicate less;
         typedef ci::skip_list::stat<> stat;
         typedef ci::skip_list::xorshift32 random_level_generator;
@@ -347,13 +347,13 @@ TYPED_TEST_P( IntrusiveSkipListSet, member_xorshift24 )
     typedef typename TestFixture::member_item_type member_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
     typedef typename TestFixture::template less<member_item_type> less_predicate;
-    typedef typename TestFixture::template cmp<member_item_type> cmp;
+    typedef typename TestFixture::template cmp<member_item_type> item_cmp;
 
     struct traits: public ci::skip_list::traits
     {
         typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< rcu_type >> hook;
         typedef mock_disposer disposer;
-        typedef cmp compare;
+        typedef item_cmp compare;
         typedef less_predicate less;
         typedef ci::skip_list::stat<> stat;
         typedef ci::skip_list::xorshift24 random_level_generator;
@@ -371,13 +371,13 @@ TYPED_TEST_P( IntrusiveSkipListSet, member_xorshift16 )
     typedef typename TestFixture::member_item_type member_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
     typedef typename TestFixture::template less<member_item_type> less_predicate;
-    typedef typename TestFixture::template cmp<member_item_type> cmp;
+    typedef typename TestFixture::template cmp<member_item_type> item_cmp;
 
     struct traits: public ci::skip_list::traits
     {
         typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< rcu_type >> hook;
         typedef mock_disposer disposer;
-        typedef cmp compare;
+        typedef item_cmp compare;
         typedef less_predicate less;
         typedef ci::skip_list::stat<> stat;
         typedef ci::skip_list::xorshift16 random_level_generator;
@@ -395,13 +395,13 @@ TYPED_TEST_P( IntrusiveSkipListSet, member_turbo32 )
     typedef typename TestFixture::member_item_type member_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
     typedef typename TestFixture::template less<member_item_type> less_predicate;
-    typedef typename TestFixture::template cmp<member_item_type> cmp;
+    typedef typename TestFixture::template cmp<member_item_type> item_cmp;
 
     struct traits: public ci::skip_list::traits
     {
         typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< rcu_type >> hook;
         typedef mock_disposer disposer;
-        typedef cmp compare;
+        typedef item_cmp compare;
         typedef less_predicate less;
         typedef ci::skip_list::stat<> stat;
         typedef ci::skip_list::turbo32 random_level_generator;
@@ -419,13 +419,13 @@ TYPED_TEST_P( IntrusiveSkipListSet, member_turbo24 )
     typedef typename TestFixture::member_item_type member_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
     typedef typename TestFixture::template less<member_item_type> less_predicate;
-    typedef typename TestFixture::template cmp<member_item_type> cmp;
+    typedef typename TestFixture::template cmp<member_item_type> item_cmp;
 
     struct traits: public ci::skip_list::traits
     {
         typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< rcu_type >> hook;
         typedef mock_disposer disposer;
-        typedef cmp compare;
+        typedef item_cmp compare;
         typedef less_predicate less;
         typedef ci::skip_list::stat<> stat;
         typedef ci::skip_list::turbo24 random_level_generator;
@@ -443,13 +443,13 @@ TYPED_TEST_P( IntrusiveSkipListSet, member_turbo16 )
     typedef typename TestFixture::member_item_type member_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
     typedef typename TestFixture::template less<member_item_type> less_predicate;
-    typedef typename TestFixture::template cmp<member_item_type> cmp;
+    typedef typename TestFixture::template cmp<member_item_type> item_cmp;
 
     struct traits: public ci::skip_list::traits
     {
         typedef ci::skip_list::member_hook< offsetof( member_item_type, hMember ), ci::opt::gc< rcu_type >> hook;
         typedef mock_disposer disposer;
-        typedef cmp compare;
+        typedef item_cmp compare;
         typedef less_predicate less;
         typedef ci::skip_list::stat<> stat;
         typedef ci::skip_list::turbo16 random_level_generator;
index 7d7176a..73e5416 100644 (file)
@@ -69,14 +69,14 @@ TYPED_TEST_P( IntrusiveSplitLazySet, base_cmp )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::base_item_type base_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template cmp<base_item_type> cmp;
+    typedef typename TestFixture::template cmp<base_item_type> item_cmp;
     typedef typename TestFixture::hash_int hash_int;
 
     typedef ci::LazyList< rcu_type
         , base_item_type
         , typename ci::lazy_list::make_traits<
             ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< rcu_type > > >
-            , ci::opt::compare< cmp >
+            , ci::opt::compare< item_cmp >
             , ci::opt::disposer< mock_disposer >
         >::type
     > bucket_type;
@@ -96,14 +96,14 @@ TYPED_TEST_P( IntrusiveSplitLazySet, base_less )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::base_item_type base_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template less<base_item_type> less;
+    typedef typename TestFixture::template less<base_item_type> item_less;
     typedef typename TestFixture::hash_int hash_int;
 
     typedef ci::LazyList< rcu_type
         , base_item_type
         , typename ci::lazy_list::make_traits<
             ci::opt::hook< ci::lazy_list::base_hook< ci::opt::gc< rcu_type >>>
-            , ci::opt::less< less >
+            , ci::opt::less< item_less >
             , ci::opt::disposer< mock_disposer >
         >::type
     > bucket_type;
@@ -270,7 +270,7 @@ TYPED_TEST_P( IntrusiveSplitLazySet, member_cmp )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::member_item_type member_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template cmp<member_item_type> cmp;
+    typedef typename TestFixture::template cmp<member_item_type> item_cmp;
     typedef typename TestFixture::hash_int hash_int;
 
     typedef ci::LazyList< rcu_type
@@ -280,7 +280,7 @@ TYPED_TEST_P( IntrusiveSplitLazySet, member_cmp )
                 offsetof( member_item_type, hMember ),
                 ci::opt::gc<rcu_type>
             >>
-            , ci::opt::compare< cmp >
+            , ci::opt::compare< item_cmp >
             , ci::opt::disposer< mock_disposer >
         >::type
     >    bucket_type;
@@ -300,7 +300,7 @@ TYPED_TEST_P( IntrusiveSplitLazySet, member_less )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::member_item_type member_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template less<member_item_type> less;
+    typedef typename TestFixture::template less<member_item_type> item_less;
     typedef typename TestFixture::hash_int hash_int;
 
     typedef ci::LazyList< rcu_type
@@ -310,7 +310,7 @@ TYPED_TEST_P( IntrusiveSplitLazySet, member_less )
                 offsetof( member_item_type, hMember ),
                 ci::opt::gc<rcu_type>
             > >
-            , ci::opt::less< less >
+            , ci::opt::less< item_less >
             , ci::opt::disposer< mock_disposer >
         >::type
     > bucket_type;
index cb7b482..5f1cf5b 100644 (file)
@@ -67,14 +67,14 @@ TYPED_TEST_P( IntrusiveSplitMichaelSet, base_cmp )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::base_item_type base_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template cmp<base_item_type> cmp;
+    typedef typename TestFixture::template cmp<base_item_type> item_cmp;
     typedef typename TestFixture::hash_int hash_int;
 
     typedef ci::MichaelList< rcu_type
         , base_item_type
         , typename ci::michael_list::make_traits<
             ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< rcu_type > > >
-            , ci::opt::compare< cmp >
+            , ci::opt::compare< item_cmp >
             , ci::opt::disposer< mock_disposer >
         >::type
     > bucket_type;
@@ -94,14 +94,14 @@ TYPED_TEST_P( IntrusiveSplitMichaelSet, base_less )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::base_item_type base_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template less<base_item_type> less;
+    typedef typename TestFixture::template less<base_item_type> item_less;
     typedef typename TestFixture::hash_int hash_int;
 
     typedef ci::MichaelList< rcu_type
         , base_item_type
         , typename ci::michael_list::make_traits<
             ci::opt::hook< ci::michael_list::base_hook< ci::opt::gc< rcu_type >>>
-            , ci::opt::less< less >
+            , ci::opt::less< item_less >
             , ci::opt::disposer< mock_disposer >
         >::type
     > bucket_type;
@@ -324,7 +324,7 @@ TYPED_TEST_P( IntrusiveSplitMichaelSet, member_cmp )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::member_item_type member_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template cmp<member_item_type> cmp;
+    typedef typename TestFixture::template cmp<member_item_type> item_cmp;
     typedef typename TestFixture::hash_int hash_int;
 
     typedef ci::MichaelList< rcu_type
@@ -334,7 +334,7 @@ TYPED_TEST_P( IntrusiveSplitMichaelSet, member_cmp )
                 offsetof( member_item_type, hMember ),
                 ci::opt::gc<rcu_type>
             >>
-            , ci::opt::compare< cmp >
+            , ci::opt::compare< item_cmp >
             , ci::opt::disposer< mock_disposer >
         >::type
     >    bucket_type;
@@ -354,7 +354,7 @@ TYPED_TEST_P( IntrusiveSplitMichaelSet, member_less )
     typedef typename TestFixture::rcu_type rcu_type;
     typedef typename TestFixture::member_item_type member_item_type;
     typedef typename TestFixture::mock_disposer mock_disposer;
-    typedef typename TestFixture::template less<member_item_type> less;
+    typedef typename TestFixture::template less<member_item_type> item_less;
     typedef typename TestFixture::hash_int hash_int;
 
     typedef ci::MichaelList< rcu_type
@@ -364,7 +364,7 @@ TYPED_TEST_P( IntrusiveSplitMichaelSet, member_less )
                 offsetof( member_item_type, hMember ),
                 ci::opt::gc<rcu_type>
             > >
-            , ci::opt::less< less >
+            , ci::opt::less< item_less >
             , ci::opt::disposer< mock_disposer >
         >::type
     > bucket_type;
index c17702a..4041d8f 100644 (file)
@@ -526,14 +526,14 @@ namespace {
             EXPECT_EQ( *a.load( oLoad ), 1 );
 
             for ( integral_type i = 1; i < aSize; ++i ) {
-                integral_type * p = a.load();
+                p = a.load();
                 EXPECT_EQ( *p, i );
                 EXPECT_EQ( a.fetch_add( 1, order ), p );
                 EXPECT_EQ( *a.load( oLoad ), i + 1 );
             }
 
             for ( integral_type i = aSize; i > 1; --i ) {
-                integral_type * p = a.load();
+                p = a.load();
                 EXPECT_EQ( *p, i  );
                 EXPECT_EQ( a.fetch_sub( 1, order ), p );
                 EXPECT_EQ( *a.load( oLoad ), i - 1 );
@@ -578,7 +578,7 @@ namespace {
             EXPECT_EQ( *a.load(), 1 );
 
             for ( integral_type i = 1; i < aSize; ++i ) {
-                integral_type * p = a.load();
+                p = a.load();
                 EXPECT_EQ( *p, i );
                 integral_type * pa = a.fetch_add( 1 );
                 EXPECT_EQ( pa, p );
@@ -586,7 +586,7 @@ namespace {
             }
 
             for ( integral_type i = aSize; i > 1; --i ) {
-                integral_type * p = a.load();
+                p = a.load();
                 EXPECT_EQ( *p, i  );
                 EXPECT_EQ( a.fetch_sub( 1 ), p );
                 EXPECT_EQ( *a.load(), i - 1 );
index 432ed4e..20c948f 100644 (file)
@@ -416,14 +416,14 @@ namespace misc {
             EXPECT_EQ( *atomics::atomic_load_explicit( &a, oLoad ), 1 );
 
             for ( integral_type i = 1; i < aSize; ++i ) {
-                integral_type * p = atomics::atomic_load_explicit( &a, oLoad );
+                p = atomics::atomic_load_explicit( &a, oLoad );
                 EXPECT_EQ( *p, i );
                 EXPECT_EQ( atomics::atomic_fetch_add_explicit( &a, 1, order ), p );
                 EXPECT_EQ( *atomics::atomic_load_explicit( &a, oLoad ), i + 1 );
             }
 
             for ( integral_type i = aSize; i > 1; --i ) {
-                integral_type * p = atomics::atomic_load_explicit( &a, oLoad );
+                p = atomics::atomic_load_explicit( &a, oLoad );
                 EXPECT_EQ( *p, i  );
                 EXPECT_EQ( atomics::atomic_fetch_sub_explicit( &a, 1, order ), p );
                 EXPECT_EQ( *atomics::atomic_load_explicit( &a, oLoad ), i - 1 );
@@ -464,14 +464,14 @@ namespace misc {
             EXPECT_EQ( *atomics::atomic_load( &a ), 1 );
 
             for ( integral_type i = 1; i < aSize; ++i ) {
-                integral_type * p = atomics::atomic_load( &a );
+                p = atomics::atomic_load( &a );
                 EXPECT_EQ( *p, i );
                 EXPECT_EQ( atomics::atomic_fetch_add( &a, 1 ), p );
                 EXPECT_EQ( *atomics::atomic_load( &a ), i + 1 );
             }
 
             for ( integral_type i = aSize; i > 1; --i ) {
-                integral_type * p = atomics::atomic_load( &a );
+                p = atomics::atomic_load( &a );
                 EXPECT_EQ( *p, i );
                 EXPECT_EQ( atomics::atomic_fetch_sub( &a, 1 ), p );
                 EXPECT_EQ( *atomics::atomic_load( &a ), i - 1 );
index b91c1a6..5fa1921 100644 (file)
@@ -116,7 +116,7 @@ namespace {
             ASSERT_EQ( pq.size(), 0u );
 
             // Clear test
-            for ( value_type * p = pFirst; p < pLast; ++p ) {
+            for ( p = pFirst; p < pLast; ++p ) {
                 ASSERT_TRUE( pq.push( *p ));
             }
             EXPECT_FALSE( pq.empty());
@@ -128,7 +128,7 @@ namespace {
             EXPECT_EQ( pq.size(), 0u );
 
             // clear_with test
-            for ( value_type * p = pFirst; p < pLast; ++p ) {
+            for ( p = pFirst; p < pLast; ++p ) {
                 ASSERT_TRUE( pq.push( *p ));
             }
             ASSERT_FALSE( pq.empty());
index 1e7dec4..338ebcd 100644 (file)
@@ -72,8 +72,8 @@ namespace {
         template <typename Func>
         bool operator()( Set& s, int key, Func f ) const
         {
-            return s.find( key, [&f]( typename Set::value_type& v, int key ) {
-                cds_test::container_set::other_item oi( key );
+            return s.find( key, [&f]( typename Set::value_type& v, int k ) {
+                cds_test::container_set::other_item oi( k );
                 f( v, oi );
             });
         }
index d82c9d1..9145c71 100644 (file)
@@ -93,25 +93,25 @@ namespace {
                 case 0:
                     ASSERT_TRUE( m.insert( i ));
                     ASSERT_FALSE( m.insert( i ));
-                    ASSERT_TRUE( m.find( i.nKey, []( key_type const& key, value_type& val ) {
-                        val.nVal = key.nKey;
-                        val.strVal = std::to_string( key.nKey );
+                    ASSERT_TRUE( m.find( i.nKey, []( key_type const& key, value_type& v ) {
+                        v.nVal = key.nKey;
+                        v.strVal = std::to_string( key.nKey );
                     } ));
                     break;
                 case 1:
                     ASSERT_TRUE( m.insert( i.nKey ));
                     ASSERT_FALSE( m.insert( i.nKey ));
-                    ASSERT_TRUE( m.find( i.nKey, []( key_type const& key, value_type& val ) {
-                        val.nVal = key.nKey;
-                        val.strVal = std::to_string( key.nKey );
+                    ASSERT_TRUE( m.find( i.nKey, []( key_type const& key, value_type& v ) {
+                        v.nVal = key.nKey;
+                        v.strVal = std::to_string( key.nKey );
                     } ));
                     break;
                 case 2:
                     ASSERT_TRUE( m.insert( std::to_string( i.nKey )));
                     ASSERT_FALSE( m.insert( std::to_string( i.nKey )));
-                    ASSERT_TRUE( m.find( i.nKey, []( key_type const& key, value_type& val ) {
-                        val.nVal = key.nKey;
-                        val.strVal = std::to_string( key.nKey );
+                    ASSERT_TRUE( m.find( i.nKey, []( key_type const& key, value_type& v ) {
+                        v.nVal = key.nKey;
+                        v.strVal = std::to_string( key.nKey );
                     } ));
                     break;
                 case 3:
@@ -127,27 +127,27 @@ namespace {
                     ASSERT_FALSE( m.insert( val.strVal, i.nKey ));
                     break;
                 case 6:
-                    ASSERT_TRUE( m.insert_with( i, []( key_type const& key, value_type& val ) {
-                        val.nVal = key.nKey;
-                        val.strVal = std::to_string( key.nKey );
+                    ASSERT_TRUE( m.insert_with( i, []( key_type const& key, value_type& v ) {
+                        v.nVal = key.nKey;
+                        v.strVal = std::to_string( key.nKey );
                     } ));
                     ASSERT_FALSE( m.insert_with( i, []( key_type const& /*key*/, value_type& /*val*/ ) {
                         EXPECT_TRUE( false );
                     } ));
                     break;
                 case 7:
-                    ASSERT_TRUE( m.insert_with( i.nKey, []( key_type const& key, value_type& val ) {
-                        val.nVal = key.nKey;
-                        val.strVal = std::to_string( key.nKey );
+                    ASSERT_TRUE( m.insert_with( i.nKey, []( key_type const& key, value_type& v ) {
+                        v.nVal = key.nKey;
+                        v.strVal = std::to_string( key.nKey );
                     } ));
                     ASSERT_FALSE( m.insert_with( i.nKey, []( key_type const& /*key*/, value_type& /*val*/ ) {
                         EXPECT_TRUE( false );
                     } ));
                     break;
                 case 8:
-                    ASSERT_TRUE( m.insert_with( val.strVal, []( key_type const& key, value_type& val ) {
-                        val.nVal = key.nKey;
-                        val.strVal = std::to_string( key.nKey );
+                    ASSERT_TRUE( m.insert_with( val.strVal, []( key_type const& key, value_type& v ) {
+                        v.nVal = key.nKey;
+                        v.strVal = std::to_string( key.nKey );
                     } ));
                     ASSERT_FALSE( m.insert_with( val.strVal, []( key_type const& /*key*/, value_type& /*val*/ ) {
                         EXPECT_TRUE( false );
@@ -160,17 +160,17 @@ namespace {
                     ASSERT_FALSE( updResult.first );
                     ASSERT_FALSE( updResult.second );
 
-                    updResult = m.update( i.nKey, []( bool bNew, key_type const& key, value_type& val ) {
+                    updResult = m.update( i.nKey, []( bool bNew, key_type const& key, value_type& v ) {
                         EXPECT_TRUE( bNew );
-                        val.nVal = key.nKey;
+                        v.nVal = key.nKey;
                     });
                     ASSERT_TRUE( updResult.first );
                     ASSERT_TRUE( updResult.second );
 
-                    updResult = m.update( i.nKey, []( bool bNew, key_type const& key, value_type& val ) {
+                    updResult = m.update( i.nKey, []( bool bNew, key_type const& key, value_type& v ) {
                         EXPECT_FALSE( bNew );
-                        EXPECT_EQ( key.nKey, val.nVal );
-                        val.strVal = std::to_string( val.nVal );
+                        EXPECT_EQ( key.nKey, v.nVal );
+                        v.strVal = std::to_string( v.nVal );
                     } );
                     ASSERT_TRUE( updResult.first );
                     ASSERT_FALSE( updResult.second );
@@ -182,17 +182,17 @@ namespace {
                     ASSERT_FALSE( updResult.first );
                     ASSERT_FALSE( updResult.second );
 
-                    updResult = m.update( i, []( bool bNew, key_type const& key, value_type& val ) {
+                    updResult = m.update( i, []( bool bNew, key_type const& key, value_type& v ) {
                         EXPECT_TRUE( bNew );
-                        val.nVal = key.nKey;
+                        v.nVal = key.nKey;
                     });
                     ASSERT_TRUE( updResult.first );
                     ASSERT_TRUE( updResult.second );
 
-                    updResult = m.update( i, []( bool bNew, key_type const& key, value_type& val ) {
+                    updResult = m.update( i, []( bool bNew, key_type const& key, value_type& v ) {
                         EXPECT_FALSE( bNew );
-                        EXPECT_EQ( key.nKey, val.nVal );
-                        val.strVal = std::to_string( val.nVal );
+                        EXPECT_EQ( key.nKey, v.nVal );
+                        v.strVal = std::to_string( v.nVal );
                     } );
                     ASSERT_TRUE( updResult.first );
                     ASSERT_FALSE( updResult.second );
@@ -204,17 +204,17 @@ namespace {
                     ASSERT_FALSE( updResult.first );
                     ASSERT_FALSE( updResult.second );
 
-                    updResult = m.update( val.strVal, []( bool bNew, key_type const& key, value_type& val ) {
+                    updResult = m.update( val.strVal, []( bool bNew, key_type const& key, value_type& v ) {
                         EXPECT_TRUE( bNew );
-                        val.nVal = key.nKey;
+                        v.nVal = key.nKey;
                     });
                     ASSERT_TRUE( updResult.first );
                     ASSERT_TRUE( updResult.second );
 
-                    updResult = m.update( val.strVal, []( bool bNew, key_type const& key, value_type& val ) {
+                    updResult = m.update( val.strVal, []( bool bNew, key_type const& key, value_type& v ) {
                         EXPECT_FALSE( bNew );
-                        EXPECT_EQ( key.nKey, val.nVal );
-                        val.strVal = std::to_string( val.nVal );
+                        EXPECT_EQ( key.nKey, v.nVal );
+                        v.strVal = std::to_string( v.nVal );
                     } );
                     ASSERT_TRUE( updResult.first );
                     ASSERT_FALSE( updResult.second );
@@ -222,9 +222,9 @@ namespace {
                 case 12:
                     ASSERT_TRUE( m.emplace( i.nKey ));
                     ASSERT_FALSE( m.emplace( i.nKey ));
-                    ASSERT_TRUE( m.find( i.nKey, []( key_type const& key, value_type& val ) {
-                        val.nVal = key.nKey;
-                        val.strVal = std::to_string( key.nKey );
+                    ASSERT_TRUE( m.find( i.nKey, []( key_type const& key, value_type& v ) {
+                        v.nVal = key.nKey;
+                        v.strVal = std::to_string( key.nKey );
                     } ));
                     break;
                 case 13:
@@ -256,17 +256,17 @@ namespace {
                 ASSERT_TRUE( m.contains( i.nKey ));
                 ASSERT_TRUE( m.contains( i ));
                 ASSERT_TRUE( m.contains( other_item( i.nKey ), other_less()));
-                ASSERT_TRUE( m.find( i, []( key_type const& key, value_type& val ) {
-                    EXPECT_EQ( key.nKey, val.nVal );
-                    EXPECT_EQ( std::to_string( key.nKey ), val.strVal );
+                ASSERT_TRUE( m.find( i, []( key_type const& key, value_type& v ) {
+                    EXPECT_EQ( key.nKey, v.nVal );
+                    EXPECT_EQ( std::to_string( key.nKey ), v.strVal );
                 } ));
-                ASSERT_TRUE( m.find( i.nKey, []( key_type const& key, value_type& val ) {
-                    EXPECT_EQ( key.nKey, val.nVal );
-                    EXPECT_EQ( std::to_string( key.nKey ), val.strVal );
+                ASSERT_TRUE( m.find( i.nKey, []( key_type const& key, value_type& v ) {
+                    EXPECT_EQ( key.nKey, v.nVal );
+                    EXPECT_EQ( std::to_string( key.nKey ), v.strVal );
                 } ));
-                ASSERT_TRUE( m.find_with( other_item( i.nKey ), other_less(), []( key_type const& key, value_type& val ) {
-                    EXPECT_EQ( key.nKey, val.nVal );
-                    EXPECT_EQ( std::to_string( key.nKey ), val.strVal );
+                ASSERT_TRUE( m.find_with( other_item( i.nKey ), other_less(), []( key_type const& key, value_type& v ) {
+                    EXPECT_EQ( key.nKey, v.nVal );
+                    EXPECT_EQ( std::to_string( key.nKey ), v.strVal );
                 } ));
             }
             ASSERT_FALSE( m.empty());
@@ -284,17 +284,17 @@ namespace {
                 ASSERT_TRUE( m.contains( val.strVal ));
                 ASSERT_TRUE( m.contains( i ));
                 ASSERT_TRUE( m.contains( other_item( i.nKey ), other_less()));
-                ASSERT_TRUE( m.find( i, []( key_type const& key, value_type& val ) {
-                    EXPECT_EQ( key.nKey, val.nVal );
-                    EXPECT_EQ( std::to_string( key.nKey ), val.strVal );
+                ASSERT_TRUE( m.find( i, []( key_type const& key, value_type& v ) {
+                    EXPECT_EQ( key.nKey, v.nVal );
+                    EXPECT_EQ( std::to_string( key.nKey ), v.strVal );
                 } ));
-                ASSERT_TRUE( m.find( i.nKey, []( key_type const& key, value_type& val ) {
-                    EXPECT_EQ( key.nKey, val.nVal );
-                    EXPECT_EQ( std::to_string( key.nKey ), val.strVal );
+                ASSERT_TRUE( m.find( i.nKey, []( key_type const& key, value_type& v ) {
+                    EXPECT_EQ( key.nKey, v.nVal );
+                    EXPECT_EQ( std::to_string( key.nKey ), v.strVal );
                 } ));
-                ASSERT_TRUE( m.find_with( other_item( i.nKey ), other_less(), []( key_type const& key, value_type& val ) {
-                    EXPECT_EQ( key.nKey, val.nVal );
-                    EXPECT_EQ( std::to_string( key.nKey ), val.strVal );
+                ASSERT_TRUE( m.find_with( other_item( i.nKey ), other_less(), []( key_type const& key, value_type& v ) {
+                    EXPECT_EQ( key.nKey, v.nVal );
+                    EXPECT_EQ( std::to_string( key.nKey ), v.strVal );
                 } ));
 
 
@@ -316,36 +316,36 @@ namespace {
                     ASSERT_FALSE( m.erase_with( other_item( i.nKey ), other_less()));
                     break;
                 case 4:
-                    ASSERT_TRUE( m.erase( i, []( key_type const& key, value_type& val ) {
-                        EXPECT_EQ( key.nKey, val.nVal );
-                        EXPECT_EQ( std::to_string( key.nKey ), val.strVal );
+                    ASSERT_TRUE( m.erase( i, []( key_type const& key, value_type& v ) {
+                        EXPECT_EQ( key.nKey, v.nVal );
+                        EXPECT_EQ( std::to_string( key.nKey ), v.strVal );
                     }));
                     ASSERT_FALSE( m.erase( i, []( key_type const& /*key*/, value_type& /*val*/ ) {
                         EXPECT_TRUE( false );
                     }));
                     break;
                 case 5:
-                    ASSERT_TRUE( m.erase( i.nKey, []( key_type const& key, value_type& val ) {
-                        EXPECT_EQ( key.nKey, val.nVal );
-                        EXPECT_EQ( std::to_string( key.nKey ), val.strVal );
+                    ASSERT_TRUE( m.erase( i.nKey, []( key_type const& key, value_type& v ) {
+                        EXPECT_EQ( key.nKey, v.nVal );
+                        EXPECT_EQ( std::to_string( key.nKey ), v.strVal );
                     }));
                     ASSERT_FALSE( m.erase( i.nKey, []( key_type const& /*key*/, value_type& /*val*/ ) {
                         EXPECT_TRUE( false );
                     }));
                     break;
                 case 6:
-                    ASSERT_TRUE( m.erase( val.strVal, []( key_type const& key, value_type& val ) {
-                        EXPECT_EQ( key.nKey, val.nVal );
-                        EXPECT_EQ( std::to_string( key.nKey ), val.strVal );
+                    ASSERT_TRUE( m.erase( val.strVal, []( key_type const& key, value_type& v ) {
+                        EXPECT_EQ( key.nKey, v.nVal );
+                        EXPECT_EQ( std::to_string( key.nKey ), v.strVal );
                     }));
                     ASSERT_FALSE( m.erase( val.strVal, []( key_type const& /*key*/, value_type& /*val*/ ) {
                         EXPECT_TRUE( false );
                     }));
                     break;
                 case 7:
-                    ASSERT_TRUE( m.erase_with( other_item( i.nKey ), other_less(), []( key_type const& key, value_type& val ) {
-                        EXPECT_EQ( key.nKey, val.nVal );
-                        EXPECT_EQ( std::to_string( key.nKey ), val.strVal );
+                    ASSERT_TRUE( m.erase_with( other_item( i.nKey ), other_less(), []( key_type const& key, value_type& v ) {
+                        EXPECT_EQ( key.nKey, v.nVal );
+                        EXPECT_EQ( std::to_string( key.nKey ), v.strVal );
                     }));
                     ASSERT_FALSE( m.erase_with( other_item( i.nKey ), other_less(), []( key_type const& /*key*/, value_type& /*val*/ ) {
                         EXPECT_TRUE( false );