//$$CDS-header$$
-#ifndef __CDS_INTRUSIVE_SPLIT_LIST_RCU_H
-#define __CDS_INTRUSIVE_SPLIT_LIST_RCU_H
+#ifndef CDSLIB_INTRUSIVE_SPLIT_LIST_RCU_H
+#define CDSLIB_INTRUSIVE_SPLIT_LIST_RCU_H
#include <cds/intrusive/details/split_list_base.h>
#include <cds/details/binary_functor_wrapper.h>
static_assert( std::is_same<gc, typename ordered_list::gc>::value, "GC and OrderedList::gc must be the same");
// atomicity::empty_item_counter is not allowed as a item counter
- static_assert( !std::is_same<item_counter, cds::atomicity::empty_item_counter>::value,
+ static_assert( !std::is_same<item_counter, cds::atomicity::empty_item_counter>::value,
"cds::atomicity::empty_item_counter is not allowed as a item counter");
// Initialize bucket 0
template <typename Q, typename Less>
value_type * extract_with_( Q const& val, Less pred )
{
+ CDS_UNUSED( pred );
return extract_( val, typename wrapped_ordered_list::template make_compare_from_less<Less>());
}
template <typename Q, typename Less>
bool erase_with( Q const& key, Less pred )
{
+ CDS_UNUSED( pred );
return erase_( key, typename wrapped_ordered_list::template make_compare_from_less<Less>() );
}
void operator()( value_type const& item );
};
\endcode
- The functor can be passed by reference with <tt>boost:ref</tt>
If the item with key equal to \p key is not found the function return \p false.
template <typename Q, typename Less, typename Func>
bool erase_with( Q const& key, Less pred, Func f )
{
+ CDS_UNUSED( pred );
return erase_( key, typename wrapped_ordered_list::template make_compare_from_less<Less>(), f );
}
/// 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
// 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
...
}
\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
\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
\endcode
where \p item is the item found, \p key is the <tt>find</tt> function argument.
- You can pass \p f argument by value or by reference using \p std::ref.
-
The functor can 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 \p item. If such access is
{
return find_( key, key_comparator(), f );
}
+ //@cond
+ template <typename Q, typename Func>
+ bool find( Q const& key, Func f )
+ {
+ return find_( key, key_comparator(), f );
+ }
+ //@endcond
/// Finds the key \p key with \p pred predicate for comparing
/**
template <typename Q, typename Less, typename Func>
bool find_with( Q& key, Less pred, Func f )
{
+ CDS_UNUSED( pred );
return find_( key, typename wrapped_ordered_list::template make_compare_from_less<Less>(), f );
}
-
+ //@cond
+ template <typename Q, typename Less, typename Func>
+ bool find_with( Q const& key, Less pred, Func f )
+ {
+ CDS_UNUSED( pred );
+ return find_( key, typename wrapped_ordered_list::template make_compare_from_less<Less>(), f );
+ }
+ //@endcond
/// Finds the key \p key
/** \anchor cds_intrusive_SplitListSet_rcu_find_val
template <typename Q, typename Less>
bool find_with( Q const& key, Less pred )
{
+ CDS_UNUSED( pred );
return find_value( key, typename wrapped_ordered_list::template make_compare_from_less<Less>() );
}
template <typename Q, typename Less>
value_type * get_with( Q const& key, Less pred )
{
+ CDS_UNUSED( pred );
return get_( key, typename wrapped_ordered_list::template make_compare_from_less<Less>());
}
}
}
+ /// Returns internal statistics
+ stat const& statistics() const
+ {
+ return m_Stat;
+ }
+
protected:
//@cond
template <bool IsConst>
/// Returns a forward const iterator addressing the first element in a split-list
const_iterator begin() const
{
- return const_iterator( m_List.begin(), m_List.end() );
+ return cbegin();
+ }
+ /// Returns a forward const iterator addressing the first element in a split-list
+ const_iterator cbegin() const
+ {
+ return const_iterator( m_List.cbegin(), m_List.cend() );
}
/// Returns an const iterator that addresses the location succeeding the last element in a split-list
const_iterator end() const
{
- return const_iterator( m_List.end(), m_List.end() );
+ return cend();
+ }
+ /// Returns an const iterator that addresses the location succeeding the last element in a split-list
+ const_iterator cend() const
+ {
+ return const_iterator( m_List.cend(), m_List.cend() );
}
};
}} // namespace cds::intrusive
-#endif // #ifndef __CDS_INTRUSIVE_SPLIT_LIST_RCU_H
+#endif // #ifndef CDSLIB_INTRUSIVE_SPLIT_LIST_RCU_H
projects / libcds.git / blobdiff