From ad22a0aee4069c04c04e558ed356665a45e9a222 Mon Sep 17 00:00:00 2001 From: khizmax Date: Thu, 13 Nov 2014 13:49:45 +0300 Subject: [PATCH] movable exempt_ptr: SplitList --- cds/container/split_list_map_rcu.h | 15 ++++++++------- cds/container/split_list_set_rcu.h | 27 +++++++++------------------ cds/intrusive/split_list_rcu.h | 25 ++++++++----------------- 3 files changed, 25 insertions(+), 42 deletions(-) diff --git a/cds/container/split_list_map_rcu.h b/cds/container/split_list_map_rcu.h index 65da6217..7b6bfae0 100644 --- a/cds/container/split_list_map_rcu.h +++ b/cds/container/split_list_map_rcu.h @@ -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 - 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 - 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()); + return base_class::extract_with( key, cds::details::predicate_wrapper()); } /// Finds the key \p key diff --git a/cds/container/split_list_set_rcu.h b/cds/container/split_list_set_rcu.h index 938bbc7c..013b6d74 100644 --- a/cds/container/split_list_set_rcu.h +++ b/cds/container/split_list_set_rcu.h @@ -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 - 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 - 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::type()); - if ( pNode ) { - dest = pNode; - return true; - } - return false; + return exempt_ptr( base_class::extract_with_( key, typename maker::template predicate_wrapper::type())); } /// Finds the key \p key diff --git a/cds/intrusive/split_list_rcu.h b/cds/intrusive/split_list_rcu.h index 12fae063..334133f8 100644 --- a/cds/intrusive/split_list_rcu.h +++ b/cds/intrusive/split_list_rcu.h @@ -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 - 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 - 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 -- 2.34.1