movable exempt_ptr: SplitList
authorkhizmax <khizmax@gmail.com>
Thu, 13 Nov 2014 10:49:45 +0000 (13:49 +0300)
committerkhizmax <khizmax@gmail.com>
Thu, 13 Nov 2014 10:49:45 +0000 (13:49 +0300)
cds/container/split_list_map_rcu.h
cds/container/split_list_set_rcu.h
cds/intrusive/split_list_rcu.h

index 65da621..7b6bfae 100644 (file)
@@ -453,8 +453,8 @@ namespace cds { namespace container {
         /// Extracts an item from the map
         /** \anchor cds_nonintrusive_SplitListMap_rcu_extract
             The function searches an item with key equal to \p key in the map,
-            unlinks it from the map, places item pointer into \p dest argument, and returns \p true.
-            If the item with the key equal to \p key is not found the function return \p false.
+            unlinks it from the map, and returns \ref cds::urcu::exempt_ptr "exempt_ptr" pointer to the 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 map
@@ -476,7 +476,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 ( theMap.extract( p, 10 )) {
+                p = theMap.extract( 10 )
+                if ( p ) {
                     // do something with p
                     ...
                 }
@@ -488,9 +489,9 @@ namespace cds { namespace container {
             \endcode
         */
         template <typename K>
-        bool extract( exempt_ptr& dest, K const& key )
+        exempt_ptr extract( K const& key )
         {
-            return base_class::extract( dest, key );
+            return base_class::extract( key );
         }
 
         /// Extracts an item from the map using \p pred predicate for searching
@@ -501,9 +502,9 @@ namespace cds { namespace container {
             \p pred must imply the same element order as the comparator used for building the map.
         */
         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 )
         {
-            return base_class::extract_with( dest, key, cds::details::predicate_wrapper<value_type, Less, key_accessor>());
+            return base_class::extract_with( key, cds::details::predicate_wrapper<value_type, Less, key_accessor>());
         }
 
         /// Finds the key \p key
index 938bbc7..013b6d7 100644 (file)
@@ -200,7 +200,7 @@ namespace cds { namespace container {
 
     public:
         /// pointer to extracted node
-        typedef cds::urcu::exempt_ptr< gc, node_type, value_type, typename maker::ordered_list_traits::disposer > exempt_ptr;
+        using exempt_ptr = cds::urcu::exempt_ptr< gc, node_type, value_type, typename maker::ordered_list_traits::disposer >;
 
     protected:
         //@cond
@@ -583,8 +583,8 @@ namespace cds { namespace container {
         /// Extracts an item from the set
         /** \anchor cds_nonintrusive_SplitListSet_rcu_extract
             The function searches an item with key equal to \p key in the set,
-            unlinks it from the set, places item pointer into \p dest argument, and returns \p true.
-            If the item with the key equal to \p key is not found the function return \p false.
+            unlinks it from the set, and returns \ref cds::urcu::exempt_ptr "exempt_ptr" pointer to the 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 set
@@ -606,7 +606,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 ( theSet.extract( p, 10 )) {
+                p = theSet.extract( 10 );
+                if ( p ) {
                     // do something with p
                     ...
                 }
@@ -618,14 +619,9 @@ namespace cds { namespace container {
             \endcode
         */
         template <typename Q>
-        bool extract( exempt_ptr& dest, Q const& key )
+        exempt_ptr extract( Q const& key )
         {
-            node_type * pNode = base_class::extract_( key, key_comparator() );
-            if ( pNode ) {
-                dest = pNode;
-                return true;
-            }
-            return false;
+            return exempt_ptr( base_class::extract_( key, key_comparator() ));
         }
 
         /// Extracts an item from the set using \p pred predicate for searching
@@ -636,14 +632,9 @@ namespace cds { namespace container {
             \p pred must imply the same element order as the comparator used for building the set.
         */
         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 )
         {
-            node_type * pNode = base_class::extract_with_( key, typename maker::template predicate_wrapper<Less>::type());
-            if ( pNode ) {
-                dest = pNode;
-                return true;
-            }
-            return false;
+            return exempt_ptr( base_class::extract_with_( key, typename maker::template predicate_wrapper<Less>::type()));
         }
 
         /// Finds the key \p key
index 12fae06..334133f 100644 (file)
@@ -692,8 +692,8 @@ namespace cds { namespace intrusive {
         /// Extracts an item from the set
         /** \anchor cds_intrusive_SplitListSet_rcu_extract
             The function searches an item with key equal to \p key in the set,
-            unlinks it, 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, and returns \ref cds::urcu::exempt_ptr "exempt_ptr" pointer to the 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 set
@@ -716,7 +716,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( p, 10 )) {
+                p = theList.extract( 10 );
+                if ( p ) {
                     // do something with p
                     ...
                 }
@@ -729,14 +730,9 @@ namespace cds { namespace intrusive {
             \endcode
         */
         template <typename Q>
-        bool extract( exempt_ptr& dest, Q const& key )
+        exempt_ptr extract( Q const& key )
         {
-            value_type * pNode = extract_( key, key_comparator() );
-            if ( pNode ) {
-                dest = pNode;
-                return true;
-            }
-            return false;
+            return exempt_ptr(extract_( key, key_comparator() ));
         }
 
         /// Extracts an item from the set using \p pred for searching
@@ -747,14 +743,9 @@ namespace cds { namespace intrusive {
             \p pred must imply the same element order as the comparator used for building the set.
         */
         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 )
         {
-            value_type * pNode = extract_with_( key, pred );
-            if ( pNode ) {
-                dest = pNode;
-                return true;
-            }
-            return false;
+            return exempt_ptr( extract_with_( key, pred ));
         }
 
         /// Finds the key \p key