Remove unused vars

[libcds.git] / cds / container / split_list_set_rcu.h

diff --git a/cds/container/split_list_set_rcu.h b/cds/container/split_list_set_rcu.h
index 14fe8c38767736159f1122a26d3a44d478c34ffa..419986731aef5d04162f8319b3a435a198359a21 100644 (file)
--- a/cds/container/split_list_set_rcu.h
+++ b/cds/container/split_list_set_rcu.h
@@ -136,7 +136,7 @@ namespace cds { namespace container {
             ,cc::split_list::make_traits<      // metafunction to build split-list traits
                 cc::split_list::ordered_list<cc::lazy_list_tag>     // tag for underlying ordered list implementation
                 ,cc::opt::hash< foo_hash >              // hash functor
-                ,cc::split_list::ordered_list_traits<   // ordered list traits 
+                ,cc::split_list::ordered_list_traits<   // ordered list traits
                     cc::lazy_list::make_traits<         // metafunction to build lazy list traits
                         cc::opt::less< foo_less >       // less-based compare functor
                     >::type
@@ -200,7 +200,7 @@ namespace cds { namespace container {
 
     public:
         /// pointer to extracted node
-        typedef cds::urcu::exempt_ptr< gc, node_type, value_type, typename maker::ordered_list_traits::disposer > exempt_ptr;
+        using exempt_ptr = cds::urcu::exempt_ptr< gc, node_type, value_type, typename maker::ordered_list_traits::disposer >;
 
     protected:
         //@cond
@@ -213,6 +213,7 @@ namespace cds { namespace container {
         template <typename Q, typename Less, typename Func>
         bool find_with_( Q& val, Less pred, Func f )
         {
+            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) ; } );
         }
@@ -388,13 +389,23 @@ namespace cds { namespace container {
         /// Returns a forward const iterator addressing the first element in a set
         const_iterator begin() const
         {
-            return const_iterator( base_class::begin() );
+            return cbegin();
+        }
+        /// Returns a forward const iterator addressing the first element in a set
+        const_iterator cbegin() const
+        {
+            return const_iterator( base_class::cbegin() );
         }
 
         /// Returns an const iterator that addresses the location succeeding the last element in a set
         const_iterator end() const
         {
-            return const_iterator( base_class::end() );
+            return cend();
+        }
+        /// Returns an const iterator that addresses the location succeeding the last element in a set
+        const_iterator cend() const
+        {
+            return const_iterator( base_class::cend() );
         }
 
     public:
@@ -526,6 +537,7 @@ namespace cds { namespace container {
         template <typename Q, typename Less>
         bool erase_with( Q const& key, Less pred )
         {
+            CDS_UNUSED( pred );
              return base_class::erase_with( key, typename maker::template predicate_wrapper<Less>::type() );
         }
 
@@ -566,6 +578,7 @@ namespace cds { namespace container {
         template <typename Q, typename Less, typename Func>
         bool erase_with( Q const& key, Less pred, Func f )
         {
+            CDS_UNUSED( pred );
             return base_class::erase_with( key, typename maker::template predicate_wrapper<Less>::type(),
                 [&f](node_type& node) { f( node.m_Value ); } );
         }
@@ -573,8 +586,8 @@ namespace cds { namespace container {
         /// Extracts an item from the set
         /** \anchor cds_nonintrusive_SplitListSet_rcu_extract
             The function searches an item with key equal to \p key in the set,
-            unlinks it from the set, places item pointer into \p dest argument, and returns \p true.
-            If the item with the key equal to \p key is not found the function return \p false.
+            unlinks it from the set, and returns \ref cds::urcu::exempt_ptr "exempt_ptr" pointer to the item found.
+            If the item with the key equal to \p key is not found the function returns an empty \p exempt_ptr.
 
             @note The function does NOT call RCU read-side lock or synchronization,
             and does NOT dispose the item found. It just excludes the item from the set
@@ -596,7 +609,8 @@ namespace cds { namespace container {
 
                 // Now, you can apply extract function
                 // Note that you must not delete the item found inside the RCU lock
-                if ( theSet.extract( p, 10 )) {
+                p = theSet.extract( 10 );
+                if ( p ) {
                     // do something with p
                     ...
                 }
@@ -608,14 +622,9 @@ namespace cds { namespace container {
             \endcode
         */
         template <typename Q>
-        bool extract( exempt_ptr& dest, Q const& key )
+        exempt_ptr extract( Q const& key )
         {
-            node_type * pNode = base_class::extract_( key, key_comparator() );
-            if ( pNode ) {
-                dest = pNode;
-                return true;
-            }
-            return false;
+            return exempt_ptr( base_class::extract_( key, key_comparator() ));
         }
 
         /// Extracts an item from the set using \p pred predicate for searching
@@ -626,14 +635,10 @@ namespace cds { namespace container {
             \p pred must imply the same element order as the comparator used for building the set.
         */
         template <typename Q, typename Less>
-        bool extract_with( exempt_ptr& dest, Q const& key, Less pred )
+        exempt_ptr extract_with( Q const& key, Less pred )
         {
-            node_type * pNode = base_class::extract_with_( key, typename maker::template predicate_wrapper<Less>::type());
-            if ( pNode ) {
-                dest = pNode;
-                return true;
-            }
-            return false;
+            CDS_UNUSED( pred );
+            return exempt_ptr( base_class::extract_with_( key, typename maker::template predicate_wrapper<Less>::type()));
         }
 
         /// Finds the key \p key
@@ -665,6 +670,13 @@ namespace cds { namespace container {
         {
             return find_( key, f );
         }
+        //@cond
+        template <typename Q, typename Func>
+        bool find( Q const& key, Func f )
+        {
+            return find_( key, f );
+        }
+        //@endcond
 
         /// Finds the key \p key using \p pred predicate for searching
         /**
@@ -678,6 +690,13 @@ namespace cds { namespace container {
         {
             return find_with_( key, pred, f );
         }
+        //@cond
+        template <typename Q, typename Less, typename Func>
+        bool find_with( Q const& key, Less pred, Func f )
+        {
+            return find_with_( key, pred, f );
+        }
+        //@endcond
 
         /// Finds the key \p key
         /** \anchor cds_nonintrusive_SplitListSet_rcu_find_val
@@ -706,6 +725,7 @@ namespace cds { namespace container {
         template <typename Q, typename Less>
         bool find_with( Q const& key, Less pred )
         {
+            CDS_UNUSED( pred );
             return base_class::find_with( key, typename maker::template predicate_wrapper<Less>::type() );
         }
 
@@ -756,6 +776,7 @@ namespace cds { namespace container {
         template <typename Q, typename Less>
         value_type * get_with( Q const& key, Less pred )
         {
+            CDS_UNUSED( pred );
             node_type * pNode = base_class::get_with( key, typename maker::template predicate_wrapper<Less>::type());
             return pNode ? &pNode->m_Value : nullptr;
         }