//$$CDS-header$$
-#ifndef __CDS_CONTAINER_IMPL_MICHAEL_LIST_H
-#define __CDS_CONTAINER_IMPL_MICHAEL_LIST_H
+#ifndef CDSLIB_CONTAINER_IMPL_MICHAEL_LIST_H
+#define CDSLIB_CONTAINER_IMPL_MICHAEL_LIST_H
#include <memory>
#include <cds/container/details/guarded_ptr_cast.h>
\anchor cds_nonintrusive_MichaelList_gc
Usually, ordered single-linked list is used as a building block for the hash table implementation.
- The complexity of searching is <tt>O(N)</tt>, where \p N is the item count in the list, not in the
+ The complexity of searching is <tt>O(N)</tt>, where \p N is the item count in the list, not in the
hash table.
Source:
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
The forward iterator for Michael's list has some features:
- it has no post-increment operator
- to protect the value, the iterator contains a GC-specific guard + another guard is required locally for increment operator.
- For some GC (gc::HP, gc::HRC), a guard is limited resource per thread, so an exception (or assertion) "no free guard"
+ For some GC (\p gc::HP), a guard is limited resource per thread, so an exception (or assertion) "no free guard"
may be thrown if a limit of guard count per thread is exceeded.
- The iterator cannot be moved across thread boundary since it contains GC's guard that is thread-private GC data.
- Iterator ensures thread-safety even if you delete the item that iterator points to. However, in case of concurrent
{
return const_iterator( head() );
}
- const_iterator cbegin()
+ const_iterator cbegin() const
{
return const_iterator( head() );
}
{
return const_iterator();
}
- const_iterator cend()
+ const_iterator cend() const
{
return const_iterator();
}
The method can be useful if complete initialization of object of \p value_type is heavyweight and
it is preferable that the initialization should be completed only if inserting is successful.
+
+ @warning See \ref cds_intrusive_item_creating "insert item troubleshooting"
*/
template <typename Q, typename Func>
bool insert( Q const& key, Func func )
Returns <tt> std::pair<bool, bool> </tt> where \p first is true if operation is successfull,
\p second is true if new item has been added or \p false if the item with \p key
already is in the list.
+
+ @warning See \ref cds_intrusive_item_creating "insert item troubleshooting"
*/
template <typename Q, typename Func>
std::pair<bool, bool> ensure( Q const& key, Func func )
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&){} );
}
void operator()(const value_type& val) { ... }
};
\endcode
- The functor may be passed by reference with <tt>boost:ref</tt>
Since the key of MichaelList's item type \p value_type is not explicitly specified,
template parameter \p Q should contain the complete key to search in the list.
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_MichaelList_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_MichaelList_hp_extract "extract(guarded_ptr&, Q const&)"
+ The function is an analog of \ref cds_nonintrusive_MichaelList_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 it should accept arguments of type \p 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 \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() );
}
{
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 \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 \p key and return the item found
/** \anchor cds_nonintrusive_MichaelList_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 it 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 \p key and return the item found
/**
- The function is an analog of \ref cds_nonintrusive_MichaelList_hp_get "get( guarded_ptr& ptr, Q const&)"
+ The function is an analog of \ref cds_nonintrusive_MichaelList_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 accept arguments of type \p 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;
}
/// Check if 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 );
}
}} // namespace cds::container
-#endif // #ifndef __CDS_CONTAINER_IMPL_MICHAEL_LIST_H
+#endif // #ifndef CDSLIB_CONTAINER_IMPL_MICHAEL_LIST_H