,cc::split_list::make_traits< // metafunction to build split-list traits
cc::split_list::ordered_list<cc::lazy_list_tag> // tag for underlying ordered list implementation
,cc::opt::hash< foo_hash > // hash functor
- ,cc::split_list::ordered_list_traits< // ordered list traits
+ ,cc::split_list::ordered_list_traits< // ordered list traits
cc::lazy_list::make_traits< // metafunction to build lazy list traits
cc::opt::less< foo_less > // less-based compare functor
>::type
/// Hash functor for \ref value_type and all its derivatives that you use
typedef typename base_class::hash hash;
typedef typename base_class::item_counter item_counter; ///< Item counter type
+ typedef typename base_class::stat stat; ///< Internal statistics
typedef typename base_class::rcu_lock rcu_lock ; ///< RCU scoped lock
/// Group of \p extract_xxx functions require external locking if underlying ordered list requires that
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
template <typename Q, typename Less, typename Func>
bool find_with_( Q& val, Less pred, Func f )
{
+ CDS_UNUSED( pred );
return base_class::find_with( val, typename maker::template predicate_wrapper<Less>::type(),
[&f]( node_type& item, Q& val ) { f(item.m_Value, val) ; } );
}
/// Returns a forward const iterator addressing the first element in a set
const_iterator begin() const
{
- return const_iterator( base_class::begin() );
+ return cbegin();
+ }
+ /// Returns a forward const iterator addressing the first element in a set
+ const_iterator cbegin() const
+ {
+ return const_iterator( base_class::cbegin() );
}
/// Returns an const iterator that addresses the location succeeding the last element in a set
const_iterator end() const
{
- return const_iterator( base_class::end() );
+ return cend();
+ }
+ /// Returns an const iterator that addresses the location succeeding the last element in a set
+ const_iterator cend() const
+ {
+ return const_iterator( base_class::cend() );
}
public:
template <typename Q, typename Less>
bool erase_with( Q const& key, Less pred )
{
+ CDS_UNUSED( pred );
return base_class::erase_with( key, typename maker::template predicate_wrapper<Less>::type() );
}
template <typename Q, typename Less, typename Func>
bool erase_with( Q const& key, Less pred, Func f )
{
+ CDS_UNUSED( pred );
return base_class::erase_with( key, typename maker::template predicate_wrapper<Less>::type(),
[&f](node_type& node) { f( node.m_Value ); } );
}
/// 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
// 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
...
}
\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
\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;
+ CDS_UNUSED( pred );
+ return exempt_ptr( base_class::extract_with_( key, typename maker::template predicate_wrapper<Less>::type()));
}
/// Finds the key \p key
{
return find_( key, f );
}
+ //@cond
+ template <typename Q, typename Func>
+ bool find( Q const& key, Func f )
+ {
+ return find_( key, f );
+ }
+ //@endcond
/// Finds the key \p key using \p pred predicate for searching
/**
{
return find_with_( key, pred, f );
}
+ //@cond
+ template <typename Q, typename Less, typename Func>
+ bool find_with( Q const& key, Less pred, Func f )
+ {
+ return find_with_( key, pred, f );
+ }
+ //@endcond
/// Finds the key \p key
/** \anchor cds_nonintrusive_SplitListSet_rcu_find_val
template <typename Q, typename Less>
bool find_with( Q const& key, Less pred )
{
+ CDS_UNUSED( pred );
return base_class::find_with( key, typename maker::template predicate_wrapper<Less>::type() );
}
template <typename Q, typename Less>
value_type * get_with( Q const& key, Less pred )
{
+ CDS_UNUSED( pred );
node_type * pNode = base_class::get_with( key, typename maker::template predicate_wrapper<Less>::type());
return pNode ? &pNode->m_Value : nullptr;
}
{
return base_class::size();
}
+
+ /// Returns internal statistics
+ stat const& statistics() const
+ {
+ return base_class::statistics();
+ }
};
}} // namespace cds::container