//$$CDS-header$$
-#ifndef __CDS_CONTAINER_LAZY_KVLIST_RCU_H
-#define __CDS_CONTAINER_LAZY_KVLIST_RCU_H
+#ifndef CDSLIB_CONTAINER_LAZY_KVLIST_RCU_H
+#define CDSLIB_CONTAINER_LAZY_KVLIST_RCU_H
#include <memory>
#include <cds/container/details/lazy_list_base.h>
public:
/// pointer to extracted node
- typedef cds::urcu::exempt_ptr< gc, node_type, value_type, typename maker::intrusive_traits::disposer,
+ using exempt_ptr = cds::urcu::exempt_ptr< gc, node_type, value_type, typename maker::intrusive_traits::disposer,
cds::urcu::details::conventional_exempt_pair_cast<node_type, value_type>
- > exempt_ptr;
+ >;
+ /// Type of \p get() member function return value
+ typedef value_type * raw_ptr;
protected:
//@cond
@warning See \ref cds_intrusive_item_creating "insert item troubleshooting"
*/
template <typename K, typename Func>
- bool insert_key( const K& key, Func func )
+ bool insert_with( const K& key, Func func )
{
- return insert_key_at( head(), key, func );
+ return insert_with_at( head(), key, func );
}
/// Inserts data of type \p mapped_type constructed from \p args
template <typename K, typename Less>
bool erase_with( K const& key, Less pred )
{
+ CDS_UNUSED( pred );
return erase_at( head(), key, typename maker::template less_wrapper<Less>::type() );
}
void operator()(value_type& val) { ... }
};
\endcode
- The functor may be passed by reference with <tt>boost:ref</tt>
RCU \p synchronize method can be called. RCU should not be locked.
template <typename K, typename Less, typename Func>
bool erase_with( K const& key, Less pred, Func f )
{
+ CDS_UNUSED( pred );
return erase_at( head(), key, typename maker::template less_wrapper<Less>::type(), f );
}
/**
@anchor cds_nonintrusive_LazyKVList_rcu_extract
The function searches an item with key equal to \p key in the list,
- unlinks it from the list, and returns pointer to an item found in \p dest argument.
- If \p key is not found the function returns \p false.
+ unlinks it from the list, and returns \ref cds::urcu::exempt_ptr "exempt_ptr" pointer to the item found.
+ If \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 list
and returns a pointer to item found.
- You should lock RCU before calling this function.
+ You should manually lock RCU before calling this function.
\code
#include <cds/urcu/general_buffered.h>
// 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 K>
- bool extract( exempt_ptr& dest, K const& key )
+ exempt_ptr extract( K const& key )
{
- dest = extract_at( head(), key, intrusive_key_comparator() );
- return !dest.empty();
+ return exempt_ptr( extract_at( head(), key, intrusive_key_comparator()));
}
/// Extracts an item from the list using \p pred predicate for searching
/**
- This function is the analog for \ref cds_nonintrusive_LazyKVList_rcu_extract "extract(exempt_ptr&, K const&)".
+ This function is the analog for \p extract(K const&).
The \p pred is a predicate used for key comparing.
\p Less has the interface like \p std::less.
\p pred must imply the same element order as \ref key_comparator.
*/
template <typename K, typename Less>
- bool extract_with( exempt_ptr& dest, K const& key, Less pred )
+ exempt_ptr extract_with( K const& key, Less pred )
{
- dest = extract_at( head(), key, typename maker::template less_wrapper<Less>::type() );
- return !dest.empty();
+ CDS_UNUSED( pred );
+ return exempt_ptr( extract_at( head(), key, typename maker::template less_wrapper<Less>::type() ));
}
/// Finds the key \p key
template <typename Q, typename Less>
bool find_with( Q const& key, Less pred ) const
{
+ CDS_UNUSED( pred );
return find_at( head(), key, typename maker::template less_wrapper<Less>::type() );
}
\endcode
where \p item is the item found.
- You may pass \p f argument by reference using \p std::ref.
-
The functor may change <tt>item.second</tt> that is reference to value of node.
Note that the function is only guarantee that \p item cannot be deleted during functor is executing.
The function does not serialize simultaneous access to the list \p item. If such access is
template <typename Q, typename Less, typename Func>
bool find_with( Q const& key, Less pred, Func f ) const
{
+ CDS_UNUSED( pred );
return find_at( head(), key, typename maker::template less_wrapper<Less>::type(), f );
}
template <typename K, typename Less>
value_type * get_with( K const& key, Less pred ) const
{
+ CDS_UNUSED( pred );
return get_at( head(), key, typename maker::template less_wrapper<Less>::type());
}
}
template <typename K, typename Func>
- bool insert_key_at( head_type& refHead, const K& key, Func f )
+ bool insert_with_at( head_type& refHead, const K& key, Func f )
{
scoped_node_ptr pNode( alloc_node( key ));
}} // namespace cds::container
-#endif // #ifndef __CDS_CONTAINER_LAZY_KVLIST_RCU_H
+#endif // #ifndef CDSLIB_CONTAINER_LAZY_KVLIST_RCU_H