movable exempt_ptr: LazyList

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

diff --git a/cds/container/lazy_kvlist_rcu.h b/cds/container/lazy_kvlist_rcu.h
index 218c2bc3e374c3bab008165fde1fb840b51a16fa..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
@@ -295,7 +295,7 @@ namespace cds { namespace container {
             ++it;   // skip dummy head
             return it;
         }
-        const_iterator cbegin()
+        const_iterator cbegin() const
         {
             const_iterator it( head() );
             ++it;   // skip dummy head
@@ -309,7 +309,7 @@ namespace cds { namespace container {
         {
             return const_iterator( tail());
         }
-        const_iterator cend()
+        const_iterator cend() const
         {
             return const_iterator( tail());
         }
@@ -485,7 +485,6 @@ namespace cds { namespace container {
                 void operator()(value_type& val) { ... }
             };
             \endcode
-            The functor may be passed by reference with <tt>boost:ref</tt>
 
             RCU \p synchronize method can be called. RCU should not be locked.
 
@@ -514,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>
@@ -539,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
                     ...
                 }
@@ -550,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
@@ -564,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
@@ -607,8 +605,6 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found.
 
-            You may pass \p f argument by reference using \p std::ref.
-
             The functor may change <tt>item.second</tt> that is reference to value of node.
             Note that the function is only guarantee that \p item cannot be deleted during functor is executing.
             The function does not serialize simultaneous access to the list \p item. If such access is