Remove 'unused vars' warnings

diff --git a/cds/intrusive/cuckoo_set.h b/cds/intrusive/cuckoo_set.h
index 7ba7b00c9671479069eba93eb1d30f0ab4d6248f..aa0e24426af9c6e69b20f8e3922e586c8d47e5db 100644 (file)
--- a/cds/intrusive/cuckoo_set.h
+++ b/cds/intrusive/cuckoo_set.h
@@ -1538,7 +1538,7 @@ namespace cds { namespace intrusive {
             struct contains<NodeTraits, true>
             {
                 template <typename BucketEntry, typename Position, typename Q, typename Compare>
-                static bool find( BucketEntry& probeset, Position& pos, unsigned int nTable, size_t nHash, Q const& val, Compare cmp )
+                static bool find( BucketEntry& probeset, Position& pos, unsigned int /*nTable*/, size_t /*nHash*/, Q const& val, Compare cmp )
                 {
                     // Ordered version
                     typedef typename BucketEntry::iterator bucket_iterator;
@@ -2576,6 +2576,7 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Predicate>
         value_type * erase_with( Q const& val, Predicate pred )
         {
+            CDS_UNUSED( pred );
             return erase_( val, typename predicate_wrapper<Predicate>::type(), [](value_type const&) {} );
         }
 
@@ -2612,6 +2613,7 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Predicate, typename Func>
         value_type * erase_with( Q const& val, Predicate pred, Func f )
         {
+            CDS_UNUSED( pred );
             return erase_( val, typename predicate_wrapper<Predicate>::type(), f );
         }
 
@@ -2653,6 +2655,7 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Predicate, typename Func>
         bool find_with( Q& val, Predicate pred, Func f )
         {
+            CDS_UNUSED( pred );
             return find_( val, typename predicate_wrapper<Predicate>::type(), f );
         }
 
@@ -2691,6 +2694,7 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Predicate, typename Func>
         bool find_with( Q const& val, Predicate pred, Func f )
         {
+            CDS_UNUSED( pred );
             return find_( val, typename predicate_wrapper<Predicate>::type(), f );
         }
 
@@ -2719,6 +2723,7 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Predicate>
         bool find_with( Q const& val, Predicate pred )
         {
+            CDS_UNUSED( pred );
             return find_with( val, typename predicate_wrapper<Predicate>::type(), [](value_type& , Q const& ) {} );
         }
 

diff --git a/cds/intrusive/details/lazy_list_base.h b/cds/intrusive/details/lazy_list_base.h
index e348eac59c1d533b4d02063ca3ef7584abd05cb0..c83393423b84d7e0a75ce2ef07b8056a30dc25e3 100644 (file)
--- a/cds/intrusive/details/lazy_list_base.h
+++ b/cds/intrusive/details/lazy_list_base.h
@@ -147,6 +147,7 @@ namespace cds { namespace intrusive {
             static void is_empty( node_type const * pNode )
             {
                 assert( pNode->m_pNext.load( atomics::memory_order_relaxed ) == nullptr );
+                CDS_UNUSED( pNode );
             }
         };
 

diff --git a/cds/intrusive/details/michael_list_base.h b/cds/intrusive/details/michael_list_base.h
index a3f79441cd33dc86401e51b8f9fb9e616d44d90b..023714a31f3b8126b275efd6b156a101eb451886 100644 (file)
--- a/cds/intrusive/details/michael_list_base.h
+++ b/cds/intrusive/details/michael_list_base.h
@@ -128,6 +128,7 @@ namespace cds { namespace intrusive {
             static void is_empty( const node_type * pNode )
             {
                 assert( pNode->m_pNext.load( atomics::memory_order_relaxed ) == nullptr );
+                CDS_UNUSED( pNode );
             }
         };
 

diff --git a/cds/intrusive/details/single_link_struct.h b/cds/intrusive/details/single_link_struct.h
index 2b02e797dd2f16a5bd1b1732a117867d6374bbac..b783cc064cae29fea6d63d1920cd5ae7dabdb963 100644 (file)
--- a/cds/intrusive/details/single_link_struct.h
+++ b/cds/intrusive/details/single_link_struct.h
@@ -118,6 +118,7 @@ namespace cds { namespace intrusive {
             static void is_empty( const node_type * pNode )
             {
                 assert( pNode->m_pNext.load( atomics::memory_order_relaxed ) == nullptr );
+                CDS_UNUSED( pNode );
             }
         };
 

diff --git a/cds/intrusive/ellen_bintree_rcu.h b/cds/intrusive/ellen_bintree_rcu.h
index 20ec705d19ad14eb26e40649fdb6206aa3bdc93a..cdaa96ea593cea4f3cddfb79c545295a54bf51e3 100644 (file)
--- a/cds/intrusive/ellen_bintree_rcu.h
+++ b/cds/intrusive/ellen_bintree_rcu.h
@@ -900,6 +900,7 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Less>
         bool erase_with( const Q& key, Less pred )
         {
+            CDS_UNUSED( pred );
             typedef ellen_bintree::details::compare<
                 key_type,
                 value_type,
@@ -951,6 +952,7 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Less, typename Func>
         bool erase_with( Q const& key, Less pred, Func f )
         {
+            CDS_UNUSED( pred );
             typedef ellen_bintree::details::compare<
                 key_type,
                 value_type,
@@ -1072,6 +1074,7 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Less>
         bool find_with( Q const& key, Less pred ) const
         {
+            CDS_UNUSED( pred );
             typedef ellen_bintree::details::compare<
                 key_type,
                 value_type,
@@ -1169,6 +1172,7 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Less>
         value_type * get_with( Q const& key, Less pred ) const
         {
+            CDS_UNUSED( pred );
             typedef ellen_bintree::details::compare<
                 key_type,
                 value_type,
@@ -1640,6 +1644,7 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Less>
         value_type * extract_with_( Q const& val, Less pred )
         {
+            CDS_UNUSED( pred );
             typedef ellen_bintree::details::compare<
                 key_type,
                 value_type,
@@ -1846,6 +1851,7 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Less, typename Func>
         bool find_with_( Q& val, Less pred, Func f ) const
         {
+            CDS_UNUSED( pred );
             typedef ellen_bintree::details::compare<
                 key_type,
                 value_type,

diff --git a/cds/intrusive/impl/ellen_bintree.h b/cds/intrusive/impl/ellen_bintree.h
index 0b6ec56ee326369010615f0bb61a404cdc338b92..dbcafc1170e143c3357481cc3756b9181c38b359 100644 (file)
--- a/cds/intrusive/impl/ellen_bintree.h
+++ b/cds/intrusive/impl/ellen_bintree.h
@@ -485,6 +485,7 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Less>
         bool erase_with( const Q& key, Less pred )
         {
+            CDS_UNUSED( pred );
             typedef ellen_bintree::details::compare<
                 key_type,
                 value_type,
@@ -534,6 +535,7 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Less, typename Func>
         bool erase_with( Q const& key, Less pred, Func f )
         {
+            CDS_UNUSED( pred );
             typedef ellen_bintree::details::compare<
                 key_type,
                 value_type,
@@ -655,6 +657,7 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Less>
         bool find_with( Q const& key, Less pred ) const
         {
+            CDS_UNUSED( pred );
             typedef ellen_bintree::details::compare<
                 key_type,
                 value_type,
@@ -1336,6 +1339,7 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Less>
         bool extract_with_( typename guarded_ptr::native_guard& guard, Q const& key, Less pred )
         {
+            CDS_UNUSED( pred );
             typedef ellen_bintree::details::compare<
                 key_type,
                 value_type,
@@ -1467,6 +1471,7 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Less, typename Func>
         bool find_with_( Q& val, Less pred, Func f ) const
         {
+            CDS_UNUSED( pred );
             typedef ellen_bintree::details::compare<
                 key_type,
                 value_type,

diff --git a/cds/intrusive/impl/lazy_list.h b/cds/intrusive/impl/lazy_list.h
index f2c9eaf6a7a75927401c1afece810ca7035a4697..269fa348a61cbaf64dfa4d186dfb600bcddb8706 100644 (file)
--- a/cds/intrusive/impl/lazy_list.h
+++ b/cds/intrusive/impl/lazy_list.h
@@ -596,6 +596,7 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Less>
         bool erase_with( Q const& key, Less pred )
         {
+            CDS_UNUSED( pred );
             return erase_at( &m_Head, key, cds::opt::details::make_comparator_from_less<Less>() );
         }
 
@@ -628,6 +629,7 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Less, typename Func>
         bool erase_with( const Q& key, Less pred, Func func )
         {
+            CDS_UNUSED( pred );
             return erase_at( &m_Head, key, cds::opt::details::make_comparator_from_less<Less>(), func );
         }
 
@@ -678,6 +680,7 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Less>
         guarded_ptr extract_with( Q const& key, Less pred )
         {
+            CDS_UNUSED( pred );
             guarded_ptr gp;
             extract_at( &m_Head, gp.guard(), key, cds::opt::details::make_comparator_from_less<Less>() );
             return gp;
@@ -722,12 +725,14 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Less, typename Func>
         bool find_with( Q& key, Less pred, Func f )
         {
+            CDS_UNUSED( pred );
             return find_at( &m_Head, key, cds::opt::details::make_comparator_from_less<Less>(), f );
         }
         //@cond
         template <typename Q, typename Less, typename Func>
         bool find_with( Q const& key, Less pred, Func f )
         {
+            CDS_UNUSED( pred );
             return find_at( &m_Head, key, cds::opt::details::make_comparator_from_less<Less>(), f );
         }
         //@endcond
@@ -753,6 +758,7 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Less>
         bool find_with( Q const& key, Less pred )
         {
+            CDS_UNUSED( pred );
             return find_at( &m_Head, key, cds::opt::details::make_comparator_from_less<Less>() );
         }
 
@@ -805,6 +811,7 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Less>
         guarded_ptr get_with( Q const& key, Less pred )
         {
+            CDS_UNUSED( pred );
             guarded_ptr gp;
             get_at( &m_Head, gp.guard(), key, cds::opt::details::make_comparator_from_less<Less>() );
             return gp;

diff --git a/cds/intrusive/impl/michael_list.h b/cds/intrusive/impl/michael_list.h
index 5f039362542fc715f6ef922e1cf960581963a789..103e5ac7a42f61920b0fa4a2412257cc8aec6b56 100644 (file)
--- a/cds/intrusive/impl/michael_list.h
+++ b/cds/intrusive/impl/michael_list.h
@@ -596,6 +596,7 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Less>
         bool erase_with( Q const& key, Less pred )
         {
+            CDS_UNUSED( pred );
             return erase_at( m_pHead, key, cds::opt::details::make_comparator_from_less<Less>());
         }
 
@@ -627,6 +628,7 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Less, typename Func>
         bool erase_with( Q const& key, Less pred, Func f )
         {
+            CDS_UNUSED( pred );
             return erase_at( m_pHead, key, cds::opt::details::make_comparator_from_less<Less>(), f );
         }
 
@@ -677,6 +679,7 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Less>
         guarded_ptr extract_with( Q const& key, Less pred )
         {
+            CDS_UNUSED( pred );
             guarded_ptr gp;
             extract_at( m_pHead, gp.guard(), key, cds::opt::details::make_comparator_from_less<Less>() );
             return gp;
@@ -726,12 +729,14 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Less, typename Func>
         bool find_with( Q& key, Less pred, Func f )
         {
+            CDS_UNUSED( pred );
             return find_at( m_pHead, key, cds::opt::details::make_comparator_from_less<Less>(), f );
         }
         //@cond
         template <typename Q, typename Less, typename Func>
         bool find_with( Q const& key, Less pred, Func f )
         {
+            CDS_UNUSED( pred );
             return find_at( m_pHead, key, cds::opt::details::make_comparator_from_less<Less>(), f );
         }
         //@endcond
@@ -757,6 +762,7 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Less>
         bool find_with( Q const& key, Less pred )
         {
+            CDS_UNUSED( pred );
             return find_at( m_pHead, key, cds::opt::details::make_comparator_from_less<Less>() );
         }
 
@@ -809,6 +815,7 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Less>
         guarded_ptr get_with( Q const& key, Less pred )
         {
+            CDS_UNUSED( pred );
             guarded_ptr gp;
             get_at( m_pHead, gp.guard(), key, cds::opt::details::make_comparator_from_less<Less>() );
             return gp;

diff --git a/cds/intrusive/lazy_list_nogc.h b/cds/intrusive/lazy_list_nogc.h
index 1faed75e9ed14a5cf7b9c0d59d4bc06d68da96c2..12d82851a43a51c8820257a071982012b53aef16 100644 (file)
--- a/cds/intrusive/lazy_list_nogc.h
+++ b/cds/intrusive/lazy_list_nogc.h
@@ -402,12 +402,14 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Less, typename Func>
         bool find_with( Q& key, Less pred, Func f )
         {
+            CDS_UNUSED( pred );
             return find_at( &m_Head, key, cds::opt::details::make_comparator_from_less<Less>(), f );
         }
         //@cond
         template <typename Q, typename Less, typename Func>
         bool find_with( Q const& key, Less pred, Func f )
         {
+            CDS_UNUSED( pred );
             return find_at( &m_Head, key, cds::opt::details::make_comparator_from_less<Less>(), f );
         }
         //@endcond
@@ -433,6 +435,7 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Less>
         value_type * find_with( Q const& key, Less pred )
         {
+            CDS_UNUSED( pred );
             return find_at( &m_Head, key, cds::opt::details::make_comparator_from_less<Less>() );
         }
 

diff --git a/cds/intrusive/lazy_list_rcu.h b/cds/intrusive/lazy_list_rcu.h
index 0d89f94085dc3c18c2a089f2a25c30c5094a76f3..81b5512e596c9155fd0cf17ab49a7cc552fa7748 100644 (file)
--- a/cds/intrusive/lazy_list_rcu.h
+++ b/cds/intrusive/lazy_list_rcu.h
@@ -535,10 +535,10 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Less>
         bool erase_with( Q const& key, Less pred )
         {
+            CDS_UNUSED( pred );
             return erase_at( &m_Head, key, cds::opt::details::make_comparator_from_less<Less>());
         }
 
-
         /// Deletes the item from the list
         /** \anchor cds_intrusive_LazyList_rcu_find_erase_func
             The function searches an item with key equal to \p key in the list,
@@ -574,6 +574,7 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Less, typename Func>
         bool erase_with( Q const& key, Less pred, Func func )
         {
+            CDS_UNUSED( pred );
             return erase_at( &m_Head, key, cds::opt::details::make_comparator_from_less<Less>(), func );
         }
 
@@ -637,6 +638,7 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Less>
         exempt_ptr extract_with( Q const& key, Less pred )
         {
+            CDS_UNUSED( pred );
             return exempt_ptr( extract_at( &m_Head, key, cds::opt::details::make_comparator_from_less<Less>() ));
         }
 
@@ -680,12 +682,14 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Less, typename Func>
         bool find_with( Q& key, Less pred, Func f ) const
         {
+            CDS_UNUSED( pred );
             return find_at( const_cast<node_type *>( &m_Head ), key, cds::opt::details::make_comparator_from_less<Less>(), f );
         }
         //@cond
         template <typename Q, typename Less, typename Func>
         bool find_with( Q const& key, Less pred, Func f ) const
         {
+            CDS_UNUSED( pred );
             return find_at( const_cast<node_type *>(&m_Head), key, cds::opt::details::make_comparator_from_less<Less>(), f );
         }
         //@endcond
@@ -711,6 +715,7 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Less>
         bool find_with( Q const& key, Less pred ) const
         {
+            CDS_UNUSED( pred );
             return find_at( const_cast<node_type *>( &m_Head ), key, cds::opt::details::make_comparator_from_less<Less>() );
         }
 
@@ -759,6 +764,7 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Less>
         value_type * get_with( Q const& key, Less pred ) const
         {
+            CDS_UNUSED( pred );
             return get_at( const_cast<node_type *>( &m_Head ), key, cds::opt::details::make_comparator_from_less<Less>());
         }
 

diff --git a/cds/intrusive/michael_list_nogc.h b/cds/intrusive/michael_list_nogc.h
index 17908a6d3b21521c52befed75162a75642478a49..2a8c3f6d6af8350ac4d52d5fca955c75b04bfe0f 100644 (file)
--- a/cds/intrusive/michael_list_nogc.h
+++ b/cds/intrusive/michael_list_nogc.h
@@ -373,12 +373,14 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Less, typename Func>
         bool find_with( Q& key, Less pred, Func f )
         {
+            CDS_UNUSED( pred );
             return find_at( m_pHead, key, cds::opt::details::make_comparator_from_less<Less>(), f );
         }
         //@cond
         template <typename Q, typename Less, typename Func>
         bool find_with( Q const& key, Less pred, Func f )
         {
+            CDS_UNUSED( pred );
             return find_at( m_pHead, key, cds::opt::details::make_comparator_from_less<Less>(), f );
         }
         //@endcond
@@ -404,6 +406,7 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Less>
         value_type * find_with( Q const& key, Less pred )
         {
+            CDS_UNUSED( pred );
             return find_at( m_pHead, key, cds::opt::details::make_comparator_from_less<Less>());
         }
 

diff --git a/cds/intrusive/michael_list_rcu.h b/cds/intrusive/michael_list_rcu.h
index 263a2b9d504d7609db4bd881751dd530491cbc72..f55f8a879eb8abcd122adba46ea28ef8e903e4d1 100644 (file)
--- a/cds/intrusive/michael_list_rcu.h
+++ b/cds/intrusive/michael_list_rcu.h
@@ -436,6 +436,7 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Less>
         bool erase_with( Q const& key, Less pred )
         {
+            CDS_UNUSED( pred );
             return erase_at( m_pHead, key, cds::opt::details::make_comparator_from_less<Less>() );
         }
 
@@ -474,6 +475,7 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Less, typename Func>
         bool erase_with( Q const& key, Less pred, Func func )
         {
+            CDS_UNUSED( pred );
             return erase_at( m_pHead, key, cds::opt::details::make_comparator_from_less<Less>(), func );
         }
 
@@ -537,6 +539,7 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Less>
         exempt_ptr extract_with( Q const& key, Less pred )
         {
+            CDS_UNUSED( pred );
             return exempt_ptr( extract_at( m_pHead, key, cds::opt::details::make_comparator_from_less<Less>() ));
         }
 
@@ -583,12 +586,14 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Less, typename Func>
         bool find_with( Q& key, Less pred, Func f ) const
         {
+            CDS_UNUSED( pred );
             return find_at( const_cast<atomic_node_ptr&>( m_pHead ), key, cds::opt::details::make_comparator_from_less<Less>(), f );
         }
         //@cond
         template <typename Q, typename Less, typename Func>
         bool find_with( Q const& key, Less pred, Func f ) const
         {
+            CDS_UNUSED( pred );
             return find_at( const_cast<atomic_node_ptr&>(m_pHead), key, cds::opt::details::make_comparator_from_less<Less>(), f );
         }
         //@endcond
@@ -614,6 +619,7 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Less>
         bool find_with( Q const& key, Less pred ) const
         {
+            CDS_UNUSED( pred );
             return find_at( const_cast<atomic_node_ptr&>( m_pHead ), key, cds::opt::details::make_comparator_from_less<Less>() );
         }
 
@@ -662,6 +668,7 @@ namespace cds { namespace intrusive {
         template <typename Q, typename Less>
         value_type * get_with( Q const& key, Less pred ) const
         {
+            CDS_UNUSED( pred );
             return get_at( const_cast<atomic_node_ptr&>( m_pHead ), key, cds::opt::details::make_comparator_from_less<Less>());
         }
 

diff --git a/cds/intrusive/optimistic_queue.h b/cds/intrusive/optimistic_queue.h
index f316baa2790754a2c2f34ede0824169eefa39b33..5009efac4c54ed14c2aa16fb80fae4eef35ddc60 100644 (file)
--- a/cds/intrusive/optimistic_queue.h
+++ b/cds/intrusive/optimistic_queue.h
@@ -116,6 +116,7 @@ namespace cds { namespace intrusive {
             {
                 assert( pNode->m_pNext.load( atomics::memory_order_relaxed ) == nullptr );
                 assert( pNode->m_pPrev.load( atomics::memory_order_relaxed ) == nullptr );
+                CDS_UNUSED( pNode );
             }
         };
 

diff --git a/cds/memory/pool_allocator.h b/cds/memory/pool_allocator.h
index c7aaadfad6ea95164beeee407fe73701a0172535..660fb98cd45295d5252d14a3e4d2506f1c3e2cb9 100644 (file)
--- a/cds/memory/pool_allocator.h
+++ b/cds/memory/pool_allocator.h
@@ -87,7 +87,7 @@ namespace cds { namespace memory {
         {
             return &x;
         }
-        pointer allocate( size_type n, void const * hint = 0)
+        pointer allocate( size_type n, void const * /*hint*/ = 0)
         {
             static_assert( sizeof(value_type) <= sizeof(typename accessor_type::value_type), "Incompatible type" );
 

diff --git a/cds/memory/vyukov_queue_pool.h b/cds/memory/vyukov_queue_pool.h
index f7c3ceb578a1192be0caa9336e4f18f18dac70ce..663f1b8d65b9ed6cadba66dac172cd35bf80399e 100644 (file)
--- a/cds/memory/vyukov_queue_pool.h
+++ b/cds/memory/vyukov_queue_pool.h
@@ -439,6 +439,7 @@ namespace cds { namespace memory {
         value_type * allocate( size_t n )
         {
             assert( n == 1 );
+            CDS_UNUSED( n );
 
             value_type * p = m_Queue.pop();
             if ( p ) {
@@ -459,6 +460,7 @@ namespace cds { namespace memory {
         void deallocate( value_type * p, size_t n )
         {
             assert( n == 1 );
+            CDS_UNUSED( n );
 
             if ( p ) {
                 assert( from_pool( p ));

diff --git a/cds/opt/hash.h b/cds/opt/hash.h
index 882f644031eeb28f348a794e50fb2d48483d20e9..22f702e1530a3fabb871bcfb1bbd15e8b2e50aed 100644 (file)
--- a/cds/opt/hash.h
+++ b/cds/opt/hash.h
@@ -83,7 +83,7 @@ namespace cds { namespace opt {
             {}
 
             template <size_t I, typename T>
-            typename std::enable_if< (I == sizeof...(Functors)) >::type apply( size_t * dest, T const& v ) const
+            typename std::enable_if< (I == sizeof...(Functors)) >::type apply( size_t * /*dest*/, T const& /*v*/ ) const
             {}
 
             template <size_t I, typename T>

diff --git a/tests/test-hdr/misc/michael_allocator.h b/tests/test-hdr/misc/michael_allocator.h
index 013c2a54a5ed6647bb9cd1eb339222218a692383..1daf24b98e56dec19f9c2bd0f4cfa3bb2e7235a4 100644 (file)
--- a/tests/test-hdr/misc/michael_allocator.h
+++ b/tests/test-hdr/misc/michael_allocator.h
@@ -35,12 +35,12 @@ namespace misc {
         };
 
 
-        pointer allocate( size_t nSize, const void * pHint )
+        pointer allocate( size_t nSize, const void * /*pHint*/ )
         {
             return reinterpret_cast<pointer>( s_MichaelHeap_NoStat.alloc( sizeof(T) * nSize ) );
         }
 
-        void deallocate( pointer p, size_t nCount )
+        void deallocate( pointer p, size_t /*nCount*/ )
         {
             s_MichaelHeap_NoStat.free( p );
         }
@@ -59,7 +59,7 @@ namespace misc {
             alignment = 1
         };
 
-        static void stat(summary_stat& s)
+        static void stat(summary_stat& /*s*/)
         {}
     };
 
@@ -74,12 +74,12 @@ namespace misc {
             alignment = 1
         };
 
-        pointer allocate( size_t nSize, const void * pHint )
+        pointer allocate( size_t nSize, const void * /*pHint*/ )
         {
             return reinterpret_cast<pointer>( s_MichaelHeap_Stat.alloc( sizeof(T) * nSize ) );
         }
 
-        void deallocate( pointer p, size_t nCount )
+        void deallocate( pointer p, size_t /*nCount*/ )
         {
             s_MichaelHeap_Stat.free( p );
         }
@@ -101,12 +101,12 @@ namespace misc {
             alignment = ALIGN
         };
 
-        pointer allocate( size_t nSize, const void * pHint )
+        pointer allocate( size_t nSize, const void * /*pHint*/ )
         {
             return reinterpret_cast<pointer>( s_MichaelHeap_NoStat.alloc_aligned( sizeof(T) * nSize, ALIGN ) );
         }
 
-        void deallocate( pointer p, size_t nCount )
+        void deallocate( pointer p, size_t /*nCount*/ )
         {
             s_MichaelHeap_NoStat.free_aligned( p );
         }
@@ -127,12 +127,12 @@ namespace misc {
             alignment = ALIGN
         };
 
-        pointer allocate( size_t nSize, const void * pHint )
+        pointer allocate( size_t nSize, const void * /*pHint*/ )
         {
             return reinterpret_cast<pointer>( s_MichaelHeap_Stat.alloc_aligned( sizeof(T) * nSize, ALIGN ) );
         }
 
-        void deallocate( pointer p, size_t nCount )
+        void deallocate( pointer p, size_t /*nCount*/ )
         {
             s_MichaelHeap_Stat.free_aligned( p );
         }
@@ -154,17 +154,17 @@ namespace misc {
             alignment = ALIGN
         };
 
-        pointer allocate( size_t nSize, const void * pHint )
+        pointer allocate( size_t nSize, const void * /*pHint*/ )
         {
             return reinterpret_cast<pointer>( cds::OS::aligned_malloc( sizeof(T) * nSize, ALIGN ) );
         }
 
-        void deallocate( pointer p, size_t nCount )
+        void deallocate( pointer p, size_t /*nCount*/ )
         {
             cds::OS::aligned_free( p );
         }
 
-        static void stat(summary_stat& s)
+        static void stat(summary_stat& /*s*/)
         {}
     };
 

diff --git a/tests/test-hdr/ordered_list/hdr_michael.h b/tests/test-hdr/ordered_list/hdr_michael.h
index 4f3665df7c58ad0c1dbf3caac7af4bfa6d7be67a..8d3fb9a3a0facbdd2d1a1d762caa9c984a495110 100644 (file)
--- a/tests/test-hdr/ordered_list/hdr_michael.h
+++ b/tests/test-hdr/ordered_list/hdr_michael.h
@@ -180,7 +180,7 @@ namespace ordlist {
         };
 
         struct ensure_functor {
-            void operator()( bool /*bNew*/, item& i, int n )
+            void operator()( bool /*bNew*/, item& i, int /*n*/ )
             {
                 i.nVal = i.nKey * 1024;
             }

diff --git a/tests/test-hdr/set/hdr_cuckoo_set.h b/tests/test-hdr/set/hdr_cuckoo_set.h
index c3f269a0df2766bc0b1006d1257db5cbf60e57ad..ce7d5fba7afcc699e76a432b80294a802f7e2693 100644 (file)
--- a/tests/test-hdr/set/hdr_cuckoo_set.h
+++ b/tests/test-hdr/set/hdr_cuckoo_set.h
@@ -269,12 +269,12 @@ namespace set {
         struct find_functor
         {
             template <typename Item, typename T>
-            void operator()( Item& i, T& val )
+            void operator()( Item& i, T& /*val*/ )
             {
                 ++i.nFindCount;
             }
             template <typename Item, typename T>
-            void operator()( Item& i, T const& val )
+            void operator()( Item& i, T const& /*val*/ )
             {
                 ++i.nFindCount;
             }

diff --git a/tests/test-hdr/set/hdr_striped_set.h b/tests/test-hdr/set/hdr_striped_set.h
index 36d22b70ad64889d2fbd3a766477a9894af78e0e..e0b5a86ff9a942eed5c006d8fee7c8b45922f258 100644 (file)
--- a/tests/test-hdr/set/hdr_striped_set.h
+++ b/tests/test-hdr/set/hdr_striped_set.h
@@ -257,12 +257,12 @@ namespace set {
         struct find_functor
         {
             template <typename Item, typename T>
-            void operator()( Item& i, T& val )
+            void operator()( Item& i, T& /*val*/ ) const
             {
                 ++i.nFindCount;
             }
             template <typename Item, typename T>
-            void operator()( Item& i, T const& val )
+            void operator()( Item& i, T const& /*val*/ ) const
             {
                 ++i.nFindCount;
             }

diff --git a/tests/test-hdr/tree/hdr_ellenbintree_set.h b/tests/test-hdr/tree/hdr_ellenbintree_set.h
index 08658ef5ecc12aeb1db8564131cd5760202f4b94..0e3363f07b7000005e53de9095844bcc75d1b9d1 100644 (file)
--- a/tests/test-hdr/tree/hdr_ellenbintree_set.h
+++ b/tests/test-hdr/tree/hdr_ellenbintree_set.h
@@ -205,12 +205,12 @@ namespace tree {
         struct find_functor
         {
             template <typename T>
-            void operator()( value_type& i, T& val )
+            void operator()( value_type& i, T& /*val*/ )
             {
                 ++i.stat.nFindFuncCall;
             }
             template <typename T>
-            void operator()( value_type& i, T const& val )
+            void operator()( value_type& i, T const& /*val*/ )
             {
                 ++i.stat.nFindConstFuncCall;
             }

diff --git a/tests/test-hdr/tree/hdr_intrusive_bintree.h b/tests/test-hdr/tree/hdr_intrusive_bintree.h
index 78a17c50a78176215d8c1b70d4929dae3ec3255d..cf9a5ec8718413dc561e7240f46d9be8f3c1286c 100644 (file)
--- a/tests/test-hdr/tree/hdr_intrusive_bintree.h
+++ b/tests/test-hdr/tree/hdr_intrusive_bintree.h
@@ -230,12 +230,12 @@ namespace tree {
 
         struct find_functor {
             template <typename T, typename Q>
-            void operator()( T const& v, Q& q ) const
+            void operator()( T const& v, Q& /*q*/ ) const
             {
                 ++v.stat.nFindFuncCall;
             }
             template <typename T, typename Q>
-            void operator()( T const& v, Q const& q ) const
+            void operator()( T const& v, Q const& /*q*/ ) const
             {
                 ++v.stat.nFindConstFuncCall;
             }

diff --git a/tests/unit/print_cuckoo_stat.h b/tests/unit/print_cuckoo_stat.h
index c1308f08db75b33adb605f32b96d88f62ea9aaed..e94d66187eb009012f4d28b43b47e64f6f5925ae 100644 (file)
--- a/tests/unit/print_cuckoo_stat.h
+++ b/tests/unit/print_cuckoo_stat.h
@@ -40,7 +40,7 @@ namespace std {
             << "\t\t            m_nResizeCount: " << s.m_nResizeCount.get()             << "\n"
 ;
     }
-    static inline ostream& operator <<( ostream& o, cds::intrusive::cuckoo::empty_refinable_stat const& s )
+    static inline ostream& operator <<( ostream& o, cds::intrusive::cuckoo::empty_refinable_stat const& /*s*/ )
     {
         return o;
     }
@@ -79,7 +79,7 @@ namespace std {
 ;
     }
 
-    static inline ostream& operator <<( ostream& o, cds::intrusive::cuckoo::empty_stat const& s )
+    static inline ostream& operator <<( ostream& o, cds::intrusive::cuckoo::empty_stat const& /*s*/ )
     {
         return o;
     }