}
};
- // Declare type_traits
+ // Declare traits
struct my_traits: public cds::container::lazy_list::traits
{
typedef my_compare compare;
public:
/// Guarded pointer
- typedef cds::gc::guarded_ptr< gc, node_type, value_type, details::guarded_ptr_cast_set<node_type, value_type> > guarded_ptr;
+ typedef typename gc::template guarded_ptr< node_type, value_type, details::guarded_ptr_cast_set<node_type, value_type> > guarded_ptr;
private:
//@cond
++it ; // skip dummy head node
return it;
}
- const_iterator cbegin()
+ const_iterator cbegin() const
{
const_iterator it( head() );
++it ; // skip dummy head node
{
return const_iterator( tail() );
}
- const_iterator cend()
+ const_iterator cend() const
{
return const_iterator( tail() );
}
\code void func( value_type& item ) ;\endcode
The argument \p item of user-defined functor \p func is the reference
- to the list's item inserted.
+ to the list's item inserted.
When \p func is called it has exclusive access to the item.
The user-defined functor is called only if the inserting is success.
template <typename Q, typename Less>
bool erase_with( Q const& key, Less pred )
{
+ CDS_UNUSED( pred );
return erase_at( head(), key, typename maker::template less_wrapper<Less>::type(), [](value_type const&){} );
}
template <typename Q, typename Less, typename Func>
bool erase_with( Q const& key, Less pred, Func f )
{
+ CDS_UNUSED( pred );
return erase_at( head(), key, typename maker::template less_wrapper<Less>::type(), f );
}
/// Extracts the item from the list with specified \p key
/** \anchor cds_nonintrusive_LazyList_hp_extract
The function searches an item with key equal to \p key,
- unlinks it from the list, 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 list, 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 Q that can be not the same as \p value_type.
ord_list theList;
// ...
{
- ord_list::guarded_ptr gp;
- theList.extract( gp, 5 );
- // Deal with gp
- // ...
-
+ ord_list::guarded_ptr gp(theList.extract( 5 ));
+ if ( gp ) {
+ // Deal with gp
+ // ...
+ }
// Destructor of gp releases internal HP guard and frees the item
}
\endcode
*/
template <typename Q>
- bool extract( guarded_ptr& dest, Q const& key )
+ guarded_ptr extract( Q const& key )
{
- return extract_at( head(), dest.guard(), key, intrusive_key_comparator() );
+ guarded_ptr gp;
+ extract_at( head(), gp.guard(), key, intrusive_key_comparator() );
+ return gp;
}
/// Extracts the item from the list with comparing functor \p pred
/**
- The function is an analog of \ref cds_nonintrusive_LazyList_hp_extract "extract(guarded_ptr&, Q const&)"
+ The function is an analog of \ref cds_nonintrusive_LazyList_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
\p pred must imply the same element order as the comparator used for building the list.
*/
template <typename Q, typename Less>
- bool extract_with( guarded_ptr& dest, Q const& key, Less pred )
+ guarded_ptr extract_with( Q const& key, Less pred )
{
- return extract_at( head(), dest.guard(), key, typename maker::template less_wrapper<Less>::type() );
+ CDS_UNUSED( pred );
+ guarded_ptr gp;
+ extract_at( head(), gp.guard(), key, typename maker::template less_wrapper<Less>::type() );
+ return gp;
}
/// Finds the key \p key
template <typename Q, typename Less>
bool find_with( Q const& key, Less pred )
{
+ CDS_UNUSED( pred );
return find_at( head(), key, typename maker::template less_wrapper<Less>::type() );
}
\endcode
where \p item is the item found, \p key is the <tt>find</tt> function argument.
- You may pass \p f argument by reference using \p std::ref.
-
The functor may change non-key fields of \p item. 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
{
return find_at( head(), key, intrusive_key_comparator(), f );
}
+ //@cond
+ template <typename Q, typename Func>
+ bool find( Q const& key, Func f )
+ {
+ return find_at( head(), key, intrusive_key_comparator(), f );
+ }
+ //@endcond
/// Finds the key \p key using \p pred predicate for searching
/**
template <typename Q, typename Less, typename Func>
bool find_with( Q& key, Less pred, Func f )
{
+ CDS_UNUSED( pred );
+ return find_at( head(), key, typename maker::template less_wrapper<Less>::type(), f );
+ }
+ //@cond
+ template <typename Q, typename Less, typename Func>
+ bool find_with( Q const& key, Less pred, Func f )
+ {
+ CDS_UNUSED( pred );
return find_at( head(), key, typename maker::template less_wrapper<Less>::type(), f );
}
+ //@endcond
/// Finds the key \p key and return the item found
/** \anchor cds_nonintrusive_LazyList_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 item found as \p guarded_ptr.
+ 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.
ord_list theList;
// ...
{
- ord_list::guarded_ptr gp;
- if ( theList.get( gp, 5 )) {
+ ord_list::guarded_ptr gp( theList.get( 5 ));
+ if ( gp ) {
// Deal with gp
//...
}
should accept a parameter of type \p Q that can be not the same as \p value_type.
*/
template <typename Q>
- bool get( guarded_ptr& ptr, Q const& key )
+ guarded_ptr get( Q const& key )
{
- return get_at( head(), ptr.guard(), key, intrusive_key_comparator() );
+ guarded_ptr gp;
+ get_at( head(), gp.guard(), key, intrusive_key_comparator() );
+ return gp;
}
/// Finds the key \p key and return the item found
/**
- The function is an analog of \ref cds_nonintrusive_LazyList_hp_get "get( guarded_ptr& ptr, Q const&)"
+ The function is an analog of \ref cds_nonintrusive_LazyList_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
\p pred must imply the same element order as the comparator used for building the list.
*/
template <typename Q, typename Less>
- bool get_with( guarded_ptr& ptr, Q const& key, Less pred )
+ guarded_ptr get_with( Q const& key, Less pred )
{
- return get_at( head(), ptr.guard(), key, typename maker::template less_wrapper<Less>::type() );
+ CDS_UNUSED( pred );
+ guarded_ptr gp;
+ get_at( head(), gp.guard(), key, typename maker::template less_wrapper<Less>::type() );
+ return gp;
}
/// Checks whether the list is empty
}
template <typename Q, typename Compare>
- bool extract_at( head_type& refHead, typename gc::Guard& dest, Q const& key, Compare cmp )
+ bool extract_at( head_type& refHead, typename guarded_ptr::native_guard& guard, Q const& key, Compare cmp )
{
- return base_class::extract_at( &refHead, dest, key, cmp );
+ return base_class::extract_at( &refHead, guard, key, cmp );
}
template <typename Q, typename Func>
}
template <typename Q, typename Compare>
- bool get_at( head_type& refHead, typename gc::Guard& guard, Q const& key, Compare cmp )
+ bool get_at( head_type& refHead, typename guarded_ptr::native_guard& guard, Q const& key, Compare cmp )
{
return base_class::get_at( &refHead, guard, key, cmp );
}
projects / libcds.git / blobdiff