movable exempt_ptr: LazyList

diff --git a/cds/container/lazy_kvlist_rcu.h b/cds/container/lazy_kvlist_rcu.h
index b460c6d61277b519fcf619a1424c6e855ef42ba7..caae0c704083558a5ada5d51c185e631ca7375d7 100644 (file)
--- a/cds/container/lazy_kvlist_rcu.h
+++ b/cds/container/lazy_kvlist_rcu.h
@@ -121,9 +121,9 @@ namespace cds { namespace container {
 
     public:
         /// pointer to extracted node
-        typedef cds::urcu::exempt_ptr< gc, node_type, value_type, typename maker::intrusive_traits::disposer,
+        using exempt_ptr = cds::urcu::exempt_ptr< gc, node_type, value_type, typename maker::intrusive_traits::disposer,
             cds::urcu::details::conventional_exempt_pair_cast<node_type, value_type>
-        > exempt_ptr;
+        >;
 
     protected:
         //@cond
@@ -513,13 +513,13 @@ namespace cds { namespace container {
         /**
         @anchor cds_nonintrusive_LazyKVList_rcu_extract
             The function searches an item with key equal to \p key in the list,
-            unlinks it from the list, and returns pointer to an item found in \p dest argument.
-            If \p key is not found the function returns \p false.
+            unlinks it from the list, and returns \ref cds::urcu::exempt_ptr "exempt_ptr" pointer to the item found.
+            If \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 list
             and returns a pointer to item found.
-            You should lock RCU before calling this function.
+            You should manually lock RCU before calling this function.
 
             \code
             #include <cds/urcu/general_buffered.h>
@@ -538,7 +538,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 ( theList.extract( p, 10 )) {
+                p = theList.extract( 10 );
+                if ( !p ) {
                     // do something with p
                     ...
                 }
@@ -549,10 +550,9 @@ namespace cds { namespace container {
             \endcode
         */
         template <typename K>
-        bool extract( exempt_ptr& dest, K const& key )
+        exempt_ptr extract( K const& key )
         {
-            dest = extract_at( head(), key, intrusive_key_comparator() );
-            return !dest.empty();
+            return exempt_ptr( extract_at( head(), key, intrusive_key_comparator()));
         }
 
         /// Extracts an item from the list using \p pred predicate for searching
@@ -563,10 +563,9 @@ namespace cds { namespace container {
             \p pred must imply the same element order as \ref key_comparator.
         */
         template <typename K, typename Less>
-        bool extract_with( exempt_ptr& dest, K const& key, Less pred )
+        exempt_ptr extract_with( K const& key, Less pred )
         {
-            dest = extract_at( head(), key, typename maker::template less_wrapper<Less>::type() );
-            return !dest.empty();
+            return exempt_ptr( extract_at( head(), key, typename maker::template less_wrapper<Less>::type() ));
         }
 
         /// Finds the key \p key

diff --git a/cds/container/lazy_list_rcu.h b/cds/container/lazy_list_rcu.h
index 0d8344279638701b2bbd41b6f3f20bcc68dd2802..1b0fb60e00d6f29e6b13220888d805f9dc5e483d 100644 (file)
--- a/cds/container/lazy_list_rcu.h
+++ b/cds/container/lazy_list_rcu.h
@@ -129,7 +129,7 @@ namespace cds { namespace container {
         //@endcond
 
     public:
-        typedef cds::urcu::exempt_ptr< gc, node_type, value_type, typename maker::intrusive_traits::disposer > exempt_ptr; ///< pointer to extracted node
+        using exempt_ptr = cds::urcu::exempt_ptr< gc, node_type, value_type, typename maker::intrusive_traits::disposer >; ///< pointer to extracted node
 
     private:
         //@cond
@@ -490,8 +490,8 @@ namespace cds { namespace container {
         /**
         @anchor cds_nonintrusive_LazyList_rcu_extract
             The function searches an item with key equal to \p key in the list,
-            unlinks it from the list, and returns pointer to an item found in \p dest argument.
-            If the item with the key equal to \p key is not found the function returns \p false.
+            unlinks it from the list, and returns \ref cds::urcu::exempt_ptr "exempt_ptr" pointer to an 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 list
@@ -515,7 +515,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 ( theList.extract( p, 10 )) {
+                p = theList.extract( 10 );
+                if ( p ) {
                     // do something with p
                     ...
                 }
@@ -526,10 +527,9 @@ namespace cds { namespace container {
             \endcode
         */
         template <typename Q>
-        bool extract( exempt_ptr& dest, Q const& key )
+        exempt_ptr extract( Q const& key )
         {
-            dest = extract_at( head(), key, intrusive_key_comparator() );
-            return !dest.empty();
+            return exempt_ptr(extract_at( head(), key, intrusive_key_comparator()));
         }
 
         /// Extracts an item from the list using \p pred predicate for searching
@@ -541,10 +541,9 @@ namespace cds { namespace container {
             \p pred must imply the same element order as \ref key_comparator.
         */
         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 )
         {
-            dest = extract_at( head(), key, typename maker::template less_wrapper<Less>::type() );
-            return !dest.empty();
+            return exempt_ptr( extract_at( head(), key, typename maker::template less_wrapper<Less>::type()));
         }
 
         /// Finds the key \p key

diff --git a/cds/intrusive/lazy_list_rcu.h b/cds/intrusive/lazy_list_rcu.h
index 38cae1d9cca56a54273c59783280ca7597acd080..0d89f94085dc3c18c2a089f2a25c30c5094a76f3 100644 (file)
--- a/cds/intrusive/lazy_list_rcu.h
+++ b/cds/intrusive/lazy_list_rcu.h
@@ -230,7 +230,8 @@ namespace cds { namespace intrusive {
         //@endcond
 
     public:
-        typedef cds::urcu::exempt_ptr< gc, value_type, value_type, clear_and_dispose, void > exempt_ptr ; ///< pointer to extracted node
+        /// pointer to extracted node
+        using exempt_ptr = cds::urcu::exempt_ptr< gc, value_type, value_type, clear_and_dispose, void >; 
 
     protected:
         //@cond
@@ -580,14 +581,13 @@ namespace cds { namespace intrusive {
         /**
         \anchor cds_intrusive_LazyList_rcu_extract
             The function searches an item with key equal to \p key in the list,
-            unlinks it from the list, and returns pointer to an item found in \p dest parameter.
-            If the item with the key equal to \p key is not found the function returns \p false,
-            \p dest is empty.
+            unlinks it from the list, and returns \ref cds::urcu::exempt_ptr "exempt_ptr" pointer to an item found.
+            If the item is not found the function returns 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 list
-            and returns a pointer to item found.
-            You should lock RCU before calling this function, and you should manually synchronize RCU
+            and returns a pointer to it.
+            You should manually lock RCU before calling this function, and you should manually synchronize RCU
             outside the RCU lock region before reusing returned pointer.
 
             \code
@@ -607,7 +607,8 @@ namespace cds { namespace intrusive {
 
                 // Now, you can apply extract function
                 // Note that you must not delete the item found inside the RCU lock
-                if ( theList.extract( p1, 10 )) {
+                p1 = theList.extract(  10 )
+                if ( p1 ) {
                     // do something with p1
                     ...
                 }
@@ -620,10 +621,9 @@ namespace cds { namespace intrusive {
             \endcode
         */
         template <typename Q>
-        bool extract( exempt_ptr& dest, Q const& key )
+        exempt_ptr extract( Q const& key )
         {
-            dest = extract_at( &m_Head, key, key_comparator() );
-            return !dest.empty();
+            return exempt_ptr( extract_at( &m_Head, key, key_comparator() ));
         }
 
         /// Extracts an item from the list using \p pred predicate for searching
@@ -635,10 +635,9 @@ namespace cds { namespace intrusive {
             \p pred must imply the same element order as \ref key_comparator.
         */
         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 )
         {
-            dest = extract_at( &m_Head, key, cds::opt::details::make_comparator_from_less<Less>() );
-            return !dest.empty();
+            return exempt_ptr( extract_at( &m_Head, key, cds::opt::details::make_comparator_from_less<Less>() ));
         }
 
         /// Finds the key \p key
@@ -663,6 +662,13 @@ namespace cds { namespace intrusive {
         {
             return find_at( const_cast<node_type *>( &m_Head ), key, key_comparator(), f );
         }
+        //@cond
+        template <typename Q, typename Func>
+        bool find( Q const& key, Func f ) const
+        {
+            return find_at( const_cast<node_type *>(&m_Head), key, key_comparator(), f );
+        }
+        //@endcond
 
         /// Finds the key \p key using \p pred predicate for searching
         /**
@@ -676,6 +682,13 @@ namespace cds { namespace intrusive {
         {
             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
+        {
+            return find_at( const_cast<node_type *>(&m_Head), key, cds::opt::details::make_comparator_from_less<Less>(), f );
+        }
+        //@endcond
 
         /// Finds the key \p key
         /** \anchor cds_intrusive_LazyList_rcu_find_val

diff --git a/tests/test-hdr/ordered_list/hdr_intrusive_lazy.h b/tests/test-hdr/ordered_list/hdr_intrusive_lazy.h
index 76198cd69e49c480cb5d05cd2844aaa83d78ae0c..4d9a3b3461665c4a174bc68ab7f93bf7ead8977d 100644 (file)
--- a/tests/test-hdr/ordered_list/hdr_intrusive_lazy.h
+++ b/tests/test-hdr/ordered_list/hdr_intrusive_lazy.h
@@ -558,7 +558,8 @@ namespace ordlist {
                         CPPUNIT_CHECK( pGet->nKey == a[i] );
                         CPPUNIT_CHECK( pGet->nVal == a[i] * 2 );
 
-                        CPPUNIT_ASSERT( l.extract( ep, a[i] ));
+                        ep = l.extract( a[i] );
+                        CPPUNIT_ASSERT( ep );
                         CPPUNIT_ASSERT( !ep.empty() );
                         CPPUNIT_CHECK( ep->nKey == a[i] );
                         CPPUNIT_CHECK( (*ep).nVal == a[i] * 2 );
@@ -567,7 +568,7 @@ namespace ordlist {
                     {
                         rcu_lock lock;
                         CPPUNIT_CHECK( l.get( a[i] ) == nullptr );
-                        CPPUNIT_CHECK( !l.extract( ep, a[i] ) );
+                        CPPUNIT_CHECK( !l.extract( a[i] ) );
                         CPPUNIT_CHECK( ep.empty() );
                     }
                 }
@@ -576,7 +577,8 @@ namespace ordlist {
                 {
                     rcu_lock lock;
                     CPPUNIT_CHECK( l.get( a[0] ) == nullptr );
-                    CPPUNIT_CHECK( !l.extract( ep, a[0] ));
+                    ep = l.extract( a[0] );
+                    CPPUNIT_CHECK( !ep );
                     CPPUNIT_CHECK( ep.empty() );
                 }
                 // Apply retired pointer
@@ -596,7 +598,8 @@ namespace ordlist {
                         CPPUNIT_CHECK( pGet->nKey == a[i] );
                         CPPUNIT_CHECK( pGet->nVal == a[i] * 2 );
 
-                        CPPUNIT_ASSERT( l.extract_with( ep, itm, other_less() ) );
+                        ep = l.extract_with( itm, other_less() );
+                        CPPUNIT_ASSERT( ep );
                         CPPUNIT_ASSERT( !ep.empty() );
                         CPPUNIT_CHECK( ep->nKey == a[i] );
                         CPPUNIT_CHECK( ep->nVal == a[i] * 2 );
@@ -605,7 +608,8 @@ namespace ordlist {
                     {
                         rcu_lock lock;
                         CPPUNIT_CHECK( l.get_with( itm, other_less() ) == nullptr );
-                        CPPUNIT_CHECK( !l.extract_with( ep, itm, other_less() ));
+                        ep = l.extract_with( itm, other_less() );
+                        CPPUNIT_CHECK( !ep );
                         CPPUNIT_CHECK( ep.empty() );
                     }
                 }
@@ -614,7 +618,7 @@ namespace ordlist {
                 {
                     rcu_lock lock;
                     CPPUNIT_CHECK( l.get_with( other_item( 0 ), other_less() ) == nullptr );
-                    CPPUNIT_CHECK( !l.extract_with( ep, other_item(0), other_less() ));
+                    CPPUNIT_CHECK( !l.extract_with( other_item(0), other_less() ));
                     CPPUNIT_CHECK( ep.empty() );
                 }
                 // Apply retired pointer

diff --git a/tests/test-hdr/ordered_list/hdr_lazy.h b/tests/test-hdr/ordered_list/hdr_lazy.h
index fef2592b94680fc30989d35a1e896a88403ce44b..360b43c17d0ba82f70aee35c7b252f6d8244e5f2 100644 (file)
--- a/tests/test-hdr/ordered_list/hdr_lazy.h
+++ b/tests/test-hdr/ordered_list/hdr_lazy.h
@@ -560,7 +560,8 @@ namespace ordlist {
                         CPPUNIT_CHECK( pGet->nKey == a[i] );
                         CPPUNIT_CHECK( pGet->nVal == a[i] * 2 );
 
-                        CPPUNIT_ASSERT( l.extract( ep, a[i] ));
+                        ep = l.extract( a[i] );
+                        CPPUNIT_ASSERT( ep );
                         CPPUNIT_ASSERT( !ep.empty() );
                         CPPUNIT_CHECK( ep->nKey == a[i] );
                         CPPUNIT_CHECK( (*ep).nVal == a[i] * 2 );
@@ -569,8 +570,7 @@ namespace ordlist {
                     {
                         rcu_lock lock;
                         CPPUNIT_CHECK( l.get( a[i] ) == nullptr );
-                        CPPUNIT_CHECK( !l.extract( ep, a[i] ));
-                        CPPUNIT_CHECK( ep.empty() );
+                        CPPUNIT_CHECK( !l.extract( a[i] ));
                     }
                 }
                 CPPUNIT_ASSERT( l.empty() );
@@ -578,7 +578,8 @@ namespace ordlist {
                 {
                     rcu_lock lock;
                     CPPUNIT_CHECK( l.get( a[0] ) == nullptr );
-                    CPPUNIT_CHECK( !l.extract( ep, a[0] ) );
+                    ep = l.extract( a[0] );
+                    CPPUNIT_CHECK( !ep );
                     CPPUNIT_CHECK( ep.empty() );
                 }
 
@@ -596,7 +597,8 @@ namespace ordlist {
                         CPPUNIT_CHECK( pGet->nKey == a[i] );
                         CPPUNIT_CHECK( pGet->nVal == a[i] * 2 );
 
-                        CPPUNIT_ASSERT( l.extract_with( ep, itm, other_less() ));
+                        ep = l.extract_with( itm, other_less() );
+                        CPPUNIT_ASSERT( ep );
                         CPPUNIT_ASSERT( !ep.empty() );
                         CPPUNIT_CHECK( ep->nKey == a[i] );
                         CPPUNIT_CHECK( ep->nVal == a[i] * 2 );
@@ -605,7 +607,8 @@ namespace ordlist {
                     {
                         rcu_lock lock;
                         CPPUNIT_CHECK( l.get_with( itm, other_less() ) == nullptr );
-                        CPPUNIT_CHECK( !l.extract_with( ep, itm, other_less() ));
+                        ep = l.extract_with( itm, other_less() );
+                        CPPUNIT_CHECK( !ep );
                         CPPUNIT_CHECK( ep.empty() );
                     }
                 }
@@ -614,7 +617,7 @@ namespace ordlist {
                 {
                     rcu_lock lock;
                     CPPUNIT_CHECK( l.get_with( other_item( 0 ), other_less() ) == nullptr );
-                    CPPUNIT_CHECK( !l.extract_with( ep, other_item(0), other_less() ));
+                    CPPUNIT_CHECK( !l.extract_with( other_item(0), other_less() ));
                     CPPUNIT_CHECK( ep.empty() );
                 }
             }

diff --git a/tests/test-hdr/ordered_list/hdr_lazy_kv.h b/tests/test-hdr/ordered_list/hdr_lazy_kv.h
index 1aef413f2a665abe7abaad2ff04246e7723653ba..5c6bbdb042ca181842cbc640fab62c4b1765201f 100644 (file)
--- a/tests/test-hdr/ordered_list/hdr_lazy_kv.h
+++ b/tests/test-hdr/ordered_list/hdr_lazy_kv.h
@@ -387,7 +387,8 @@ namespace ordlist {
                         CPPUNIT_CHECK( pGet->first == a[i] );
                         CPPUNIT_CHECK( pGet->second.m_val == a[i] * 2 );
 
-                        CPPUNIT_ASSERT( l.extract( ep, a[i] ));
+                        ep = l.extract( a[i] );
+                        CPPUNIT_ASSERT( ep );
                         CPPUNIT_ASSERT( !ep.empty() );
                         CPPUNIT_CHECK( ep->first == a[i] );
                         CPPUNIT_CHECK( (*ep).second.m_val == a[i] * 2 );
@@ -396,7 +397,8 @@ namespace ordlist {
                     {
                         rcu_lock lock;
                         CPPUNIT_CHECK( l.get( a[i] ) == nullptr );
-                        CPPUNIT_CHECK( !l.extract( ep, a[i] ));
+                        ep = l.extract( a[i] );
+                        CPPUNIT_CHECK( !ep );
                         CPPUNIT_CHECK( ep.empty() );
                     }
                 }
@@ -405,8 +407,8 @@ namespace ordlist {
                 {
                     rcu_lock lock;
                     CPPUNIT_CHECK( l.get( a[0] ) == nullptr );
-                    CPPUNIT_CHECK( !l.extract( ep, a[0] ) );
-                    CPPUNIT_CHECK( ep.empty() );
+                    CPPUNIT_CHECK( !l.extract( a[0] ) );
+                    //CPPUNIT_CHECK( ep.empty() );
                 }
 
                 // extract_with/get_with
@@ -423,7 +425,8 @@ namespace ordlist {
                         CPPUNIT_CHECK( pGet->first == a[i] );
                         CPPUNIT_CHECK( pGet->second.m_val == a[i] * 2 );
 
-                        CPPUNIT_ASSERT( l.extract_with( ep, itm, other_less() ));
+                        ep = l.extract_with( itm, other_less() );
+                        CPPUNIT_ASSERT( ep );
                         CPPUNIT_ASSERT( !ep.empty() );
                         CPPUNIT_CHECK( ep->first == a[i] );
                         CPPUNIT_CHECK( ep->second.m_val == a[i] * 2 );
@@ -432,7 +435,8 @@ namespace ordlist {
                     {
                         rcu_lock lock;
                         CPPUNIT_CHECK( l.get_with( itm, other_less()) == nullptr );
-                        CPPUNIT_CHECK( !l.extract_with( ep, itm, other_less() ));
+                        ep = l.extract_with( itm, other_less() );
+                        CPPUNIT_CHECK( !ep );
                         CPPUNIT_CHECK( ep.empty() );
                     }
                 }
@@ -441,7 +445,7 @@ namespace ordlist {
                 {
                     rcu_lock lock;
                     CPPUNIT_CHECK( l.get_with( 3.14f, other_less() ) == nullptr );
-                    CPPUNIT_CHECK( !l.extract_with( ep, 3.14f, other_less() ));
+                    CPPUNIT_CHECK( !l.extract_with( 3.14f, other_less() ));
                     CPPUNIT_CHECK( ep.empty() );
                 }
             }