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
 
     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>
             cds::urcu::details::conventional_exempt_pair_cast<node_type, value_type>

-        > exempt_ptr;
+        >;

 
     protected:
         //@cond
 
     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,
         /**
         @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.
 
             @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>
 
             \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
 
                 // 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
                     ...
                 }
                     // do something with p
                     ...
                 }


@@ -549,10 +550,9 @@ namespace cds { namespace container {
             \endcode
         */
         template <typename K>
             \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
         }
 
         /// 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>
             \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
         }
 
         /// 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:
         //@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
 
     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,
         /**
         @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
 
             @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
 
                 // 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
                     ...
                 }
                     // do something with p
                     ...
                 }


@@ -526,10 +527,9 @@ namespace cds { namespace container {
             \endcode
         */
         template <typename Q>
             \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
         }
 
         /// 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>
             \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
         }
 
         /// 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:
         //@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
 
     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,
         /**
         \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
 
             @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
             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
 
                 // 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
                     ...
                 }
                     // do something with p1
                     ...
                 }


@@ -620,10 +621,9 @@ namespace cds { namespace intrusive {
             \endcode
         */
         template <typename Q>
             \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
         }
 
         /// 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>
             \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
         }
 
         /// 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 );
         }
         {
             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
         /**
 
         /// 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 );
         }
         {
             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
 
         /// 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_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 );
                         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 );
                     {
                         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() );
                     }
                 }
                         CPPUNIT_CHECK( ep.empty() );
                     }
                 }


@@ -576,7 +577,8 @@ namespace ordlist {
                 {
                     rcu_lock lock;
                     CPPUNIT_CHECK( l.get( a[0] ) == nullptr );
                 {
                     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
                     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_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 );
                         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 );
                     {
                         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() );
                     }
                 }
                         CPPUNIT_CHECK( ep.empty() );
                     }
                 }


@@ -614,7 +618,7 @@ namespace ordlist {
                 {
                     rcu_lock lock;
                     CPPUNIT_CHECK( l.get_with( other_item( 0 ), other_less() ) == nullptr );
                 {
                     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
                     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_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 );
                         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 );
                     {
                         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() );
                     }
                 }
                 CPPUNIT_ASSERT( l.empty() );


@@ -578,7 +578,8 @@ namespace ordlist {
                 {
                     rcu_lock lock;
                     CPPUNIT_CHECK( l.get( a[0] ) == nullptr );
                 {
                     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() );
                 }
 
                     CPPUNIT_CHECK( ep.empty() );
                 }
 


@@ -596,7 +597,8 @@ namespace ordlist {
                         CPPUNIT_CHECK( pGet->nKey == a[i] );
                         CPPUNIT_CHECK( pGet->nVal == a[i] * 2 );
 
                         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 );
                         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 );
                     {
                         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() );
                     }
                 }
                         CPPUNIT_CHECK( ep.empty() );
                     }
                 }


@@ -614,7 +617,7 @@ namespace ordlist {
                 {
                     rcu_lock lock;
                     CPPUNIT_CHECK( l.get_with( other_item( 0 ), other_less() ) == nullptr );
                 {
                     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() );
                 }
             }
                     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_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 );
                         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 );
                     {
                         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() );
                     }
                 }
                         CPPUNIT_CHECK( ep.empty() );
                     }
                 }


@@ -405,8 +407,8 @@ namespace ordlist {
                 {
                     rcu_lock lock;
                     CPPUNIT_CHECK( l.get( a[0] ) == nullptr );
                 {
                     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
                 }
 
                 // 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_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 );
                         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 );
                     {
                         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() );
                     }
                 }
                         CPPUNIT_CHECK( ep.empty() );
                     }
                 }


@@ -441,7 +445,7 @@ namespace ordlist {
                 {
                     rcu_lock lock;
                     CPPUNIT_CHECK( l.get_with( 3.14f, other_less() ) == nullptr );
                 {
                     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() );
                 }
             }
                     CPPUNIT_CHECK( ep.empty() );
                 }
             }