-//$$CDS-header$$
+/*
+ This file is a part of libcds - Concurrent Data Structures library
+
+ (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016
+
+ Source code repo: http://github.com/khizmax/libcds/
+ Download: http://sourceforge.net/projects/libcds/files/
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
#ifndef CDSLIB_CONTAINER_SPLIT_LIST_SET_H
#define CDSLIB_CONTAINER_SPLIT_LIST_SET_H
You may use the modern option-based declaration instead of classic traits-based one:
\code
- typedef cc:SplitListSet<
+ typedef cc::SplitListSet<
cs::gc::DHP // GC used
,foo // type of data stored
,cc::split_list::make_traits< // metafunction to build split-list traits
typedef typename base_class::item_counter item_counter; ///< Item counter type
typedef typename base_class::stat stat; ///< Internal statistics
+ /// Count of hazard pointer required
+ static CDS_CONSTEXPR const size_t c_nHazardPtrCount = base_class::c_nHazardPtrCount;
+
protected:
//@cond
typedef typename maker::cxx_node_allocator cxx_node_allocator;
assert( pNode != nullptr );
scoped_node_ptr p(pNode);
- if ( base_class::insert( *pNode ) ) {
+ if ( base_class::insert( *pNode )) {
p.release();
return true;
}
//@endcond
protected:
- /// Forward iterator
- /**
- \p IsConst - constness boolean flag
-
- The forward iterator for a split-list has the following features:
- - it has no post-increment operator
- - it depends on underlying ordered list iterator
- - The iterator object 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
- deleting operations it is no guarantee that you iterate all item in the split-list.
-
- Therefore, the use of iterators in concurrent environment is not good idea. Use it for debug purpose only.
- */
+ //@cond
template <bool IsConst>
class iterator_type: protected base_class::template iterator_type<IsConst>
{
- //@cond
typedef typename base_class::template iterator_type<IsConst> iterator_base_class;
friend class SplitListSet;
- //@endcond
+
public:
/// Value pointer type (const for const iterator)
typedef typename cds::details::make_const_type<value_type, IsConst>::pointer value_ptr;
{}
protected:
- //@cond
explicit iterator_type( iterator_base_class const& src )
: iterator_base_class( src )
{}
- //@endcond
public:
/// Dereference operator
return iterator_base_class::operator!=(i);
}
};
+ //@endcond
public:
/// Initializes split-ordered list of default capacity
{}
public:
+ ///@name Forward iterators (only for debugging purpose)
+ //@{
/// Forward iterator
+ /**
+ The forward iterator for a split-list has the following features:
+ - it has no post-increment operator
+ - it depends on underlying ordered list iterator
+ - The iterator object cannot be moved across thread boundary because 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
+ deleting operations it is no guarantee that you iterate all item in the split-list.
+ Moreover, a crash is possible when you try to iterate the next element that has been deleted by concurrent thread.
+
+ @warning Use this iterator on the concurrent container for debugging purpose only.
+
+ The iterator interface:
+ \code
+ class iterator {
+ public:
+ // Default constructor
+ iterator();
+
+ // Copy construtor
+ iterator( iterator const& src );
+
+ // Dereference operator
+ value_type * operator ->() const;
+
+ // Dereference operator
+ value_type& operator *() const;
+
+ // Preincrement operator
+ iterator& operator ++();
+
+ // Assignment operator
+ iterator& operator = (iterator const& src);
+
+ // Equality operators
+ bool operator ==(iterator const& i ) const;
+ bool operator !=(iterator const& i ) const;
+ };
+ \endcode
+ */
typedef iterator_type<false> iterator;
/// Const forward iterator
*/
iterator begin()
{
- return iterator( base_class::begin() );
+ return iterator( base_class::begin());
}
/// Returns an iterator that addresses the location succeeding the last element in a set
*/
iterator end()
{
- return iterator( base_class::end() );
+ return iterator( base_class::end());
}
/// Returns a forward const iterator addressing the first element in a set
/// Returns a forward const iterator addressing the first element in a set
const_iterator cbegin() const
{
- return const_iterator( base_class::cbegin() );
+ return const_iterator( base_class::cbegin());
}
/// Returns an const iterator that addresses the location succeeding the last element in a set
/// 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() );
+ return const_iterator( base_class::cend());
}
+ //@}
public:
/// Inserts new node
template <typename Q>
bool insert( Q const& val )
{
- return insert_node( alloc_node( val ) );
+ return insert_node( alloc_node( val ));
}
/// Inserts new node
return insert_node( alloc_node( std::forward<Args>(args)...));
}
- /// Ensures that the \p item exists in the set
+ /// Updates the node
/**
The operation performs inserting or changing data with lock-free manner.
- If the \p val key not found in the set, then the new item created from \p val
- is inserted into the set. Otherwise, the functor \p func is called with the item found.
- The functor \p Func should be a function with signature:
- \code
- void func( bool bNew, value_type& item, const Q& val );
- \endcode
- or a functor:
+ If \p key is not found in the set, then \p key is inserted iff \p bAllowInsert is \p true.
+ Otherwise, the functor \p func is called with item found.
+
+ The functor signature is:
\code
struct my_functor {
void operator()( bool bNew, value_type& item, const Q& val );
};
\endcode
-
with arguments:
- \p bNew - \p true if the item has been inserted, \p false otherwise
- \p item - item of the set
- - \p val - argument \p val passed into the \p ensure function
+ - \p val - argument \p val passed into the \p %update() function
The functor may change non-key fields of the \p item.
- Returns <tt> std::pair<bool, bool> </tt> where \p first is true if operation is successfull,
+ Returns <tt> std::pair<bool, bool> </tt> where \p first is true if operation is successful,
\p second is true if new item has been added or \p false if the item with \p key
- already is in the set.
+ already is in the map.
@warning For \ref cds_intrusive_MichaelList_hp "MichaelList" as the bucket see \ref cds_intrusive_item_creating "insert item troubleshooting".
\ref cds_intrusive_LazyList_hp "LazyList" provides exclusive access to inserted item and does not require any node-level
synchronization.
*/
template <typename Q, typename Func>
- std::pair<bool, bool> ensure( Q const& val, Func func )
+ std::pair<bool, bool> update( Q const& val, Func func, bool bAllowInsert = true )
{
scoped_node_ptr pNode( alloc_node( val ));
- std::pair<bool, bool> bRet = base_class::ensure( *pNode,
+ std::pair<bool, bool> bRet = base_class::update( *pNode,
[&func, &val]( bool bNew, node_type& item, node_type const& /*val*/ ) {
func( bNew, item.m_Value, val );
- } );
+ }, bAllowInsert );
if ( bRet.first && bRet.second )
pNode.release();
return bRet;
}
+ //@cond
+ template <typename Q, typename Func>
+ CDS_DEPRECATED("ensure() is deprecated, use update()")
+ std::pair<bool, bool> ensure( Q const& val, Func func )
+ {
+ return update( val, func, true );
+ }
+ //@endcond
/// Deletes \p key from the set
/** \anchor cds_nonintrusive_SplitListSet_erase_val
bool erase_with( Q const& key, Less pred )
{
CDS_UNUSED( pred );
- return base_class::erase_with( key, typename maker::template predicate_wrapper<Less>::type() );
+ return base_class::erase_with( key, typename maker::template predicate_wrapper<Less>::type());
}
/// Deletes \p key from the set
}
//@endcond
- /// Finds the key \p key
- /** \anchor cds_nonintrusive_SplitListSet_find_val
-
+ /// Checks whether the set contains \p key
+ /**
The function searches the item with key equal to \p key
and returns \p true if it is found, and \p false otherwise.
Note the hash functor specified for class \p Traits template parameter
- should accept a parameter of type \p Q that can be not the same as \ref value_type.
+ should accept a parameter of type \p Q that can be not the same as \p value_type.
+ Otherwise, you may use \p contains( Q const&, Less pred ) functions with explicit predicate for key comparing.
*/
template <typename Q>
+ bool contains( Q const& key )
+ {
+ return base_class::contains( key );
+ }
+ //@cond
+ template <typename Q>
+ CDS_DEPRECATED("deprecated, use contains()")
bool find( Q const& key )
{
- return base_class::find( key );
+ return contains( key );
}
+ //@endcond
- /// Finds the key \p key using \p pred predicate for searching
+ /// Checks whether the map contains \p key using \p pred predicate for searching
/**
- The function is an analog of \ref cds_nonintrusive_SplitListSet_find_val "find(Q const&)"
- but \p pred is used for key comparing.
+ The function is similar to <tt>contains( key )</tt> but \p pred is used for key comparing.
\p Less functor has the interface like \p std::less.
- \p Less must imply the same element order as the comparator used for building the set.
+ \p Less must imply the same element order as the comparator used for building the map.
*/
template <typename Q, typename Less>
- bool find_with( Q const& key, Less pred )
+ bool contains( Q const& key, Less pred )
{
CDS_UNUSED( pred );
- return base_class::find_with( key, typename maker::template predicate_wrapper<Less>::type() );
+ return base_class::contains( key, typename maker::template predicate_wrapper<Less>::type());
}
+ //@cond
+ template <typename Q, typename Less>
+ CDS_DEPRECATED("deprecated, use contains()")
+ bool find_with( Q const& key, Less pred )
+ {
+ return contains( key, pred );
+ }
+ //@endcond
/// Finds the key \p key and return the item found
/** \anchor cds_nonintrusive_SplitListSet_hp_get
bool extract_with_( typename guarded_ptr::native_guard& guard, Q const& key, Less pred )
{
CDS_UNUSED( pred );
- return base_class::extract_with_( guard, key, typename maker::template predicate_wrapper<Less>::type() );
+ return base_class::extract_with_( guard, key, typename maker::template predicate_wrapper<Less>::type());
}
template <typename Q, typename Less>
bool get_with_( typename guarded_ptr::native_guard& guard, Q const& key, Less pred )
{
CDS_UNUSED( pred );
- return base_class::get_with_( guard, key, typename maker::template predicate_wrapper<Less>::type() );
+ return base_class::get_with_( guard, key, typename maker::template predicate_wrapper<Less>::type());
}
//@endcond
projects / libcds.git / blobdiff