X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=cds%2Fcontainer%2Fskip_list_set_rcu.h;h=a61ce17af46df20c78890f294e158743a3e262b9;hb=6e2784d24f15873dc5b971499276cc8e4147fd46;hp=82b7b838bb20dc1a0695f411cca83361f05d8c04;hpb=ab7af122c1440e755bcab9192ad3394332c8eec1;p=libcds.git diff --git a/cds/container/skip_list_set_rcu.h b/cds/container/skip_list_set_rcu.h index 82b7b838..a61ce17a 100644 --- a/cds/container/skip_list_set_rcu.h +++ b/cds/container/skip_list_set_rcu.h @@ -185,7 +185,7 @@ namespace cds { namespace container { static CDS_CONSTEXPR const bool c_bExtractLockExternal = base_class::c_bExtractLockExternal; /// pointer to extracted node - typedef cds::urcu::exempt_ptr< gc, node_type, value_type, typename maker::intrusive_traits::disposer > exempt_ptr; + using exempt_ptr = cds::urcu::exempt_ptr< gc, node_type, value_type, typename maker::intrusive_traits::disposer >; protected: //@cond @@ -391,6 +391,7 @@ namespace cds { namespace container { template bool erase_with( Q const& key, Less pred ) { + CDS_UNUSED( pred ); return base_class::erase_with( key, cds::details::predicate_wrapper< node_type, Less, typename maker::value_accessor >()); } @@ -434,6 +435,7 @@ namespace cds { namespace container { template bool erase_with( Q const& key, Less pred, Func f ) { + CDS_UNUSED( pred ); return base_class::erase_with( key, cds::details::predicate_wrapper< node_type, Less, typename maker::value_accessor >(), [&f]( node_type const& node) { f( node.m_Value ); } ); } @@ -441,22 +443,22 @@ namespace cds { namespace container { /// Extracts the item from the set with specified \p key /** \anchor cds_nonintrusive_SkipListSet_rcu_extract The function searches an item with key equal to \p key in the set, - unlinks it from the set, and returns it in \p result 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 \ref cds::urcu::exempt_ptr "exempt_ptr" pointer to the item found. + If the item is not found the function returns an empty \p exempt_ptr Note the compare functor from \p Traits class' template argument should accept a parameter of type \p Q that can be not the same as \p value_type. RCU \p synchronize method can be called. RCU should NOT be locked. + The function does not free the item found. - The item will be implicitly freed when \p result object is destroyed or when - result.release() is called, see \p cds::urcu::exempt_ptr for explanation. - @note Before reusing \p result object you should call its \p release() method. + The item will be implicitly freed when the returned object is destroyed or when + its \p release() member function is called. */ template - bool extract( exempt_ptr& result, Q const& key ) + exempt_ptr extract( Q const& key ) { - return base_class::do_extract( result, key ); + return exempt_ptr( base_class::do_extract( key )); } /// Extracts the item from the set with comparing functor \p pred @@ -467,41 +469,44 @@ 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& result, Q const& key, Less pred ) + exempt_ptr extract_with( Q const& key, Less pred ) { - return base_class::do_extract_with( result, key, cds::details::predicate_wrapper< node_type, Less, typename maker::value_accessor >()); + CDS_UNUSED( pred ); + return exempt_ptr( base_class::do_extract_with( key, cds::details::predicate_wrapper< node_type, Less, typename maker::value_accessor >())); } /// Extracts an item with minimal key from the set /** - The function searches an item with minimal key, unlinks it, and returns the item found in \p result parameter. - If the skip-list is empty the function returns \p false. + The function searches an item with minimal key, unlinks it, + and returns \ref cds::urcu::exempt_ptr "exempt_ptr" pointer to the item. + If the skip-list is empty the function returns an empty \p exempt_ptr. RCU \p synchronize method can be called. RCU should NOT be locked. + The function does not free the item found. - The item will be implicitly freed when \p result object is destroyed or when - result.release() is called, see cds::urcu::exempt_ptr for explanation. - @note Before reusing \p result object you should call its \p release() method. + The item will be implicitly freed when the returned object is destroyed or when + its \p release() member function is called. */ - bool extract_min( exempt_ptr& result ) + exempt_ptr extract_min() { - return base_class::do_extract_min(result); + return exempt_ptr( base_class::do_extract_min()); } /// Extracts an item with maximal key from the set /** - The function searches an item with maximal key, unlinks it from the set, and returns the item found - in \p result parameter. If the skip-list is empty the function returns \p false. + The function searches an item with maximal key, unlinks it from the set, + and returns \ref cds::urcu::exempt_ptr "exempt_ptr" pointer to the item. + If the skip-list is empty the function returns an empty \p exempt_ptr. RCU \p synchronize method can be called. RCU should NOT be locked. + The function does not free the item found. - The item will be implicitly freed when \p result object is destroyed or when - result.release() is called, see cds::urcu::exempt_ptr for explanation. - @note Before reusing \p result object you should call its \p release() method. + The item will be implicitly freed when the returned object is destroyed or when + its \p release() member function is called. */ - bool extract_max(exempt_ptr& result) + exempt_ptr extract_max() { - return base_class::do_extract_max(result); + return exempt_ptr( base_class::do_extract_max()); } /// Find the key \p val @@ -537,6 +542,13 @@ namespace cds { namespace container { { return base_class::find( val, [&f]( node_type& node, Q& v ) { f( node.m_Value, v ); }); } + //@cond + template + bool find( Q const& val, Func f ) + { + return base_class::find( val, [&f]( node_type& node, Q& v ) { f( node.m_Value, v ); } ); + } + //@endcond /// Finds the key \p val using \p pred predicate for searching /** @@ -548,53 +560,19 @@ namespace cds { namespace container { template bool find_with( Q& val, Less pred, Func f ) { + CDS_UNUSED( pred ); return base_class::find_with( val, cds::details::predicate_wrapper< node_type, Less, typename maker::value_accessor >(), [&f]( node_type& node, Q& v ) { f( node.m_Value, v ); } ); } - - /// Find the key \p val - /** @anchor cds_nonintrusive_SkipListSet_rcu_find_cfunc - - The function searches the item with key equal to \p val and calls the functor \p f for item found. - The interface of \p Func functor is: - \code - struct functor { - void operator()( value_type& item, Q const& val ); - }; - \endcode - where \p item is the item found, \p val is the find function argument. - - The functor may change non-key fields of \p item. Note that the functor is only guarantee - that \p item cannot be disposed during functor is executing. - The functor does not serialize simultaneous access to the set's \p item. If such access is - possible you must provide your own synchronization schema on item level to exclude unsafe item modifications. - - Note the hash functor specified for class \p Traits template parameter - should accept a parameter of type \p Q that may be not the same as \p value_type. - - The function applies RCU lock internally. - - The function returns \p true if \p val is found, \p false otherwise. - */ - template - bool find( Q const& val, Func f ) - { - return base_class::find( val, [&f]( node_type& node, Q const& v ) { f( node.m_Value, v ); }); - } - - /// Finds the key \p val using \p pred predicate for searching - /** - The function is an analog of \ref cds_nonintrusive_SkipListSet_rcu_find_cfunc "find(Q const&, Func)" - but \p pred is used for key comparing. - \p Less functor has the semantics like \p std::less. - \p Less must imply the same element order as the comparator used for building the set. - */ + //@cond template bool find_with( Q const& val, Less pred, Func f ) { + CDS_UNUSED( pred ); return base_class::find_with( val, cds::details::predicate_wrapper< node_type, Less, typename maker::value_accessor >(), - [&f]( node_type& node, Q const& v ) { f( node.m_Value, v ); } ); + [&f]( node_type& node, Q& v ) { f( node.m_Value, v ); } ); } + //@endcond /// Find the key \p val /** @anchor cds_nonintrusive_SkipListSet_rcu_find_val @@ -623,6 +601,7 @@ namespace cds { namespace container { template bool find_with( Q const& val, Less pred ) { + CDS_UNUSED( pred ); return base_class::find_with( val, cds::details::predicate_wrapper< node_type, Less, typename maker::value_accessor >()); } @@ -674,6 +653,7 @@ namespace cds { namespace container { template value_type * get_with( Q const& val, Less pred ) { + CDS_UNUSED( pred ); return to_value_ptr( base_class::get_with( val, cds::details::predicate_wrapper< node_type, Less, typename maker::value_accessor >() )); }