/// Updates the item
/**
- If \p key is not in the list and \p bAllowInsert is \p true,
- the function inserts a new item.
+ If \p key is not in the map and \p bAllowInsert is \p true, the function inserts a new item.
Otherwise, the function returns an iterator pointing to the item found.
Returns <tt> std::pair<iterator, bool> </tt> where \p first is an iterator pointing to
- item found or inserted, \p second is true if new item has been added or \p false if the item
- already is in the list.
+ item found or inserted (if inserting is not allowed and \p key is not found, the iterator will be \p end()),
+ \p second is true if new item has been added or \p false if the item
+ already is in the map.
@warning For \ref cds_nonintrusive_MichaelKVList_nogc "MichaelKVList" as the bucket see \ref cds_intrusive_item_creating "insert item troubleshooting".
\ref cds_nonintrusive_LazyKVList_nogc "LazyKVList" provides exclusive access to inserted item and does not require any node-level
return base_class::emplace( std::forward<K>(key), std::move(mapped_type(std::forward<Args>(args)...)));
}
- /// Ensures that the \p key exists in the map
+ /// Updates the node
/**
The operation performs inserting or changing data with lock-free manner.
- If the \p key not found in the map, then the new item created from \p key
- is inserted into the map (note that in this case the \ref key_type should be
- constructible from type \p K).
+ If \p key is not found in the map, then \p key is inserted iff \p bAllowInsert is \p true.
Otherwise, the functor \p func is called with item found.
- The functor \p Func may be a function with signature:
- \code
- void func( bool bNew, value_type& item );
- \endcode
- or a functor:
+
+ The functor signature is:
\code
struct my_functor {
void operator()( bool bNew, value_type& item );
with arguments:
- \p bNew - \p true if the item has been inserted, \p false otherwise
- - \p item - item of the list
+ - \p item - item of the map
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.
+ already is in the map.
@warning For \ref cds_nonintrusive_MichaelKVList_gc "MichaelKVList" as the ordered list see \ref cds_intrusive_item_creating "insert item troubleshooting".
\ref cds_nonintrusive_LazyKVList_gc "LazyKVList" provides exclusive access to inserted item and does not require any node-level
synchronization.
*/
template <typename K, typename Func>
- std::pair<bool, bool> ensure( K const& key, Func func )
+ std::pair<bool, bool> update( K const& key, Func func, bool bAllowInsert = true )
{
//TODO: pass arguments by reference (make_pair makes copy)
- return base_class::ensure( std::make_pair( key, mapped_type() ),
+ return base_class::update( std::make_pair( key, mapped_type() ),
[&func](bool bNew, value_type& item, value_type const& /*val*/) {
func( bNew, item );
- } );
+ },
+ bAllowInsert );
+ }
+ //@cond
+ // Deprecated, use update()
+ template <typename K, typename Func>
+ std::pair<bool, bool> ensure( K const& key, Func func )
+ {
+ return update( key, func, true );
}
+ //@endcond
/// Deletes \p key from the map
/** \anchor cds_nonintrusive_SplitListMap_erase_val
[&f](value_type& pair, K const&){ f( pair ); } );
}
- /// Finds the key \p key
- /** \anchor cds_nonintrusive_SplitListMap_find_val
-
+ /// Checks whether the map 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 \p value_type.
+ Otherwise, you may use \p contains( Q const&, Less pred ) functions with explicit predicate for key comparing.
*/
template <typename K>
+ bool contains( K const& key )
+ {
+ return base_class::contains( key );
+ }
+ //@cond
+ // Deprecated, use contains()
+ template <typename K>
bool find( K const& key )
{
- return base_class::find( key );
+ return contains( key );
}
+ //@endcond
- /// Finds the key \p val 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_SplitListMap_find_val "find(K 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 map.
*/
template <typename K, typename Less>
- bool find_with( K const& key, Less pred )
+ bool contains( K const& key, Less pred )
{
CDS_UNUSED( pred );
- return base_class::find( key, cds::details::predicate_wrapper<value_type, Less, key_accessor>() );
+ return base_class::contains( key, cds::details::predicate_wrapper<value_type, Less, key_accessor>() );
}
+ //@cond
+ // Deprecated, use contains()
+ template <typename K, typename Less>
+ bool find_with( K const& key, Less pred )
+ {
+ return contains( key, pred );
+ }
+ //@endcond
/// Finds \p key and return the item found
/** \anchor cds_nonintrusive_SplitListMap_hp_get
return base_class::emplace( std::forward<K>(key), std::move(mapped_type(std::forward<Args>(args)...)));
}
- /// Ensures that the key \p key exists in the map
+ /// Updates the item
/**
- The operation inserts new item if the key \p key is not found in the map.
- Otherwise, the function returns an iterator that points to item found.
+ If \p key is not in the map and \p bAllowInsert is \p true, the function inserts a new item.
+ Otherwise, the function returns an iterator pointing to the item found.
- Returns <tt> std::pair<iterator, bool> </tt> where \p first is an iterator pointing to
- item found or inserted, \p second is true if new item has been added or \p false if the item
- already is in the list.
+ Returns <tt> std::pair<iterator, bool> </tt> where \p first is an iterator pointing to
+ item found or inserted (if inserting is not allowed and \p key is not found, the iterator will be \p end()),
+ \p second is true if new item has been added or \p false if the item
+ already is in the map.
*/
template <typename K>
- std::pair<iterator, bool> ensure( K const& key )
+ std::pair<iterator, bool> update( K const& key, bool bAllowInsert = true )
{
//TODO: pass arguments by reference (make_pair makes copy)
- return base_class::ensure( std::make_pair( key, mapped_type() ));
+ return base_class::update( std::make_pair( key, mapped_type() ), bAllowInsert );
}
+ //@cond
+ // Deprecated, use update()
+ template <typename K>
+ std::pair<iterator, bool> ensure( K const& key )
+ {
+ return update( key, true );
+ }
+ //@endcond
- /// Find the key \p key
- /** \anchor cds_nonintrusive_SplitListMap_nogc_find
-
+ /// Checks whether the map contains \p key
+ /**
The function searches the item with key equal to \p key
- and returns an iterator pointed to item found if the key is found,
- and \p end() otherwise
+ and returns an iterator pointed to item found and \ref end() otherwise
*/
template <typename K>
+ iterator contains( K const& key )
+ {
+ return base_class::contains( key );
+ }
+ //@cond
+ // Deprecated, use contains()
+ template <typename K>
iterator find( K 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_SplitListMap_nogc_find "find(K const&)"
- but \p pred is used for key comparing.
+ The function is an analog of <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 map.
+ \p pred must imply the same element order as the comparator used for building the map.
*/
template <typename K, typename Less>
- iterator find_with( K const& key, Less pred )
+ iterator contains( K const& key, Less pred )
{
CDS_UNUSED( pred );
- return base_class::find_with( key, cds::details::predicate_wrapper<value_type, Less, key_accessor>() );
+ return base_class::contains( key, cds::details::predicate_wrapper<value_type, Less, key_accessor>() );
+ }
+ //@cond
+ // Deprecated, use contains()
+ template <typename K, typename Less>
+ iterator find_with( K const& key, Less pred )
+ {
+ return contains( key, pred );
}
+ //@endcond
/// Checks if the map is empty
/**
return base_class::emplace( std::forward<K>(key), std::move(mapped_type(std::forward<Args>(args)...)));
}
- /// Ensures that the \p key exists in the map
+ /// Updates data by \p key
/**
- The operation performs inserting or changing data with lock-free manner.
+ The operation performs inserting or replacing the element with lock-free manner.
If the \p key not found in the map, then the new item created from \p key
- is inserted into the map; in this case the \p key_type should be
- constructible from type \p K.
- Otherwise, the functor \p func is called with item found.
+ will be inserted into the map iff \p bAllowInsert is \p true.
+ (note that in this case the \ref key_type should be constructible from type \p K).
+ Otherwise, if \p key is found, the functor \p func is called with item found.
+
The functor \p Func signature is:
\code
struct my_functor {
\endcode
with arguments:
- \p bNew - \p true if the item has been inserted, \p false otherwise
- - \p item - item of the list
+ - \p item - the item found or inserted
- The functor may change any fields of the \p item.second that is \p mapped_type;
- however, \p func must guarantee that during changing no any other modifications
- could be made on this item by concurrent threads.
+ The functor may change any fields of the \p item.second that is \p mapped_type.
The function applies RCU lock internally.
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.
+ already exists.
@warning For \ref cds_nonintrusive_MichaelKVList_gc "MichaelKVList" as the ordered list see \ref cds_intrusive_item_creating "insert item troubleshooting".
\ref cds_nonintrusive_LazyKVList_gc "LazyKVList" provides exclusive access to inserted item and does not require any node-level
synchronization.
*/
template <typename K, typename Func>
- std::pair<bool, bool> ensure( K const& key, Func func )
+ std::pair<bool, bool> update( K const& key, Func func, bool bAllowInsert = true )
{
//TODO: pass arguments by reference (make_pair makes copy)
- return base_class::ensure( std::make_pair( key, mapped_type() ),
+ return base_class::update( std::make_pair( key, mapped_type() ),
[&func](bool bNew, value_type& item, value_type const& /*val*/) {
func( bNew, item );
- } );
+ },
+ bAllowInsert );
+ }
+ //@cond
+ // Deprecated, use update()
+ template <typename K, typename Func>
+ std::pair<bool, bool> ensure( K const& key, Func func )
+ {
+ return update( key, func, true );
}
+ //@endcond
/// Deletes \p key from the map
/** \anchor cds_nonintrusive_SplitListMap_rcu_erase_val
[&f](value_type& pair, K const&){ f( pair ); } );
}
- /// Finds the key \p key
- /** \anchor cds_nonintrusive_SplitListMap_rcu_find_val
-
+ /// Checks whether the map 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.
The function applies RCU lock internally.
*/
template <typename K>
+ bool contains( K const& key )
+ {
+ return base_class::contains( key );
+ }
+ //@cond
+ // Deprecated, use contains()
+ template <typename K>
bool find( K const& key )
{
return base_class::find( 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_SplitListMap_rcu_find_val "find(K const&)"
- but \p pred is used for key comparing.
+ The function is an analog of <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 map.
*/
template <typename K, typename Less>
- bool find_with( K const& key, Less pred )
+ bool contains( K const& key, Less pred )
{
CDS_UNUSED( pred );
- return base_class::find_with( key, cds::details::predicate_wrapper<value_type, Less, key_accessor>() );
+ return base_class::contains( key, cds::details::predicate_wrapper<value_type, Less, key_accessor>() );
}
+ //@cond
+ // Deprecated, use contains()
+ template <typename K, typename Less>
+ bool find_with( K const& key, Less pred )
+ {
+ return contains( key, pred );
+ }
+ //@endcond
/// Finds \p key and return the item found
/** \anchor cds_intrusive_SplitListMap_rcu_get
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 );
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,
\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
+ // Deprecated, use update()
+ template <typename Q, typename Func>
+ 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
}
//@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
+ // Deprecated, use contains()
+ template <typename Q>
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
+ // Deprecated, use contains()
+ template <typename Q, typename Less>
+ 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
return insert_node( alloc_node( std::forward<Args>(args)... ) );
}
- /// Ensures that the item \p val exists in the set
+ /// Updates the item
/**
- The operation inserts new item created from \p val if the key \p val is not found in the set.
- Otherwise, the function returns an iterator that points to item found.
- The \p value_type should be constructible from a value of type \p Q.
+ If \p key is not in the set and \p bAllowInsert is \p true, the function inserts a new item.
+ Otherwise, the function returns an iterator pointing to the item found.
Returns <tt> std::pair<iterator, bool> </tt> where \p first is an iterator pointing to
- item found or inserted, \p second is true if new item has been added or \p false if the item
+ item found or inserted (if inserting is not allowed and \p key is not found, the iterator will be \p end()),
+ \p second is true if new item has been added or \p false if the item
already is in the set.
+
+ @warning If the set is based on \ref cds_nonintrusive_MichaelList_nogc "MichaelList",
+ see \ref cds_intrusive_item_creating "insert item troubleshooting".
+ \ref cds_nonintrusive_LazyList_nogc "LazyList" as the base provides exclusive access to inserted item
+ and does not require any node-level synchronization.
*/
template <typename Q>
- std::pair<iterator, bool> ensure( const Q& val )
+ std::pair<iterator, bool> update( Q const& key, bool bAllowInsert = true )
{
- scoped_node_ptr pNode( alloc_node( val ));
+ scoped_node_ptr pNode( alloc_node( key ));
- std::pair<typename base_class::iterator, bool> ret = base_class::ensure_( *pNode, [](bool /*bNew*/, node_type& /*item*/, node_type& /*val*/){} );
+ std::pair<typename base_class::iterator, bool> ret = base_class::update_( *pNode,
+ [](bool /*bNew*/, node_type& /*item*/, node_type& /*val*/){},
+ bAllowInser );
if ( ret.first != base_class::end() && ret.second ) {
pNode.release();
return std::make_pair( iterator(ret.first), ret.second );
return std::make_pair( iterator(ret.first), ret.second );
}
+ //@cond
+ // Deprecated, use update()
+ template <typename Q>
+ std::pair<iterator, bool> ensure( const Q& val )
+ {
+ return update( val, true );
+ }
+ //@endcond
- /// Find the key \p key
- /** \anchor cds_nonintrusive_SplitListSet_nogc_find
-
+ /// Checks whether the set contains \p key
+ /**
The function searches the item with key equal to \p key
- and returns an iterator pointed to item found if the key is found,
- and \ref end() otherwise.
+ and returns an iterator pointed to item found and \ref end() otherwise
*/
template <typename Q>
- iterator find( Q const& key )
+ iterator contains( Q const& key )
{
return iterator( base_class::find_( key ));
}
+ //@cond
+ // Deprecated, use contains()
+ template <typename Q>
+ iterator find( Q const& key )
+ {
+ return contains( key );
+ }
+ //@endcond
- /// Finds the key \p key using \p pred predicate for searching
+ /// Checks whether the set contains \p key using \p pred predicate for searching
/**
- The function is an analog of \ref cds_nonintrusive_SplitListSet_nogc_find "find(Q const&)"
- but \p pred is used for key comparing.
+ The function is an analog of <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 pred must imply the same element order as the comparator used for building the set.
*/
template <typename Q, typename Less>
- iterator find_with( Q const& key, Less pred )
+ iterator contains( Q const& key, Less pred )
{
CDS_UNUSED( pred );
return iterator( base_class::find_with_( key, typename maker::template predicate_wrapper<Less>::type() ));
}
+ //@cond
+ // eprecated, use contains()
+ template <typename Q, typename Less>
+ iterator find_with( Q const& key, Less pred )
+ {
+ return contains( key, pred );
+ }
+ //@endcond
/// Checks if the set is empty
/**
\p second is true if new item has been added or \p false if the item with \p key
already is in the set.
*/
+ /// Updates the node
+ /**
+ The operation performs inserting or changing data with lock-free manner.
+
+ 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 %update() function
+
+ The functor may change non-key fields of the \p item.
+
+ The function applies RCU lock internally.
+
+ 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 map.
+
+ @warning For \ref cds_intrusive_MichaelList_rcu "MichaelList" as the bucket see \ref cds_intrusive_item_creating "insert item troubleshooting".
+ \ref cds_intrusive_LazyList_rcu "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
+ // Dprecated, use update()
+ template <typename Q, typename Func>
+ 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_rcu_erase_val
}
//@endcond
- /// Finds the key \p key
- /** \anchor cds_nonintrusive_SplitListSet_rcu_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 \p value_type.
+ Otherwise, you may use \p contains( Q const&, Less pred ) functions with explicit predicate for key comparing.
- The function makes RCU lock internally.
+ The function applies RCU lock internally.
*/
template <typename Q>
+ bool contains( Q const& key )
+ {
+ return base_class::contains( key );
+ }
+ //@cond
+ // Deprecated, use contains()
+ template <typename Q>
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_rcu_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
+ // Deprecated, use contains()
+ template <typename Q, typename Less>
+ 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_rcu_get
}
//@endcond
- /// Checks whether the map contains \p key using \p pred predicate for searching
+ /// Checks whether the list contains \p key using \p pred predicate for searching
/**
The function is an analog of <tt>contains( key )</tt> but \p pred is used for key comparing.
\p Less functor has the interface like \p std::less.
}
template <typename Func>
- std::pair<bool, bool> ensure_at( dummy_node_type * pHead, value_type& val, Func func )
+ std::pair<bool, bool> update_at( dummy_node_type * pHead, value_type& val, Func func, bool bAllowInsert )
{
assert( pHead != nullptr );
bucket_head_type h(pHead);
- return base_class::ensure_at( h, val, func );
+ return base_class::update_at( h, val, func, bAllowInsert );
}
bool unlink_at( dummy_node_type * pHead, value_type& val )
return false;
}
- /// Ensures that the \p val exists in the set
+ /// Updates the node
/**
The operation performs inserting or changing data with lock-free manner.
- If the item \p val is not found in the set, then \p val is inserted into the set.
+ If the item \p val is not found in the set, then \p val is inserted
+ iff \p bAllowInsert is \p true.
Otherwise, the functor \p func is called with item found.
The functor signature is:
\code
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
If new item has been inserted (i.e. \p bNew is \p true) then \p item and \p val arguments
refers to the same thing.
- The functor can change non-key fields of the \p item.
+ The functor may change non-key fields of the \p item.
Returns std::pair<bool, bool> where \p first is \p true if operation is successfull,
\p second is \p 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 list.
@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 Func>
- std::pair<bool, bool> ensure( value_type& val, Func func )
+ std::pair<bool, bool> update( value_type& val, Func func, bool bAllowInsert = true )
{
size_t nHash = hash_value( val );
dummy_node_type * pHead = get_bucket( nHash );
node_traits::to_node_ptr( val )->m_nHash = split_list::regular_hash( nHash );
- std::pair<bool, bool> bRet = m_List.ensure_at( pHead, val, func );
+ std::pair<bool, bool> bRet = m_List.update_at( pHead, val, func, bAllowInsert );
if ( bRet.first && bRet.second ) {
inc_item_count();
m_Stat.onEnsureNew();
m_Stat.onEnsureExist();
return bRet;
}
+ //@cond
+ // Deprecated, use update()
+ template <typename Func>
+ std::pair<bool, bool> ensure( value_type& val, Func func )
+ {
+ return update( val, func, true );
+ }
+ //@endcond
/// Unlinks the item \p val from the set
/**
}
//@endcond
- /// Finds the key \p key
- /** \anchor cds_intrusive_SplitListSet_hp_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 \p value_type.
- Otherwise, you may use \p find_with functions with explicit predicate for key comparing.
+ Otherwise, you may use \p contains( Q const&, Less pred ) functions with explicit predicate for key comparing.
*/
template <typename Q>
- bool find( Q const& key )
+ bool contains( Q const& key )
{
return find_( key, key_comparator() );
}
+ //@cond
+ // Deprecated, use contains()
+ template <typename Q>
+ bool find( Q const& key )
+ {
+ return contains( key );
+ }
+ //@endcond
- /// Finds the key \p key with \p pred predicate for comparing
+ /// Checks whether the set contains \p key using \p pred predicate for searching
/**
- The function is an analog of \ref cds_intrusive_SplitListSet_hp_find_val "find(Q const&)"
- but \p cmp is used for key compare.
- \p Less has the interface like \p std::less.
- \p cmp must imply the same element order as the comparator used for building the set.
+ The function is an analog of <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.
*/
template <typename Q, typename Less>
- bool find_with( Q const& key, Less pred )
+ bool contains( Q const& key, Less pred )
{
CDS_UNUSED( pred );
return find_( key, typename wrapped_ordered_list::template make_compare_from_less<Less>() );
}
+ //@cond
+ // Deprecated, use contains()
+ template <typename Q, typename Less>
+ 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_intrusive_SplitListSet_hp_get
}
template <typename Func>
- std::pair<list_iterator, bool> ensure_at_( dummy_node_type * pHead, value_type& val, Func func )
+ std::pair<list_iterator, bool> update_at_( dummy_node_type * pHead, value_type& val, Func func, bool bAllowInsert )
{
assert( pHead != nullptr );
bucket_head_type h(static_cast<list_node_type *>(pHead));
- return base_class::ensure_at_( h, val, func );
+ return base_class::update_at_( h, val, func, bAllowInsert );
}
template <typename Q, typename Compare, typename Func>
return insert_( val ) != end();
}
- /// 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 item \p val not found in the set, then \p val is inserted into the set.
+ If the item \p val is not found in the set, then \p val is inserted
+ iff \p bAllowInsert is \p true.
Otherwise, the functor \p func is called with item found.
The functor signature is:
\code
- struct ensure_functor {
- void operator()( bool bNew, value_type& item, value_type& val );
- };
+ void func( bool bNew, value_type& item, value_type& 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
If new item has been inserted (i.e. \p bNew is \p true) then \p item and \p val arguments
refers to the same thing.
- The functor can change non-key fields of the \p item.
+ The functor may change non-key fields of the \p item.
Returns std::pair<bool, bool> where \p first is \p true if operation is successfull,
- \p second is \p true if new item has been added or \p false if the item with given key
- already is in the set.
+ \p second is \p true if new item has been added or \p false if the item with \p key
+ already is in the list.
- @warning For \ref cds_intrusive_MichaelList_nogc "MichaelList" as the bucket see \ref cds_intrusive_item_creating "insert item troubleshooting".
- \ref cds_intrusive_LazyList_nogc "LazyList" provides exclusive access to inserted item and does not require any node-level
+ @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 Func>
- std::pair<bool, bool> ensure( value_type& val, Func func )
+ std::pair<bool, bool> update( value_type& val, Func func, bool bAllowInsert = true )
{
- std::pair<iterator, bool> ret = ensure_( val, func );
+ std::pair<iterator, bool> ret = update_( val, func, bAllowInsert );
return std::make_pair( ret.first != end(), ret.second );
}
+ //@cond
+ // Deprecated, use update()
+ template <typename Func>
+ std::pair<bool, bool> ensure( value_type& val, Func func )
+ {
+ return update( val, func, true );
+ }
+ //@endcond
- /// Finds the key \p key
- /** \anchor cds_intrusive_SplitListSet_nogc_find_val
+ /// Checks whether the set contains \p key
+ /**
The function searches the item with key equal to \p key
- and returns pointer to item found or , and \p nullptr otherwise.
+ 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 \p value_type.
+ Otherwise, you may use \p contains( Q const&, Less pred ) functions with explicit predicate for key comparing.
*/
template <typename Q>
- value_type * find( Q const& key )
+ value_type * contains( Q const& key )
{
iterator it = find_( key );
if ( it == end() )
return nullptr;
return &*it;
}
+ //@cond
+ // Deprecated, use contains()
+ template <typename Q>
+ value_type * find( Q const& key )
+ {
+ return contains( key );
+ }
+ //@endcond
- /// Finds the key \p key with \p pred predicate for comparing
+ /// Checks whether the set contains \p key using \p pred predicate for searching
/**
- The function is an analog of \ref cds_intrusive_SplitListSet_nogc_find_val "find(Q const&)"
- but \p cmp is used for key compare.
- \p Less has the interface like \p std::less.
- \p cmp must imply the same element order as the comparator used for building the set.
+ 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 list.
*/
template <typename Q, typename Less>
- value_type * find_with( Q const& key, Less pred )
+ value_type * contains( Q const& key, Less pred )
{
iterator it = find_with_( key, pred );
if ( it == end() )
return nullptr;
return &*it;
}
+ //@cond
+ // Deprecated, use contains()
+ template <typename Q, typename Less>
+ value_type * find_with( Q const& key, Less pred )
+ {
+ return contains( key, pred );
+ }
+ //@endcond
/// Finds the key \p key
/** \anchor cds_intrusive_SplitListSet_nogc_find_func
}
template <typename Func>
- std::pair<iterator, bool> ensure_( value_type& val, Func func )
+ std::pair<iterator, bool> update_( value_type& val, Func func, bool bAllowInsert )
{
size_t nHash = hash_value( val );
dummy_node_type * pHead = get_bucket( nHash );
node_traits::to_node_ptr( val )->m_nHash = split_list::regular_hash( nHash );
- std::pair<list_iterator, bool> ret = m_List.ensure_at_( pHead, val, func );
+ std::pair<list_iterator, bool> ret = m_List.update_at_( pHead, val, func, bAllowInsert );
if ( ret.first != m_List.end() ) {
if ( ret.second ) {
inc_item_count();
}
template <typename Func>
- std::pair<bool, bool> ensure_at( dummy_node_type * pHead, value_type& val, Func func )
+ std::pair<bool, bool> update_at( dummy_node_type * pHead, value_type& val, Func func, bool bAllowInsert )
{
assert( pHead != nullptr );
bucket_head_type h(pHead);
- return base_class::ensure_at( h, val, func );
+ return base_class::update_at( h, val, func, bAllowInsert );
}
bool unlink_at( dummy_node_type * pHead, value_type& val )
return false;
}
- /// Ensures that the \p val exists in the set
+ /// Updates the node
/**
The operation performs inserting or changing data with lock-free manner.
- If the item \p val is not found in the set, then \p val is inserted into the set.
+ If the item \p val is not found in the set, then \p val is inserted
+ iff \p bAllowInsert is \p true.
Otherwise, the functor \p func is called with item found.
The functor signature is:
\code
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
If new item has been inserted (i.e. \p bNew is \p true) then \p item and \p val arguments
- refers to the same thing.
+ refers to the same stuff.
- The function makes RCU lock internally.
+ The functor may change non-key fields of the \p item.
+
+ The function applies RCU lock internally.
Returns std::pair<bool, bool> where \p first is \p true if operation is successfull,
\p second is \p 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 list.
@warning For \ref cds_intrusive_MichaelList_rcu "MichaelList" as the bucket see \ref cds_intrusive_item_creating "insert item troubleshooting".
\ref cds_intrusive_LazyList_rcu "LazyList" provides exclusive access to inserted item and does not require any node-level
synchronization.
- */
+ */
template <typename Func>
- std::pair<bool, bool> ensure( value_type& val, Func func )
+ std::pair<bool, bool> update( value_type& val, Func func, bool bAllowInsert = true )
{
size_t nHash = hash_value( val );
dummy_node_type * pHead = get_bucket( nHash );
node_traits::to_node_ptr( val )->m_nHash = split_list::regular_hash( nHash );
- std::pair<bool, bool> bRet = m_List.ensure_at( pHead, val, func );
+ std::pair<bool, bool> bRet = m_List.update_at( pHead, val, func, bAllowInsert );
if ( bRet.first && bRet.second ) {
inc_item_count();
m_Stat.onEnsureNew();
m_Stat.onEnsureExist();
return bRet;
}
+ //@cond
+ // Deprecated, use update()
+ template <typename Func>
+ std::pair<bool, bool> ensure( value_type& val, Func func )
+ {
+ return update( val, func, true );
+ }
+ //@endcond
/// Unlinks the item \p val from the set
/**
}
//@endcond
- /// Finds the key \p key
- /** \anchor cds_intrusive_SplitListSet_rcu_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 \p key found or \p false otherwise.
+ 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 \p value_type.
+ Otherwise, you may use \p contains( Q const&, Less pred ) functions with explicit predicate for key comparing.
*/
template <typename Q>
- bool find( Q const& key )
+ bool contains( Q const& key )
{
return find_value( key, key_comparator() );
}
+ //@cond
+ // Deprecated, use contains()
+ template <typename Q>
+ bool find( Q const& key )
+ {
+ return contains( key );
+ }
+ //@endcond
- /// Finds the key \p key with \p pred predicate for comparing
+ /// Checks whether the set contains \p key using \p pred predicate for searching
/**
- The function is an analog of \ref cds_intrusive_SplitListSet_rcu_find_val "find(Q const&)"
- but \p cmp is used for key compare.
- \p Less has the interface like \p std::less.
- \p pred must imply the same element order as the comparator used for building the set.
+ The function is an analog of <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 list.
*/
template <typename Q, typename Less>
- bool find_with( Q const& key, Less pred )
+ bool contains( Q const& key, Less pred )
{
CDS_UNUSED( pred );
return find_value( key, typename wrapped_ordered_list::template make_compare_from_less<Less>() );
}
+ //@cond
+ // Deprecated, use contains()
+ template <typename Q, typename Less>
+ 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_intrusive_SplitListSet_rcu_get
{}
};
//@endcond
+
public:
/// Forward iterator
/**
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='DebugVLD|x64'">true</ExcludedFromBuild>\r
</ClCompile>\r
<ClCompile Include="..\..\..\tests\unit\map2\map_delodd_split.cpp">\r
- <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='DebugVLD|x64'">true</ExcludedFromBuild>\r
+ <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='DebugVLD|x64'">false</ExcludedFromBuild>\r
</ClCompile>\r
</ItemGroup>\r
<ItemGroup>\r
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
# define CDSUNIT_DECLARE_SplitList_RCU_signal \
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_SHB_dyn_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_SHB_dyn_cmp_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_SHB_st_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_SHB_dyn_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_SHB_st_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_SHB_st_less_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_SHT_dyn_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_SHT_dyn_cmp_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_SHT_st_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_SHT_dyn_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_SHT_st_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_SHT_st_less_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_SHB_dyn_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_SHB_dyn_cmp_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_SHB_st_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_SHB_dyn_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_SHB_st_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_SHB_st_less_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_SHT_dyn_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_SHT_dyn_cmp_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_SHT_st_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_SHT_dyn_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_SHT_st_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_SHT_st_less_stat)
-
-# define CDSUNIT_DEFINE_SplitList_RCU_signal( IMPL, C ) \
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_RCU_SHB_dyn_cmp)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_RCU_SHB_dyn_cmp_stat)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_RCU_SHB_st_cmp)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_RCU_SHB_dyn_less)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_RCU_SHB_st_less)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_RCU_SHB_st_less_stat)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_RCU_SHT_dyn_cmp)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_RCU_SHT_dyn_cmp_stat)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_RCU_SHT_st_cmp)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_RCU_SHT_dyn_less)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_RCU_SHT_st_less)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_RCU_SHT_st_less_stat)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_RCU_SHB_dyn_cmp)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_RCU_SHB_dyn_cmp_stat)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_RCU_SHB_st_cmp)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_RCU_SHB_dyn_less)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_RCU_SHB_st_less)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_RCU_SHB_st_less_stat)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_RCU_SHT_dyn_cmp)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_RCU_SHT_dyn_cmp_stat)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_RCU_SHT_st_cmp)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_RCU_SHT_dyn_less)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_RCU_SHT_st_less)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_RCU_SHT_st_less_stat)
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_RCU_SHB_dyn_cmp)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_RCU_SHB_dyn_cmp_stat)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_RCU_SHB_st_cmp)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_RCU_SHB_dyn_less)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_RCU_SHB_st_less)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_RCU_SHB_st_less_stat)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_RCU_SHT_dyn_cmp)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_RCU_SHT_dyn_cmp_stat)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_RCU_SHT_st_cmp)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_RCU_SHT_dyn_less)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_RCU_SHT_st_less)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_RCU_SHT_st_less_stat)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_RCU_SHB_dyn_cmp)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_RCU_SHB_dyn_cmp_stat)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_RCU_SHB_st_cmp)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_RCU_SHB_dyn_less)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_RCU_SHB_st_less)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_RCU_SHB_st_less_stat)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_RCU_SHT_dyn_cmp)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_RCU_SHT_dyn_cmp_stat)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_RCU_SHT_st_cmp)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_RCU_SHT_dyn_less)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_RCU_SHT_st_less)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_RCU_SHT_st_less_stat)
# define CDSUNIT_TEST_SplitList_RCU_signal \
CPPUNIT_TEST(SplitList_Michael_RCU_SHB_dyn_cmp)\
#endif
#define CDSUNIT_DECLARE_SplitList \
- CDSUNIT_DECLARE_TEST(SplitList_Michael_HP_dyn_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_HP_dyn_cmp_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_HP_st_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_HP_dyn_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_HP_st_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_HP_st_less_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_DHP_dyn_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_DHP_dyn_cmp_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_DHP_st_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_DHP_dyn_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_DHP_st_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_DHP_st_less_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPI_dyn_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPI_dyn_cmp_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPI_st_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPI_dyn_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPI_st_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPI_st_less_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPB_dyn_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPB_dyn_cmp_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPB_st_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPB_dyn_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPB_st_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPB_st_less_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPT_dyn_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPT_dyn_cmp_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPT_st_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPT_dyn_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPT_st_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_RCU_GPT_st_less_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_HP_dyn_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_HP_dyn_cmp_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_HP_st_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_HP_dyn_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_HP_st_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_HP_st_less_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_DHP_dyn_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_DHP_dyn_cmp_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_DHP_st_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_DHP_dyn_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_DHP_st_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_DHP_st_less_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPI_dyn_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPI_dyn_cmp_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPI_st_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPI_dyn_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPI_st_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPI_st_less_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPB_dyn_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPB_dyn_cmp_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPB_st_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPB_dyn_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPB_st_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPB_st_less_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPT_dyn_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPT_dyn_cmp_stat)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPT_st_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPT_dyn_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPT_st_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_RCU_GPT_st_less_stat)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_HP_dyn_cmp)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_HP_dyn_cmp_stat)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_HP_st_cmp)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_HP_dyn_less)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_HP_st_less)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_HP_st_less_stat)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_DHP_dyn_cmp)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_DHP_dyn_cmp_stat)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_DHP_st_cmp)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_DHP_dyn_less)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_DHP_st_less)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_DHP_st_less_stat)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_RCU_GPI_dyn_cmp)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_RCU_GPI_dyn_cmp_stat)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_RCU_GPI_st_cmp)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_RCU_GPI_dyn_less)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_RCU_GPI_st_less)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_RCU_GPI_st_less_stat)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_RCU_GPB_dyn_cmp)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_RCU_GPB_dyn_cmp_stat)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_RCU_GPB_st_cmp)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_RCU_GPB_dyn_less)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_RCU_GPB_st_less)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_RCU_GPB_st_less_stat)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_RCU_GPT_dyn_cmp)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_RCU_GPT_dyn_cmp_stat)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_RCU_GPT_st_cmp)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_RCU_GPT_dyn_less)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_RCU_GPT_st_less)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_RCU_GPT_st_less_stat)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_HP_dyn_cmp)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_HP_dyn_cmp_stat)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_HP_st_cmp)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_HP_dyn_less)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_HP_st_less)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_HP_st_less_stat)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_DHP_dyn_cmp)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_DHP_dyn_cmp_stat)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_DHP_st_cmp)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_DHP_dyn_less)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_DHP_st_less)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_DHP_st_less_stat)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_RCU_GPI_dyn_cmp)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_RCU_GPI_dyn_cmp_stat)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_RCU_GPI_st_cmp)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_RCU_GPI_dyn_less)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_RCU_GPI_st_less)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_RCU_GPI_st_less_stat)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_RCU_GPB_dyn_cmp)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_RCU_GPB_dyn_cmp_stat)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_RCU_GPB_st_cmp)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_RCU_GPB_dyn_less)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_RCU_GPB_st_less)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_RCU_GPB_st_less_stat)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_RCU_GPT_dyn_cmp)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_RCU_GPT_dyn_cmp_stat)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_RCU_GPT_st_cmp)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_RCU_GPT_dyn_less)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_RCU_GPT_st_less)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_RCU_GPT_st_less_stat)\
CDSUNIT_DECLARE_SplitList_RCU_signal
-#define CDSUNIT_DEFINE_SplitList( IMPL, C ) \
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_HP_dyn_cmp)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_HP_dyn_cmp_stat)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_HP_st_cmp)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_HP_dyn_less)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_HP_st_less)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_HP_st_less_stat)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_DHP_dyn_cmp)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_DHP_dyn_cmp_stat)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_DHP_st_cmp)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_DHP_dyn_less)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_DHP_st_less)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_DHP_st_less_stat)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_RCU_GPI_dyn_cmp)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_RCU_GPI_dyn_cmp_stat)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_RCU_GPI_st_cmp)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_RCU_GPI_dyn_less)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_RCU_GPI_st_less)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_RCU_GPI_st_less_stat)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_RCU_GPB_dyn_cmp)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_RCU_GPB_dyn_cmp_stat)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_RCU_GPB_st_cmp)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_RCU_GPB_dyn_less)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_RCU_GPB_st_less)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_RCU_GPB_st_less_stat)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_RCU_GPT_dyn_cmp)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_RCU_GPT_dyn_cmp_stat)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_RCU_GPT_st_cmp)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_RCU_GPT_dyn_less)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_RCU_GPT_st_less)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Michael_RCU_GPT_st_less_stat)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_HP_dyn_cmp)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_HP_dyn_cmp_stat)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_HP_st_cmp)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_HP_dyn_less)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_HP_st_less)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_HP_st_less_stat)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_DHP_dyn_cmp)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_DHP_dyn_cmp_stat)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_DHP_st_cmp)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_DHP_dyn_less)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_DHP_st_less)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_DHP_st_less_stat)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_RCU_GPI_dyn_cmp)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_RCU_GPI_dyn_cmp_stat)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_RCU_GPI_st_cmp)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_RCU_GPI_dyn_less)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_RCU_GPI_st_less)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_RCU_GPI_st_less_stat)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_RCU_GPB_dyn_cmp)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_RCU_GPB_dyn_cmp_stat)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_RCU_GPB_st_cmp)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_RCU_GPB_dyn_less)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_RCU_GPB_st_less)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_RCU_GPB_st_less_stat)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_RCU_GPT_dyn_cmp)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_RCU_GPT_dyn_cmp_stat)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_RCU_GPT_st_cmp)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_RCU_GPT_dyn_less)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_RCU_GPT_st_less)\
- TEST_MAP_EXTRACT(IMPL, C, SplitList_Lazy_RCU_GPT_st_less_stat)\
- CDSUNIT_DEFINE_SplitList_RCU_signal( IMPL, C )
-
#define CDSUNIT_TEST_SplitList \
CPPUNIT_TEST(SplitList_Michael_HP_dyn_cmp)\
CPPUNIT_TEST(SplitList_Michael_HP_dyn_cmp_stat)\
CDSUNIT_TEST_SplitList_RCU_signal
#define CDSUNIT_DECLARE_SplitList_nogc \
- CDSUNIT_DECLARE_TEST(SplitList_Michael_NOGC_dyn_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_NOGC_st_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_NOGC_dyn_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Michael_NOGC_st_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_NOGC_dyn_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_NOGC_st_cmp)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_NOGC_dyn_less)\
- CDSUNIT_DECLARE_TEST(SplitList_Lazy_NOGC_st_less)
-
-#define CDSUNIT_DEFINE_SplitList_nogc( IMPL, C ) \
- TEST_MAP(IMPL, C, SplitList_Michael_NOGC_dyn_cmp)\
- TEST_MAP(IMPL, C, SplitList_Michael_NOGC_st_cmp)\
- TEST_MAP(IMPL, C, SplitList_Michael_NOGC_dyn_less)\
- TEST_MAP(IMPL, C, SplitList_Michael_NOGC_st_less)\
- TEST_MAP(IMPL, C, SplitList_Lazy_NOGC_dyn_cmp)\
- TEST_MAP(IMPL, C, SplitList_Lazy_NOGC_st_cmp)\
- TEST_MAP(IMPL, C, SplitList_Lazy_NOGC_dyn_less)\
- TEST_MAP(IMPL, C, SplitList_Lazy_NOGC_st_less)
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_NOGC_dyn_cmp)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_NOGC_st_cmp)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_NOGC_dyn_less)\
+ TEST_CASE(tag_SplitListMap, SplitList_Michael_NOGC_st_less)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_NOGC_dyn_cmp)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_NOGC_st_cmp)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_NOGC_dyn_less)\
+ TEST_CASE(tag_SplitListMap, SplitList_Lazy_NOGC_st_less)
#define CDSUNIT_TEST_SplitList_nogc \
CPPUNIT_TEST(SplitList_Michael_NOGC_dyn_cmp)\
# include "map2/map_defs.h"
CDSUNIT_DECLARE_MichaelMap
+ CDSUNIT_DECLARE_SplitList
// This test is not suitable for MultiLevelHashMap
//CDSUNIT_DECLARE_MultiLevelHashMap
CPPUNIT_TEST_SUITE(Map_DelOdd)
CDSUNIT_TEST_MichaelMap
+ CDSUNIT_TEST_SplitList
//CDSUNIT_TEST_MultiLevelHashMap // the test is not suitable
CPPUNIT_TEST_SUITE_END();
- //CDSUNIT_DECLARE_MichaelMap
- //CDSUNIT_DECLARE_SplitList
////CDSUNIT_DECLARE_StripedMap
////CDSUNIT_DECLARE_RefinableMap
//CDSUNIT_DECLARE_CuckooMap
namespace map2 {
CDSUNIT_DECLARE_MichaelMap
} // namespace map2
-
#include "map2/map_delodd.h"
#include "map2/map_type_split_list.h"
-namespace map2 {
- CDSUNIT_DEFINE_SplitList( cc::split_list::implementation_tag, Map_DelOdd )
+#undef TEST_CASE
+#define TEST_CASE(TAG, X) void Map_DelOdd::X() { run_test<typename map_type< TAG, key_type, value_type>::X>(); }
+#include "map2/map_defs.h"
- CPPUNIT_TEST_SUITE_PART( Map_DelOdd, run_SplitList )
- CDSUNIT_TEST_SplitList
- CPPUNIT_TEST_SUITE_END_PART()
+namespace map2 {
+ CDSUNIT_DECLARE_SplitList
} // namespace map2
namespace map2 {
+ template <class GC, typename Key, typename T, typename Traits = cc::split_list::traits >
+ class SplitListMap : public cc::SplitListMap< GC, Key, T, Traits >
+ {
+ typedef cc::SplitListMap< GC, Key, T, Traits > base_class;
+ public:
+ template <typename Config>
+ SplitListMap( Config const& cfg)
+ : base_class( cfg.c_nMapSize, cfg.c_nLoadFactor )
+ {}
+
+ // for testing
+ static CDS_CONSTEXPR bool const c_bExtractSupported = true;
+ static CDS_CONSTEXPR bool const c_bLoadFactorDepended = true;
+ };
+
+ template <typename Key, typename T, typename Traits >
+ class SplitListMap< cds::gc::nogc, Key, T, Traits> : public cc::SplitListMap< cds::gc::nogc, Key, T, Traits >
+ {
+ typedef cc::SplitListMap< cds::gc::nogc, Key, T, Traits > base_class;
+ public:
+ template <typename Config>
+ SplitListMap( Config const& cfg)
+ : base_class( cfg.c_nMapSize, cfg.c_nLoadFactor )
+ {}
+
+ template <typename K>
+ bool insert( K const& key )
+ {
+ return base_class::insert( key ) != base_class::end();
+ }
+
+ template <typename K, typename V>
+ bool insert( K const& key, V const& val )
+ {
+ return base_class::insert( key, val ) != base_class::end();
+ }
+
+ template <typename K, typename Func>
+ bool insert_with( K const& key, Func func )
+ {
+ return base_class::insert_with( key, func ) != base_class::end();
+ }
+
+ template <typename K>
+ bool find( K const& key )
+ {
+ return base_class::find( key ) != base_class::end();
+ }
+
+ void clear()
+ {}
+
+ // for testing
+ static CDS_CONSTEXPR bool const c_bExtractSupported = true;
+ static CDS_CONSTEXPR bool const c_bLoadFactorDepended = true;
+ };
+
+ struct tag_SplitListMap;
+
template <typename Key, typename Value>
- struct map_type< cc::split_list::implementation_tag, Key, Value >: public map_type_base< Key, Value >
+ struct map_type< tag_SplitListMap, Key, Value >: public map_type_base< Key, Value >
{
typedef map_type_base< Key, Value > base_class;
typedef typename base_class::compare compare;
typedef typename base_class::key_hash key_hash;
typedef typename base_class::hash hash;
- // SplitListMap<gc::nogc> has no clear() method
- template <typename Base>
- class NogcSplitMapWrapper: public Base
- {
- typedef Base base_class;
- public:
- NogcSplitMapWrapper( size_t nMaxItemCount, size_t nLoadFactor )
- : base_class( nMaxItemCount, nLoadFactor )
- {}
-
- template <typename K>
- bool insert( K const& key )
- {
- return base_class::insert( key ) != base_class::end();
- }
-
- template <typename K, typename V>
- bool insert( K const& key, V const& val )
- {
- return base_class::insert( key, val ) != base_class::end();
- }
-
- template <typename K, typename Func>
- bool insert_with( K const& key, Func func )
- {
- return base_class::insert_with( key, func ) != base_class::end();
- }
-
- template <typename K>
- bool find( K const& key )
- {
- return base_class::find( key ) != base_class::end();
- }
-
- void clear()
- {}
- };
-
// ***************************************************************************
// SplitListMap based on MichaelList
>
>::type
{};
- typedef cc::SplitListMap< cds::gc::HP, Key, Value, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_HP_dyn_cmp;
- typedef cc::SplitListMap< cds::gc::DHP, Key, Value, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_DHP_dyn_cmp;
- typedef NogcSplitMapWrapper< cc::SplitListMap< cds::gc::nogc, Key, Value, traits_SplitList_Michael_dyn_cmp >> SplitList_Michael_NOGC_dyn_cmp;
- typedef cc::SplitListMap< rcu_gpi, Key, Value, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_RCU_GPI_dyn_cmp;
- typedef cc::SplitListMap< rcu_gpb, Key, Value, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_RCU_GPB_dyn_cmp;
- typedef cc::SplitListMap< rcu_gpt, Key, Value, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_RCU_GPT_dyn_cmp;
+ typedef SplitListMap< cds::gc::HP, Key, Value, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_HP_dyn_cmp;
+ typedef SplitListMap< cds::gc::DHP, Key, Value, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_DHP_dyn_cmp;
+ typedef SplitListMap< cds::gc::nogc, Key, Value, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_NOGC_dyn_cmp;
+ typedef SplitListMap< rcu_gpi, Key, Value, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_RCU_GPI_dyn_cmp;
+ typedef SplitListMap< rcu_gpb, Key, Value, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_RCU_GPB_dyn_cmp;
+ typedef SplitListMap< rcu_gpt, Key, Value, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_RCU_GPT_dyn_cmp;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SplitListMap< rcu_shb, Key, Value, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_RCU_SHB_dyn_cmp;
- typedef cc::SplitListMap< rcu_sht, Key, Value, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_RCU_SHT_dyn_cmp;
+ typedef SplitListMap< rcu_shb, Key, Value, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_RCU_SHB_dyn_cmp;
+ typedef SplitListMap< rcu_sht, Key, Value, traits_SplitList_Michael_dyn_cmp > SplitList_Michael_RCU_SHT_dyn_cmp;
#endif
struct traits_SplitList_Michael_dyn_cmp_stat : public traits_SplitList_Michael_dyn_cmp
{
typedef cc::split_list::stat<> stat;
};
- typedef cc::SplitListMap< cds::gc::HP, Key, Value, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_HP_dyn_cmp_stat;
- typedef cc::SplitListMap< cds::gc::DHP, Key, Value, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_DHP_dyn_cmp_stat;
- typedef NogcSplitMapWrapper< cc::SplitListMap< cds::gc::nogc, Key, Value, traits_SplitList_Michael_dyn_cmp_stat >> SplitList_Michael_NOGC_dyn_cmp_stat;
- typedef cc::SplitListMap< rcu_gpi, Key, Value, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_RCU_GPI_dyn_cmp_stat;
- typedef cc::SplitListMap< rcu_gpb, Key, Value, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_RCU_GPB_dyn_cmp_stat;
- typedef cc::SplitListMap< rcu_gpt, Key, Value, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_RCU_GPT_dyn_cmp_stat;
+ typedef SplitListMap< cds::gc::HP, Key, Value, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_HP_dyn_cmp_stat;
+ typedef SplitListMap< cds::gc::DHP, Key, Value, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_DHP_dyn_cmp_stat;
+ typedef SplitListMap< cds::gc::nogc, Key, Value, traits_SplitList_Michael_dyn_cmp_stat> SplitList_Michael_NOGC_dyn_cmp_stat;
+ typedef SplitListMap< rcu_gpi, Key, Value, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_RCU_GPI_dyn_cmp_stat;
+ typedef SplitListMap< rcu_gpb, Key, Value, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_RCU_GPB_dyn_cmp_stat;
+ typedef SplitListMap< rcu_gpt, Key, Value, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_RCU_GPT_dyn_cmp_stat;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SplitListMap< rcu_shb, Key, Value, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_RCU_SHB_dyn_cmp_stat;
- typedef cc::SplitListMap< rcu_sht, Key, Value, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_RCU_SHT_dyn_cmp_stat;
+ typedef SplitListMap< rcu_shb, Key, Value, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_RCU_SHB_dyn_cmp_stat;
+ typedef SplitListMap< rcu_sht, Key, Value, traits_SplitList_Michael_dyn_cmp_stat > SplitList_Michael_RCU_SHT_dyn_cmp_stat;
#endif
struct traits_SplitList_Michael_dyn_cmp_seqcst: public cc::split_list::make_traits<
>
>::type
{};
- typedef cc::SplitListMap< cds::gc::HP, Key, Value, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_HP_dyn_cmp_seqcst;
- typedef cc::SplitListMap< cds::gc::DHP, Key, Value, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_DHP_dyn_cmp_seqcst;
- typedef NogcSplitMapWrapper< cc::SplitListMap< cds::gc::nogc, Key, Value, traits_SplitList_Michael_dyn_cmp_seqcst >> SplitList_Michael_NOGC_dyn_cmp_seqcst;
- typedef cc::SplitListMap< rcu_gpi, Key, Value, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_RCU_GPI_dyn_cmp_seqcst;
- typedef cc::SplitListMap< rcu_gpb, Key, Value, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_RCU_GPB_dyn_cmp_seqcst;
- typedef cc::SplitListMap< rcu_gpt, Key, Value, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_RCU_GPT_dyn_cmp_seqcst;
+ typedef SplitListMap< cds::gc::HP, Key, Value, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_HP_dyn_cmp_seqcst;
+ typedef SplitListMap< cds::gc::DHP, Key, Value, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_DHP_dyn_cmp_seqcst;
+ typedef SplitListMap< cds::gc::nogc, Key, Value, traits_SplitList_Michael_dyn_cmp_seqcst> SplitList_Michael_NOGC_dyn_cmp_seqcst;
+ typedef SplitListMap< rcu_gpi, Key, Value, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_RCU_GPI_dyn_cmp_seqcst;
+ typedef SplitListMap< rcu_gpb, Key, Value, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_RCU_GPB_dyn_cmp_seqcst;
+ typedef SplitListMap< rcu_gpt, Key, Value, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_RCU_GPT_dyn_cmp_seqcst;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SplitListMap< rcu_shb, Key, Value, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_RCU_SHB_dyn_cmp_seqcst;
- typedef cc::SplitListMap< rcu_sht, Key, Value, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_RCU_SHT_dyn_cmp_seqcst;
+ typedef SplitListMap< rcu_shb, Key, Value, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_RCU_SHB_dyn_cmp_seqcst;
+ typedef SplitListMap< rcu_sht, Key, Value, traits_SplitList_Michael_dyn_cmp_seqcst > SplitList_Michael_RCU_SHT_dyn_cmp_seqcst;
#endif
struct traits_SplitList_Michael_st_cmp: public cc::split_list::make_traits<
>
>::type
{};
- typedef cc::SplitListMap< cds::gc::HP, Key, Value, traits_SplitList_Michael_st_cmp > SplitList_Michael_HP_st_cmp;
- typedef cc::SplitListMap< cds::gc::DHP, Key, Value, traits_SplitList_Michael_st_cmp > SplitList_Michael_DHP_st_cmp;
- typedef NogcSplitMapWrapper< cc::SplitListMap< cds::gc::nogc, Key, Value, traits_SplitList_Michael_st_cmp >> SplitList_Michael_NOGC_st_cmp;
- typedef cc::SplitListMap< rcu_gpi, Key, Value, traits_SplitList_Michael_st_cmp > SplitList_Michael_RCU_GPI_st_cmp;
- typedef cc::SplitListMap< rcu_gpb, Key, Value, traits_SplitList_Michael_st_cmp > SplitList_Michael_RCU_GPB_st_cmp;
- typedef cc::SplitListMap< rcu_gpt, Key, Value, traits_SplitList_Michael_st_cmp > SplitList_Michael_RCU_GPT_st_cmp;
+ typedef SplitListMap< cds::gc::HP, Key, Value, traits_SplitList_Michael_st_cmp > SplitList_Michael_HP_st_cmp;
+ typedef SplitListMap< cds::gc::DHP, Key, Value, traits_SplitList_Michael_st_cmp > SplitList_Michael_DHP_st_cmp;
+ typedef SplitListMap< cds::gc::nogc, Key, Value, traits_SplitList_Michael_st_cmp> SplitList_Michael_NOGC_st_cmp;
+ typedef SplitListMap< rcu_gpi, Key, Value, traits_SplitList_Michael_st_cmp > SplitList_Michael_RCU_GPI_st_cmp;
+ typedef SplitListMap< rcu_gpb, Key, Value, traits_SplitList_Michael_st_cmp > SplitList_Michael_RCU_GPB_st_cmp;
+ typedef SplitListMap< rcu_gpt, Key, Value, traits_SplitList_Michael_st_cmp > SplitList_Michael_RCU_GPT_st_cmp;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SplitListMap< rcu_shb, Key, Value, traits_SplitList_Michael_st_cmp > SplitList_Michael_RCU_SHB_st_cmp;
- typedef cc::SplitListMap< rcu_sht, Key, Value, traits_SplitList_Michael_st_cmp > SplitList_Michael_RCU_SHT_st_cmp;
+ typedef SplitListMap< rcu_shb, Key, Value, traits_SplitList_Michael_st_cmp > SplitList_Michael_RCU_SHB_st_cmp;
+ typedef SplitListMap< rcu_sht, Key, Value, traits_SplitList_Michael_st_cmp > SplitList_Michael_RCU_SHT_st_cmp;
#endif
struct traits_SplitList_Michael_st_cmp_seqcst: public cc::split_list::make_traits<
>
>::type
{};
- typedef cc::SplitListMap< cds::gc::HP, Key, Value, traits_SplitList_Michael_st_cmp_seqcst > SplitList_Michael_HP_st_cmp_seqcst;
- typedef cc::SplitListMap< cds::gc::DHP, Key, Value, traits_SplitList_Michael_st_cmp_seqcst > SplitList_Michael_DHP_st_cmp_seqcst;
- typedef NogcSplitMapWrapper< cc::SplitListMap< cds::gc::nogc, Key, Value, traits_SplitList_Michael_st_cmp_seqcst >> SplitList_Michael_NOGC_st_cmp_seqcst;
- typedef cc::SplitListMap< rcu_gpi, Key, Value, traits_SplitList_Michael_st_cmp_seqcst > SplitList_Michael_RCU_GPI_st_cmp_seqcst;
- typedef cc::SplitListMap< rcu_gpb, Key, Value, traits_SplitList_Michael_st_cmp_seqcst > SplitList_Michael_RCU_GPB_st_cmp_seqcst;
- typedef cc::SplitListMap< rcu_gpt, Key, Value, traits_SplitList_Michael_st_cmp_seqcst > SplitList_Michael_RCU_GPT_st_cmp_seqcst;
+ typedef SplitListMap< cds::gc::HP, Key, Value, traits_SplitList_Michael_st_cmp_seqcst > SplitList_Michael_HP_st_cmp_seqcst;
+ typedef SplitListMap< cds::gc::DHP, Key, Value, traits_SplitList_Michael_st_cmp_seqcst > SplitList_Michael_DHP_st_cmp_seqcst;
+ typedef SplitListMap< cds::gc::nogc, Key, Value, traits_SplitList_Michael_st_cmp_seqcst> SplitList_Michael_NOGC_st_cmp_seqcst;
+ typedef SplitListMap< rcu_gpi, Key, Value, traits_SplitList_Michael_st_cmp_seqcst > SplitList_Michael_RCU_GPI_st_cmp_seqcst;
+ typedef SplitListMap< rcu_gpb, Key, Value, traits_SplitList_Michael_st_cmp_seqcst > SplitList_Michael_RCU_GPB_st_cmp_seqcst;
+ typedef SplitListMap< rcu_gpt, Key, Value, traits_SplitList_Michael_st_cmp_seqcst > SplitList_Michael_RCU_GPT_st_cmp_seqcst;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SplitListMap< rcu_shb, Key, Value, traits_SplitList_Michael_st_cmp_seqcst > SplitList_Michael_RCU_SHB_st_cmp_seqcst;
- typedef cc::SplitListMap< rcu_sht, Key, Value, traits_SplitList_Michael_st_cmp_seqcst > SplitList_Michael_RCU_SHT_st_cmp_seqcst;
+ typedef SplitListMap< rcu_shb, Key, Value, traits_SplitList_Michael_st_cmp_seqcst > SplitList_Michael_RCU_SHB_st_cmp_seqcst;
+ typedef SplitListMap< rcu_sht, Key, Value, traits_SplitList_Michael_st_cmp_seqcst > SplitList_Michael_RCU_SHT_st_cmp_seqcst;
#endif
//HP + less
>
>::type
{};
- typedef cc::SplitListMap< cds::gc::HP, Key, Value, traits_SplitList_Michael_dyn_less > SplitList_Michael_HP_dyn_less;
- typedef cc::SplitListMap< cds::gc::DHP, Key, Value, traits_SplitList_Michael_dyn_less > SplitList_Michael_DHP_dyn_less;
- typedef NogcSplitMapWrapper< cc::SplitListMap< cds::gc::nogc, Key, Value, traits_SplitList_Michael_dyn_less >> SplitList_Michael_NOGC_dyn_less;
- typedef cc::SplitListMap< rcu_gpi, Key, Value, traits_SplitList_Michael_dyn_less > SplitList_Michael_RCU_GPI_dyn_less;
- typedef cc::SplitListMap< rcu_gpb, Key, Value, traits_SplitList_Michael_dyn_less > SplitList_Michael_RCU_GPB_dyn_less;
- typedef cc::SplitListMap< rcu_gpt, Key, Value, traits_SplitList_Michael_dyn_less > SplitList_Michael_RCU_GPT_dyn_less;
+ typedef SplitListMap< cds::gc::HP, Key, Value, traits_SplitList_Michael_dyn_less > SplitList_Michael_HP_dyn_less;
+ typedef SplitListMap< cds::gc::DHP, Key, Value, traits_SplitList_Michael_dyn_less > SplitList_Michael_DHP_dyn_less;
+ typedef SplitListMap< cds::gc::nogc, Key, Value, traits_SplitList_Michael_dyn_less> SplitList_Michael_NOGC_dyn_less;
+ typedef SplitListMap< rcu_gpi, Key, Value, traits_SplitList_Michael_dyn_less > SplitList_Michael_RCU_GPI_dyn_less;
+ typedef SplitListMap< rcu_gpb, Key, Value, traits_SplitList_Michael_dyn_less > SplitList_Michael_RCU_GPB_dyn_less;
+ typedef SplitListMap< rcu_gpt, Key, Value, traits_SplitList_Michael_dyn_less > SplitList_Michael_RCU_GPT_dyn_less;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SplitListMap< rcu_shb, Key, Value, traits_SplitList_Michael_dyn_less > SplitList_Michael_RCU_SHB_dyn_less;
- typedef cc::SplitListMap< rcu_sht, Key, Value, traits_SplitList_Michael_dyn_less > SplitList_Michael_RCU_SHT_dyn_less;
+ typedef SplitListMap< rcu_shb, Key, Value, traits_SplitList_Michael_dyn_less > SplitList_Michael_RCU_SHB_dyn_less;
+ typedef SplitListMap< rcu_sht, Key, Value, traits_SplitList_Michael_dyn_less > SplitList_Michael_RCU_SHT_dyn_less;
#endif
>
>::type
{};
- typedef cc::SplitListMap< cds::gc::HP, Key, Value, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_HP_dyn_less_seqcst;
- typedef cc::SplitListMap< cds::gc::DHP, Key, Value, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_DHP_dyn_less_seqcst;
- typedef NogcSplitMapWrapper< cc::SplitListMap< cds::gc::nogc, Key, Value, traits_SplitList_Michael_dyn_less_seqcst >> SplitList_Michael_NOGC_dyn_less_seqcst;
- typedef cc::SplitListMap< rcu_gpi, Key, Value, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_RCU_GPI_dyn_less_seqcst;
- typedef cc::SplitListMap< rcu_gpb, Key, Value, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_RCU_GPB_dyn_less_seqcst;
- typedef cc::SplitListMap< rcu_gpt, Key, Value, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_RCU_GPT_dyn_less_seqcst;
+ typedef SplitListMap< cds::gc::HP, Key, Value, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_HP_dyn_less_seqcst;
+ typedef SplitListMap< cds::gc::DHP, Key, Value, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_DHP_dyn_less_seqcst;
+ typedef SplitListMap< cds::gc::nogc, Key, Value, traits_SplitList_Michael_dyn_less_seqcst> SplitList_Michael_NOGC_dyn_less_seqcst;
+ typedef SplitListMap< rcu_gpi, Key, Value, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_RCU_GPI_dyn_less_seqcst;
+ typedef SplitListMap< rcu_gpb, Key, Value, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_RCU_GPB_dyn_less_seqcst;
+ typedef SplitListMap< rcu_gpt, Key, Value, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_RCU_GPT_dyn_less_seqcst;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SplitListMap< rcu_shb, Key, Value, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_RCU_SHB_dyn_less_seqcst;
- typedef cc::SplitListMap< rcu_sht, Key, Value, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_RCU_SHT_dyn_less_seqcst;
+ typedef SplitListMap< rcu_shb, Key, Value, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_RCU_SHB_dyn_less_seqcst;
+ typedef SplitListMap< rcu_sht, Key, Value, traits_SplitList_Michael_dyn_less_seqcst > SplitList_Michael_RCU_SHT_dyn_less_seqcst;
#endif
struct traits_SplitList_Michael_st_less: public cc::split_list::make_traits<
>
>::type
{};
- typedef cc::SplitListMap< cds::gc::HP, Key, Value, traits_SplitList_Michael_st_less > SplitList_Michael_HP_st_less;
- typedef cc::SplitListMap< cds::gc::DHP, Key, Value, traits_SplitList_Michael_st_less > SplitList_Michael_DHP_st_less;
- typedef NogcSplitMapWrapper< cc::SplitListMap< cds::gc::nogc, Key, Value, traits_SplitList_Michael_st_less >> SplitList_Michael_NOGC_st_less;
- typedef cc::SplitListMap< rcu_gpi, Key, Value, traits_SplitList_Michael_st_less > SplitList_Michael_RCU_GPI_st_less;
- typedef cc::SplitListMap< rcu_gpb, Key, Value, traits_SplitList_Michael_st_less > SplitList_Michael_RCU_GPB_st_less;
- typedef cc::SplitListMap< rcu_gpt, Key, Value, traits_SplitList_Michael_st_less > SplitList_Michael_RCU_GPT_st_less;
+ typedef SplitListMap< cds::gc::HP, Key, Value, traits_SplitList_Michael_st_less > SplitList_Michael_HP_st_less;
+ typedef SplitListMap< cds::gc::DHP, Key, Value, traits_SplitList_Michael_st_less > SplitList_Michael_DHP_st_less;
+ typedef SplitListMap< cds::gc::nogc, Key, Value, traits_SplitList_Michael_st_less> SplitList_Michael_NOGC_st_less;
+ typedef SplitListMap< rcu_gpi, Key, Value, traits_SplitList_Michael_st_less > SplitList_Michael_RCU_GPI_st_less;
+ typedef SplitListMap< rcu_gpb, Key, Value, traits_SplitList_Michael_st_less > SplitList_Michael_RCU_GPB_st_less;
+ typedef SplitListMap< rcu_gpt, Key, Value, traits_SplitList_Michael_st_less > SplitList_Michael_RCU_GPT_st_less;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SplitListMap< rcu_shb, Key, Value, traits_SplitList_Michael_st_less > SplitList_Michael_RCU_SHB_st_less;
- typedef cc::SplitListMap< rcu_sht, Key, Value, traits_SplitList_Michael_st_less > SplitList_Michael_RCU_SHT_st_less;
+ typedef SplitListMap< rcu_shb, Key, Value, traits_SplitList_Michael_st_less > SplitList_Michael_RCU_SHB_st_less;
+ typedef SplitListMap< rcu_sht, Key, Value, traits_SplitList_Michael_st_less > SplitList_Michael_RCU_SHT_st_less;
#endif
struct traits_SplitList_Michael_st_less_stat : traits_SplitList_Michael_st_less
{
typedef cc::split_list::stat<> stat;
};
- typedef cc::SplitListMap< cds::gc::HP, Key, Value, traits_SplitList_Michael_st_less_stat > SplitList_Michael_HP_st_less_stat;
- typedef cc::SplitListMap< cds::gc::DHP, Key, Value, traits_SplitList_Michael_st_less_stat > SplitList_Michael_DHP_st_less_stat;
- typedef NogcSplitMapWrapper< cc::SplitListMap< cds::gc::nogc, Key, Value, traits_SplitList_Michael_st_less_stat >> SplitList_Michael_NOGC_st_less_stat;
- typedef cc::SplitListMap< rcu_gpi, Key, Value, traits_SplitList_Michael_st_less_stat > SplitList_Michael_RCU_GPI_st_less_stat;
- typedef cc::SplitListMap< rcu_gpb, Key, Value, traits_SplitList_Michael_st_less_stat > SplitList_Michael_RCU_GPB_st_less_stat;
- typedef cc::SplitListMap< rcu_gpt, Key, Value, traits_SplitList_Michael_st_less_stat > SplitList_Michael_RCU_GPT_st_less_stat;
+ typedef SplitListMap< cds::gc::HP, Key, Value, traits_SplitList_Michael_st_less_stat > SplitList_Michael_HP_st_less_stat;
+ typedef SplitListMap< cds::gc::DHP, Key, Value, traits_SplitList_Michael_st_less_stat > SplitList_Michael_DHP_st_less_stat;
+ typedef SplitListMap< cds::gc::nogc, Key, Value, traits_SplitList_Michael_st_less_stat> SplitList_Michael_NOGC_st_less_stat;
+ typedef SplitListMap< rcu_gpi, Key, Value, traits_SplitList_Michael_st_less_stat > SplitList_Michael_RCU_GPI_st_less_stat;
+ typedef SplitListMap< rcu_gpb, Key, Value, traits_SplitList_Michael_st_less_stat > SplitList_Michael_RCU_GPB_st_less_stat;
+ typedef SplitListMap< rcu_gpt, Key, Value, traits_SplitList_Michael_st_less_stat > SplitList_Michael_RCU_GPT_st_less_stat;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SplitListMap< rcu_shb, Key, Value, traits_SplitList_Michael_st_less_stat > SplitList_Michael_RCU_SHB_st_less_stat;
- typedef cc::SplitListMap< rcu_sht, Key, Value, traits_SplitList_Michael_st_less_stat > SplitList_Michael_RCU_SHT_st_less_stat;
+ typedef SplitListMap< rcu_shb, Key, Value, traits_SplitList_Michael_st_less_stat > SplitList_Michael_RCU_SHB_st_less_stat;
+ typedef SplitListMap< rcu_sht, Key, Value, traits_SplitList_Michael_st_less_stat > SplitList_Michael_RCU_SHT_st_less_stat;
#endif
>
>::type
{};
- typedef cc::SplitListMap< cds::gc::HP, Key, Value, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_HP_st_less_seqcst;
- typedef cc::SplitListMap< cds::gc::DHP, Key, Value, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_DHP_st_less_seqcst;
- typedef NogcSplitMapWrapper< cc::SplitListMap< cds::gc::nogc, Key, Value, traits_SplitList_Michael_st_less_seqcst >> SplitList_Michael_NOGC_st_less_seqcst;
- typedef cc::SplitListMap< rcu_gpi, Key, Value, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_RCU_GPI_st_less_seqcst;
- typedef cc::SplitListMap< rcu_gpb, Key, Value, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_RCU_GPB_st_less_seqcst;
- typedef cc::SplitListMap< rcu_gpt, Key, Value, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_RCU_GPT_st_less_seqcst;
+ typedef SplitListMap< cds::gc::HP, Key, Value, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_HP_st_less_seqcst;
+ typedef SplitListMap< cds::gc::DHP, Key, Value, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_DHP_st_less_seqcst;
+ typedef SplitListMap< cds::gc::nogc, Key, Value, traits_SplitList_Michael_st_less_seqcst> SplitList_Michael_NOGC_st_less_seqcst;
+ typedef SplitListMap< rcu_gpi, Key, Value, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_RCU_GPI_st_less_seqcst;
+ typedef SplitListMap< rcu_gpb, Key, Value, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_RCU_GPB_st_less_seqcst;
+ typedef SplitListMap< rcu_gpt, Key, Value, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_RCU_GPT_st_less_seqcst;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SplitListMap< rcu_shb, Key, Value, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_RCU_SHB_st_less_seqcst;
- typedef cc::SplitListMap< rcu_sht, Key, Value, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_RCU_SHT_st_less_seqcst;
+ typedef SplitListMap< rcu_shb, Key, Value, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_RCU_SHB_st_less_seqcst;
+ typedef SplitListMap< rcu_sht, Key, Value, traits_SplitList_Michael_st_less_seqcst > SplitList_Michael_RCU_SHT_st_less_seqcst;
#endif
>
>::type
{};
- typedef cc::SplitListMap< cds::gc::HP, Key, Value, SplitList_Lazy_dyn_cmp > SplitList_Lazy_HP_dyn_cmp;
- typedef cc::SplitListMap< cds::gc::DHP, Key, Value, SplitList_Lazy_dyn_cmp > SplitList_Lazy_DHP_dyn_cmp;
- typedef NogcSplitMapWrapper< cc::SplitListMap< cds::gc::nogc, Key, Value, SplitList_Lazy_dyn_cmp >> SplitList_Lazy_NOGC_dyn_cmp;
- typedef cc::SplitListMap< rcu_gpi, Key, Value, SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_GPI_dyn_cmp;
- typedef cc::SplitListMap< rcu_gpb, Key, Value, SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_GPB_dyn_cmp;
- typedef cc::SplitListMap< rcu_gpt, Key, Value, SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_GPT_dyn_cmp;
+ typedef SplitListMap< cds::gc::HP, Key, Value, SplitList_Lazy_dyn_cmp > SplitList_Lazy_HP_dyn_cmp;
+ typedef SplitListMap< cds::gc::DHP, Key, Value, SplitList_Lazy_dyn_cmp > SplitList_Lazy_DHP_dyn_cmp;
+ typedef SplitListMap< cds::gc::nogc, Key, Value, SplitList_Lazy_dyn_cmp> SplitList_Lazy_NOGC_dyn_cmp;
+ typedef SplitListMap< rcu_gpi, Key, Value, SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_GPI_dyn_cmp;
+ typedef SplitListMap< rcu_gpb, Key, Value, SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_GPB_dyn_cmp;
+ typedef SplitListMap< rcu_gpt, Key, Value, SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_GPT_dyn_cmp;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SplitListMap< rcu_shb, Key, Value, SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_SHB_dyn_cmp;
- typedef cc::SplitListMap< rcu_sht, Key, Value, SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_SHT_dyn_cmp;
+ typedef SplitListMap< rcu_shb, Key, Value, SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_SHB_dyn_cmp;
+ typedef SplitListMap< rcu_sht, Key, Value, SplitList_Lazy_dyn_cmp > SplitList_Lazy_RCU_SHT_dyn_cmp;
#endif
struct SplitList_Lazy_dyn_cmp_stat : public SplitList_Lazy_dyn_cmp
{
typedef cc::split_list::stat<> stat;
};
- typedef cc::SplitListMap< cds::gc::HP, Key, Value, SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_HP_dyn_cmp_stat;
- typedef cc::SplitListMap< cds::gc::DHP, Key, Value, SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_DHP_dyn_cmp_stat;
- typedef NogcSplitMapWrapper< cc::SplitListMap< cds::gc::nogc, Key, Value, SplitList_Lazy_dyn_cmp_stat >> SplitList_Lazy_NOGC_dyn_cmp_stat;
- typedef cc::SplitListMap< rcu_gpi, Key, Value, SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_RCU_GPI_dyn_cmp_stat;
- typedef cc::SplitListMap< rcu_gpb, Key, Value, SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_RCU_GPB_dyn_cmp_stat;
- typedef cc::SplitListMap< rcu_gpt, Key, Value, SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_RCU_GPT_dyn_cmp_stat;
+ typedef SplitListMap< cds::gc::HP, Key, Value, SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_HP_dyn_cmp_stat;
+ typedef SplitListMap< cds::gc::DHP, Key, Value, SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_DHP_dyn_cmp_stat;
+ typedef SplitListMap< cds::gc::nogc, Key, Value, SplitList_Lazy_dyn_cmp_stat> SplitList_Lazy_NOGC_dyn_cmp_stat;
+ typedef SplitListMap< rcu_gpi, Key, Value, SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_RCU_GPI_dyn_cmp_stat;
+ typedef SplitListMap< rcu_gpb, Key, Value, SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_RCU_GPB_dyn_cmp_stat;
+ typedef SplitListMap< rcu_gpt, Key, Value, SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_RCU_GPT_dyn_cmp_stat;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SplitListMap< rcu_shb, Key, Value, SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_RCU_SHB_dyn_cmp_stat;
- typedef cc::SplitListMap< rcu_sht, Key, Value, SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_RCU_SHT_dyn_cmp_stat;
+ typedef SplitListMap< rcu_shb, Key, Value, SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_RCU_SHB_dyn_cmp_stat;
+ typedef SplitListMap< rcu_sht, Key, Value, SplitList_Lazy_dyn_cmp_stat > SplitList_Lazy_RCU_SHT_dyn_cmp_stat;
#endif
struct SplitList_Lazy_dyn_cmp_seqcst :
>
>::type
{};
- typedef cc::SplitListMap< cds::gc::HP, Key, Value, SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_HP_dyn_cmp_seqcst;
- typedef cc::SplitListMap< cds::gc::DHP, Key, Value, SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_DHP_dyn_cmp_seqcst;
- typedef NogcSplitMapWrapper< cc::SplitListMap< cds::gc::nogc, Key, Value, SplitList_Lazy_dyn_cmp_seqcst >> SplitList_Lazy_NOGC_dyn_cmp_seqcst;
- typedef cc::SplitListMap< rcu_gpi, Key, Value, SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_RCU_GPI_dyn_cmp_seqcst;
- typedef cc::SplitListMap< rcu_gpb, Key, Value, SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_RCU_GPB_dyn_cmp_seqcst;
- typedef cc::SplitListMap< rcu_gpt, Key, Value, SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_RCU_GPT_dyn_cmp_seqcst;
+ typedef SplitListMap< cds::gc::HP, Key, Value, SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_HP_dyn_cmp_seqcst;
+ typedef SplitListMap< cds::gc::DHP, Key, Value, SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_DHP_dyn_cmp_seqcst;
+ typedef SplitListMap< cds::gc::nogc, Key, Value, SplitList_Lazy_dyn_cmp_seqcst> SplitList_Lazy_NOGC_dyn_cmp_seqcst;
+ typedef SplitListMap< rcu_gpi, Key, Value, SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_RCU_GPI_dyn_cmp_seqcst;
+ typedef SplitListMap< rcu_gpb, Key, Value, SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_RCU_GPB_dyn_cmp_seqcst;
+ typedef SplitListMap< rcu_gpt, Key, Value, SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_RCU_GPT_dyn_cmp_seqcst;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SplitListMap< rcu_shb, Key, Value, SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_RCU_SHB_dyn_cmp_seqcst;
- typedef cc::SplitListMap< rcu_sht, Key, Value, SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_RCU_SHT_dyn_cmp_seqcst;
+ typedef SplitListMap< rcu_shb, Key, Value, SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_RCU_SHB_dyn_cmp_seqcst;
+ typedef SplitListMap< rcu_sht, Key, Value, SplitList_Lazy_dyn_cmp_seqcst > SplitList_Lazy_RCU_SHT_dyn_cmp_seqcst;
#endif
struct SplitList_Lazy_st_cmp :
>
>::type
{};
- typedef cc::SplitListMap< cds::gc::HP, Key, Value, SplitList_Lazy_st_cmp > SplitList_Lazy_HP_st_cmp;
- typedef cc::SplitListMap< cds::gc::DHP, Key, Value, SplitList_Lazy_st_cmp > SplitList_Lazy_DHP_st_cmp;
- typedef NogcSplitMapWrapper< cc::SplitListMap< cds::gc::nogc, Key, Value, SplitList_Lazy_st_cmp >> SplitList_Lazy_NOGC_st_cmp;
- typedef cc::SplitListMap< rcu_gpi, Key, Value, SplitList_Lazy_st_cmp > SplitList_Lazy_RCU_GPI_st_cmp;
- typedef cc::SplitListMap< rcu_gpb, Key, Value, SplitList_Lazy_st_cmp > SplitList_Lazy_RCU_GPB_st_cmp;
- typedef cc::SplitListMap< rcu_gpt, Key, Value, SplitList_Lazy_st_cmp > SplitList_Lazy_RCU_GPT_st_cmp;
+ typedef SplitListMap< cds::gc::HP, Key, Value, SplitList_Lazy_st_cmp > SplitList_Lazy_HP_st_cmp;
+ typedef SplitListMap< cds::gc::DHP, Key, Value, SplitList_Lazy_st_cmp > SplitList_Lazy_DHP_st_cmp;
+ typedef SplitListMap< cds::gc::nogc, Key, Value, SplitList_Lazy_st_cmp> SplitList_Lazy_NOGC_st_cmp;
+ typedef SplitListMap< rcu_gpi, Key, Value, SplitList_Lazy_st_cmp > SplitList_Lazy_RCU_GPI_st_cmp;
+ typedef SplitListMap< rcu_gpb, Key, Value, SplitList_Lazy_st_cmp > SplitList_Lazy_RCU_GPB_st_cmp;
+ typedef SplitListMap< rcu_gpt, Key, Value, SplitList_Lazy_st_cmp > SplitList_Lazy_RCU_GPT_st_cmp;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SplitListMap< rcu_shb, Key, Value, SplitList_Lazy_st_cmp > SplitList_Lazy_RCU_SHB_st_cmp;
- typedef cc::SplitListMap< rcu_sht, Key, Value, SplitList_Lazy_st_cmp > SplitList_Lazy_RCU_SHT_st_cmp;
+ typedef SplitListMap< rcu_shb, Key, Value, SplitList_Lazy_st_cmp > SplitList_Lazy_RCU_SHB_st_cmp;
+ typedef SplitListMap< rcu_sht, Key, Value, SplitList_Lazy_st_cmp > SplitList_Lazy_RCU_SHT_st_cmp;
#endif
>
>::type
{};
- typedef cc::SplitListMap< cds::gc::HP, Key, Value, SplitList_Lazy_st_cmp_seqcst> SplitList_Lazy_HP_st_cmp_seqcst;
- typedef cc::SplitListMap< cds::gc::DHP, Key, Value, SplitList_Lazy_st_cmp_seqcst> SplitList_Lazy_DHP_st_cmp_seqcst;
- typedef NogcSplitMapWrapper< cc::SplitListMap< cds::gc::nogc, Key, Value, SplitList_Lazy_st_cmp_seqcst >> SplitList_Lazy_NOGC_st_cmp_seqcst;
- typedef cc::SplitListMap< rcu_gpi, Key, Value, SplitList_Lazy_st_cmp_seqcst> SplitList_Lazy_RCU_GPI_st_cmp_seqcst;
- typedef cc::SplitListMap< rcu_gpb, Key, Value, SplitList_Lazy_st_cmp_seqcst> SplitList_Lazy_RCU_GPB_st_cmp_seqcst;
- typedef cc::SplitListMap< rcu_gpt, Key, Value, SplitList_Lazy_st_cmp_seqcst> SplitList_Lazy_RCU_GPT_st_cmp_seqcst;
+ typedef SplitListMap< cds::gc::HP, Key, Value, SplitList_Lazy_st_cmp_seqcst> SplitList_Lazy_HP_st_cmp_seqcst;
+ typedef SplitListMap< cds::gc::DHP, Key, Value, SplitList_Lazy_st_cmp_seqcst> SplitList_Lazy_DHP_st_cmp_seqcst;
+ typedef SplitListMap< cds::gc::nogc, Key, Value, SplitList_Lazy_st_cmp_seqcst> SplitList_Lazy_NOGC_st_cmp_seqcst;
+ typedef SplitListMap< rcu_gpi, Key, Value, SplitList_Lazy_st_cmp_seqcst> SplitList_Lazy_RCU_GPI_st_cmp_seqcst;
+ typedef SplitListMap< rcu_gpb, Key, Value, SplitList_Lazy_st_cmp_seqcst> SplitList_Lazy_RCU_GPB_st_cmp_seqcst;
+ typedef SplitListMap< rcu_gpt, Key, Value, SplitList_Lazy_st_cmp_seqcst> SplitList_Lazy_RCU_GPT_st_cmp_seqcst;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SplitListMap< rcu_shb, Key, Value, SplitList_Lazy_st_cmp_seqcst> SplitList_Lazy_RCU_SHB_st_cmp_seqcst;
- typedef cc::SplitListMap< rcu_sht, Key, Value, SplitList_Lazy_st_cmp_seqcst> SplitList_Lazy_RCU_SHT_st_cmp_seqcst;
+ typedef SplitListMap< rcu_shb, Key, Value, SplitList_Lazy_st_cmp_seqcst> SplitList_Lazy_RCU_SHB_st_cmp_seqcst;
+ typedef SplitListMap< rcu_sht, Key, Value, SplitList_Lazy_st_cmp_seqcst> SplitList_Lazy_RCU_SHT_st_cmp_seqcst;
#endif
>
>::type
{};
- typedef cc::SplitListMap< cds::gc::HP, Key, Value, SplitList_Lazy_dyn_less > SplitList_Lazy_HP_dyn_less;
- typedef cc::SplitListMap< cds::gc::DHP, Key, Value, SplitList_Lazy_dyn_less > SplitList_Lazy_DHP_dyn_less;
- typedef NogcSplitMapWrapper< cc::SplitListMap< cds::gc::nogc, Key, Value, SplitList_Lazy_dyn_less >> SplitList_Lazy_NOGC_dyn_less;
- typedef cc::SplitListMap< rcu_gpi, Key, Value, SplitList_Lazy_dyn_less > SplitList_Lazy_RCU_GPI_dyn_less;
- typedef cc::SplitListMap< rcu_gpb, Key, Value, SplitList_Lazy_dyn_less > SplitList_Lazy_RCU_GPB_dyn_less;
- typedef cc::SplitListMap< rcu_gpt, Key, Value, SplitList_Lazy_dyn_less > SplitList_Lazy_RCU_GPT_dyn_less;
+ typedef SplitListMap< cds::gc::HP, Key, Value, SplitList_Lazy_dyn_less > SplitList_Lazy_HP_dyn_less;
+ typedef SplitListMap< cds::gc::DHP, Key, Value, SplitList_Lazy_dyn_less > SplitList_Lazy_DHP_dyn_less;
+ typedef SplitListMap< cds::gc::nogc, Key, Value, SplitList_Lazy_dyn_less> SplitList_Lazy_NOGC_dyn_less;
+ typedef SplitListMap< rcu_gpi, Key, Value, SplitList_Lazy_dyn_less > SplitList_Lazy_RCU_GPI_dyn_less;
+ typedef SplitListMap< rcu_gpb, Key, Value, SplitList_Lazy_dyn_less > SplitList_Lazy_RCU_GPB_dyn_less;
+ typedef SplitListMap< rcu_gpt, Key, Value, SplitList_Lazy_dyn_less > SplitList_Lazy_RCU_GPT_dyn_less;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SplitListMap< rcu_shb, Key, Value, SplitList_Lazy_dyn_less > SplitList_Lazy_RCU_SHB_dyn_less;
- typedef cc::SplitListMap< rcu_sht, Key, Value, SplitList_Lazy_dyn_less > SplitList_Lazy_RCU_SHT_dyn_less;
+ typedef SplitListMap< rcu_shb, Key, Value, SplitList_Lazy_dyn_less > SplitList_Lazy_RCU_SHB_dyn_less;
+ typedef SplitListMap< rcu_sht, Key, Value, SplitList_Lazy_dyn_less > SplitList_Lazy_RCU_SHT_dyn_less;
#endif
struct SplitList_Lazy_dyn_less_seqcst:
>
>::type
{};
- typedef cc::SplitListMap< cds::gc::HP, Key, Value, SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_HP_dyn_less_seqcst;
- typedef cc::SplitListMap< cds::gc::DHP, Key, Value, SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_DHP_dyn_less_seqcst;
- typedef NogcSplitMapWrapper< cc::SplitListMap< cds::gc::nogc, Key, Value, SplitList_Lazy_dyn_less_seqcst >> SplitList_Lazy_NOGC_dyn_less_seqcst;
- typedef cc::SplitListMap< rcu_gpi, Key, Value, SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_RCU_GPI_dyn_less_seqcst;
- typedef cc::SplitListMap< rcu_gpb, Key, Value, SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_RCU_GPB_dyn_less_seqcst;
- typedef cc::SplitListMap< rcu_gpt, Key, Value, SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_RCU_GPT_dyn_less_seqcst;
+ typedef SplitListMap< cds::gc::HP, Key, Value, SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_HP_dyn_less_seqcst;
+ typedef SplitListMap< cds::gc::DHP, Key, Value, SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_DHP_dyn_less_seqcst;
+ typedef SplitListMap< cds::gc::nogc, Key, Value, SplitList_Lazy_dyn_less_seqcst> SplitList_Lazy_NOGC_dyn_less_seqcst;
+ typedef SplitListMap< rcu_gpi, Key, Value, SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_RCU_GPI_dyn_less_seqcst;
+ typedef SplitListMap< rcu_gpb, Key, Value, SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_RCU_GPB_dyn_less_seqcst;
+ typedef SplitListMap< rcu_gpt, Key, Value, SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_RCU_GPT_dyn_less_seqcst;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SplitListMap< rcu_shb, Key, Value, SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_RCU_SHB_dyn_less_seqcst;
- typedef cc::SplitListMap< rcu_sht, Key, Value, SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_RCU_SHT_dyn_less_seqcst;
+ typedef SplitListMap< rcu_shb, Key, Value, SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_RCU_SHB_dyn_less_seqcst;
+ typedef SplitListMap< rcu_sht, Key, Value, SplitList_Lazy_dyn_less_seqcst > SplitList_Lazy_RCU_SHT_dyn_less_seqcst;
#endif
struct SplitList_Lazy_st_less :
>
>::type
{};
- typedef cc::SplitListMap< cds::gc::HP, Key, Value, SplitList_Lazy_st_less > SplitList_Lazy_HP_st_less;
- typedef cc::SplitListMap< cds::gc::DHP, Key, Value, SplitList_Lazy_st_less > SplitList_Lazy_DHP_st_less;
- typedef NogcSplitMapWrapper< cc::SplitListMap< cds::gc::nogc, Key, Value, SplitList_Lazy_st_less >> SplitList_Lazy_NOGC_st_less;
- typedef cc::SplitListMap< rcu_gpi, Key, Value, SplitList_Lazy_st_less > SplitList_Lazy_RCU_GPI_st_less;
- typedef cc::SplitListMap< rcu_gpb, Key, Value, SplitList_Lazy_st_less > SplitList_Lazy_RCU_GPB_st_less;
- typedef cc::SplitListMap< rcu_gpt, Key, Value, SplitList_Lazy_st_less > SplitList_Lazy_RCU_GPT_st_less;
+ typedef SplitListMap< cds::gc::HP, Key, Value, SplitList_Lazy_st_less > SplitList_Lazy_HP_st_less;
+ typedef SplitListMap< cds::gc::DHP, Key, Value, SplitList_Lazy_st_less > SplitList_Lazy_DHP_st_less;
+ typedef SplitListMap< cds::gc::nogc, Key, Value, SplitList_Lazy_st_less> SplitList_Lazy_NOGC_st_less;
+ typedef SplitListMap< rcu_gpi, Key, Value, SplitList_Lazy_st_less > SplitList_Lazy_RCU_GPI_st_less;
+ typedef SplitListMap< rcu_gpb, Key, Value, SplitList_Lazy_st_less > SplitList_Lazy_RCU_GPB_st_less;
+ typedef SplitListMap< rcu_gpt, Key, Value, SplitList_Lazy_st_less > SplitList_Lazy_RCU_GPT_st_less;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SplitListMap< rcu_shb, Key, Value, SplitList_Lazy_st_less > SplitList_Lazy_RCU_SHB_st_less;
- typedef cc::SplitListMap< rcu_sht, Key, Value, SplitList_Lazy_st_less > SplitList_Lazy_RCU_SHT_st_less;
+ typedef SplitListMap< rcu_shb, Key, Value, SplitList_Lazy_st_less > SplitList_Lazy_RCU_SHB_st_less;
+ typedef SplitListMap< rcu_sht, Key, Value, SplitList_Lazy_st_less > SplitList_Lazy_RCU_SHT_st_less;
#endif
struct SplitList_Lazy_st_less_stat : public SplitList_Lazy_st_less
{
typedef cc::split_list::stat<> stat;
};
- typedef cc::SplitListMap< cds::gc::HP, Key, Value, SplitList_Lazy_st_less_stat > SplitList_Lazy_HP_st_less_stat;
- typedef cc::SplitListMap< cds::gc::DHP, Key, Value, SplitList_Lazy_st_less_stat > SplitList_Lazy_DHP_st_less_stat;
- typedef NogcSplitMapWrapper< cc::SplitListMap< cds::gc::nogc, Key, Value, SplitList_Lazy_st_less_stat >> SplitList_Lazy_NOGC_st_less_stat;
- typedef cc::SplitListMap< rcu_gpi, Key, Value, SplitList_Lazy_st_less_stat > SplitList_Lazy_RCU_GPI_st_less_stat;
- typedef cc::SplitListMap< rcu_gpb, Key, Value, SplitList_Lazy_st_less_stat > SplitList_Lazy_RCU_GPB_st_less_stat;
- typedef cc::SplitListMap< rcu_gpt, Key, Value, SplitList_Lazy_st_less_stat > SplitList_Lazy_RCU_GPT_st_less_stat;
+ typedef SplitListMap< cds::gc::HP, Key, Value, SplitList_Lazy_st_less_stat > SplitList_Lazy_HP_st_less_stat;
+ typedef SplitListMap< cds::gc::DHP, Key, Value, SplitList_Lazy_st_less_stat > SplitList_Lazy_DHP_st_less_stat;
+ typedef SplitListMap< cds::gc::nogc, Key, Value, SplitList_Lazy_st_less_stat> SplitList_Lazy_NOGC_st_less_stat;
+ typedef SplitListMap< rcu_gpi, Key, Value, SplitList_Lazy_st_less_stat > SplitList_Lazy_RCU_GPI_st_less_stat;
+ typedef SplitListMap< rcu_gpb, Key, Value, SplitList_Lazy_st_less_stat > SplitList_Lazy_RCU_GPB_st_less_stat;
+ typedef SplitListMap< rcu_gpt, Key, Value, SplitList_Lazy_st_less_stat > SplitList_Lazy_RCU_GPT_st_less_stat;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SplitListMap< rcu_shb, Key, Value, SplitList_Lazy_st_less_stat > SplitList_Lazy_RCU_SHB_st_less_stat;
- typedef cc::SplitListMap< rcu_sht, Key, Value, SplitList_Lazy_st_less_stat > SplitList_Lazy_RCU_SHT_st_less_stat;
+ typedef SplitListMap< rcu_shb, Key, Value, SplitList_Lazy_st_less_stat > SplitList_Lazy_RCU_SHB_st_less_stat;
+ typedef SplitListMap< rcu_sht, Key, Value, SplitList_Lazy_st_less_stat > SplitList_Lazy_RCU_SHT_st_less_stat;
#endif
struct SplitList_Lazy_st_less_seqcst :
>
>::type
{};
- typedef cc::SplitListMap< cds::gc::HP, Key, Value, SplitList_Lazy_st_less_seqcst > SplitList_Lazy_HP_st_less_seqcst;
- typedef cc::SplitListMap< cds::gc::DHP, Key, Value, SplitList_Lazy_st_less_seqcst > SplitList_Lazy_DHP_st_less_seqcst;
- typedef NogcSplitMapWrapper< cc::SplitListMap< cds::gc::nogc, Key, Value, SplitList_Lazy_st_less_seqcst >> SplitList_Lazy_NOGC_st_less_seqcst;
- typedef cc::SplitListMap< rcu_gpi, Key, Value, SplitList_Lazy_st_less_seqcst > SplitList_Lazy_RCU_GPI_st_less_seqcst;
- typedef cc::SplitListMap< rcu_gpb, Key, Value, SplitList_Lazy_st_less_seqcst > SplitList_Lazy_RCU_GPB_st_less_seqcst;
- typedef cc::SplitListMap< rcu_gpt, Key, Value, SplitList_Lazy_st_less_seqcst > SplitList_Lazy_RCU_GPT_st_less_seqcst;
+ typedef SplitListMap< cds::gc::HP, Key, Value, SplitList_Lazy_st_less_seqcst > SplitList_Lazy_HP_st_less_seqcst;
+ typedef SplitListMap< cds::gc::DHP, Key, Value, SplitList_Lazy_st_less_seqcst > SplitList_Lazy_DHP_st_less_seqcst;
+ typedef SplitListMap< cds::gc::nogc, Key, Value, SplitList_Lazy_st_less_seqcst> SplitList_Lazy_NOGC_st_less_seqcst;
+ typedef SplitListMap< rcu_gpi, Key, Value, SplitList_Lazy_st_less_seqcst > SplitList_Lazy_RCU_GPI_st_less_seqcst;
+ typedef SplitListMap< rcu_gpb, Key, Value, SplitList_Lazy_st_less_seqcst > SplitList_Lazy_RCU_GPB_st_less_seqcst;
+ typedef SplitListMap< rcu_gpt, Key, Value, SplitList_Lazy_st_less_seqcst > SplitList_Lazy_RCU_GPT_st_less_seqcst;
#ifdef CDS_URCU_SIGNAL_HANDLING_ENABLED
- typedef cc::SplitListMap< rcu_shb, Key, Value, SplitList_Lazy_st_less_seqcst > SplitList_Lazy_RCU_SHB_st_less_seqcst;
- typedef cc::SplitListMap< rcu_sht, Key, Value, SplitList_Lazy_st_less_seqcst > SplitList_Lazy_RCU_SHT_st_less_seqcst;
+ typedef SplitListMap< rcu_shb, Key, Value, SplitList_Lazy_st_less_seqcst > SplitList_Lazy_RCU_SHB_st_less_seqcst;
+ typedef SplitListMap< rcu_sht, Key, Value, SplitList_Lazy_st_less_seqcst > SplitList_Lazy_RCU_SHT_st_less_seqcst;
#endif
};
template <typename GC, typename K, typename T, typename Traits >
- static inline void print_stat( cc::SplitListMap< GC, K, T, Traits > const& m )
+ static inline void print_stat( SplitListMap< GC, K, T, Traits > const& m )
{
CPPUNIT_MSG( m.statistics() );
}
projects / libcds.git / commitdiff