movable guarded_ptr: MichaelSet/Map

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

diff --git a/cds/container/michael_map.h b/cds/container/michael_map.h
index 5cc0350a470ebf5288e947751d196b09445c4cab..a090a6d46d270be3dfba6bcb3b580453ac8c1f71 100644 (file)
--- a/cds/container/michael_map.h
+++ b/cds/container/michael_map.h
@@ -597,12 +597,12 @@ namespace cds { namespace container {
         /// Extracts the item with specified \p key
         /** \anchor cds_nonintrusive_MichaelHashMap_hp_extract
             The function searches an item with key equal to \p key,
-            unlinks it from the set, 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 set, 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 may be not the same as \p key_type.
 
-            The extracted item is freed automatically when returned \ref guarded_ptr object will be destroyed or released.
+            The extracted item is freed automatically when returned \p guarded_ptr object will be destroyed or released.
             @note Each \p guarded_ptr object uses the GC's guard that can be limited resource.
 
             Usage:
@@ -611,40 +611,40 @@ namespace cds { namespace container {
             michael_map theMap;
             // ...
             {
-                michael_map::guarded_ptr gp;
-                theMap.extract( gp, 5 );
-                // Deal with gp
-                // ...
-
+                michael_map::guarded_ptr gp( theMap.extract( 5 ));
+                if ( gp ) {
+                    // Deal with gp
+                    // ...
+                }
                 // Destructor of gp releases internal HP guard
             }
             \endcode
         */
         template <typename K>
-        bool extract( guarded_ptr& dest, K const& key )
+        guarded_ptr extract( K const& key )
         {
-            const bool bRet = bucket( key ).extract( dest, key );
-            if ( bRet )
+            guarded_ptr gp( bucket( key ).extract( key ));
+            if ( gp )
                 --m_ItemCounter;
-            return bRet;
+            return gp;
         }
 
         /// Extracts the item using compare functor \p pred
         /**
-            The function is an analog of \ref cds_nonintrusive_MichaelHashMap_hp_extract "extract(guarded_ptr&, K const&)"
+            The function is an analog of \ref cds_nonintrusive_MichaelHashMap_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
+            \p Less functor has the semantics like \p std::less but should take arguments of type \p key_type and \p K
             in any order.
             \p pred must imply the same element order as the comparator used for building the map.
         */
         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 )
         {
-            const bool bRet = bucket( key ).extract_with( dest, key, pred );
-            if ( bRet )
+            guarded_ptr gp( bucket( key ).extract_with( key, pred ));
+            if ( gp )
                 --m_ItemCounter;
-            return bRet;
+            return gp;
         }
 
         /// Finds the key \p key
@@ -712,9 +712,8 @@ namespace cds { namespace container {
         /// Finds \p key and return the item found
         /** \anchor cds_nonintrusive_MichaelHashMap_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 guarded pointer to the item found.
+            If \p key is not found the function returns an empty guarded pointer,
 
             @note Each \p guarded_ptr object uses one GC's guard which can be limited resource.
 
@@ -724,8 +723,8 @@ namespace cds { namespace container {
             michael_map theMap;
             // ...
             {
-                michael_map::guarded_ptr gp;
-                if ( theMap.get( gp, 5 )) {
+                michael_map::guarded_ptr gp( theMap.get( 5 ));
+                if ( gp ) {
                     // Deal with gp
                     //...
                 }
@@ -737,24 +736,24 @@ 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 bucket( key ).get( ptr, key );
+            return bucket( key ).get( key );
         }
 
         /// Finds \p key and return the item found
         /**
-            The function is an analog of \ref cds_nonintrusive_MichaelHashMap_hp_get "get( guarded_ptr& ptr, K const&)"
+            The function is an analog of \ref cds_nonintrusive_MichaelHashMap_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
+            \p Less functor has the semantics like \p std::less but should take arguments of type \p key_type and \p K
             in any order.
             \p pred must imply the same element order as the comparator used for building the map.
         */
         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 )
         {
-            return bucket( key ).get_with( ptr, key, pred );
+            return bucket( key ).get_with( key, pred );
         }
 
         /// Clears the map (not atomic)