Remove 'unused vars' warnings
authorkhizmax <libcds.dev@gmail.com>
Wed, 19 Nov 2014 06:50:57 +0000 (09:50 +0300)
committerkhizmax <libcds.dev@gmail.com>
Wed, 19 Nov 2014 06:50:57 +0000 (09:50 +0300)
23 files changed:
cds/intrusive/cuckoo_set.h
cds/intrusive/details/lazy_list_base.h
cds/intrusive/details/michael_list_base.h
cds/intrusive/details/single_link_struct.h
cds/intrusive/ellen_bintree_rcu.h
cds/intrusive/impl/ellen_bintree.h
cds/intrusive/impl/lazy_list.h
cds/intrusive/impl/michael_list.h
cds/intrusive/lazy_list_nogc.h
cds/intrusive/lazy_list_rcu.h
cds/intrusive/michael_list_nogc.h
cds/intrusive/michael_list_rcu.h
cds/intrusive/optimistic_queue.h
cds/memory/pool_allocator.h
cds/memory/vyukov_queue_pool.h
cds/opt/hash.h
tests/test-hdr/misc/michael_allocator.h
tests/test-hdr/ordered_list/hdr_michael.h
tests/test-hdr/set/hdr_cuckoo_set.h
tests/test-hdr/set/hdr_striped_set.h
tests/test-hdr/tree/hdr_ellenbintree_set.h
tests/test-hdr/tree/hdr_intrusive_bintree.h
tests/unit/print_cuckoo_stat.h

index 7ba7b00..aa0e244 100644 (file)
@@ -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& ) {} );
         }
 
index e348eac..c833934 100644 (file)
@@ -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 );
             }
         };
 
index a3f7944..023714a 100644 (file)
@@ -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 );
             }
         };
 
index 2b02e79..b783cc0 100644 (file)
@@ -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 );
             }
         };
 
index 20ec705..cdaa96e 100644 (file)
@@ -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,
index 0b6ec56..dbcafc1 100644 (file)
@@ -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,
index f2c9eaf..269fa34 100644 (file)
@@ -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;
index 5f03936..103e5ac 100644 (file)
@@ -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;
index 1faed75..12d8285 100644 (file)
@@ -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>() );
         }
 
index 0d89f94..81b5512 100644 (file)
@@ -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>());
         }
 
index 17908a6..2a8c3f6 100644 (file)
@@ -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>());
         }
 
index 263a2b9..f55f8a8 100644 (file)
@@ -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>());
         }
 
index f316baa..5009efa 100644 (file)
@@ -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 );
             }
         };
 
index c7aaadf..660fb98 100644 (file)
@@ -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" );
 
index f7c3ceb..663f1b8 100644 (file)
@@ -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 ));
index 882f644..22f702e 100644 (file)
@@ -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>
index 013c2a5..1daf24b 100644 (file)
@@ -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*/)
         {}
     };
 
index 4f3665d..8d3fb9a 100644 (file)
@@ -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;
             }
index c3f269a..ce7d5fb 100644 (file)
@@ -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;
             }
index 36d22b7..e0b5a86 100644 (file)
@@ -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;
             }
index 08658ef..0e3363f 100644 (file)
@@ -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;
             }
index 78a17c5..cf9a5ec 100644 (file)
@@ -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;
             }
index c1308f0..e94d661 100644 (file)
@@ -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;
     }