movable guarded_ptr: LazyList, MichaelList

[libcds.git] / cds / container / impl / lazy_kvlist.h

diff --git a/cds/container/impl/lazy_kvlist.h b/cds/container/impl/lazy_kvlist.h
index 953b5bc1cb25a4551df3f737ce6fdcf9e3397a8d..e8b83f7a7cbc001194618e5465ae86ea95454784 100644 (file)
--- a/cds/container/impl/lazy_kvlist.h
+++ b/cds/container/impl/lazy_kvlist.h
@@ -118,7 +118,7 @@ namespace cds { namespace container {
 
     public:
         /// Guarded pointer
-        typedef cds::gc::guarded_ptr< gc, node_type, value_type, details::guarded_ptr_cast_map<node_type, value_type> > guarded_ptr;
+        typedef typename gc::template guarded_ptr< node_type, value_type, details::guarded_ptr_cast_map<node_type, value_type> > guarded_ptr;
 
     protected:
         //@cond
@@ -514,8 +514,8 @@ namespace cds { namespace container {
         /// Extracts the item from the list with specified \p key
         /** \anchor cds_nonintrusive_LazyKVList_hp_extract
             The function searches an item with key equal to \p key,
-            unlinks it from the list, and returns it in \p dest parameter.
-            If the item with key equal to \p key is not found the function returns \p false.
+            unlinks it from the list, and returns it as \p guarded_ptr.
+            If \p key is not found the function returns an empty guarded pointer.
 
             Note the compare functor should accept a parameter of type \p K that can be not the same as \p key_type.
 
@@ -527,24 +527,26 @@ namespace cds { namespace container {
             ord_list theList;
             // ...
             {
-                ord_list::guarded_ptr gp;
-                theList.extract( gp, 5 );
-                // Deal with gp
-                // ...
-
+                ord_list::guarded_ptr gp( theList.extract( 5 ));
+                if ( gp ) {
+                    // Deal with gp
+                    // ...
+                }
                 // Destructor of gp releases internal HP guard and frees the item
             }
             \endcode
         */
         template <typename K>
-        bool extract( guarded_ptr& dest, K const& key )
+        guarded_ptr extract( K const& key )
         {
-            return extract_at( head(), dest.guard(), key, intrusive_key_comparator() );
+            guarded_ptr gp;
+            extract_at( head(), gp.guard(), key, intrusive_key_comparator() );
+            return gp;
         }
 
         /// Extracts the item from the list with comparing functor \p pred
         /**
-            The function is an analog of \ref cds_nonintrusive_LazyKVList_hp_extract "extract(guarded_ptr&, K const&)"
+            The function is an analog of \ref cds_nonintrusive_LazyKVList_hp_extract "extract(K const&)"
             but \p pred predicate is used for key comparing.
 
             \p Less functor has the semantics like \p std::less but should take arguments of type \ref key_type and \p K
@@ -552,10 +554,12 @@ namespace cds { namespace container {
             \p pred must imply the same element order as the comparator used for building the list.
         */
         template <typename K, typename Less>
-        bool extract_with( guarded_ptr& dest, K const& key, Less pred )
+        guarded_ptr extract_with( K const& key, Less pred )
         {
             CDS_UNUSED( pred );
-            return extract_at( head(), dest.guard(), key, typename maker::template less_wrapper<Less>::type() );
+            guarded_ptr gp;
+            extract_at( head(), gp.guard(), key, typename maker::template less_wrapper<Less>::type() );
+            return gp;
         }
 
         /// Finds the key \p key
@@ -624,9 +628,8 @@ namespace cds { namespace container {
         /// Finds \p key and return the item found
         /** \anchor cds_nonintrusive_LazyKVList_hp_get
             The function searches the item with key equal to \p key
-            and assigns the item found to guarded pointer \p ptr.
-            The function returns \p true if \p key is found, and \p false otherwise.
-            If \p key is not found the \p ptr parameter is not changed.
+            and returns the item found as a guarded pointer.
+            If \p key is not found the functions returns an empty \p guarded_ptr.
 
             @note Each \p guarded_ptr object uses one GC's guard which can be limited resource.
 
@@ -636,8 +639,8 @@ namespace cds { namespace container {
             ord_list theList;
             // ...
             {
-                ord_list::guarded_ptr gp;
-                if ( theList.get( gp, 5 )) {
+                ord_list::guarded_ptr gp( theList.get( 5 ));
+                if ( gp ) {
                     // Deal with gp
                     //...
                 }
@@ -649,14 +652,16 @@ namespace cds { namespace container {
             should accept a parameter of type \p K that can be not the same as \p key_type.
         */
         template <typename K>
-        bool get( guarded_ptr& ptr, K const& key )
+        guarded_ptr get( K const& key )
         {
-            return get_at( head(), ptr.guard(), key, intrusive_key_comparator() );
+            guarded_ptr gp;
+            get_at( head(), gp.guard(), key, intrusive_key_comparator() );
+            return gp;
         }
 
         /// Finds the key \p val and return the item found
         /**
-            The function is an analog of \ref cds_nonintrusive_LazyKVList_hp_get "get(guarded_ptr& ptr, K const&)"
+            The function is an analog of \ref cds_nonintrusive_LazyKVList_hp_get "get(K const&)"
             but \p pred is used for comparing the keys.
 
             \p Less functor has the semantics like \p std::less but should take arguments of type \ref key_type and \p K
@@ -664,10 +669,12 @@ namespace cds { namespace container {
             \p pred must imply the same element order as the comparator used for building the list.
         */
         template <typename K, typename Less>
-        bool get_with( guarded_ptr& ptr, K const& key, Less pred )
+        guarded_ptr get_with( K const& key, Less pred )
         {
             CDS_UNUSED( pred );
-            return get_at( head(), ptr.guard(), key, typename maker::template less_wrapper<Less>::type() );
+            guarded_ptr gp;
+            get_at( head(), gp.guard(), key, typename maker::template less_wrapper<Less>::type() );
+            return gp;
         }
 
         /// Checks if the list is empty
@@ -753,9 +760,9 @@ namespace cds { namespace container {
         }
 
         template <typename K, typename Compare>
-        bool extract_at( head_type& refHead, typename gc::Guard& dest, K const& key, Compare cmp )
+        bool extract_at( head_type& refHead, typename guarded_ptr::native_guard& guard, K const& key, Compare cmp )
         {
-            return base_class::extract_at( &refHead, dest, key, cmp );
+            return base_class::extract_at( &refHead, guard, key, cmp );
         }
 
         template <typename K, typename Func>
@@ -784,7 +791,7 @@ namespace cds { namespace container {
         }
 
         template <typename K, typename Compare>
-        bool get_at( head_type& refHead, typename gc::Guard& guard, K const& key, Compare cmp )
+        bool get_at( head_type& refHead, typename guarded_ptr::native_guard& guard, K const& key, Compare cmp )
         {
             return base_class::get_at( &refHead, guard, key, cmp );
         }