From 8cc7c73969b4374a1c8be76da02eb36c5e10f13b Mon Sep 17 00:00:00 2001 From: khizmax Date: Thu, 20 Nov 2014 10:09:53 +0300 Subject: [PATCH] movable guarded_ptr: MichaelSet/Map --- cds/container/michael_map.h | 57 ++++++++++++++++++------------------- cds/container/michael_set.h | 53 +++++++++++++++++----------------- cds/intrusive/michael_set.h | 55 +++++++++++++++++------------------ 3 files changed, 80 insertions(+), 85 deletions(-) diff --git a/cds/container/michael_map.h b/cds/container/michael_map.h index 5cc0350a..a090a6d4 100644 --- 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 - 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 - 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 - 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 - 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) diff --git a/cds/container/michael_set.h b/cds/container/michael_set.h index a7cff653..6729eba6 100644 --- a/cds/container/michael_set.h +++ b/cds/container/michael_set.h @@ -498,12 +498,12 @@ namespace cds { namespace container { /// Extracts the item with specified \p key /** \anchor cds_nonintrusive_MichaelHashSet_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 guadd pointer. Note the compare functor should accept a parameter of type \p Q that may be not the same as \p value_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: @@ -512,27 +512,27 @@ namespace cds { namespace container { michael_set theSet; // ... { - michael_set::guarded_ptr gp; - theSet.extract( gp, 5 ); - // Deal with gp - // ... - + michael_set::guarded_ptr gp( theSet.extract( 5 )); + if ( gp ) { + // Deal with gp + // ... + } // Destructor of gp releases internal HP guard } \endcode */ template - bool extract( guarded_ptr& dest, Q const& key ) + guarded_ptr extract( Q 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_MichaelHashSet_hp_extract "extract(guarded_ptr&, Q const&)" + The function is an analog of \ref cds_nonintrusive_MichaelHashSet_hp_extract "extract(Q 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 value_type and \p Q @@ -540,12 +540,12 @@ namespace cds { namespace container { \p pred must imply the same element order as the comparator used for building the set. */ template - bool extract_with( guarded_ptr& dest, Q const& key, Less pred ) + guarded_ptr extract_with( Q 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 @@ -636,9 +636,8 @@ namespace cds { namespace container { /// Finds the key \p key and return the item found /** \anchor cds_nonintrusive_MichaelHashSet_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 functin returns an empty guarded pointer. @note Each \p guarded_ptr object uses one GC's guard which can be limited resource. @@ -648,8 +647,8 @@ namespace cds { namespace container { michael_set theSet; // ... { - michael_set::guarded_ptr gp; - if ( theSet.get( gp, 5 )) { + michael_set::guarded_ptr gp( theSet.get( 5 )); + if ( gp ) { // Deal with gp //... } @@ -661,14 +660,14 @@ namespace cds { namespace container { should accept a parameter of type \p Q that can be not the same as \p value_type. */ template - bool get( guarded_ptr& ptr, Q const& key ) + guarded_ptr get( Q const& key ) { - return bucket( key ).get( ptr, key ); + return bucket( key ).get( key ); } /// Finds the key \p key and return the item found /** - The function is an analog of \ref cds_nonintrusive_MichaelHashSet_hp_get "get( guarded_ptr& ptr, Q const&)" + The function is an analog of \ref cds_nonintrusive_MichaelHashSet_hp_get "get( Q 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 value_type and \p Q @@ -676,9 +675,9 @@ namespace cds { namespace container { \p pred must imply the same element order as the comparator used for building the set. */ template - bool get_with( guarded_ptr& ptr, Q const& key, Less pred ) + guarded_ptr get_with( Q const& key, Less pred ) { - return bucket( key ).get_with( ptr, key, pred ); + return bucket( key ).get_with( key, pred ); } /// Clears the set (non-atomic) diff --git a/cds/intrusive/michael_set.h b/cds/intrusive/michael_set.h index 3f579008..b0449570 100644 --- a/cds/intrusive/michael_set.h +++ b/cds/intrusive/michael_set.h @@ -550,12 +550,12 @@ namespace cds { namespace intrusive { /// Extracts the item with specified \p key /** \anchor cds_intrusive_MichaelHashSet_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 an guarded pointer to the item extracted. + If \p key is not found the function returns an empty guarded pointer. Note the compare functor should accept a parameter of type \p Q that may be not the same as \p value_type. - The \ref disposer specified in \p OrderedList class' template parameter is called automatically + The \p disposer specified in \p OrderedList class' template parameter is called automatically by garbage collector \p GC when returned \ref guarded_ptr object will be destroyed or released. @note Each \p guarded_ptr object uses the GC's guard that can be limited resource. @@ -565,28 +565,27 @@ namespace cds { namespace intrusive { michael_set theSet; // ... { - michael_set::guarded_ptr gp; - theSet.extract( gp, 5 ); - // Deal with gp - // ... - + michael_set::guarded_ptr gp( theSet.extract( 5 )); + if ( gp ) { + // Deal with gp + // ... + } // Destructor of gp releases internal HP guard } \endcode */ template - bool extract( guarded_ptr& dest, Q const& key ) + guarded_ptr extract( Q const& key ) { - if ( bucket( key ).extract( dest, key )) { + guarded_ptr gp = bucket( key ).extract( key ); + if ( gp ) --m_ItemCounter; - return true; - } - return false; + return gp; } /// Extracts the item using compare functor \p pred /** - The function is an analog of \ref cds_intrusive_MichaelHashSet_hp_extract "extract(guarded_ptr&, Q const&)" + The function is an analog of \ref cds_intrusive_MichaelHashSet_hp_extract "extract(Q 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 value_type and \p Q @@ -594,13 +593,12 @@ namespace cds { namespace intrusive { \p pred must imply the same element order as the comparator used for building the list. */ template - bool extract_with( guarded_ptr& dest, Q const& key, Less pred ) + guarded_ptr extract_with( Q const& key, Less pred ) { - if ( bucket( key ).extract_with( dest, key, pred )) { + guarded_ptr gp = bucket( key ).extract_with( key, pred ); + if ( gp ) --m_ItemCounter; - return true; - } - return false; + return gp; } /// Finds the key \p key @@ -690,9 +688,8 @@ namespace cds { namespace intrusive { /// Finds the key \p key and return the item found /** \anchor cds_intrusive_MichaelHashSet_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 \p guarded_ptr. @note Each \p guarded_ptr object uses one GC's guard which can be limited resource. @@ -702,8 +699,8 @@ namespace cds { namespace intrusive { michael_set theSet; // ... { - michael_set::guarded_ptr gp; - if ( theSet.get( gp, 5 )) { + michael_set::guarded_ptr gp( theSet.get( 5 )); + if ( theSet.get( 5 )) { // Deal with gp //... } @@ -715,14 +712,14 @@ namespace cds { namespace intrusive { should accept a parameter of type \p Q that can be not the same as \p value_type. */ template - bool get( guarded_ptr& ptr, Q const& key ) + guarded_ptr get( Q const& key ) { - return bucket( key ).get( ptr, key ); + return bucket( key ).get( key ); } /// Finds the key \p key and return the item found /** - The function is an analog of \ref cds_intrusive_MichaelHashSet_hp_get "get( guarded_ptr& ptr, Q const&)" + The function is an analog of \ref cds_intrusive_MichaelHashSet_hp_get "get( Q 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 value_type and \p Q @@ -730,9 +727,9 @@ namespace cds { namespace intrusive { \p pred must imply the same element order as the comparator used for building the set. */ template - bool get_with( guarded_ptr& ptr, Q const& key, Less pred ) + guarded_ptr get_with( Q const& key, Less pred ) { - return bucket( key ).get_with( ptr, key, pred ); + return bucket( key ).get_with( key, pred ); } /// Clears the set (non-atomic) -- 2.34.1