Replace cds::ref/boost::ref with std::ref, remove cds::unref and cds/ref.h header
authorkhizmax <libcds.dev@gmail.com>
Sun, 28 Sep 2014 14:30:55 +0000 (18:30 +0400)
committerkhizmax <libcds.dev@gmail.com>
Sun, 28 Sep 2014 14:30:55 +0000 (18:30 +0400)
119 files changed:
cds/container/basket_queue.h
cds/container/cuckoo_map.h
cds/container/cuckoo_set.h
cds/container/details/make_split_list_set.h
cds/container/ellen_bintree_map_rcu.h
cds/container/ellen_bintree_set_rcu.h
cds/container/impl/ellen_bintree_map.h
cds/container/impl/ellen_bintree_set.h
cds/container/impl/lazy_kvlist.h
cds/container/impl/lazy_list.h
cds/container/impl/michael_kvlist.h
cds/container/impl/michael_list.h
cds/container/impl/skip_list_map.h
cds/container/impl/skip_list_set.h
cds/container/lazy_kvlist_nogc.h
cds/container/lazy_kvlist_rcu.h
cds/container/lazy_list_rcu.h
cds/container/michael_kvlist_nogc.h
cds/container/michael_kvlist_rcu.h
cds/container/michael_list_rcu.h
cds/container/michael_map.h
cds/container/michael_map_nogc.h
cds/container/michael_map_rcu.h
cds/container/michael_set.h
cds/container/michael_set_rcu.h
cds/container/moir_queue.h
cds/container/mspriority_queue.h
cds/container/msqueue.h
cds/container/optimistic_queue.h
cds/container/rwqueue.h
cds/container/segmented_queue.h
cds/container/skip_list_map_nogc.h
cds/container/skip_list_map_rcu.h
cds/container/skip_list_set_rcu.h
cds/container/split_list_map.h
cds/container/split_list_map_nogc.h
cds/container/split_list_map_rcu.h
cds/container/split_list_set.h
cds/container/split_list_set_rcu.h
cds/container/striped_map.h
cds/container/striped_map/boost_list.h
cds/container/striped_map/boost_slist.h
cds/container/striped_map/std_hash_map_std.h
cds/container/striped_map/std_hash_map_vc.h
cds/container/striped_map/std_list.h
cds/container/striped_map/std_map.h
cds/container/striped_set.h
cds/container/striped_set/adapter.h
cds/container/striped_set/boost_list.h
cds/container/striped_set/boost_slist.h
cds/container/striped_set/boost_stable_vector.h
cds/container/striped_set/boost_vector.h
cds/container/striped_set/std_hash_set_std.h
cds/container/striped_set/std_hash_set_vc.h
cds/container/striped_set/std_list.h
cds/container/striped_set/std_set.h
cds/container/striped_set/std_vector.h
cds/container/tsigas_cycle_queue.h
cds/container/vyukov_mpmc_cycle_queue.h
cds/details/functor_wrapper.h
cds/intrusive/basket_queue.h
cds/intrusive/cuckoo_set.h
cds/intrusive/details/lazy_list_base.h
cds/intrusive/details/michael_list_base.h
cds/intrusive/details/michael_set_base.h
cds/intrusive/ellen_bintree_rcu.h
cds/intrusive/impl/ellen_bintree.h
cds/intrusive/impl/lazy_list.h
cds/intrusive/impl/michael_list.h
cds/intrusive/impl/skip_list.h
cds/intrusive/lazy_list_nogc.h
cds/intrusive/lazy_list_rcu.h
cds/intrusive/michael_list_nogc.h
cds/intrusive/michael_list_rcu.h
cds/intrusive/michael_set.h
cds/intrusive/michael_set_nogc.h
cds/intrusive/michael_set_rcu.h
cds/intrusive/mspriority_queue.h
cds/intrusive/optimistic_queue.h
cds/intrusive/skip_list_nogc.h
cds/intrusive/skip_list_rcu.h
cds/intrusive/split_list.h
cds/intrusive/split_list_nogc.h
cds/intrusive/split_list_rcu.h
cds/intrusive/striped_set.h
cds/intrusive/striped_set/adapter.h
cds/intrusive/striped_set/boost_list.h
cds/intrusive/striped_set/boost_slist.h
cds/intrusive/striped_set/boost_unordered_set.h
cds/intrusive/treiber_stack.h
cds/intrusive/tsigas_cycle_queue.h
cds/intrusive/vyukov_mpmc_cycle_queue.h
cds/ref.h [deleted file]
tests/test-hdr/map/hdr_cuckoo_map.h
tests/test-hdr/map/hdr_map.h
tests/test-hdr/map/hdr_striped_map.h
tests/test-hdr/ordered_list/hdr_lazy.h
tests/test-hdr/ordered_list/hdr_lazy_kv.h
tests/test-hdr/ordered_list/hdr_michael.h
tests/test-hdr/ordered_list/hdr_michael_kv.h
tests/test-hdr/priority_queue/hdr_intrusive_pqueue.h
tests/test-hdr/priority_queue/hdr_pqueue.h
tests/test-hdr/queue/hdr_segmented_queue.h
tests/test-hdr/set/hdr_cuckoo_set.h
tests/test-hdr/set/hdr_intrusive_set.h
tests/test-hdr/set/hdr_intrusive_skiplist_set.h
tests/test-hdr/set/hdr_set.h
tests/test-hdr/set/hdr_striped_set.h
tests/test-hdr/tree/hdr_ellenbintree_map.h
tests/test-hdr/tree/hdr_ellenbintree_set.h
tests/unit/map2/map_insdel_func.cpp
tests/unit/map2/std_hash_map_gcc.h
tests/unit/map2/std_hash_map_vc.h
tests/unit/map2/std_map_gcc.h
tests/unit/map2/std_map_vc.h
tests/unit/set2/set_insdel_func.h
tests/unit/set2/std_hash_set_std.h
tests/unit/set2/std_hash_set_vc9.h
tests/unit/set2/std_set.h

index 2c67bca..db3604a 100644 (file)
@@ -4,12 +4,11 @@
 #define __CDS_CONTAINER_BASKET_QUEUE_H
 
 #include <memory>
+#include <functional>   // ref
 #include <cds/intrusive/basket_queue.h>
 #include <cds/container/details/base.h>
-#include <cds/ref.h>
 #include <cds/details/trivial_assign.h>
 
-
 namespace cds { namespace container {
 
     //@cond
@@ -268,7 +267,7 @@ namespace cds { namespace container {
         bool enqueue( const Type& data, Func f  )
         {
             scoped_node_ptr p( alloc_node());
-            cds::unref(f)( p->m_value, data );
+            f( p->m_value, data );
             if ( base_class::enqueue( *p )) {
                 p.release();
                 return true;
@@ -311,7 +310,7 @@ namespace cds { namespace container {
         {
             typename base_class::dequeue_result res;
             if ( base_class::do_dequeue( res, true )) {
-                cds::unref(f)( dest, node_traits::to_value_ptr( *res.pNext )->m_value );
+                f( dest, node_traits::to_value_ptr( *res.pNext )->m_value );
                 return true;
             }
             return false;
index 7cffae9..a6043b0 100644 (file)
@@ -507,7 +507,7 @@ namespace cds { namespace container {
                 - <tt>item.first</tt> is a const reference to item's key that cannot be changed.
                 - <tt>item.second</tt> is a reference to item's value that may be changed.
 
-            The user-defined functor can be passed by reference using <tt>boost::ref</tt>
+            The user-defined functor can be passed by reference using \p std::ref
             and it is called only if inserting is successful.
 
             The key_type should be constructible from value of type \p K.
@@ -524,7 +524,7 @@ namespace cds { namespace container {
         bool insert_key( const K& key, Func func )
         {
             scoped_node_ptr pNode( alloc_node( key ));
-            if ( base_class::insert( *pNode, [&func]( node_type& item ) { cds::unref(func)( item.m_val ); } )) {
+            if ( base_class::insert( *pNode, [&func]( node_type& item ) { func( item.m_val ); } )) {
                 pNode.release();
                 return true;
             }
@@ -571,7 +571,7 @@ namespace cds { namespace container {
 
             The functor may change any fields of the \p item.second that is \ref value_type.
 
-            You may pass \p func argument by reference using <tt>boost::ref</tt>.
+            You may pass \p func argument by reference using \p std::ref
 
             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
@@ -582,7 +582,7 @@ namespace cds { namespace container {
         {
             scoped_node_ptr pNode( alloc_node( key ));
             std::pair<bool, bool> res = base_class::ensure( *pNode,
-                [&func](bool bNew, node_type& item, node_type const& ){ cds::unref(func)( bNew, item.m_val ); }
+                [&func](bool bNew, node_type& item, node_type const& ){ func( bNew, item.m_val ); }
             );
             if ( res.first && res.second )
                 pNode.release();
@@ -647,7 +647,7 @@ namespace cds { namespace container {
         {
             node_type * pNode = base_class::erase( key );
             if ( pNode ) {
-                cds::unref(f)( pNode->m_val );
+                f( pNode->m_val );
                 free_node( pNode );
                 return true;
             }
@@ -667,7 +667,7 @@ namespace cds { namespace container {
         {
             node_type * pNode = base_class::erase_with( key, cds::details::predicate_wrapper<node_type, Predicate, key_accessor>() );
             if ( pNode ) {
-                cds::unref(f)( pNode->m_val );
+                f( pNode->m_val );
                 free_node( pNode );
                 return true;
             }
@@ -686,7 +686,7 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found.
 
-            You can pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You can pass \p f argument by reference using \p std::ref
 
             The functor may change \p item.second.
 
@@ -695,7 +695,7 @@ namespace cds { namespace container {
         template <typename K, typename Func>
         bool find( K const& key, Func f )
         {
-            return base_class::find( key, [&f](node_type& item, K const& ) { cds::unref(f)( item.m_val );});
+            return base_class::find( key, [&f](node_type& item, K const& ) { f( item.m_val );});
         }
 
         /// Find the key \p val using \p pred predicate for comparing
@@ -710,7 +710,7 @@ namespace cds { namespace container {
         bool find_with( K const& key, Predicate pred, Func f )
         {
             return base_class::find_with( key, cds::details::predicate_wrapper<node_type, Predicate, key_accessor>(),
-                [&f](node_type& item, K const& ) { cds::unref(f)( item.m_val );});
+                [&f](node_type& item, K const& ) { f( item.m_val );});
         }
 
         /// Find the key \p key
index 5f2bf3e..605f2a4 100644 (file)
@@ -537,13 +537,13 @@ namespace cds { namespace container {
             Therefore, the \p value_type should be constructible from type \p Q.
 
             The user-defined functor is called only if the inserting is success. It can be passed by reference
-            using <tt>boost::ref</tt>
+            using \p std::ref
         */
         template <typename Q, typename Func>
         bool insert( Q const& val, Func f )
         {
             scoped_node_ptr pNode( alloc_node( val ));
-            if ( base_class::insert( *pNode, [&f]( node_type& node ) { cds::unref(f)( node.m_val ); } )) {
+            if ( base_class::insert( *pNode, [&f]( node_type& node ) { f( node.m_val ); } )) {
                 pNode.release();
                 return true;
             }
@@ -589,7 +589,7 @@ namespace cds { namespace container {
 
             The functor can change non-key fields of the \p item.
 
-            You can pass \p func argument by value or by reference using <tt>boost::ref</tt>.
+            You can pass \p func argument by value or by reference using \p std::ref
 
             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 val key
@@ -600,7 +600,7 @@ namespace cds { namespace container {
         {
             scoped_node_ptr pNode( alloc_node( val ));
             std::pair<bool, bool> res = base_class::ensure( *pNode,
-                [&val,&func](bool bNew, node_type& item, node_type const& ){ cds::unref(func)( bNew, item.m_val, val ); }
+                [&val,&func](bool bNew, node_type& item, node_type const& ){ func( bNew, item.m_val, val ); }
             );
             if ( res.first && res.second )
                 pNode.release();
@@ -668,7 +668,7 @@ namespace cds { namespace container {
         {
             node_type * pNode = base_class::erase( key );
             if ( pNode ) {
-                cds::unref(f)( pNode->m_val );
+                f( pNode->m_val );
                 free_node( pNode );
                 return true;
             }
@@ -688,7 +688,7 @@ namespace cds { namespace container {
         {
             node_type * pNode = base_class::erase_with( key, typename maker::template predicate_wrapper<Predicate, bool>() );
             if ( pNode ) {
-                cds::unref(f)( pNode->m_val );
+                f( pNode->m_val );
                 free_node( pNode );
                 return true;
             }
@@ -707,7 +707,7 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You can pass \p f argument by value or by reference using <tt>boost::ref</tt> or cds::ref.
+            You can pass \p f argument by value or by reference using \p std::ref
 
             The functor can change non-key fields of \p item.
             The \p val argument is non-const since it can be used as \p f functor destination i.e., the functor
@@ -721,7 +721,7 @@ namespace cds { namespace container {
         template <typename Q, typename Func>
         bool find( Q& val, Func f )
         {
-            return base_class::find( val, [&f](node_type& item, Q& v) { cds::unref(f)( item.m_val, v );});
+            return base_class::find( val, [&f](node_type& item, Q& v) { f( item.m_val, v );});
         }
 
         /// Find the key \p val using \p pred predicate for comparing
@@ -736,7 +736,7 @@ namespace cds { namespace container {
         bool find_with( Q& val, Predicate pred, Func f )
         {
             return base_class::find_with( val, typename maker::template predicate_wrapper<Predicate, bool>(),
-                [&f](node_type& item, Q& v) { cds::unref(f)( item.m_val, v );});
+                [&f](node_type& item, Q& v) { f( item.m_val, v );});
         }
 
         /// Find the key \p val
@@ -751,7 +751,7 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You can pass \p f argument by value or by reference using <tt>boost::ref</tt> or cds::ref.
+            You can pass \p f argument by value or by reference using \p std::ref
 
             The functor can change non-key fields of \p item.
 
@@ -763,7 +763,7 @@ namespace cds { namespace container {
         template <typename Q, typename Func>
         bool find( Q const& val, Func f )
         {
-            return base_class::find( val, [&f](node_type& item, Q const& v) { cds::unref(f)( item.m_val, v );});
+            return base_class::find( val, [&f](node_type& item, Q const& v) { f( item.m_val, v );});
         }
 
         /// Find the key \p val using \p pred predicate for comparing
@@ -778,7 +778,7 @@ namespace cds { namespace container {
         bool find_with( Q const& val, Predicate pred, Func f )
         {
             return base_class::find_with( val, typename maker::template predicate_wrapper<Predicate, bool>(),
-                [&f](node_type& item, Q const& v) { cds::unref(f)( item.m_val, v );});
+                [&f](node_type& item, Q const& v) { f( item.m_val, v );});
         }
 
         /// Find the key \p val
index 630f821..fce37e0 100644 (file)
@@ -16,7 +16,7 @@ namespace cds { namespace container {
 
     namespace details {
 
-#ifdef __CDS_CONTAINER_MICHAEL_LIST_BASE_H
+#ifdef __CDS_CONTAINER_DETAILS_MICHAEL_LIST_BASE_H
         // if michael_list included
 
         template <typename GC, typename T, typename Traits>
@@ -117,9 +117,9 @@ namespace cds { namespace container {
             typedef cds::intrusive::MichaelList< gc, node_type, ordered_list_traits >   ordered_list;
             typedef cds::intrusive::SplitListSet< gc, ordered_list, type_traits >       type;
         };
-#endif  // ifdef __CDS_CONTAINER_MICHAEL_LIST_BASE_H
+#endif  // ifdef __CDS_CONTAINER_DETAILS_MICHAEL_LIST_BASE_H
 
-#ifdef __CDS_CONTAINER_LAZY_LIST_BASE_H
+#ifdef __CDS_CONTAINER_DETAILS_LAZY_LIST_BASE_H
         // if lazy_list included
         template <typename GC, typename T, typename Traits>
         struct make_split_list_set< GC, T, lazy_list_tag, Traits >
@@ -226,7 +226,7 @@ namespace cds { namespace container {
             typedef cds::intrusive::LazyList< gc, node_type, ordered_list_traits >  ordered_list;
             typedef cds::intrusive::SplitListSet< gc, ordered_list, type_traits >   type;
         };
-#endif  // ifdef __CDS_CONTAINER_LAZY_LIST_BASE_H
+#endif  // ifdef __CDS_CONTAINER_DETAILS_LAZY_LIST_BASE_H
 
     }   // namespace details
 }}  // namespace cds::container
index 3da5594..3ac34c4 100644 (file)
@@ -213,7 +213,7 @@ namespace cds { namespace container {
                 - <tt>item.first</tt> is a const reference to item's key that cannot be changed.
                 - <tt>item.second</tt> is a reference to item's value that may be changed.
 
-            The user-defined functor can be passed by reference using <tt>boost::ref</tt>
+            The user-defined functor can be passed by reference using \p std::ref
             and it is called only if inserting is successful.
 
             The key_type should be constructible from value of type \p K.
@@ -232,7 +232,7 @@ namespace cds { namespace container {
         bool insert_key( const K& key, Func func )
         {
             scoped_node_ptr pNode( cxx_leaf_node_allocator().New( key ));
-            if ( base_class::insert( *pNode, [&func]( leaf_node& item ) { cds::unref(func)( item.m_Value ); } )) {
+            if ( base_class::insert( *pNode, [&func]( leaf_node& item ) { func( item.m_Value ); } )) {
                 pNode.release();
                 return true;
             }
@@ -281,7 +281,7 @@ namespace cds { namespace container {
 
             The functor may change any fields of the \p item.second that is \ref value_type.
 
-            You may pass \p func argument by reference using <tt>boost::ref</tt>.
+            You may pass \p func argument by reference using \p std::ref
 
             RCU \p synchronize method can be called. RCU should not be locked.
 
@@ -294,7 +294,7 @@ namespace cds { namespace container {
         {
             scoped_node_ptr pNode( cxx_leaf_node_allocator().New( key ));
             std::pair<bool, bool> res = base_class::ensure( *pNode,
-                [&func](bool bNew, leaf_node& item, leaf_node const& ){ cds::unref(func)( bNew, item.m_Value ); }
+                [&func](bool bNew, leaf_node& item, leaf_node const& ){ func( bNew, item.m_Value ); }
             );
             if ( res.first && res.second )
                 pNode.release();
@@ -348,7 +348,7 @@ namespace cds { namespace container {
         template <typename K, typename Func>
         bool erase( K const& key, Func f )
         {
-            return base_class::erase( key, [&f]( leaf_node& node) { cds::unref(f)( node.m_Value ); } );
+            return base_class::erase( key, [&f]( leaf_node& node) { f( node.m_Value ); } );
         }
 
         /// Deletes the item from the map using \p pred predicate for searching
@@ -362,7 +362,7 @@ namespace cds { namespace container {
         bool erase_with( K const& key, Less pred, Func f )
         {
             return base_class::erase_with( key, cds::details::predicate_wrapper< leaf_node, Less, typename maker::key_accessor >(),
-                [&f]( leaf_node& node) { cds::unref(f)( node.m_Value ); } );
+                [&f]( leaf_node& node) { f( node.m_Value ); } );
         }
 
         /// Extracts an item with minimal key from the map
@@ -452,7 +452,7 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found.
 
-            You can pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You can pass \p f argument by reference using \p std::ref
 
             The functor may change \p item.second.
 
@@ -463,7 +463,7 @@ namespace cds { namespace container {
         template <typename K, typename Func>
         bool find( K const& key, Func f )
         {
-            return base_class::find( key, [&f](leaf_node& item, K const& ) { cds::unref(f)( item.m_Value );});
+            return base_class::find( key, [&f](leaf_node& item, K const& ) { f( item.m_Value );});
         }
 
         /// Finds the key \p val using \p pred predicate for searching
@@ -477,7 +477,7 @@ namespace cds { namespace container {
         bool find_with( K const& key, Less pred, Func f )
         {
             return base_class::find_with( key, cds::details::predicate_wrapper< leaf_node, Less, typename maker::key_accessor >(),
-                [&f](leaf_node& item, K const& ) { cds::unref(f)( item.m_Value );});
+                [&f](leaf_node& item, K const& ) { f( item.m_Value );});
         }
 
         /// Find the key \p key
index 96788e5..405acc9 100644 (file)
@@ -224,7 +224,7 @@ namespace cds { namespace container {
             where \p val is the item inserted. User-defined functor \p f should guarantee that during changing
             \p val no any other changes could be made on this set's item by concurrent threads.
             The user-defined functor is called only if the inserting is success. It may be passed by reference
-            using <tt>boost::ref</tt>
+            using \p std::ref
 
             RCU \p synchronize method can be called. RCU should not be locked.
         */
@@ -232,7 +232,7 @@ namespace cds { namespace container {
         bool insert( Q const& val, Func f )
         {
             scoped_node_ptr sp( cxx_leaf_node_allocator().New( val ));
-            if ( base_class::insert( *sp.get(), [&f]( leaf_node& val ) { cds::unref(f)( val.m_Value ); } )) {
+            if ( base_class::insert( *sp.get(), [&f]( leaf_node& val ) { f( val.m_Value ); } )) {
                 sp.release();
                 return true;
             }
@@ -264,7 +264,7 @@ namespace cds { namespace container {
             The functor may change non-key fields of the \p item; however, \p func must guarantee
             that during changing no any other modifications could be made on this item by concurrent threads.
 
-            You may pass \p func argument by reference using <tt>boost::ref</tt>.
+            You may pass \p func argument by reference using \p std::ref
 
             RCU \p synchronize method can be called. RCU should not be locked.
 
@@ -277,7 +277,7 @@ namespace cds { namespace container {
         {
             scoped_node_ptr sp( cxx_leaf_node_allocator().New( val ));
             std::pair<bool, bool> bRes = base_class::ensure( *sp,
-                [&func, &val](bool bNew, leaf_node& node, leaf_node&){ cds::unref(func)( bNew, node.m_Value, val ); });
+                [&func, &val](bool bNew, leaf_node& node, leaf_node&){ func( bNew, node.m_Value, val ); });
             if ( bRes.first && bRes.second )
                 sp.release();
             return bRes;
@@ -357,7 +357,7 @@ namespace cds { namespace container {
         template <typename Q, typename Func>
         bool erase( Q const& key, Func f )
         {
-            return base_class::erase( key, [&f]( leaf_node const& node) { cds::unref(f)( node.m_Value ); } );
+            return base_class::erase( key, [&f]( leaf_node const& node) { f( node.m_Value ); } );
         }
 
         /// Deletes the item from the set using \p pred predicate for searching
@@ -371,7 +371,7 @@ namespace cds { namespace container {
         bool erase_with( Q const& key, Less pred, Func f )
         {
             return base_class::erase_with( key, cds::details::predicate_wrapper< leaf_node, Less, typename maker::value_accessor >(),
-                [&f]( leaf_node const& node) { cds::unref(f)( node.m_Value ); } );
+                [&f]( leaf_node const& node) { f( node.m_Value ); } );
         }
 
         /// Extracts an item with minimal key from the set
@@ -462,7 +462,7 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p f argument by reference using \p std::ref.
 
             The functor may change non-key fields of \p item. Note that the functor is only guarantee
             that \p item cannot be disposed during functor is executing.
@@ -482,7 +482,7 @@ namespace cds { namespace container {
         template <typename Q, typename Func>
         bool find( Q& val, Func f ) const
         {
-            return base_class::find( val, [&f]( leaf_node& node, Q& v ) { cds::unref(f)( node.m_Value, v ); });
+            return base_class::find( val, [&f]( leaf_node& node, Q& v ) { f( node.m_Value, v ); });
         }
 
         /// Finds the key \p val using \p pred predicate for searching
@@ -496,7 +496,7 @@ namespace cds { namespace container {
         bool find_with( Q& val, Less pred, Func f ) const
         {
             return base_class::find_with( val, cds::details::predicate_wrapper< leaf_node, Less, typename maker::value_accessor >(),
-                [&f]( leaf_node& node, Q& v ) { cds::unref(f)( node.m_Value, v ); } );
+                [&f]( leaf_node& node, Q& v ) { f( node.m_Value, v ); } );
         }
 
         /// Find the key \p val
@@ -511,7 +511,7 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p f argument by reference using \p std::ref.
 
             The functor may change non-key fields of \p item. Note that the functor is only guarantee
             that \p item cannot be disposed during functor is executing.
@@ -528,7 +528,7 @@ namespace cds { namespace container {
         template <typename Q, typename Func>
         bool find( Q const& val, Func f ) const
         {
-            return base_class::find( val, [&f]( leaf_node& node, Q const& v ) { cds::unref(f)( node.m_Value, v ); });
+            return base_class::find( val, [&f]( leaf_node& node, Q const& v ) { f( node.m_Value, v ); });
         }
 
         /// Finds the key \p val using \p pred predicate for searching
@@ -542,7 +542,7 @@ namespace cds { namespace container {
         bool find_with( Q const& val, Less pred, Func f ) const
         {
             return base_class::find_with( val, cds::details::predicate_wrapper< leaf_node, Less, typename maker::value_accessor >(),
-                [&f]( leaf_node& node, Q const& v ) { cds::unref(f)( node.m_Value, v ); } );
+                [&f]( leaf_node& node, Q const& v ) { f( node.m_Value, v ); } );
         }
 
         /// Find the key \p val
index 028f5d6..e3e35ce 100644 (file)
@@ -210,7 +210,7 @@ namespace cds { namespace container {
                 - <tt>item.first</tt> is a const reference to item's key that cannot be changed.
                 - <tt>item.second</tt> is a reference to item's value that may be changed.
 
-            The user-defined functor can be passed by reference using <tt>boost::ref</tt>
+            The user-defined functor can be passed by reference using \p std::ref
             and it is called only if inserting is successful.
 
             The key_type should be constructible from value of type \p K.
@@ -227,7 +227,7 @@ namespace cds { namespace container {
         bool insert_key( const K& key, Func func )
         {
             scoped_node_ptr pNode( cxx_leaf_node_allocator().New( key ));
-            if ( base_class::insert( *pNode, [&func]( leaf_node& item ) { cds::unref(func)( item.m_Value ); } )) {
+            if ( base_class::insert( *pNode, [&func]( leaf_node& item ) { func( item.m_Value ); } )) {
                 pNode.release();
                 return true;
             }
@@ -274,7 +274,7 @@ namespace cds { namespace container {
 
             The functor may change any fields of the \p item.second that is \ref value_type.
 
-            You may pass \p func argument by reference using <tt>boost::ref</tt>.
+            You may pass \p func argument by reference using \p std::ref.
 
             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
@@ -285,7 +285,7 @@ namespace cds { namespace container {
         {
             scoped_node_ptr pNode( cxx_leaf_node_allocator().New( key ));
             std::pair<bool, bool> res = base_class::ensure( *pNode,
-                [&func](bool bNew, leaf_node& item, leaf_node const& ){ cds::unref(func)( bNew, item.m_Value ); }
+                [&func](bool bNew, leaf_node& item, leaf_node const& ){ func( bNew, item.m_Value ); }
             );
             if ( res.first && res.second )
                 pNode.release();
@@ -335,7 +335,7 @@ namespace cds { namespace container {
         template <typename K, typename Func>
         bool erase( K const& key, Func f )
         {
-            return base_class::erase( key, [&f]( leaf_node& node) { cds::unref(f)( node.m_Value ); } );
+            return base_class::erase( key, [&f]( leaf_node& node) { f( node.m_Value ); } );
         }
 
         /// Deletes the item from the map using \p pred predicate for searching
@@ -349,7 +349,7 @@ namespace cds { namespace container {
         bool erase_with( K const& key, Less pred, Func f )
         {
             return base_class::erase_with( key, cds::details::predicate_wrapper< leaf_node, Less, typename maker::key_accessor >(),
-                [&f]( leaf_node& node) { cds::unref(f)( node.m_Value ); } );
+                [&f]( leaf_node& node) { f( node.m_Value ); } );
         }
 
         /// Extracts an item with minimal key from the map
@@ -432,7 +432,7 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found.
 
-            You can pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You can pass \p f argument by reference using std::ref.
 
             The functor may change \p item.second.
 
@@ -441,7 +441,7 @@ namespace cds { namespace container {
         template <typename K, typename Func>
         bool find( K const& key, Func f )
         {
-            return base_class::find( key, [&f](leaf_node& item, K const& ) { cds::unref(f)( item.m_Value );});
+            return base_class::find( key, [&f](leaf_node& item, K const& ) { f( item.m_Value );});
         }
 
         /// Finds the key \p val using \p pred predicate for searching
@@ -455,7 +455,7 @@ namespace cds { namespace container {
         bool find_with( K const& key, Less pred, Func f )
         {
             return base_class::find_with( key, cds::details::predicate_wrapper< leaf_node, Less, typename maker::key_accessor >(),
-                [&f](leaf_node& item, K const& ) { cds::unref(f)( item.m_Value );});
+                [&f](leaf_node& item, K const& ) { f( item.m_Value );});
         }
 
         /// Find the key \p key
index e47739d..632b2b7 100644 (file)
@@ -223,13 +223,13 @@ namespace cds { namespace container {
             where \p val is the item inserted. User-defined functor \p f should guarantee that during changing
             \p val no any other changes could be made on this set's item by concurrent threads.
             The user-defined functor is called only if the inserting is success. It may be passed by reference
-            using <tt>boost::ref</tt>
+            using \p std::ref
         */
         template <typename Q, typename Func>
         bool insert( Q const& val, Func f )
         {
             scoped_node_ptr sp( cxx_leaf_node_allocator().New( val ));
-            if ( base_class::insert( *sp.get(), [&f]( leaf_node& val ) { cds::unref(f)( val.m_Value ); } )) {
+            if ( base_class::insert( *sp.get(), [&f]( leaf_node& val ) { f( val.m_Value ); } )) {
                 sp.release();
                 return true;
             }
@@ -261,7 +261,7 @@ namespace cds { namespace container {
             The functor may change non-key fields of the \p item; however, \p func must guarantee
             that during changing no any other modifications could be made on this item by concurrent threads.
 
-            You may pass \p func argument by reference using <tt>boost::ref</tt>.
+            You may pass \p func argument by reference using \p std::ref.
 
             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
@@ -272,7 +272,7 @@ namespace cds { namespace container {
         {
             scoped_node_ptr sp( cxx_leaf_node_allocator().New( val ));
             std::pair<bool, bool> bRes = base_class::ensure( *sp,
-                [&func, &val](bool bNew, leaf_node& node, leaf_node&){ cds::unref(func)( bNew, node.m_Value, val ); });
+                [&func, &val](bool bNew, leaf_node& node, leaf_node&){ func( bNew, node.m_Value, val ); });
             if ( bRes.first && bRes.second )
                 sp.release();
             return bRes;
@@ -344,7 +344,7 @@ namespace cds { namespace container {
         template <typename Q, typename Func>
         bool erase( Q const& key, Func f )
         {
-            return base_class::erase( key, [&f]( leaf_node const& node) { cds::unref(f)( node.m_Value ); } );
+            return base_class::erase( key, [&f]( leaf_node const& node) { f( node.m_Value ); } );
         }
 
         /// Deletes the item from the set using \p pred predicate for searching
@@ -358,7 +358,7 @@ namespace cds { namespace container {
         bool erase_with( Q const& key, Less pred, Func f )
         {
             return base_class::erase_with( key, cds::details::predicate_wrapper< leaf_node, Less, typename maker::value_accessor >(),
-                [&f]( leaf_node const& node) { cds::unref(f)( node.m_Value ); } );
+                [&f]( leaf_node const& node) { f( node.m_Value ); } );
         }
 
         /// Extracts an item with minimal key from the set
@@ -442,7 +442,7 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p f argument by reference using \p std::ref.
 
             The functor may change non-key fields of \p item. Note that the functor is only guarantee
             that \p item cannot be disposed during functor is executing.
@@ -460,7 +460,7 @@ namespace cds { namespace container {
         template <typename Q, typename Func>
         bool find( Q& val, Func f )
         {
-            return base_class::find( val, [&f]( leaf_node& node, Q& v ) { cds::unref(f)( node.m_Value, v ); });
+            return base_class::find( val, [&f]( leaf_node& node, Q& v ) { f( node.m_Value, v ); });
         }
 
         /// Finds the key \p val using \p pred predicate for searching
@@ -474,7 +474,7 @@ namespace cds { namespace container {
         bool find_with( Q& val, Less pred, Func f )
         {
             return base_class::find_with( val, cds::details::predicate_wrapper< leaf_node, Less, typename maker::value_accessor >(),
-                [&f]( leaf_node& node, Q& v ) { cds::unref(f)( node.m_Value, v ); } );
+                [&f]( leaf_node& node, Q& v ) { f( node.m_Value, v ); } );
         }
 
         /// Find the key \p val
@@ -489,7 +489,7 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p f argument by reference using \p std::ref.
 
             The functor may change non-key fields of \p item. Note that the functor is only guarantee
             that \p item cannot be disposed during functor is executing.
@@ -504,7 +504,7 @@ namespace cds { namespace container {
         template <typename Q, typename Func>
         bool find( Q const& val, Func f )
         {
-            return base_class::find( val, [&f]( leaf_node& node, Q const& v ) { cds::unref(f)( node.m_Value, v ); });
+            return base_class::find( val, [&f]( leaf_node& node, Q const& v ) { f( node.m_Value, v ); });
         }
 
         /// Finds the key \p val using \p pred predicate for searching
@@ -518,7 +518,7 @@ namespace cds { namespace container {
         bool find_with( Q const& val, Less pred, Func f )
         {
             return base_class::find_with( val, cds::details::predicate_wrapper< leaf_node, Less, typename maker::value_accessor >(),
-                [&f]( leaf_node& node, Q const& v ) { cds::unref(f)( node.m_Value, v ); } );
+                [&f]( leaf_node& node, Q const& v ) { f( node.m_Value, v ); } );
         }
 
         /// Find the key \p val
index f4265bd..3fc3644 100644 (file)
@@ -4,7 +4,7 @@
 #define __CDS_CONTAINER_IMPL_LAZY_KVLIST_H
 
 #include <memory>
-#include <cds/ref.h>
+#include <functional>   // ref
 #include <cds/details/functor_wrapper.h>
 #include <cds/container/details/guarded_ptr_cast.h>
 
@@ -417,7 +417,7 @@ namespace cds { namespace container {
             to the list's item inserted. <tt>item.second</tt> is a reference to item's value that may be changed.
             User-defined functor \p func should guarantee that during changing item's value no any other changes
             could be made on this list's item by concurrent threads.
-            The user-defined functor can be passed by reference using <tt>boost::ref</tt>
+            The user-defined functor can be passed by reference using \p std::ref
             and it is called only if inserting is successful.
 
             The key_type should be constructible from value of type \p K.
@@ -473,7 +473,7 @@ namespace cds { namespace container {
             however, \p func must guarantee that during changing no any other modifications
             could be made on this item by concurrent threads.
 
-            You may pass \p func argument by reference using <tt>boost::ref</tt>.
+            You may pass \p func argument by reference using \p std::ref.
 
             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
@@ -624,7 +624,7 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found.
 
-            You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p f argument by reference using \p std::ref.
 
             The functor may change <tt>item.second</tt> that is reference to value of node.
             Note that the function is only guarantee that \p item cannot be deleted during functor is executing.
@@ -760,7 +760,7 @@ namespace cds { namespace container {
         {
             scoped_node_ptr pNode( alloc_node( key ));
 
-            if ( base_class::insert_at( &refHead, *pNode, [&f](node_type& node){ cds::unref(f)( node.m_Data ); } )) {
+            if ( base_class::insert_at( &refHead, *pNode, [&f](node_type& node){ f( node.m_Data ); } )) {
                 pNode.release();
                 return true;
             }
@@ -782,7 +782,7 @@ namespace cds { namespace container {
         template <typename K, typename Compare, typename Func>
         bool erase_at( head_type& refHead, K const& key, Compare cmp, Func f )
         {
-            return base_class::erase_at( &refHead, key, cmp, [&f](node_type const & node){cds::unref(f)( const_cast<value_type&>(node.m_Data)); });
+            return base_class::erase_at( &refHead, key, cmp, [&f](node_type const & node){f( const_cast<value_type&>(node.m_Data)); });
         }
 
         template <typename K, typename Compare>
@@ -797,7 +797,7 @@ namespace cds { namespace container {
             scoped_node_ptr pNode( alloc_node( key ));
 
             std::pair<bool, bool> ret = base_class::ensure_at( &refHead, *pNode,
-                [&f]( bool bNew, node_type& node, node_type& ){ cds::unref(f)( bNew, node.m_Data ); });
+                [&f]( bool bNew, node_type& node, node_type& ){ f( bNew, node.m_Data ); });
             if ( ret.first && ret.second )
                 pNode.release();
 
@@ -813,7 +813,7 @@ namespace cds { namespace container {
         template <typename K, typename Compare, typename Func>
         bool find_at( head_type& refHead, K& key, Compare cmp, Func f )
         {
-            return base_class::find_at( &refHead, key, cmp, [&f]( node_type& node, K& ){ cds::unref(f)( node.m_Data ); });
+            return base_class::find_at( &refHead, key, cmp, [&f]( node_type& node, K& ){ f( node.m_Data ); });
         }
 
         template <typename K, typename Compare>
index 57777dd..783e08d 100644 (file)
@@ -376,7 +376,7 @@ namespace cds { namespace container {
             The argument \p itemValue of user-defined functor \p func is the reference
             to the list's item inserted. User-defined functor \p func should guarantee that during changing
             item's value no any other changes could be made on this list's item by concurrent threads.
-            The user-defined functor can be passed by reference using <tt>boost::ref</tt>
+            The user-defined functor can be passed by reference using \p std::ref
             and it is called only if the inserting is success.
 
             The type \p Q should contain the complete key of the node.
@@ -431,7 +431,7 @@ namespace cds { namespace container {
             The functor may change non-key fields of the \p item; however, \p func must guarantee
             that during changing no any other modifications could be made on this item by concurrent threads.
 
-            You may pass \p func argument by reference using <tt>boost::ref</tt>.
+            You may pass \p func argument by reference using \p std::ref
 
             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
@@ -593,7 +593,7 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p f argument by reference using \p std::ref.
 
             The functor may change non-key fields of \p item. Note that the function is only guarantee
             that \p item cannot be deleted during functor is executing.
@@ -635,7 +635,7 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p f argument by reference using \p std::ref.
 
             The function does not serialize simultaneous access to the list \p item. If such access is
             possible you must provide your own synchronization schema to exclude unsafe item modifications.
@@ -769,7 +769,7 @@ namespace cds { namespace container {
         {
             scoped_node_ptr pNode( alloc_node( key ));
 
-            if ( base_class::insert_at( &refHead, *pNode, [&f](node_type& node){ cds::unref(f)( node_to_value(node) ); } )) {
+            if ( base_class::insert_at( &refHead, *pNode, [&f](node_type& node){ f( node_to_value(node) ); } )) {
                 pNode.release();
                 return true;
             }
@@ -779,7 +779,7 @@ namespace cds { namespace container {
         template <typename Q, typename Compare, typename Func>
         bool erase_at( head_type& refHead, const Q& key, Compare cmp, Func f )
         {
-            return base_class::erase_at( &refHead, key, cmp, [&f](node_type const& node){ cds::unref(f)( node_to_value(node) ); } );
+            return base_class::erase_at( &refHead, key, cmp, [&f](node_type const& node){ f( node_to_value(node) ); } );
         }
 
         template <typename Q, typename Compare>
@@ -794,7 +794,7 @@ namespace cds { namespace container {
             scoped_node_ptr pNode( alloc_node( key ));
 
             std::pair<bool, bool> ret = base_class::ensure_at( &refHead, *pNode,
-                [&f, &key](bool bNew, node_type& node, node_type&){cds::unref(f)( bNew, node_to_value(node), key ); });
+                [&f, &key](bool bNew, node_type& node, node_type&){f( bNew, node_to_value(node), key ); });
             if ( ret.first && ret.second )
                 pNode.release();
 
@@ -810,7 +810,7 @@ namespace cds { namespace container {
         template <typename Q, typename Compare, typename Func>
         bool find_at( head_type& refHead, Q& val, Compare cmp, Func f )
         {
-            return base_class::find_at( &refHead, val, cmp, [&f](node_type& node, Q& val){ cds::unref(f)( node_to_value(node), val ); });
+            return base_class::find_at( &refHead, val, cmp, [&f](node_type& node, Q& val){ f( node_to_value(node), val ); });
         }
 
         template <typename Q, typename Compare>
index d9dffc9..cd50086 100644 (file)
@@ -4,7 +4,7 @@
 #define __CDS_CONTAINER_IMPL_MICHAEL_KVLIST_H
 
 #include <memory>
-#include <cds/ref.h>
+#include <functional>   // ref
 #include <cds/details/functor_wrapper.h>
 #include <cds/container/details/guarded_ptr_cast.h>
 
@@ -396,7 +396,7 @@ namespace cds { namespace container {
             to the list's item inserted. <tt>item.second</tt> is a reference to item's value that may be changed.
             User-defined functor \p func should guarantee that during changing item's value no any other changes
             could be made on this list's item by concurrent threads.
-            The user-defined functor can be passed by reference using <tt>boost::ref</tt>
+            The user-defined functor can be passed by reference using \p std::ref
             and it is called only if inserting is successful.
 
             The key_type should be constructible from value of type \p K.
@@ -442,7 +442,7 @@ namespace cds { namespace container {
             however, \p func must guarantee that during changing no any other modifications
             could be made on this item by concurrent threads.
 
-            You may pass \p func argument by reference using <tt>boost::ref</tt>.
+            You may pass \p func argument by reference using \p std::ref
 
             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
@@ -608,7 +608,7 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found.
 
-            You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p f argument by reference using \p std::ref
 
             The functor may change <tt>item.second</tt> that is reference to value of node.
             Note that the function is only guarantee that \p item cannot be deleted during functor is executing.
@@ -745,7 +745,7 @@ namespace cds { namespace container {
         {
             scoped_node_ptr pNode( alloc_node( key ));
 
-            if ( base_class::insert_at( refHead, *pNode, [&f](node_type& node){ cds::unref(f)( node.m_Data ); })) {
+            if ( base_class::insert_at( refHead, *pNode, [&f](node_type& node){ f( node.m_Data ); })) {
                 pNode.release();
                 return true;
             }
@@ -764,7 +764,7 @@ namespace cds { namespace container {
             scoped_node_ptr pNode( alloc_node( key ));
 
             std::pair<bool, bool> ret = base_class::ensure_at( refHead, *pNode,
-                [&f]( bool bNew, node_type& node, node_type& ){ cds::unref(f)( bNew, node.m_Data ); });
+                [&f]( bool bNew, node_type& node, node_type& ){ f( bNew, node.m_Data ); });
             if ( ret.first && ret.second )
                 pNode.release();
 
@@ -780,7 +780,7 @@ namespace cds { namespace container {
         template <typename K, typename Compare, typename Func>
         bool erase_at( head_type& refHead, K const& key, Compare cmp, Func f )
         {
-            return base_class::erase_at( refHead, key, cmp, [&f]( node_type const & node ){ cds::unref(f)( const_cast<value_type&>(node.m_Data)); });
+            return base_class::erase_at( refHead, key, cmp, [&f]( node_type const & node ){ f( const_cast<value_type&>(node.m_Data)); });
         }
         template <typename K, typename Compare>
         bool extract_at( head_type& refHead, typename gc::Guard& dest, K const& key, Compare cmp )
@@ -797,7 +797,7 @@ namespace cds { namespace container {
         template <typename K, typename Compare, typename Func>
         bool find_at( head_type& refHead, K& key, Compare cmp, Func f )
         {
-            return base_class::find_at( refHead, key, cmp, [&f](node_type& node, K const&){ cds::unref(f)( node.m_Data ); });
+            return base_class::find_at( refHead, key, cmp, [&f](node_type& node, K const&){ f( node.m_Data ); });
         }
 
         template <typename K, typename Compare>
index 4bbf019..7ef71ec 100644 (file)
@@ -347,7 +347,7 @@ namespace cds { namespace container {
             The argument \p itemValue of user-defined functor \p func is the reference
             to the list's item inserted. User-defined functor \p func should guarantee that during changing
             item's value no any other changes could be made on this list's item by concurrent threads.
-            The user-defined functor can be passed by reference using <tt>boost::ref</tt>
+            The user-defined functor can be passed by reference using \p std::ref
             and it is called only if the inserting is success.
 
             The type \p Q should contain the complete key of the node.
@@ -392,7 +392,7 @@ namespace cds { namespace container {
             The functor may change non-key fields of the \p item; however, \p func must guarantee
             that during changing no any other modifications could be made on this item by concurrent threads.
 
-            You may pass \p func argument by reference using <tt>boost::ref</tt>.
+            You may pass \p func argument by reference by \p std::ref
 
             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
@@ -564,7 +564,7 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p f argument by reference using \p std::ref
 
             The functor may change non-key fields of \p item. Note that the function is only guarantee
             that \p item cannot be deleted during functor is executing.
@@ -606,7 +606,7 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p f argument by reference using \p std::ref
 
             The functor may change non-key fields of \p item. Note that the function is only guarantee
             that \p item cannot be deleted during functor is executing.
@@ -735,7 +735,7 @@ namespace cds { namespace container {
         {
             scoped_node_ptr pNode( alloc_node( key ));
 
-            if ( base_class::insert_at( refHead, *pNode, [&f]( node_type& node ) { cds::unref(f)( node_to_value(node) ); } )) {
+            if ( base_class::insert_at( refHead, *pNode, [&f]( node_type& node ) { f( node_to_value(node) ); } )) {
                 pNode.release();
                 return true;
             }
@@ -751,7 +751,7 @@ namespace cds { namespace container {
         template <typename Q, typename Compare, typename Func>
         bool erase_at( head_type& refHead, Q const& key, Compare cmp, Func f )
         {
-            return base_class::erase_at( refHead, key, cmp, [&f](node_type const& node){ cds::unref(f)( node_to_value(node) ); } );
+            return base_class::erase_at( refHead, key, cmp, [&f](node_type const& node){ f( node_to_value(node) ); } );
         }
 
         template <typename Q, typename Compare>
@@ -766,7 +766,7 @@ namespace cds { namespace container {
             scoped_node_ptr pNode( alloc_node( key ));
 
             std::pair<bool, bool> ret = base_class::ensure_at( refHead, *pNode,
-                [&f, &key](bool bNew, node_type& node, node_type&){ cds::unref(f)( bNew, node_to_value(node), key ); });
+                [&f, &key](bool bNew, node_type& node, node_type&){ f( bNew, node_to_value(node), key ); });
             if ( ret.first && ret.second )
                 pNode.release();
 
@@ -782,7 +782,7 @@ namespace cds { namespace container {
         template <typename Q, typename Compare, typename Func>
         bool find_at( head_type& refHead, Q& val, Compare cmp, Func f )
         {
-            return base_class::find_at( refHead, val, cmp, [&f](node_type& node, Q& v){ cds::unref(f)( node_to_value(node), v ); });
+            return base_class::find_at( refHead, val, cmp, [&f](node_type& node, Q& v){ f( node_to_value(node), v ); });
         }
 
         template <typename Q, typename Compare>
index dd5e785..6ad9a18 100644 (file)
@@ -274,7 +274,7 @@ namespace cds { namespace container {
                 - <tt>item.first</tt> is a const reference to item's key that cannot be changed.
                 - <tt>item.second</tt> is a reference to item's value that may be changed.
 
-            The user-defined functor can be passed by reference using <tt>boost::ref</tt>
+            The user-defined functor can be passed by reference using \p std::ref
             and it is called only if inserting is successful.
 
             The key_type should be constructible from value of type \p K.
@@ -291,7 +291,7 @@ namespace cds { namespace container {
         bool insert_key( const K& key, Func func )
         {
             scoped_node_ptr pNode( node_allocator().New( random_level(), key ));
-            if ( base_class::insert( *pNode, [&func]( node_type& item ) { cds::unref(func)( item.m_Value ); } )) {
+            if ( base_class::insert( *pNode, [&func]( node_type& item ) { func( item.m_Value ); } )) {
                 pNode.release();
                 return true;
             }
@@ -338,7 +338,7 @@ namespace cds { namespace container {
 
             The functor may change any fields of the \p item.second that is \ref value_type.
 
-            You may pass \p func argument by reference using <tt>boost::ref</tt>.
+            You may pass \p func argument by reference using \p std::ref
 
             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
@@ -349,7 +349,7 @@ namespace cds { namespace container {
         {
             scoped_node_ptr pNode( node_allocator().New( random_level(), key ));
             std::pair<bool, bool> res = base_class::ensure( *pNode,
-                [&func](bool bNew, node_type& item, node_type const& ){ cds::unref(func)( bNew, item.m_Value ); }
+                [&func](bool bNew, node_type& item, node_type const& ){ func( bNew, item.m_Value ); }
             );
             if ( res.first && res.second )
                 pNode.release();
@@ -399,7 +399,7 @@ namespace cds { namespace container {
         template <typename K, typename Func>
         bool erase( K const& key, Func f )
         {
-            return base_class::erase( key, [&f]( node_type& node) { cds::unref(f)( node.m_Value ); } );
+            return base_class::erase( key, [&f]( node_type& node) { f( node.m_Value ); } );
         }
 
         /// Deletes the item from the map using \p pred predicate for searching
@@ -414,7 +414,7 @@ namespace cds { namespace container {
         {
             return base_class::erase_with( key,
                 cds::details::predicate_wrapper< node_type, Less, typename maker::key_accessor >(),
-                [&f]( node_type& node) { cds::unref(f)( node.m_Value ); } );
+                [&f]( node_type& node) { f( node.m_Value ); } );
         }
 
         /// Extracts the item from the map with specified \p key
@@ -536,7 +536,7 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found.
 
-            You can pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You can pass \p f argument by reference using \p std::ref
 
             The functor may change \p item.second.
 
@@ -545,7 +545,7 @@ namespace cds { namespace container {
         template <typename K, typename Func>
         bool find( K const& key, Func f )
         {
-            return base_class::find( key, [&f](node_type& item, K const& ) { cds::unref(f)( item.m_Value );});
+            return base_class::find( key, [&f](node_type& item, K const& ) { f( item.m_Value );});
         }
 
         /// Finds the key \p val using \p pred predicate for searching
@@ -560,7 +560,7 @@ namespace cds { namespace container {
         {
             return base_class::find_with( key,
                 cds::details::predicate_wrapper< node_type, Less, typename maker::key_accessor >(),
-                [&f](node_type& item, K const& ) { cds::unref(f)( item.m_Value );});
+                [&f](node_type& item, K const& ) { f( item.m_Value );});
         }
 
         /// Find the key \p key
index f4a89c9..783bc86 100644 (file)
@@ -250,13 +250,13 @@ namespace cds { namespace container {
             where \p val is the item inserted. User-defined functor \p f should guarantee that during changing
             \p val no any other changes could be made on this set's item by concurrent threads.
             The user-defined functor is called only if the inserting is success. It may be passed by reference
-            using <tt>boost::ref</tt>
+            using \p std::ref
         */
         template <typename Q, typename Func>
         bool insert( Q const& val, Func f )
         {
             scoped_node_ptr sp( node_allocator().New( random_level(), val ));
-            if ( base_class::insert( *sp.get(), [&f]( node_type& val ) { cds::unref(f)( val.m_Value ); } )) {
+            if ( base_class::insert( *sp.get(), [&f]( node_type& val ) { f( val.m_Value ); } )) {
                 sp.release();
                 return true;
             }
@@ -288,7 +288,7 @@ namespace cds { namespace container {
             The functor may change non-key fields of the \p item; however, \p func must guarantee
             that during changing no any other modifications could be made on this item by concurrent threads.
 
-            You may pass \p func argument by reference using <tt>boost::ref</tt>.
+            You may pass \p func argument by reference using \p std::ref
 
             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
@@ -299,7 +299,7 @@ namespace cds { namespace container {
         {
             scoped_node_ptr sp( node_allocator().New( random_level(), val ));
             std::pair<bool, bool> bRes = base_class::ensure( *sp,
-                [&func, &val](bool bNew, node_type& node, node_type&){ cds::unref(func)( bNew, node.m_Value, val ); });
+                [&func, &val](bool bNew, node_type& node, node_type&){ func( bNew, node.m_Value, val ); });
             if ( bRes.first && bRes.second )
                 sp.release();
             return bRes;
@@ -373,7 +373,7 @@ namespace cds { namespace container {
         template <typename Q, typename Func>
         bool erase( Q const& key, Func f )
         {
-            return base_class::erase( key, [&f]( node_type const& node) { cds::unref(f)( node.m_Value ); } );
+            return base_class::erase( key, [&f]( node_type const& node) { f( node.m_Value ); } );
         }
 
         /// Deletes the item from the set using \p pred predicate for searching
@@ -387,7 +387,7 @@ namespace cds { namespace container {
         bool erase_with( Q const& key, Less pred, Func f )
         {
             return base_class::erase_with( key, cds::details::predicate_wrapper< node_type, Less, typename maker::value_accessor >(),
-                [&f]( node_type const& node) { cds::unref(f)( node.m_Value ); } );
+                [&f]( node_type const& node) { f( node.m_Value ); } );
         }
 
         /// Extracts the item from the set with specified \p key
@@ -509,7 +509,7 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p f argument by reference using \p std::ref
 
             The functor may change non-key fields of \p item. Note that the functor is only guarantee
             that \p item cannot be disposed during functor is executing.
@@ -527,7 +527,7 @@ namespace cds { namespace container {
         template <typename Q, typename Func>
         bool find( Q& val, Func f )
         {
-            return base_class::find( val, [&f]( node_type& node, Q& v ) { cds::unref(f)( node.m_Value, v ); });
+            return base_class::find( val, [&f]( node_type& node, Q& v ) { f( node.m_Value, v ); });
         }
 
         /// Finds the key \p val using \p pred predicate for searching
@@ -541,7 +541,7 @@ namespace cds { namespace container {
         bool find_with( Q& val, Less pred, Func f )
         {
             return base_class::find_with( val, cds::details::predicate_wrapper< node_type, Less, typename maker::value_accessor >(),
-                [&f]( node_type& node, Q& v ) { cds::unref(f)( node.m_Value, v ); } );
+                [&f]( node_type& node, Q& v ) { f( node.m_Value, v ); } );
         }
 
         /// Find the key \p val
@@ -556,7 +556,7 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p f argument by reference using \p std::ref
 
             The functor may change non-key fields of \p item. Note that the functor is only guarantee
             that \p item cannot be disposed during functor is executing.
@@ -571,7 +571,7 @@ namespace cds { namespace container {
         template <typename Q, typename Func>
         bool find( Q const& val, Func f )
         {
-            return base_class::find( val, [&f]( node_type& node, Q const& v ) { cds::unref(f)( node.m_Value, v ); });
+            return base_class::find( val, [&f]( node_type& node, Q const& v ) { f( node.m_Value, v ); });
         }
 
         /// Finds the key \p val using \p pred predicate for searching
@@ -585,7 +585,7 @@ namespace cds { namespace container {
         bool find_with( Q const& val, Less cmp, Func f )
         {
             return base_class::find_with( val, cds::details::predicate_wrapper< node_type, Less, typename maker::value_accessor >(),
-                [&f]( node_type& node, Q const& v ) { cds::unref(f)( node.m_Value, v ); } );
+                [&f]( node_type& node, Q const& v ) { f( node.m_Value, v ); } );
         }
 
         /// Find the key \p val
index f05fc44..f698242 100644 (file)
@@ -387,7 +387,7 @@ namespace cds { namespace container {
             to the list's item inserted. <tt>item.second</tt> is a reference to item's value that may be changed.
             User-defined functor \p func should guarantee that during changing item's value no any other changes
             could be made on this list's item by concurrent threads.
-            The user-defined functor can be passed by reference using <tt>boost::ref</tt>
+            The user-defined functor can be passed by reference using \p std::ref
             and it is called only if the inserting is successful.
 
             The key_type should be constructible from value of type \p K.
@@ -517,7 +517,7 @@ namespace cds { namespace container {
             scoped_node_ptr pNode( alloc_node( key ));
 
             if ( base_class::insert_at( &refHead, *pNode )) {
-                cds::unref(f)( pNode->m_Data );
+                f( pNode->m_Data );
                 return pNode.release();
             }
 
@@ -555,7 +555,7 @@ namespace cds { namespace container {
         template <typename K, typenam Compare, typename Func>
         bool find_at( head_type& refHead, K& key, Compare cmp, Func f )
         {
-            return base_class::find_at( &refHead, key, cmp, [&f]( node_type& node, K const& ){ cds::unref(f)( node.m_Data ); });
+            return base_class::find_at( &refHead, key, cmp, [&f]( node_type& node, K const& ){ f( node.m_Data ); });
         }
         */
         //@endcond
index 10d47ae..c93b2d3 100644 (file)
@@ -4,10 +4,10 @@
 #define __CDS_CONTAINER_LAZY_KVLIST_RCU_H
 
 #include <memory>
+#include <functional>   // ref
 #include <cds/container/details/lazy_list_base.h>
 #include <cds/intrusive/lazy_list_rcu.h>
 #include <cds/container/details/make_lazy_kvlist.h>
-#include <cds/ref.h>
 #include <cds/details/functor_wrapper.h>
 
 namespace cds { namespace container {
@@ -398,7 +398,7 @@ namespace cds { namespace container {
             to the list's item inserted. <tt>item.second</tt> is a reference to item's value that may be changed.
             User-defined functor \p func should guarantee that during changing item's value no any other changes
             could be made on this list's item by concurrent threads.
-            The user-defined functor can be passed by reference using <tt>boost::ref</tt>
+            The user-defined functor can be passed by reference using \p std::ref
             and it is called only if inserting is successful.
 
             The key_type should be constructible from value of type \p K.
@@ -458,7 +458,7 @@ namespace cds { namespace container {
             however, \p func must guarantee that during changing no any other modifications
             could be made on this item by concurrent threads.
 
-            You may pass \p func argument by reference using <tt>boost::ref</tt>.
+            You may pass \p func argument by reference using \p std::ref
 
             The function makes RCU lock internally.
 
@@ -631,7 +631,7 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found.
 
-            You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p f argument by reference using \p std::ref.
 
             The functor may change <tt>item.second</tt> that is reference to value of node.
             Note that the function is only guarantee that \p item cannot be deleted during functor is executing.
@@ -769,7 +769,7 @@ namespace cds { namespace container {
         {
             scoped_node_ptr pNode( alloc_node( key ));
 
-            if ( base_class::insert_at( &refHead, *pNode, [&f](node_type& node){ cds::unref(f)( node.m_Data ); } )) {
+            if ( base_class::insert_at( &refHead, *pNode, [&f](node_type& node){ f( node.m_Data ); } )) {
                 pNode.release();
                 return true;
             }
@@ -791,7 +791,7 @@ namespace cds { namespace container {
         template <typename K, typename Compare, typename Func>
         bool erase_at( head_type& refHead, K const & key, Compare cmp, Func f )
         {
-            return base_class::erase_at( &refHead, key, cmp, [&f](node_type const & node){cds::unref(f)( const_cast<value_type&>(node.m_Data)); });
+            return base_class::erase_at( &refHead, key, cmp, [&f](node_type const & node){f( const_cast<value_type&>(node.m_Data)); });
         }
 
         template <typename K, typename Func>
@@ -800,7 +800,7 @@ namespace cds { namespace container {
             scoped_node_ptr pNode( alloc_node( key ));
 
             std::pair<bool, bool> ret = base_class::ensure_at( &refHead, *pNode,
-                [&f]( bool bNew, node_type& node, node_type& ){ cds::unref(f)( bNew, node.m_Data ); });
+                [&f]( bool bNew, node_type& node, node_type& ){ f( bNew, node.m_Data ); });
             if ( ret.first && ret.second )
                 pNode.release();
 
@@ -822,7 +822,7 @@ namespace cds { namespace container {
         template <typename K, typename Compare, typename Func>
         bool find_at( head_type& refHead, K& key, Compare cmp, Func f ) const
         {
-            return base_class::find_at( &refHead, key, cmp, [&f]( node_type& node, K& ){ cds::unref(f)( node.m_Data ); });
+            return base_class::find_at( &refHead, key, cmp, [&f]( node_type& node, K& ){ f( node.m_Data ); });
         }
 
         template <typename K, typename Compare>
index 745273f..a3ff3e5 100644 (file)
@@ -370,7 +370,7 @@ namespace cds { namespace container {
             The argument \p itemValue of user-defined functor \p func is the reference
             to the list's item inserted. User-defined functor \p func should guarantee that during changing
             item's value no any other changes could be made on this list's item by concurrent threads.
-            The user-defined functor can be passed by reference using <tt>boost::ref</tt>
+            The user-defined functor can be passed by reference using \p std::ref
             and it is called only if the inserting is success.
 
             The type \p Q should contain the complete key of the node.
@@ -429,7 +429,7 @@ namespace cds { namespace container {
             The functor may change non-key fields of the \p item; however, \p func must guarantee
             that during changing no any other modifications could be made on this item by concurrent threads.
 
-            You may pass \p func argument by reference using <tt>boost::ref</tt>.
+            You may pass \p func argument by reference using \p std::ref
 
             The function applies RCU lock internally.
 
@@ -610,9 +610,9 @@ namespace cds { namespace container {
                 void operator()( value_type& item, Q& val );
             };
             \endcode
-            where \p item is the item found, \p val is the <tt>find</tt> function argument.
+            where \p item is the item found, \p val is the \p find() function argument.
 
-            You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p f argument by reference using \p std::ref.
 
             The functor may change non-key fields of \p item. Note that the function is only guarantee
             that \p item cannot be deleted during functor is executing.
@@ -656,7 +656,7 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p f argument by reference using \p std::ref.
 
             The function does not serialize simultaneous access to the list \p item. If such access is
             possible you must provide your own synchronization schema to exclude unsafe item modifications.
@@ -792,7 +792,7 @@ namespace cds { namespace container {
         {
             scoped_node_ptr pNode( alloc_node( key ));
 
-            if ( base_class::insert_at( &refHead, *pNode, [&f](node_type& node){ cds::unref(f)( node_to_value(node) ); } )) {
+            if ( base_class::insert_at( &refHead, *pNode, [&f](node_type& node){ f( node_to_value(node) ); } )) {
                 pNode.release();
                 return true;
             }
@@ -802,7 +802,7 @@ namespace cds { namespace container {
         template <typename Q, typename Compare, typename Func>
         bool erase_at( head_type& refHead, Q const& key, Compare cmp, Func f )
         {
-            return base_class::erase_at( &refHead, key, cmp, [&f](node_type const& node){ cds::unref(f)( node_to_value(node) ); } );
+            return base_class::erase_at( &refHead, key, cmp, [&f](node_type const& node){ f( node_to_value(node) ); } );
         }
 
         template <typename Q, typename Compare>
@@ -817,7 +817,7 @@ namespace cds { namespace container {
             scoped_node_ptr pNode( alloc_node( key ));
 
             std::pair<bool, bool> ret = base_class::ensure_at( &refHead, *pNode,
-                [&f, &key](bool bNew, node_type& node, node_type&){cds::unref(f)( bNew, node_to_value(node), key ); });
+                [&f, &key](bool bNew, node_type& node, node_type&){f( bNew, node_to_value(node), key ); });
             if ( ret.first && ret.second )
                 pNode.release();
 
@@ -833,7 +833,7 @@ namespace cds { namespace container {
         template <typename Q, typename Compare, typename Func>
         bool find_at( head_type& refHead, Q& val, Compare cmp, Func f ) const
         {
-            return base_class::find_at( &refHead, val, cmp, [&f](node_type& node, Q& val){ cds::unref(f)( node_to_value(node), val ); });
+            return base_class::find_at( &refHead, val, cmp, [&f](node_type& node, Q& val){ f( node_to_value(node), val ); });
         }
 
         template <typename Q, typename Compare>
index bae83d1..b098279 100644 (file)
@@ -370,7 +370,7 @@ namespace cds { namespace container {
             to the list's item inserted. <tt>item.second</tt> is a reference to item's value that may be changed.
             User-defined functor \p func should guarantee that during changing item's value no any other changes
             could be made on this list's item by concurrent threads.
-            The user-defined functor can be passed by reference using <tt>boost::ref</tt>
+            The user-defined functor can be passed by reference using \p std::ref
             and it is called only if the inserting is successful.
 
             The key_type should be constructible from value of type \p K.
@@ -500,7 +500,7 @@ namespace cds { namespace container {
             scoped_node_ptr pNode( alloc_node( key ));
 
             if ( base_class::insert_at( refHead, *pNode )) {
-                cds::unref(f)( pNode->m_Data );
+                f( pNode->m_Data );
                 return pNode.release();
             }
             return nullptr;
@@ -536,7 +536,7 @@ namespace cds { namespace container {
         template <typename K, typename Compare typename Func>
         bool find_at( head_type& refHead, K& key, Compare cmp, Func f )
         {
-            return base_class::find_at( refHead, key, cmp, [&f]( node_type& node, K const& ){ cds::unref(f)( node.m_Data ); });
+            return base_class::find_at( refHead, key, cmp, [&f]( node_type& node, K const& ){ f( node.m_Data ); });
         }
         */
         //@endcond
index aaf03ae..679c648 100644 (file)
@@ -4,10 +4,10 @@
 #define __CDS_CONTAINER_MICHAEL_KVLIST_RCU_H
 
 #include <memory>
+#include <functional>   // ref
 #include <cds/container/details/michael_list_base.h>
 #include <cds/intrusive/michael_list_rcu.h>
 #include <cds/container/details/make_michael_kvlist.h>
-#include <cds/ref.h>
 #include <cds/details/functor_wrapper.h>
 
 namespace cds { namespace container {
@@ -379,7 +379,7 @@ namespace cds { namespace container {
             to the list's item inserted. <tt>item.second</tt> is a reference to item's value that may be changed.
             User-defined functor \p func should guarantee that during changing item's value no any other changes
             could be made on this list's item by concurrent threads.
-            The user-defined functor can be passed by reference using <tt>boost::ref</tt>
+            The user-defined functor can be passed by reference using \p std::ref
             and it is called only if inserting is successful.
 
             The key_type should be constructible from value of type \p K.
@@ -427,7 +427,7 @@ namespace cds { namespace container {
             however, \p func must guarantee that during changing no any other modifications
             could be made on this item by concurrent threads.
 
-            You may pass \p func argument by reference using <tt>boost::ref</tt>.
+            You may pass \p func argument by reference using \p std::ref
 
             The function makes RCU lock internally.
 
@@ -615,7 +615,7 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found.
 
-            You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p f argument by reference using \p std::ref.
 
             The functor may change <tt>item.second</tt> that is reference to value of node.
             Note that the function is only guarantee that \p item cannot be deleted during functor is executing.
@@ -751,7 +751,7 @@ namespace cds { namespace container {
         {
             scoped_node_ptr pNode( alloc_node( key ));
 
-            if ( base_class::insert_at( refHead, *pNode, [&f](node_type& node){ cds::unref(f)( node.m_Data ); })) {
+            if ( base_class::insert_at( refHead, *pNode, [&f](node_type& node){ f( node.m_Data ); })) {
                 pNode.release();
                 return true;
             }
@@ -770,7 +770,7 @@ namespace cds { namespace container {
             scoped_node_ptr pNode( alloc_node( key ));
 
             std::pair<bool, bool> ret = base_class::ensure_at( refHead, *pNode,
-                [&f]( bool bNew, node_type& node, node_type& ){ cds::unref(f)( bNew, node.m_Data ); });
+                [&f]( bool bNew, node_type& node, node_type& ){ f( bNew, node.m_Data ); });
             if ( ret.first && ret.second )
                 pNode.release();
 
@@ -786,7 +786,7 @@ namespace cds { namespace container {
         template <typename K, typename Compare, typename Func>
         bool erase_at( head_type& refHead, K const& key, Compare cmp, Func f )
         {
-            return base_class::erase_at( refHead, key, cmp, [&f]( node_type const & node ){ cds::unref(f)( const_cast<value_type&>(node.m_Data)); });
+            return base_class::erase_at( refHead, key, cmp, [&f]( node_type const & node ){ f( const_cast<value_type&>(node.m_Data)); });
         }
 
         template <typename K, typename Compare>
@@ -804,7 +804,7 @@ namespace cds { namespace container {
         template <typename K, typename Compare, typename Func>
         bool find_at( head_type& refHead, K& key, Compare cmp, Func f ) const
         {
-            return base_class::find_at( refHead, key, cmp, [&f](node_type& node, K const&){ cds::unref(f)( node.m_Data ); });
+            return base_class::find_at( refHead, key, cmp, [&f](node_type& node, K const&){ f( node.m_Data ); });
         }
 
         template <typename K, typename Compare>
index e7b0c09..40010e8 100644 (file)
@@ -339,7 +339,7 @@ namespace cds { namespace container {
             The argument \p itemValue of user-defined functor \p func is the reference
             to the list's item inserted. User-defined functor \p func should guarantee that during changing
             item's value no any other changes could be made on this list's item by concurrent threads.
-            The user-defined functor can be passed by reference using <tt>boost::ref</tt>
+            The user-defined functor can be passed by reference using \p std::ref
             and it is called only if the inserting is success.
 
             The type \p Q should contain the complete key of the node.
@@ -386,7 +386,7 @@ namespace cds { namespace container {
             The functor may change non-key fields of the \p item; however, \p func must guarantee
             that during changing no any other modifications could be made on this item by concurrent threads.
 
-            You may pass \p func argument by reference using <tt>boost::ref</tt>.
+            You may pass \p func argument by reference using \p std::ref
 
             The function makes RCU lock internally.
 
@@ -581,7 +581,7 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p f argument by reference using \p std::ref.
 
             The functor may change non-key fields of \p item. Note that the function is only guarantee
             that \p item cannot be deleted during functor is executing.
@@ -625,7 +625,7 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p f argument by reference using \p std::ref.
 
             The functor may change non-key fields of \p item. Note that the function is only guarantee
             that \p item cannot be deleted during functor is executing.
@@ -756,7 +756,7 @@ namespace cds { namespace container {
         {
             scoped_node_ptr pNode( alloc_node( key ));
 
-            if ( base_class::insert_at( refHead, *pNode, [&f]( node_type& node ) { cds::unref(f)( node_to_value(node) ); } )) {
+            if ( base_class::insert_at( refHead, *pNode, [&f]( node_type& node ) { f( node_to_value(node) ); } )) {
                 pNode.release();
                 return true;
             }
@@ -772,7 +772,7 @@ namespace cds { namespace container {
         template <typename Q, typename Compare, typename Func>
         bool erase_at( head_type& refHead, Q const& key, Compare cmp, Func f )
         {
-            return base_class::erase_at( refHead, key, cmp, [&f](node_type const& node){ cds::unref(f)( node_to_value(node) ); } );
+            return base_class::erase_at( refHead, key, cmp, [&f](node_type const& node){ f( node_to_value(node) ); } );
         }
 
         template <typename Q, typename Func>
@@ -781,7 +781,7 @@ namespace cds { namespace container {
             scoped_node_ptr pNode( alloc_node( key ));
 
             std::pair<bool, bool> ret = base_class::ensure_at( refHead, *pNode,
-                [&f, &key](bool bNew, node_type& node, node_type&){ cds::unref(f)( bNew, node_to_value(node), key ); });
+                [&f, &key](bool bNew, node_type& node, node_type&){ f( bNew, node_to_value(node), key ); });
             if ( ret.first && ret.second )
                 pNode.release();
 
@@ -803,7 +803,7 @@ namespace cds { namespace container {
         template <typename Q, typename Compare, typename Func>
         bool find_at( head_type& refHead, Q& val, Compare cmp, Func f ) const
         {
-            return base_class::find_at( refHead, val, cmp, [&f](node_type& node, Q& v){ cds::unref(f)( node_to_value(node), v ); });
+            return base_class::find_at( refHead, val, cmp, [&f](node_type& node, Q& v){ f( node_to_value(node), v ); });
         }
 
         template <typename Q, typename Compare>
index 6f4a387..791492a 100644 (file)
@@ -451,7 +451,7 @@ namespace cds { namespace container {
 
             User-defined functor \p func should guarantee that during changing item's value no any other changes
             could be made on this map's item by concurrent threads.
-            The user-defined functor can be passed by reference using <tt>boost::ref</tt>
+            The user-defined functor can be passed by reference using \p std::ref
             and it is called only if inserting is successful.
 
             The key_type should be constructible from value of type \p K.
@@ -501,7 +501,7 @@ namespace cds { namespace container {
             however, \p func must guarantee that during changing no any other modifications
             could be made on this item by concurrent threads.
 
-            You may pass \p func argument by reference using <tt>boost::ref</tt>.
+            You may pass \p func argument by reference using \p std::ref
 
             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
@@ -667,7 +667,7 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found.
 
-            You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p f argument by reference using \p std::ref.
 
             The functor may change \p item.second. Note that the functor is only guarantee
             that \p item cannot be disposed during functor is executing.
index 20a3e98..44f50b5 100644 (file)
@@ -342,7 +342,7 @@ namespace cds { namespace container {
             to the map's item inserted. <tt>item.second</tt> is a reference to item's value that may be changed.
             User-defined functor \p func should guarantee that during changing item's value no any other changes
             could be made on this map's item by concurrent threads.
-            The user-defined functor can be passed by reference using <tt>boost::ref</tt>
+            The user-defined functor can be passed by reference using \p std::ref
             and it is called only if the inserting is successful.
 
             The key_type should be constructible from value of type \p K.
index 02e8861..a4205a1 100644 (file)
@@ -379,7 +379,7 @@ namespace cds { namespace container {
 
             User-defined functor \p func should guarantee that during changing item's value no any other changes
             could be made on this map's item by concurrent threads.
-            The user-defined functor can be passed by reference using <tt>boost::ref</tt>
+            The user-defined functor can be passed by reference using \p std::ref
             and it is called only if inserting is successful.
 
             The key_type should be constructible from value of type \p K.
@@ -431,7 +431,7 @@ namespace cds { namespace container {
             however, \p func must guarantee that during changing no any other modifications
             could be made on this item by concurrent threads.
 
-            You may pass \p func argument by reference using <tt>boost::ref</tt>.
+            You may pass \p func argument by reference using \p std::ref
 
             The function applies RCU lock internally.
 
@@ -619,7 +619,7 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found.
 
-            You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p f argument by reference using \p std::ref.
 
             The functor may change \p item.second. Note that the functor is only guarantee
             that \p item cannot be disposed during functor is executing.
index 18e8a7b..49627a9 100644 (file)
@@ -356,7 +356,7 @@ namespace cds { namespace container {
             where \p val is the item inserted. User-defined functor \p f should guarantee that during changing
             \p val no any other changes could be made on this set's item by concurrent threads.
             The user-defined functor is called only if the inserting is success. It may be passed by reference
-            using <tt>boost::ref</tt>
+            using \p std::ref
         */
         template <typename Q, typename Func>
         bool insert( Q const& val, Func f )
@@ -392,7 +392,7 @@ namespace cds { namespace container {
             The functor may change non-key fields of the \p item; however, \p func must guarantee
             that during changing no any other modifications could be made on this item by concurrent threads.
 
-            You may pass \p func argument by reference using <tt>boost::ref</tt>.
+            You may pass \p func argument by reference using \p std::ref
 
             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
@@ -566,7 +566,7 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p f argument by reference using \p std::ref.
 
             The functor may change non-key fields of \p item. Note that the functor is only guarantee
             that \p item cannot be disposed during functor is executing.
@@ -612,7 +612,7 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p f argument by reference using \p std::ref.
 
             The functor may change non-key fields of \p item. Note that the functor is only guarantee
             that \p item cannot be disposed during functor is executing.
index 9001e37..279081b 100644 (file)
@@ -305,7 +305,7 @@ namespace cds { namespace container {
             where \p val is the item inserted. User-defined functor \p f should guarantee that during changing
             \p val no any other changes could be made on this set's item by concurrent threads.
             The user-defined functor is called only if the inserting is success. It may be passed by reference
-            using <tt>boost::ref</tt>
+            using \p std::ref
 
             The function applies RCU lock internally.
         */
@@ -343,7 +343,7 @@ namespace cds { namespace container {
             The functor may change non-key fields of the \p item; however, \p func must guarantee
             that during changing no any other modifications could be made on this item by concurrent threads.
 
-            You may pass \p func argument by reference using <tt>boost::ref</tt>.
+            You may pass \p func argument by reference using \p std::ref
 
             The function applies RCU lock internally.
 
@@ -541,7 +541,7 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p f argument by reference using \p std::ref.
 
             The functor may change non-key fields of \p item. Note that the functor is only guarantee
             that \p item cannot be disposed during functor is executing.
@@ -589,7 +589,7 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p f argument by reference using \p std::ref.
 
             The functor may change non-key fields of \p item. Note that the functor is only guarantee
             that \p item cannot be disposed during functor is executing.
index b2cdeb6..38ac55d 100644 (file)
@@ -4,10 +4,10 @@
 #define __CDS_CONTAINER_MOIR_QUEUE_H
 
 #include <memory>
+#include <functional>   // ref
 #include <cds/intrusive/moir_queue.h>
 #include <cds/intrusive/details/queue_stat.h>
 #include <cds/container/details/base.h>
-#include <cds/ref.h>
 #include <cds/details/trivial_assign.h>
 
 namespace cds { namespace container {
@@ -211,7 +211,7 @@ namespace cds { namespace container {
         bool enqueue( const Type& data, Func f  )
         {
             scoped_node_ptr p( alloc_node());
-            unref(f)( node_traits::to_value_ptr( *p )->m_value, data );
+            f( node_traits::to_value_ptr( *p )->m_value, data );
             if ( base_class::enqueue( *p )) {
                 p.release();
                 return true;
@@ -242,7 +242,7 @@ namespace cds { namespace container {
         {
             typename base_class::dequeue_result res;
             if ( base_class::do_dequeue( res )) {
-                unref(f)( dest, node_traits::to_value_ptr( *res.pNext )->m_value );
+                f( dest, node_traits::to_value_ptr( *res.pNext )->m_value );
 
                 base_class::dispose_result( res );
 
index dda777f..c47a930 100644 (file)
@@ -229,7 +229,7 @@ namespace cds { namespace container {
         {
             value_type * pVal = base_class::pop();
             if ( pVal ) {
-                cds::unref(f)( dest, *pVal );
+                f( dest, *pVal );
                 cxx_allocator().Delete( pVal );
                 return true;
             }
@@ -262,7 +262,7 @@ namespace cds { namespace container {
         template <typename Func>
         void clear_with( Func f )
         {
-            base_class::clear_with( [&f]( value_type& val ) { cds::unref(f)(val); value_deleter()( &val ); } );
+            base_class::clear_with( [&f]( value_type& val ) { f(val); value_deleter()( &val ); } );
         }
 
         /// Checks is the priority queue is empty
index c144bdb..4368c1c 100644 (file)
@@ -4,9 +4,9 @@
 #define __CDS_CONTAINER_MSQUEUE_H
 
 #include <memory>
+#include <functional>   // ref
 #include <cds/intrusive/msqueue.h>
 #include <cds/container/details/base.h>
-#include <cds/ref.h>
 #include <cds/details/trivial_assign.h>
 
 namespace cds { namespace container {
@@ -222,7 +222,7 @@ namespace cds { namespace container {
         bool enqueue( Type const& data, Func f  )
         {
             scoped_node_ptr p( alloc_node() );
-            unref(f)( p->m_value, data );
+            f( p->m_value, data );
             if ( base_class::enqueue( *p )) {
                 p.release();
                 return true;
@@ -253,7 +253,7 @@ namespace cds { namespace container {
         {
             typename base_class::dequeue_result res;
             if ( base_class::do_dequeue( res )) {
-                unref(f)( dest, node_traits::to_value_ptr( *res.pNext )->m_value );
+                f( dest, node_traits::to_value_ptr( *res.pNext )->m_value );
 
                 base_class::dispose_result( res );
 
index 4ee76da..bfe5e07 100644 (file)
@@ -4,9 +4,9 @@
 #define __CDS_CONTAINER_OPTIMISTIC_QUEUE_H
 
 #include <memory>
+#include <functional>   // ref
 #include <cds/intrusive/optimistic_queue.h>
 #include <cds/container/details/base.h>
-#include <cds/ref.h>
 #include <cds/details/trivial_assign.h>
 
 namespace cds { namespace container {
@@ -231,7 +231,7 @@ namespace cds { namespace container {
         bool enqueue( const Type& data, Func f  )
         {
             scoped_node_ptr p( alloc_node() );
-            unref(f)( p->m_value, data );
+            f( p->m_value, data );
             if ( base_class::enqueue( *p )) {
                 p.release();
                 return true;
@@ -274,7 +274,7 @@ namespace cds { namespace container {
         {
             typename base_class::dequeue_result res;
             if ( base_class::do_dequeue( res )) {
-                unref(f)( dest, node_traits::to_value_ptr( *res.pNext )->m_value );
+                f( dest, node_traits::to_value_ptr( *res.pNext )->m_value );
 
                 base_class::dispose_result( res );
 
index 4b687dc..b63d2ad 100644 (file)
@@ -4,12 +4,12 @@
 #define __CDS_CONTAINER_RWQUEUE_H
 
 #include <memory>
+#include <functional>   // ref
 #include <cds/opt/options.h>
 #include <cds/lock/spinlock.h>
 #include <cds/intrusive/details/queue_stat.h>
 #include <cds/details/allocator.h>
 #include <cds/details/trivial_assign.h>
-#include <cds/ref.h>
 
 namespace cds { namespace container {
 
@@ -213,7 +213,7 @@ namespace cds { namespace container {
         bool enqueue( Type const& data, Func f  )
         {
             scoped_node_ptr p( alloc_node());
-            unref(f)( p->m_value, data );
+            f( p->m_value, data );
             if ( enqueue_node( p.get() )) {
                 p.release();
                 return true;
@@ -261,7 +261,7 @@ namespace cds { namespace container {
                 node_type * pNewHead = pNode->m_pNext;
                 if ( pNewHead == nullptr )
                     return false;
-                unref(f)( dest, pNewHead->m_value );
+                f( dest, pNewHead->m_value );
                 m_pHead = pNewHead;
             }    // unlock here
             --m_ItemCounter;
index ed5ad02..f5c506c 100644 (file)
@@ -4,9 +4,9 @@
 #define __CDS_CONTAINER_SEGMENTED_QUEUE_H
 
 #include <memory>
+#include <functional>   // ref
 #include <cds/intrusive/segmented_queue.h>
 #include <cds/details/trivial_assign.h>
-#include <cds/ref.h>
 
 namespace cds { namespace container {
 
@@ -272,7 +272,7 @@ namespace cds { namespace container {
         bool enqueue( Q const& data, Func f  )
         {
             scoped_node_ptr p( alloc_node() );
-            unref(f)( *p, data );
+            f( *p, data );
             if ( base_class::enqueue( *p )) {
                 p.release();
                 return true;
@@ -320,7 +320,7 @@ namespace cds { namespace container {
         {
             value_type * p = base_class::dequeue();
             if ( p ) {
-                unref(f)( dest, *p );
+                f( dest, *p );
                 gc::template retire< typename maker::node_disposer >( p );
                 return true;
             }
index 76644e6..e4146eb 100644 (file)
@@ -238,7 +238,7 @@ namespace cds { namespace container {
             to the map's item inserted. <tt>item.second</tt> is a reference to item's value that may be changed.
             User-defined functor \p func should guarantee that during changing item's value no any other changes
             could be made on this map's item by concurrent threads.
-            The user-defined functor can be passed by reference using <tt>boost::ref</tt>
+            The user-defined functor can be passed by reference using \p std::ref
             and it is called only if the inserting is successful.
 
             The key_type should be constructible from value of type \p K.
@@ -258,7 +258,7 @@ namespace cds { namespace container {
         {
             iterator it = insert( key );
             if ( it != end() )
-                cds::unref( func )( (*it) );
+                func( (*it) );
             return it;
         }
 
index cc8b991..213c2fb 100644 (file)
@@ -282,7 +282,7 @@ namespace cds { namespace container {
                 - <tt>item.first</tt> is a const reference to item's key that cannot be changed.
                 - <tt>item.second</tt> is a reference to item's value that may be changed.
 
-            The user-defined functor can be passed by reference using <tt>boost::ref</tt>
+            The user-defined functor can be passed by reference using \p std::ref
             and it is called only if inserting is successful.
 
             The key_type should be constructible from value of type \p K.
@@ -301,7 +301,7 @@ namespace cds { namespace container {
         bool insert_key( const K& key, Func func )
         {
             scoped_node_ptr pNode( node_allocator().New( random_level(), key ));
-            if ( base_class::insert( *pNode, [&func]( node_type& item ) { cds::unref(func)( item.m_Value ); } )) {
+            if ( base_class::insert( *pNode, [&func]( node_type& item ) { func( item.m_Value ); } )) {
                 pNode.release();
                 return true;
             }
@@ -350,7 +350,7 @@ namespace cds { namespace container {
 
             The functor may change any fields of the \p item.second that is \ref value_type.
 
-            You may pass \p func argument by reference using <tt>boost::ref</tt>.
+            You may pass \p func argument by reference using \p std::ref
 
             RCU \p synchronize method can be called. RCU should not be locked.
 
@@ -363,7 +363,7 @@ namespace cds { namespace container {
         {
             scoped_node_ptr pNode( node_allocator().New( random_level(), key ));
             std::pair<bool, bool> res = base_class::ensure( *pNode,
-                [&func](bool bNew, node_type& item, node_type const& ){ cds::unref(func)( bNew, item.m_Value ); }
+                [&func](bool bNew, node_type& item, node_type const& ){ func( bNew, item.m_Value ); }
             );
             if ( res.first && res.second )
                 pNode.release();
@@ -417,7 +417,7 @@ namespace cds { namespace container {
         template <typename K, typename Func>
         bool erase( K const& key, Func f )
         {
-            return base_class::erase( key, [&f]( node_type& node) { cds::unref(f)( node.m_Value ); } );
+            return base_class::erase( key, [&f]( node_type& node) { f( node.m_Value ); } );
         }
 
         /// Deletes the item from the map using \p pred predicate for searching
@@ -431,7 +431,7 @@ namespace cds { namespace container {
         bool erase_with( K const& key, Less pred, Func f )
         {
             return base_class::erase_with( key, cds::details::predicate_wrapper< node_type, Less, typename maker::key_accessor >(),
-                [&f]( node_type& node) { cds::unref(f)( node.m_Value ); } );
+                [&f]( node_type& node) { f( node.m_Value ); } );
         }
 
         /// Extracts the item from the map with specified \p key
@@ -512,7 +512,7 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found.
 
-            You can pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You can pass \p f argument by reference using \p std::ref.
 
             The functor may change \p item.second.
 
@@ -523,7 +523,7 @@ namespace cds { namespace container {
         template <typename K, typename Func>
         bool find( K const& key, Func f )
         {
-            return base_class::find( key, [&f](node_type& item, K const& ) { cds::unref(f)( item.m_Value );});
+            return base_class::find( key, [&f](node_type& item, K const& ) { f( item.m_Value );});
         }
 
         /// Finds the key \p val using \p pred predicate for searching
@@ -537,7 +537,7 @@ namespace cds { namespace container {
         bool find_with( K const& key, Less pred, Func f )
         {
             return base_class::find_with( key, cds::details::predicate_wrapper< node_type, Less, typename maker::key_accessor >(),
-                [&f](node_type& item, K const& ) { cds::unref(f)( item.m_Value );});
+                [&f](node_type& item, K const& ) { f( item.m_Value );});
         }
 
         /// Find the key \p key
index 632f2f9..1af003d 100644 (file)
@@ -292,7 +292,7 @@ namespace cds { namespace container {
             where \p val is the item inserted. User-defined functor \p f should guarantee that during changing
             \p val no any other changes could be made on this set's item by concurrent threads.
             The user-defined functor is called only if the inserting is success. It may be passed by reference
-            using <tt>boost::ref</tt>
+            using \p std::ref
 
             RCU \p synchronize method can be called. RCU should not be locked.
         */
@@ -300,7 +300,7 @@ namespace cds { namespace container {
         bool insert( Q const& val, Func f )
         {
             scoped_node_ptr sp( node_allocator().New( random_level(), val ));
-            if ( base_class::insert( *sp.get(), [&f]( node_type& val ) { cds::unref(f)( val.m_Value ); } )) {
+            if ( base_class::insert( *sp.get(), [&f]( node_type& val ) { f( val.m_Value ); } )) {
                 sp.release();
                 return true;
             }
@@ -332,7 +332,7 @@ namespace cds { namespace container {
             The functor may change non-key fields of the \p item; however, \p func must guarantee
             that during changing no any other modifications could be made on this item by concurrent threads.
 
-            You may pass \p func argument by reference using <tt>boost::ref</tt>.
+            You may pass \p func argument by reference using \p std::ref
 
             RCU \p synchronize method can be called. RCU should not be locked.
 
@@ -345,7 +345,7 @@ namespace cds { namespace container {
         {
             scoped_node_ptr sp( node_allocator().New( random_level(), val ));
             std::pair<bool, bool> bRes = base_class::ensure( *sp,
-                [&func, &val](bool bNew, node_type& node, node_type&){ cds::unref(func)( bNew, node.m_Value, val ); });
+                [&func, &val](bool bNew, node_type& node, node_type&){ func( bNew, node.m_Value, val ); });
             if ( bRes.first && bRes.second )
                 sp.release();
             return bRes;
@@ -425,7 +425,7 @@ namespace cds { namespace container {
         template <typename Q, typename Func>
         bool erase( Q const& key, Func f )
         {
-            return base_class::erase( key, [&f]( node_type const& node) { cds::unref(f)( node.m_Value ); } );
+            return base_class::erase( key, [&f]( node_type const& node) { f( node.m_Value ); } );
         }
 
         /// Deletes the item from the set using \p pred predicate for searching
@@ -439,7 +439,7 @@ namespace cds { namespace container {
         bool erase_with( Q const& key, Less pred, Func f )
         {
             return base_class::erase_with( key, cds::details::predicate_wrapper< node_type, Less, typename maker::value_accessor >(),
-                [&f]( node_type const& node) { cds::unref(f)( node.m_Value ); } );
+                [&f]( node_type const& node) { f( node.m_Value ); } );
         }
 
         /// Extracts the item from the set with specified \p key
@@ -521,7 +521,7 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p f argument by reference using \p std::ref.
 
             The functor may change non-key fields of \p item. Note that the functor is only guarantee
             that \p item cannot be disposed during functor is executing.
@@ -541,7 +541,7 @@ namespace cds { namespace container {
         template <typename Q, typename Func>
         bool find( Q& val, Func f )
         {
-            return base_class::find( val, [&f]( node_type& node, Q& v ) { cds::unref(f)( node.m_Value, v ); });
+            return base_class::find( val, [&f]( node_type& node, Q& v ) { f( node.m_Value, v ); });
         }
 
         /// Finds the key \p val using \p pred predicate for searching
@@ -555,7 +555,7 @@ namespace cds { namespace container {
         bool find_with( Q& val, Less pred, Func f )
         {
             return base_class::find_with( val, cds::details::predicate_wrapper< node_type, Less, typename maker::value_accessor >(),
-                [&f]( node_type& node, Q& v ) { cds::unref(f)( node.m_Value, v ); } );
+                [&f]( node_type& node, Q& v ) { f( node.m_Value, v ); } );
         }
 
         /// Find the key \p val
@@ -570,7 +570,7 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p f argument by reference using \p std::ref.
 
             The functor may change non-key fields of \p item. Note that the functor is only guarantee
             that \p item cannot be disposed during functor is executing.
@@ -587,7 +587,7 @@ namespace cds { namespace container {
         template <typename Q, typename Func>
         bool find( Q const& val, Func f )
         {
-            return base_class::find( val, [&f]( node_type& node, Q const& v ) { cds::unref(f)( node.m_Value, v ); });
+            return base_class::find( val, [&f]( node_type& node, Q const& v ) { f( node.m_Value, v ); });
         }
 
         /// Finds the key \p val using \p pred predicate for searching
@@ -601,7 +601,7 @@ namespace cds { namespace container {
         bool find_with( Q const& val, Less pred, Func f )
         {
             return base_class::find_with( val, cds::details::predicate_wrapper< node_type, Less, typename maker::value_accessor >(),
-                [&f]( node_type& node, Q const& v ) { cds::unref(f)( node.m_Value, v ); } );
+                [&f]( node_type& node, Q const& v ) { f( node.m_Value, v ); } );
         }
 
         /// Find the key \p val
index eb8442c..c1ba53d 100644 (file)
@@ -277,7 +277,7 @@ namespace cds { namespace container {
             User-defined functor \p func should guarantee that during changing item's value no any other changes
             could be made on this \p item by concurrent threads.
 
-            The user-defined functor can be passed by reference using <tt>boost::ref</tt>
+            The user-defined functor can be passed by reference using \p std::ref
             and it is called only if inserting is successful.
 
             The key_type should be constructible from value of type \p K.
@@ -336,7 +336,7 @@ namespace cds { namespace container {
             however, \p func must guarantee that during changing no any other modifications
             could be made on this item by concurrent threads.
 
-            You may pass \p func argument by reference using <tt>boost::ref</tt>.
+            You may pass \p func argument by reference using \p std::ref
 
             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
@@ -348,7 +348,7 @@ namespace cds { namespace container {
             //TODO: pass arguments by reference (make_pair makes copy)
             return base_class::ensure( std::make_pair( key, mapped_type() ),
                 [&func](bool bNew, value_type& item, value_type const& /*val*/) {
-                    cds::unref(func)( bNew, item );
+                    func( bNew, item );
                 } );
         }
 
@@ -470,7 +470,7 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found.
 
-            You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p f argument by reference using \p std::ref.
 
             The functor may change \p item.second. Note that the functor is only guarantee
             that \p item cannot be disposed during functor is executing.
@@ -482,7 +482,7 @@ namespace cds { namespace container {
         template <typename K, typename Func>
         bool find( K const& key, Func f )
         {
-            return base_class::find( key, [&f](value_type& pair, K const&){ cds::unref(f)( pair ); } );
+            return base_class::find( key, [&f](value_type& pair, K const&){ f( pair ); } );
         }
 
         /// Finds the key \p val using \p pred predicate for searching
@@ -497,7 +497,7 @@ namespace cds { namespace container {
         {
             return base_class::find_with( key,
                 cds::details::predicate_wrapper<value_type, Less, key_accessor>(),
-                [&f](value_type& pair, K const&){ cds::unref(f)( pair ); } );
+                [&f](value_type& pair, K const&){ f( pair ); } );
         }
 
         /// Finds the key \p key
index f7cbac3..6df9038 100644 (file)
@@ -184,7 +184,7 @@ namespace cds { namespace container {
             to the map's item inserted. <tt>item.second</tt> is a reference to item's value that may be changed.
             User-defined functor \p func should guarantee that during changing item's value no any other changes
             could be made on this map's item by concurrent threads.
-            The user-defined functor can be passed by reference using <tt>boost::ref</tt>
+            The user-defined functor can be passed by reference using \p std::ref
             and it is called only if the inserting is successful.
 
             The key_type should be constructible from value of type \p K.
@@ -204,7 +204,7 @@ namespace cds { namespace container {
         {
             iterator it = insert( key );
             if ( it != end() )
-                cds::unref( func )( (*it) );
+                func( (*it) );
             return it;
         }
 
index cc94b74..c0a59c1 100644 (file)
@@ -318,7 +318,7 @@ namespace cds { namespace container {
             User-defined functor \p func should guarantee that during changing item's value no any other changes
             could be made on this \p item by concurrent threads.
 
-            The user-defined functor can be passed by reference using <tt>boost::ref</tt>
+            The user-defined functor can be passed by reference using \p std::ref
             and it is called only if inserting is successful.
 
             The key_type should be constructible from value of type \p K.
@@ -381,7 +381,7 @@ namespace cds { namespace container {
             however, \p func must guarantee that during changing no any other modifications
             could be made on this item by concurrent threads.
 
-            You may pass \p func argument by reference using <tt>boost::ref</tt>.
+            You may pass \p func argument by reference using \p std::ref
 
             The function applies RCU lock internally.
 
@@ -395,7 +395,7 @@ namespace cds { namespace container {
             //TODO: pass arguments by reference (make_pair makes copy)
             return base_class::ensure( std::make_pair( key, mapped_type() ),
                 [&func](bool bNew, value_type& item, value_type const& /*val*/) {
-                    cds::unref(func)( bNew, item );
+                    func( bNew, item );
                 } );
         }
 
@@ -530,7 +530,7 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found.
 
-            You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p f argument by reference using \p std::ref.
 
             The functor may change \p item.second. Note that the functor is only guarantee
             that \p item cannot be disposed during functor is executing.
@@ -544,7 +544,7 @@ namespace cds { namespace container {
         template <typename K, typename Func>
         bool find( K const& key, Func f )
         {
-            return base_class::find( key, [&f](value_type& pair, K const&){ cds::unref(f)( pair ); } );
+            return base_class::find( key, [&f](value_type& pair, K const&){ f( pair ); } );
         }
 
         /// Finds the key \p key using \p pred predicate for searching
@@ -559,7 +559,7 @@ namespace cds { namespace container {
         {
             return base_class::find_with( key,
                 cds::details::predicate_wrapper<value_type, Less, key_accessor>(),
-                [&f](value_type& pair, K const&){ cds::unref(f)( pair ); } );
+                [&f](value_type& pair, K const&){ f( pair ); } );
         }
 
         /// Finds the key \p key
index ebbf6a0..901067d 100644 (file)
@@ -172,14 +172,14 @@ namespace cds { namespace container {
         template <typename Q, typename Func>
         bool find_( Q& val, Func f )
         {
-            return base_class::find( val, [&f]( node_type& item, Q& val ) { cds::unref(f)(item.m_Value, val) ; } );
+            return base_class::find( val, [&f]( node_type& item, Q& val ) { f(item.m_Value, val) ; } );
         }
 
         template <typename Q, typename Less, typename Func>
         bool find_with_( Q& val, Less pred, Func f )
         {
             return base_class::find_with( val, typename maker::template predicate_wrapper<Less>::type(),
-                [&f]( node_type& item, Q& val ) { cds::unref(f)(item.m_Value, val) ; } );
+                [&f]( node_type& item, Q& val ) { f(item.m_Value, val) ; } );
         }
 
         template <typename... Args>
@@ -392,14 +392,14 @@ namespace cds { namespace container {
             where \p val is the item inserted. User-defined functor \p f should guarantee that during changing
             \p val no any other changes could be made on this set's item by concurrent threads.
             The user-defined functor is called only if the inserting is success. It may be passed by reference
-            using <tt>boost::ref</tt>
+            using \p std::ref
         */
         template <typename Q, typename Func>
         bool insert( Q const& val, Func f )
         {
             scoped_node_ptr pNode( alloc_node( val ));
 
-            if ( base_class::insert( *pNode, [&f](node_type& node) { cds::unref(f)( node.m_Value ) ; } )) {
+            if ( base_class::insert( *pNode, [&f](node_type& node) { f( node.m_Value ) ; } )) {
                 pNode.release();
                 return true;
             }
@@ -441,7 +441,7 @@ namespace cds { namespace container {
             The functor may change non-key fields of the \p item; however, \p func must guarantee
             that during changing no any other modifications could be made on this item by concurrent threads.
 
-            You may pass \p func argument by reference using <tt>boost::ref</tt>.
+            You may pass \p func argument by reference using \p std::ref
 
             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
@@ -454,7 +454,7 @@ namespace cds { namespace container {
 
             std::pair<bool, bool> bRet = base_class::ensure( *pNode,
                 [&func, &val]( bool bNew, node_type& item,  node_type const& /*val*/ ) {
-                    cds::unref(func)( bNew, item.m_Value, val );
+                    func( bNew, item.m_Value, val );
                 } );
 
             if ( bRet.first && bRet.second )
@@ -513,7 +513,7 @@ namespace cds { namespace container {
         template <typename Q, typename Func>
         bool erase( Q const& key, Func f )
         {
-            return base_class::erase( key, [&f](node_type& node) { cds::unref(f)( node.m_Value ); } );
+            return base_class::erase( key, [&f](node_type& node) { f( node.m_Value ); } );
         }
 
         /// Deletes the item from the set using \p pred predicate for searching
@@ -527,7 +527,7 @@ namespace cds { namespace container {
         bool erase_with( Q const& key, Less pred, Func f )
         {
             return base_class::erase_with( key, typename maker::template predicate_wrapper<Less>::type(),
-                [&f](node_type& node) { cds::unref(f)( node.m_Value ); } );
+                [&f](node_type& node) { f( node.m_Value ); } );
         }
 
         /// Extracts the item with specified \p key
@@ -589,7 +589,7 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p f argument by reference using \p std::ref.
 
             The functor may change non-key fields of \p item. Note that the functor is only guarantee
             that \p item cannot be disposed during functor is executing.
@@ -635,7 +635,7 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p f argument by reference using \p std::ref.
 
             The functor may change non-key fields of \p item. Note that the functor is only guarantee
             that \p item cannot be disposed during functor is executing.
index 43101c4..4c4fc59 100644 (file)
@@ -217,14 +217,14 @@ namespace cds { namespace container {
         template <typename Q, typename Func>
         bool find_( Q& val, Func f )
         {
-            return base_class::find( val, [&f]( node_type& item, Q& val ) { cds::unref(f)(item.m_Value, val) ; } );
+            return base_class::find( val, [&f]( node_type& item, Q& val ) { f(item.m_Value, val) ; } );
         }
 
         template <typename Q, typename Less, typename Func>
         bool find_with_( Q& val, Less pred, Func f )
         {
             return base_class::find_with( val, typename maker::template predicate_wrapper<Less>::type(),
-                [&f]( node_type& item, Q& val ) { cds::unref(f)(item.m_Value, val) ; } );
+                [&f]( node_type& item, Q& val ) { f(item.m_Value, val) ; } );
         }
 
 
@@ -436,7 +436,7 @@ namespace cds { namespace container {
             where \p val is the item inserted. User-defined functor \p f should guarantee that during changing
             \p val no any other changes could be made on this set's item by concurrent threads.
             The user-defined functor is called only if the inserting is success. It may be passed by reference
-            using <tt>boost::ref</tt>
+            using \p std::ref
 
             The function applies RCU lock internally.
         */
@@ -445,7 +445,7 @@ namespace cds { namespace container {
         {
             scoped_node_ptr pNode( alloc_node( val ));
 
-            if ( base_class::insert( *pNode, [&f](node_type& node) { cds::unref(f)( node.m_Value ) ; } )) {
+            if ( base_class::insert( *pNode, [&f](node_type& node) { f( node.m_Value ) ; } )) {
                 pNode.release();
                 return true;
             }
@@ -489,7 +489,7 @@ namespace cds { namespace container {
             The functor may change non-key fields of the \p item; however, \p func must guarantee
             that during changing no any other modifications could be made on this item by concurrent threads.
 
-            You may pass \p func argument by reference using <tt>boost::ref</tt>.
+            You may pass \p func argument by reference using \p std::ref
 
             The function applies RCU lock internally.
 
@@ -504,7 +504,7 @@ namespace cds { namespace container {
 
             std::pair<bool, bool> bRet = base_class::ensure( *pNode,
                 [&func, &val]( bool bNew, node_type& item,  node_type const& /*val*/ ) {
-                    cds::unref(func)( bNew, item.m_Value, val );
+                    func( bNew, item.m_Value, val );
                 } );
             if ( bRet.first && bRet.second )
                 pNode.release();
@@ -568,7 +568,7 @@ namespace cds { namespace container {
         template <typename Q, typename Func>
         bool erase( Q const& key, Func f )
         {
-            return base_class::erase( key, [&f](node_type& node) { cds::unref(f)( node.m_Value ); } );
+            return base_class::erase( key, [&f](node_type& node) { f( node.m_Value ); } );
         }
 
         /// Deletes the item from the set using \p pred predicate for searching
@@ -582,7 +582,7 @@ namespace cds { namespace container {
         bool erase_with( Q const& key, Less pred, Func f )
         {
             return base_class::erase_with( key, typename maker::template predicate_wrapper<Less>::type(),
-                [&f](node_type& node) { cds::unref(f)( node.m_Value ); } );
+                [&f](node_type& node) { f( node.m_Value ); } );
         }
 
         /// Extracts an item from the set
@@ -663,7 +663,7 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p f argument by reference using \p std::ref.
 
             The functor may change non-key fields of \p item. Note that the functor is only guarantee
             that \p item cannot be disposed during functor is executing.
@@ -711,7 +711,7 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p f argument by reference using \p std::ref.
 
             The functor may change non-key fields of \p item. Note that the functor is only guarantee
             that \p item cannot be disposed during functor is executing.
index 892225c..6bfa883 100644 (file)
@@ -622,7 +622,7 @@ template <class Container, typename... Options>
                 - <tt>item.first</tt> is a const reference to item's key that cannot be changed.
                 - <tt>item.second</tt> is a reference to item's value that may be changed.
 
-            The user-defined functor can be passed by reference using <tt>boost::ref</tt>
+            The user-defined functor can be passed by reference using \p std::ref
             and it is called only if inserting is successful.
 
             The key_type should be constructible from value of type \p K.
@@ -691,7 +691,7 @@ template <class Container, typename... Options>
 
             The functor may change any fields of the \p item.second that is \ref mapped_type.
 
-            You may pass \p func argument by reference using <tt>boost::ref</tt>.
+            You may pass \p func argument by reference using \p std::ref
 
             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
@@ -800,7 +800,7 @@ template <class Container, typename... Options>
             \endcode
             where \p item is the item found.
 
-            You can pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You can pass \p f argument by reference using \p std::ref.
 
             The functor may change \p item.second.
 
@@ -809,7 +809,7 @@ template <class Container, typename... Options>
         template <typename K, typename Func>
         bool find( K const& key, Func f )
         {
-            return base_class::find( key, [&f]( value_type& pair, K const& ) mutable { cds::unref(f)(pair); } );
+            return base_class::find( key, [&f]( value_type& pair, K const& ) mutable { f(pair); } );
         }
 
         /// Find the key \p val using \p pred predicate
@@ -828,7 +828,7 @@ template <class Container, typename... Options>
         bool find_with( K const& key, Less pred, Func f )
         {
             return base_class::find_with( key, cds::details::predicate_wrapper< value_type, Less, key_accessor >(),
-                [&f]( value_type& pair, K const& ) mutable { cds::unref(f)(pair); } );
+                [&f]( value_type& pair, K const& ) mutable { f(pair); } );
         }
 
         /// Find the key \p key
index 4869777..26e4409 100644 (file)
@@ -8,11 +8,11 @@
 #   error "For boost::container::list you must use boost 1.48 or above"
 #endif
 
-#include <cds/container/striped_set/adapter.h>
-#include <cds/ref.h>
-#include <boost/container/list.hpp>
+#include <functional>   // ref
 #include <algorithm>    // std::lower_bound
 #include <utility>      // std::pair
+#include <cds/container/striped_set/adapter.h>
+#include <boost/container/list.hpp>
 
 //@cond
 namespace cds { namespace container {
@@ -140,7 +140,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                 if ( it == m_List.end() || key_comparator()( key, it->first ) != 0 ) {
                     //value_type newItem( key );
                     it = m_List.insert( it, value_type( key, mapped_type()) );
-                    cds::unref( f )( *it );
+                    f( *it );
 
                     return true;
                 }
@@ -168,13 +168,13 @@ namespace cds { namespace intrusive { namespace striped_set {
                     // insert new
                     value_type newItem( key, mapped_type() );
                     it = m_List.insert( it, newItem );
-                    cds::unref( func )( true, *it );
+                    func( true, *it );
 
                     return std::make_pair( true, true );
                 }
                 else {
                     // already exists
-                    cds::unref( func )( false, *it );
+                    func( false, *it );
                     return std::make_pair( true, false );
                 }
             }
@@ -187,7 +187,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                     return false;
 
                 // key exists
-                cds::unref( f )( *it );
+                f( *it );
                 m_List.erase( it );
 
                 return true;
@@ -201,7 +201,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                     return false;
 
                 // key exists
-                cds::unref( f )( *it );
+                f( *it );
                 m_List.erase( it );
 
                 return true;
@@ -215,7 +215,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                     return false;
 
                 // key exists
-                cds::unref( f )( *it, val );
+                f( *it, val );
                 return true;
             }
 
@@ -227,7 +227,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                     return false;
 
                 // key exists
-                cds::unref( f )( *it, val );
+                f( *it, val );
                 return true;
             }
 
index 7ac83a8..87740a4 100644 (file)
@@ -8,10 +8,10 @@
 #   error "For boost::container::slist you must use boost 1.48 or above"
 #endif
 
+#include <functional>   // ref
+#include <utility>      // std::pair
 #include <cds/container/striped_set/adapter.h>
-#include <cds/ref.h>
 #include <boost/container/slist.hpp>
-#include <utility>      // std::pair
 
 //@cond
 namespace cds { namespace container {
@@ -152,7 +152,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                 if ( !pos.second ) {
                     value_type newItem( key, mapped_type() );
                     pos.first = m_List.insert_after( pos.first, newItem );
-                    cds::unref( f )( *pos.first );
+                    f( *pos.first );
                     return true;
                 }
 
@@ -179,12 +179,12 @@ namespace cds { namespace intrusive { namespace striped_set {
                     // insert new
                     value_type newItem( key, mapped_type() );
                     pos.first = m_List.insert_after( pos.first, newItem );
-                    cds::unref( func )( true, *pos.first );
+                    func( true, *pos.first );
                     return std::make_pair( true, true );
                 }
                 else {
                     // already exists
-                    cds::unref( func )( false, *(++pos.first) );
+                    func( false, *(++pos.first) );
                     return std::make_pair( true, false );
                 }
             }
@@ -198,7 +198,7 @@ namespace cds { namespace intrusive { namespace striped_set {
 
                 // key exists
                 iterator it = pos.first;
-                cds::unref( f )( *(++it) );
+                f( *(++it) );
                 m_List.erase_after( pos.first );
 
                 return true;
@@ -213,7 +213,7 @@ namespace cds { namespace intrusive { namespace striped_set {
 
                 // key exists
                 iterator it = pos.first;
-                cds::unref( f )( *(++it) );
+                f( *(++it) );
                 m_List.erase_after( pos.first );
 
                 return true;
@@ -227,7 +227,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                     return false;
 
                 // key exists
-                cds::unref( f )( *(++pos.first), val );
+                f( *(++pos.first), val );
                 return true;
             }
 
@@ -239,7 +239,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                     return false;
 
                 // key exists
-                cds::unref( f )( *(++pos.first), val );
+                f( *(++pos.first), val );
                 return true;
             }
 
index 58a8166..8738c91 100644 (file)
@@ -110,7 +110,7 @@ namespace cds { namespace intrusive { namespace striped_set {
             {
                 std::pair<iterator, bool> res = m_Map.insert( value_type( key, mapped_type() ));
                 if ( res.second )
-                    ::cds::unref(f)( const_cast<value_type&>(*res.first) );
+                    ::f( const_cast<value_type&>(*res.first) );
                 return res.second;
             }
 
@@ -125,7 +125,7 @@ namespace cds { namespace intrusive { namespace striped_set {
             std::pair<bool, bool> ensure( const Q& key, Func func )
             {
                 std::pair<iterator, bool> res = m_Map.insert( value_type( key, mapped_type() ) );
-                cds::unref(func)( res.second, const_cast<value_type&>(*res.first));
+                func( res.second, const_cast<value_type&>(*res.first));
                 return std::make_pair( true, res.second );
             }
 
@@ -135,7 +135,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                 iterator it = m_Map.find( key_type(key) );
                 if ( it == m_Map.end() )
                     return false;
-                ::cds::unref(f)( const_cast<value_type&>(*it) );
+                ::f( const_cast<value_type&>(*it) );
                 m_Map.erase( it );
                 return true;
             }
@@ -146,7 +146,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                 iterator it = m_Map.find( key_type(val) );
                 if ( it == m_Map.end() )
                     return false;
-                ::cds::unref(f)( const_cast<value_type&>(*it), val );
+                ::f( const_cast<value_type&>(*it), val );
                 return true;
             }
 
index 8850c6e..8136089 100644 (file)
@@ -111,7 +111,7 @@ namespace cds { namespace intrusive { namespace striped_set {
             {
                 std::pair<iterator, bool> res = m_Map.insert( value_type( key, mapped_type() ) );
                 if ( res.second )
-                    ::cds::unref(f)( *res.first );
+                    ::f( *res.first );
                 return res.second;
             }
 
@@ -119,7 +119,7 @@ namespace cds { namespace intrusive { namespace striped_set {
             std::pair<bool, bool> ensure( const Q& val, Func func )
             {
                 std::pair<iterator, bool> res = m_Map.insert( value_type( val, mapped_type() ));
-                ::cds::unref(func)( res.second, *res.first );
+                ::func( res.second, *res.first );
                 return std::make_pair( true, res.second );
             }
 
@@ -129,7 +129,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                 iterator it = m_Map.find( key_type(key) );
                 if ( it == m_Map.end() )
                     return false;
-                ::cds::unref(f)( *it );
+                ::f( *it );
                 m_Map.erase( it );
                 return true;
             }
@@ -140,7 +140,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                 iterator it = m_Map.find( key_type(val) );
                 if ( it == m_Map.end() )
                     return false;
-                ::cds::unref(f)( *it, val );
+                ::f( *it, val );
                 return true;
             }
 
index 914dacb..826fedc 100644 (file)
@@ -3,11 +3,11 @@
 #ifndef __CDS_CONTAINER_STRIPED_MAP_STD_LIST_ADAPTER_H
 #define __CDS_CONTAINER_STRIPED_MAP_STD_LIST_ADAPTER_H
 
-#include <cds/container/striped_set/adapter.h>
-#include <cds/ref.h>
 #include <list>
+#include <functional>   // ref
 #include <algorithm>    // std::lower_bound
 #include <utility>      // std::pair
+#include <cds/container/striped_set/adapter.h>
 
 //@cond
 namespace cds { namespace container {
@@ -145,7 +145,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                 if ( it == m_List.end() || key_comparator()( key, it->first ) != 0 ) {
                     //value_type newItem( key );
                     it = m_List.insert( it, value_type( key, mapped_type()) );
-                    cds::unref( f )( *it );
+                    f( *it );
 
 #           ifdef __GLIBCXX__
                     ++m_nSize;
@@ -181,7 +181,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                     // insert new
                     value_type newItem( key, mapped_type() );
                     it = m_List.insert( it, newItem );
-                    cds::unref( func )( true, *it );
+                    func( true, *it );
 #           ifdef __GLIBCXX__
                     ++m_nSize;
 #           endif
@@ -189,7 +189,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                 }
                 else {
                     // already exists
-                    cds::unref( func )( false, *it );
+                    func( false, *it );
                     return std::make_pair( true, false );
                 }
             }
@@ -202,7 +202,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                     return false;
 
                 // key exists
-                cds::unref( f )( *it );
+                f( *it );
                 m_List.erase( it );
 #           ifdef __GLIBCXX__
                 --m_nSize;
@@ -219,7 +219,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                     return false;
 
                 // key exists
-                cds::unref( f )( *it );
+                f( *it );
                 m_List.erase( it );
 #           ifdef __GLIBCXX__
                 --m_nSize;
@@ -236,7 +236,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                     return false;
 
                 // key exists
-                cds::unref( f )( *it, val );
+                f( *it, val );
                 return true;
             }
 
@@ -248,7 +248,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                     return false;
 
                 // key exists
-                cds::unref( f )( *it, val );
+                f( *it, val );
                 return true;
             }
 
index 80810f4..6214b58 100644 (file)
@@ -106,7 +106,7 @@ namespace cds { namespace intrusive { namespace striped_set {
             {
                 std::pair<iterator, bool> res = m_Map.insert( value_type( key, mapped_type() ) );
                 if ( res.second )
-                    ::cds::unref(f)( *res.first );
+                    ::f( *res.first );
                 return res.second;
             }
 
@@ -121,7 +121,7 @@ namespace cds { namespace intrusive { namespace striped_set {
             std::pair<bool, bool> ensure( const Q& key, Func func )
             {
                 std::pair<iterator, bool> res = m_Map.insert( value_type( key, mapped_type() ));
-                cds::unref(func)( res.second, *res.first );
+                func( res.second, *res.first );
                 return std::make_pair( true, res.second );
             }
 
@@ -131,7 +131,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                 iterator it = m_Map.find( key_type(key) );
                 if ( it == m_Map.end() )
                     return false;
-                cds::unref(f)( *it );
+                f( *it );
                 m_Map.erase( it );
                 return true;
             }
@@ -142,7 +142,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                 iterator it = m_Map.find( key_type(val) );
                 if ( it == m_Map.end() )
                     return false;
-                cds::unref(f)( *it, val );
+                f( *it, val );
                 return true;
             }
 
index 8c82d5b..18147ba 100644 (file)
@@ -589,7 +589,7 @@ namespace cds { namespace container {
             Therefore, the \p value_type should be constructible from type \p Q.
 
             The user-defined functor is called only if the inserting is success. It can be passed by reference
-            using <tt>boost::ref</tt>
+            using \p std::ref
         */
         template <typename Q, typename Func>
         bool insert( Q const& val, Func f )
@@ -658,7 +658,7 @@ namespace cds { namespace container {
 
             The functor can change non-key fields of the \p item.
 
-            You can pass \p func argument by value or by reference using <tt>boost::ref</tt>.
+            You can pass \p func argument by value or by reference using \p std::ref
 
             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 val key
@@ -788,7 +788,7 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You can pass \p f argument by value or by reference using <tt>boost::ref</tt> or cds::ref.
+            You can pass \p f argument by value or by reference using \p std::ref.
 
             The functor can change non-key fields of \p item.
             The \p val argument is non-const since it can be used as \p f functor destination i.e., the functor
@@ -835,7 +835,7 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You can pass \p f argument by value or by reference using <tt>boost::ref</tt> or cds::ref.
+            You can pass \p f argument by value or by reference using \p std::ref.
 
             The functor can change non-key fields of \p item.
 
index 3367678..fb2a34e 100644 (file)
@@ -63,7 +63,7 @@ namespace cds { namespace container {
                 Therefore, the \p value_type should be comparable with type \p Q and constructible from type \p Q,
 
                 The user-defined functor is called only if the inserting is success. It can be passed by reference
-                using <tt>boost::ref</tt>
+                using \p std::ref
                 <hr>
 
             <b>Inserts data of type \ref value_type constructed with <tt>std::forward<Args>(args)...</tt></b>
@@ -101,7 +101,7 @@ namespace cds { namespace container {
                 The type \p Q can differ from \ref value_type of items storing in the container.
                 Therefore, the \p value_type should be comparable with type \p Q and constructible from type \p Q,
 
-                You can pass \p func argument by reference using <tt>boost::ref</tt>.
+                You can pass \p func argument by reference using \p std::ref
 
                 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 val key
@@ -140,7 +140,7 @@ namespace cds { namespace container {
                 \endcode
                 where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-                You can pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+                You can pass \p f argument by reference using \p std::ref
 
                 The functor can change non-key fields of \p item.
                 The \p val argument is non-const since it can be used as \p f functor destination i.e., the functor
@@ -266,7 +266,7 @@ namespace cds { namespace container {
                 {
                     std::pair<iterator, bool> res = m_Set.insert( value_type(val) );
                     if ( res.second )
-                        cds::unref(f)( const_cast<value_type&>(*res.first) );
+                        f( const_cast<value_type&>(*res.first) );
                     return res.second;
                 }
 
@@ -281,7 +281,7 @@ namespace cds { namespace container {
                 std::pair<bool, bool> ensure( const Q& val, Func func )
                 {
                     std::pair<iterator, bool> res = m_Set.insert( value_type(val) );
-                    cds::unref(func)( res.second, const_cast<value_type&>(*res.first), val );
+                    func( res.second, const_cast<value_type&>(*res.first), val );
                     return std::make_pair( true, res.second );
                 }
 
@@ -291,7 +291,7 @@ namespace cds { namespace container {
                     const_iterator it = m_Set.find( value_type(key) );
                     if ( it == m_Set.end() )
                         return false;
-                    cds::unref(f)( const_cast<value_type&>(*it) );
+                    f( const_cast<value_type&>(*it) );
                     m_Set.erase( it );
                     return true;
                 }
@@ -302,7 +302,7 @@ namespace cds { namespace container {
                     iterator it = m_Set.find( value_type(val) );
                     if ( it == m_Set.end() )
                         return false;
-                    cds::unref(f)( const_cast<value_type&>(*it), val );
+                    f( const_cast<value_type&>(*it), val );
                     return true;
                 }
 
@@ -403,7 +403,7 @@ namespace cds { namespace container {
                 {
                     std::pair<iterator, bool> res = m_Map.insert( value_type( key, mapped_type() ) );
                     if ( res.second )
-                        cds::unref(f)( *res.first );
+                        f( *res.first );
                     return res.second;
                 }
 
@@ -418,7 +418,7 @@ namespace cds { namespace container {
                 std::pair<bool, bool> ensure( const Q& val, Func func )
                 {
                     std::pair<iterator, bool> res = m_Map.insert( value_type( val, mapped_type() ));
-                    cds::unref(func)( res.second, *res.first );
+                    func( res.second, *res.first );
                     return std::make_pair( true, res.second );
                 }
 
@@ -428,7 +428,7 @@ namespace cds { namespace container {
                     iterator it = m_Map.find( key_type(key) );
                     if ( it == m_Map.end() )
                         return false;
-                    cds::unref(f)( *it );
+                    f( *it );
                     m_Map.erase( it );
                     return true;
                 }
@@ -439,7 +439,7 @@ namespace cds { namespace container {
                     iterator it = m_Map.find( key_type(val) );
                     if ( it == m_Map.end() )
                         return false;
-                    cds::unref(f)( *it, val );
+                    f( *it, val );
                     return true;
                 }
 
index 8dad131..399f68d 100644 (file)
@@ -8,10 +8,10 @@
 #   error "For boost::container::list you must use boost 1.48 or above"
 #endif
 
+#include <algorithm>    // std::lower_bound
+#include <functional>   // ref
 #include <cds/container/striped_set/adapter.h>
-#include <cds/ref.h>
 #include <boost/container/list.hpp>
-#include <algorithm>    // std::lower_bound
 
 //@cond
 namespace cds { namespace container {
@@ -134,7 +134,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                 if ( it == m_List.end() || key_comparator()( val, *it ) != 0 ) {
                     value_type newItem( val );
                     it = m_List.insert( it, newItem );
-                    cds::unref( f )( *it );
+                    f( *it );
 
                     return true;
                 }
@@ -163,12 +163,12 @@ namespace cds { namespace intrusive { namespace striped_set {
                     // insert new
                     value_type newItem( val );
                     it = m_List.insert( it, newItem );
-                    cds::unref( func )( true, *it, val );
+                    func( true, *it, val );
                     return std::make_pair( true, true );
                 }
                 else {
                     // already exists
-                    cds::unref( func )( false, *it, val );
+                    func( false, *it, val );
                     return std::make_pair( true, false );
                 }
             }
@@ -181,7 +181,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                     return false;
 
                 // key exists
-                cds::unref( f )( *it );
+                f( *it );
                 m_List.erase( it );
 
                 return true;
@@ -195,7 +195,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                     return false;
 
                 // key exists
-                cds::unref( f )( *it );
+                f( *it );
                 m_List.erase( it );
 
                 return true;
@@ -209,7 +209,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                     return false;
 
                 // key exists
-                cds::unref( f )( *it, val );
+                f( *it, val );
                 return true;
             }
 
@@ -221,7 +221,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                     return false;
 
                 // key exists
-                cds::unref( f )( *it, val );
+                f( *it, val );
                 return true;
             }
 
index baa8468..18097ca 100644 (file)
@@ -3,8 +3,8 @@
 #ifndef __CDS_CONTAINER_STRIPED_SET_BOOST_SLIST_ADAPTER_H
 #define __CDS_CONTAINER_STRIPED_SET_BOOST_SLIST_ADAPTER_H
 
+#include <functional>   // ref
 #include <cds/container/striped_set/adapter.h>
-#include <cds/ref.h>
 #include <boost/container/slist.hpp>
 
 //@cond
@@ -143,7 +143,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                 if ( !pos.second ) {
                     value_type newItem( val );
                     pos.first = m_List.insert_after( pos.first, newItem );
-                    cds::unref( f )( *pos.first );
+                    f( *pos.first );
                     return true;
                 }
 
@@ -171,12 +171,12 @@ namespace cds { namespace intrusive { namespace striped_set {
                     // insert new
                     value_type newItem( val );
                     pos.first = m_List.insert_after( pos.first, newItem );
-                    cds::unref( func )( true, *pos.first, val );
+                    func( true, *pos.first, val );
                     return std::make_pair( true, true );
                 }
                 else {
                     // already exists
-                    cds::unref( func )( false, *(++pos.first), val );
+                    func( false, *(++pos.first), val );
                     return std::make_pair( true, false );
                 }
             }
@@ -190,7 +190,7 @@ namespace cds { namespace intrusive { namespace striped_set {
 
                 // key exists
                 iterator it = pos.first;
-                cds::unref( f )( *(++it) );
+                f( *(++it) );
                 m_List.erase_after( pos.first );
 
                 return true;
@@ -205,7 +205,7 @@ namespace cds { namespace intrusive { namespace striped_set {
 
                 // key exists
                 iterator it = pos.first;
-                cds::unref( f )( *(++it) );
+                f( *(++it) );
                 m_List.erase_after( pos.first );
 
                 return true;
@@ -219,7 +219,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                     return false;
 
                 // key exists
-                cds::unref( f )( *(++pos.first), val );
+                f( *(++pos.first), val );
                 return true;
             }
 
@@ -231,7 +231,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                     return false;
 
                 // key exists
-                cds::unref( f )( *(++pos.first), val );
+                f( *(++pos.first), val );
                 return true;
             }
 
index 7753788..9a8b806 100644 (file)
@@ -8,11 +8,11 @@
 #   error "For boost::container::stable_vector you must use boost 1.48 or above"
 #endif
 
-#include <cds/container/striped_set/adapter.h>
-#include <cds/ref.h>
-#include <boost/container/stable_vector.hpp>
+#include <functional>   // ref
 #include <algorithm>    // std::lower_bound
 #include <utility>      // std::pair
+#include <cds/container/striped_set/adapter.h>
+#include <boost/container/stable_vector.hpp>
 
 //@cond
 namespace cds { namespace container {
@@ -143,7 +143,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                 Therefore, the \p value_type should be comparable with type \p Q and constructible from type \p Q,
 
                 The user-defined functor is called only if the inserting is success. It may be passed by reference
-                using <tt>boost::ref</tt>
+                using \p std::ref
             */
             template <typename Q, typename Func>
             bool insert( const Q& val, Func f )
@@ -152,7 +152,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                 if ( it == m_Vector.end() || key_comparator()( val, *it ) != 0 ) {
                     value_type newItem( val );
                     it = m_Vector.insert( it, newItem );
-                    cds::unref( f )( *it );
+                    f( *it );
                     return true;
                 }
                 return false;
@@ -197,7 +197,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                 The type \p Q may differ from \ref value_type of items storing in the container.
                 Therefore, the \p value_type should be comparable with type \p Q and constructible from type \p Q,
 
-                You may pass \p func argument by reference using <tt>boost::ref</tt>.
+                You may pass \p func argument by reference using \p std::ref
 
                 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 val key
@@ -211,12 +211,12 @@ namespace cds { namespace intrusive { namespace striped_set {
                     // insert new
                     value_type newItem( val );
                     it = m_Vector.insert( it, newItem );
-                    cds::unref( func )( true, *it, val );
+                    func( true, *it, val );
                     return std::make_pair( true, true );
                 }
                 else {
                     // already exists
-                    cds::unref( func )( false, *it, val );
+                    func( false, *it, val );
                     return std::make_pair( true, false );
                 }
             }
@@ -247,7 +247,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                     return false;
 
                 // key exists
-                cds::unref( f )( *it );
+                f( *it );
                 m_Vector.erase( it );
                 return true;
             }
@@ -260,7 +260,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                     return false;
 
                 // key exists
-                cds::unref( f )( *it );
+                f( *it );
                 m_Vector.erase( it );
                 return true;
             }
@@ -276,7 +276,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                 \endcode
                 where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-                You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+                You may pass \p f argument by reference using \p std::ref
 
                 The functor may change non-key fields of \p item.
                 The \p val argument is non-const since it can be used as \p f functor destination i.e., the functor
@@ -295,7 +295,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                     return false;
 
                 // key exists
-                cds::unref( f )( *it, val );
+                f( *it, val );
                 return true;
             }
 
@@ -307,7 +307,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                     return false;
 
                 // key exists
-                cds::unref( f )( *it, val );
+                f( *it, val );
                 return true;
             }
 
index a9fbfe9..52db5ec 100644 (file)
@@ -8,11 +8,11 @@
 #   error "For boost::container::vector you must use boost 1.48 or above"
 #endif
 
-#include <cds/container/striped_set/adapter.h>     // lower_bound
-#include <cds/ref.h>
-#include <boost/container/vector.hpp>
+#include <functional>   // ref
 #include <algorithm>    // std::lower_bound
 #include <utility>      // std::pair
+#include <cds/container/striped_set/adapter.h>     // lower_bound
+#include <boost/container/vector.hpp>
 
 //@cond
 namespace cds { namespace container {
@@ -132,7 +132,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                 if ( it == m_Vector.end() || key_comparator()( val, *it ) != 0 ) {
                     value_type newItem( val );
                     it = m_Vector.insert( it, newItem );
-                    cds::unref( f )( *it );
+                    f( *it );
                     return true;
                 }
                 return false;
@@ -158,12 +158,12 @@ namespace cds { namespace intrusive { namespace striped_set {
                     // insert new
                     value_type newItem( val );
                     it = m_Vector.insert( it, newItem );
-                    cds::unref( func )( true, *it, val );
+                    func( true, *it, val );
                     return std::make_pair( true, true );
                 }
                 else {
                     // already exists
-                    cds::unref( func )( false, *it, val );
+                    func( false, *it, val );
                     return std::make_pair( true, false );
                 }
             }
@@ -176,7 +176,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                     return false;
 
                 // key exists
-                cds::unref( f )( *it );
+                f( *it );
                 m_Vector.erase( it );
                 return true;
             }
@@ -189,7 +189,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                     return false;
 
                 // key exists
-                cds::unref( f )( *it );
+                f( *it );
                 m_Vector.erase( it );
                 return true;
             }
@@ -202,7 +202,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                     return false;
 
                 // key exists
-                cds::unref( f )( *it, val );
+                f( *it, val );
                 return true;
             }
 
@@ -214,7 +214,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                     return false;
 
                 // key exists
-                cds::unref( f )( *it, val );
+                f( *it, val );
                 return true;
             }
 
index e0254c9..72cb3fc 100644 (file)
@@ -93,7 +93,7 @@ namespace cds { namespace intrusive { namespace striped_set {
             {
                 std::pair<iterator, bool> res = m_Set.insert( value_type(val) );
                 if ( res.second )
-                    ::cds::unref(f)( const_cast<value_type&>(*res.first) );
+                    ::f( const_cast<value_type&>(*res.first) );
                 return res.second;
             }
 
@@ -108,7 +108,7 @@ namespace cds { namespace intrusive { namespace striped_set {
             std::pair<bool, bool> ensure( const Q& val, Func func )
             {
                 std::pair<iterator, bool> res = m_Set.insert( value_type(val) );
-                cds::unref(func)( res.second, const_cast<value_type&>(*res.first), val );
+                func( res.second, const_cast<value_type&>(*res.first), val );
                 return std::make_pair( true, res.second );
             }
 
@@ -118,7 +118,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                 const_iterator it = m_Set.find( value_type(key) );
                 if ( it == m_Set.end() )
                     return false;
-                cds::unref(f)( const_cast<value_type&>(*it) );
+                f( const_cast<value_type&>(*it) );
                 m_Set.erase( it );
                 return true;
             }
@@ -129,7 +129,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                 iterator it = m_Set.find( value_type(val) );
                 if ( it == m_Set.end() )
                     return false;
-                cds::unref(f)( const_cast<value_type&>(*it), val );
+                f( const_cast<value_type&>(*it), val );
                 return true;
             }
 
index 352e30e..765a069 100644 (file)
@@ -95,7 +95,7 @@ namespace cds { namespace intrusive { namespace striped_set {
             {
                 std::pair<iterator, bool> res = m_Set.insert( value_type(val) );
                 if ( res.second )
-                    ::cds::unref(f)( *res.first );
+                    ::f( *res.first );
                 return res.second;
             }
 
@@ -103,7 +103,7 @@ namespace cds { namespace intrusive { namespace striped_set {
             std::pair<bool, bool> ensure( const Q& val, Func func )
             {
                 std::pair<iterator, bool> res = m_Set.insert( value_type(val) );
-                ::cds::unref(func)( res.second, *res.first, val );
+                ::func( res.second, *res.first, val );
                 return std::make_pair( true, res.second );
             }
 
@@ -113,7 +113,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                 iterator it = m_Set.find( value_type(key) );
                 if ( it == m_Set.end() )
                     return false;
-                ::cds::unref(f)( *it );
+                ::f( *it );
                 m_Set.erase( it );
                 return true;
             }
@@ -124,7 +124,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                 iterator it = m_Set.find( value_type(val) );
                 if ( it == m_Set.end() )
                     return false;
-                ::cds::unref(f)( *it, val );
+                ::f( *it, val );
                 return true;
             }
 
index 50411b0..8399f04 100644 (file)
@@ -3,10 +3,10 @@
 #ifndef __CDS_CONTAINER_STRIPED_SET_STD_LIST_ADAPTER_H
 #define __CDS_CONTAINER_STRIPED_SET_STD_LIST_ADAPTER_H
 
-#include <cds/container/striped_set/adapter.h>
-#include <cds/ref.h>
+#include <functional>   // ref
 #include <list>
 #include <algorithm>    // std::lower_bound
+#include <cds/container/striped_set/adapter.h>
 
 //@cond
 namespace cds { namespace container {
@@ -139,7 +139,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                 if ( it == m_List.end() || key_comparator()( val, *it ) != 0 ) {
                     value_type newItem( val );
                     it = m_List.insert( it, newItem );
-                    cds::unref( f )( *it );
+                    f( *it );
 
 #           ifdef __GLIBCXX__
                     ++m_nSize;
@@ -180,7 +180,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                     // insert new
                     value_type newItem( val );
                     it = m_List.insert( it, newItem );
-                    cds::unref( func )( true, *it, val );
+                    func( true, *it, val );
 #           ifdef __GLIBCXX__
                     ++m_nSize;
 #           endif
@@ -188,7 +188,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                 }
                 else {
                     // already exists
-                    cds::unref( func )( false, *it, val );
+                    func( false, *it, val );
                     return std::make_pair( true, false );
                 }
             }
@@ -201,7 +201,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                     return false;
 
                 // key exists
-                cds::unref( f )( *it );
+                f( *it );
                 m_List.erase( it );
 #           ifdef __GLIBCXX__
                 --m_nSize;
@@ -218,7 +218,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                     return false;
 
                 // key exists
-                cds::unref( f )( *it );
+                f( *it );
                 m_List.erase( it );
 #           ifdef __GLIBCXX__
                 --m_nSize;
@@ -235,7 +235,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                     return false;
 
                 // key exists
-                cds::unref( f )( *it, val );
+                f( *it, val );
                 return true;
             }
 
@@ -247,7 +247,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                     return false;
 
                 // key exists
-                cds::unref( f )( *it, val );
+                f( *it, val );
                 return true;
             }
 
index 6f23794..b64c5cd 100644 (file)
@@ -90,7 +90,7 @@ namespace cds { namespace intrusive { namespace striped_set {
             {
                 std::pair<iterator, bool> res = m_Set.insert( value_type(val) );
                 if ( res.second )
-                    ::cds::unref(f)( const_cast<value_type&>(*res.first) );
+                    ::f( const_cast<value_type&>(*res.first) );
                 return res.second;
             }
 
@@ -105,7 +105,7 @@ namespace cds { namespace intrusive { namespace striped_set {
             std::pair<bool, bool> ensure( const Q& val, Func func )
             {
                 std::pair<iterator, bool> res = m_Set.insert( value_type(val) );
-                ::cds::unref(func)( res.second, const_cast<value_type&>(*res.first), val );
+                ::func( res.second, const_cast<value_type&>(*res.first), val );
                 return std::make_pair( true, res.second );
             }
 
@@ -115,7 +115,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                 iterator it = m_Set.find( value_type(key) );
                 if ( it == m_Set.end() )
                     return false;
-                ::cds::unref(f)( const_cast<value_type&>(*it) );
+                ::f( const_cast<value_type&>(*it) );
                 m_Set.erase( it );
                 return true;
             }
@@ -126,7 +126,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                 iterator it = m_Set.find( value_type(val) );
                 if ( it == m_Set.end() )
                     return false;
-                ::cds::unref(f)( const_cast<value_type&>(*it), val );
+                ::f( const_cast<value_type&>(*it), val );
                 return true;
             }
 
index e1e9169..1e19993 100644 (file)
@@ -3,11 +3,11 @@
 #ifndef __CDS_CONTAINER_STRIPED_SET_STD_VECTOR_ADAPTER_H
 #define __CDS_CONTAINER_STRIPED_SET_STD_VECTOR_ADAPTER_H
 
-#include <cds/container/striped_set/adapter.h>     // lower_bound
-#include <cds/ref.h>
+#include <functional>   // ref
 #include <vector>
 #include <algorithm>    // std::lower_bound
 #include <utility>      // std::pair
+#include <cds/container/striped_set/adapter.h>     // lower_bound
 
 //@cond
 namespace cds { namespace container {
@@ -129,7 +129,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                 if ( it == m_Vector.end() || key_comparator()( val, *it ) != 0 ) {
                     value_type newItem( val );
                     it = m_Vector.insert( it, newItem );
-                    cds::unref( f )( *it );
+                    f( *it );
                     return true;
                 }
                 return false;
@@ -161,12 +161,12 @@ namespace cds { namespace intrusive { namespace striped_set {
                     // insert new
                     value_type newItem( val );
                     it = m_Vector.insert( it, newItem );
-                    cds::unref( func )( true, *it, val );
+                    func( true, *it, val );
                     return std::make_pair( true, true );
                 }
                 else {
                     // already exists
-                    cds::unref( func )( false, *it, val );
+                    func( false, *it, val );
                     return std::make_pair( true, false );
                 }
             }
@@ -179,7 +179,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                     return false;
 
                 // key exists
-                cds::unref( f )( *it );
+                f( *it );
                 m_Vector.erase( it );
                 return true;
             }
@@ -192,7 +192,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                     return false;
 
                 // key exists
-                cds::unref( f )( *it );
+                f( *it );
                 m_Vector.erase( it );
                 return true;
             }
@@ -205,7 +205,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                     return false;
 
                 // key exists
-                cds::unref( f )( *it, val );
+                f( *it, val );
                 return true;
             }
 
@@ -217,7 +217,7 @@ namespace cds { namespace intrusive { namespace striped_set {
                     return false;
 
                 // key exists
-                cds::unref( f )( *it, val );
+                f( *it, val );
                 return true;
             }
 
index 9638889..cf09e50 100644 (file)
@@ -224,7 +224,7 @@ namespace cds { namespace container {
         bool enqueue( const Type& data, Func f  )
         {
             scoped_node_ptr p( alloc_node());
-            unref(f)( *p, data );
+            f( *p, data );
             if ( base_class::enqueue( *p )) {
                 p.release();
                 return true;
@@ -267,7 +267,7 @@ namespace cds { namespace container {
         {
             value_type * p = base_class::dequeue();
             if ( p ) {
-                unref(f)( dest, *p );
+                f( dest, *p );
                 node_disposer()( p );
                 return true;
             }
index 1d7aa89..2c2a7bf 100644 (file)
@@ -3,11 +3,11 @@
 #ifndef __CDS_CONTAINER_VYUKOV_MPMC_CYCLE_QUEUE_H
 #define __CDS_CONTAINER_VYUKOV_MPMC_CYCLE_QUEUE_H
 
+#include <functional>   // ref
 #include <cds/container/details/base.h>
 #include <cds/opt/buffer.h>
 #include <cds/opt/value_cleaner.h>
 #include <cds/cxx11_atomic.h>
-#include <cds/ref.h>
 #include <cds/details/trivial_assign.h>
 #include <cds/details/bounded_container.h>
 
@@ -194,7 +194,7 @@ namespace cds { namespace container {
                     pos = m_posEnqueue.load(memory_model::memory_order_relaxed);
             }
 
-            unref(func)( cell->data, data );
+            func( cell->data, data );
 
             cell->sequence.store(pos + 1, memory_model::memory_order_release);
             ++m_ItemCounter;
@@ -280,7 +280,7 @@ namespace cds { namespace container {
                     pos = m_posDequeue.load(memory_model::memory_order_relaxed);
             }
 
-            unref(func)( data, cell->data );
+            func( data, cell->data );
             value_cleaner()( cell->data );
             --m_ItemCounter;
             cell->sequence.store( pos + m_nBufferMask + 1, memory_model::memory_order_release );
index a8ca972..3ee34fc 100644 (file)
@@ -3,7 +3,7 @@
 #ifndef __CDS_DETAILS_FUNCTOR_WRAPPER_H
 #define __CDS_DETAILS_FUNCTOR_WRAPPER_H
 
-#include <cds/ref.h>
+#include <functional>   // ref
 
 //@cond
 namespace cds { namespace details {
index c556e81..46f2ca0 100644 (file)
@@ -4,11 +4,11 @@
 #define __CDS_INTRUSIVE_BASKET_QUEUE_H
 
 #include <type_traits>
+#include <functional>   // ref
 #include <cds/intrusive/details/base.h>
 #include <cds/details/marked_ptr.h>
 #include <cds/intrusive/details/queue_stat.h>
 #include <cds/intrusive/details/single_link_struct.h>
-#include <cds/ref.h>
 #include <cds/intrusive/details/dummy_node_holder.h>
 
 namespace cds { namespace intrusive {
index 87404c7..6815bb7 100644 (file)
@@ -6,11 +6,11 @@
 #include <memory>
 #include <type_traits>
 #include <mutex>
+#include <functional>   // ref
 #include <cds/intrusive/details/base.h>
 #include <cds/opt/compare.h>
 #include <cds/opt/hash.h>
 #include <cds/lock/array.h>
-#include <cds/ref.h>
 #include <cds/os/thread.h>
 #include <cds/details/functor_wrapper.h>
 #include <cds/lock/spinlock.h>
@@ -1316,7 +1316,7 @@ namespace cds { namespace intrusive {
                     for ( node_type * pNode = pHead; pNode; pNode = pNext ) {
                         pNext = pNode->m_pNext;
                         pNode->clear();
-                        cds::unref(disp)( pNode );
+                        disp( pNode );
                     }
 
                     nSize = 0;
@@ -1465,7 +1465,7 @@ namespace cds { namespace intrusive {
                 void clear( Disposer disp )
                 {
                     for ( unsigned int i = 0; i < m_nSize; ++i ) {
-                        cds::unref(disp)( m_arrNode[i] );
+                        disp( m_arrNode[i] );
                     }
                     m_nSize = 0;
                 }
@@ -2035,7 +2035,7 @@ namespace cds { namespace intrusive {
                 unsigned int nTable = contains( arrPos, arrHash, val, pred );
                 if ( nTable != c_nUndefTable ) {
                     node_type& node = *arrPos[nTable].itFound;
-                    cds::unref(f)( *node_traits::to_value_ptr(node) );
+                    f( *node_traits::to_value_ptr(node) );
                     bucket( nTable, arrHash[nTable]).remove( arrPos[nTable].itPrev, arrPos[nTable].itFound );
                     --m_ItemCounter;
                     m_Stat.onEraseSuccess();
@@ -2057,7 +2057,7 @@ namespace cds { namespace intrusive {
 
             unsigned int nTable = contains( arrPos, arrHash, val, pred );
             if ( nTable != c_nUndefTable ) {
-                cds::unref(f)( *node_traits::to_value_ptr( *arrPos[nTable].itFound ), val );
+                f( *node_traits::to_value_ptr( *arrPos[nTable].itFound ), val );
                 m_Stat.onFindSuccess();
                 return true;
             }
@@ -2367,7 +2367,7 @@ namespace cds { namespace intrusive {
             where \p val is the item inserted.
 
             The user-defined functor is called only if the inserting is success and can be passed by reference
-            using <tt>boost::ref</tt>
+            using \p std::ref
         */
         template <typename Func>
         bool insert( value_type& val, Func f )
@@ -2393,7 +2393,7 @@ namespace cds { namespace intrusive {
                         bucket_entry& refBucket = bucket( i, arrHash[i] );
                         if ( refBucket.size() < m_nProbesetThreshold ) {
                             refBucket.insert_after( arrPos[i].itPrev, pNode );
-                            cds::unref(f)( val );
+                            f( val );
                             ++m_ItemCounter;
                             m_Stat.onInsertSuccess();
                             return true;
@@ -2404,7 +2404,7 @@ namespace cds { namespace intrusive {
                         bucket_entry& refBucket = bucket( i, arrHash[i] );
                         if ( refBucket.size() < m_nProbesetSize ) {
                             refBucket.insert_after( arrPos[i].itPrev, pNode );
-                            cds::unref(f)( val );
+                            f( val );
                             ++m_ItemCounter;
                             nGoalTable = i;
                             assert( refBucket.size() > 1 );
@@ -2449,7 +2449,7 @@ namespace cds { namespace intrusive {
 
             The functor may change non-key fields of the \p item.
 
-            You may pass \p func argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p func argument by reference using \p std::ref.
 
             Returns <tt> std::pair<bool, bool> </tt> where \p first is \p true if operation is successful,
             \p second is \p true if new item has been added or \p false if the item with \p key
@@ -2472,7 +2472,7 @@ namespace cds { namespace intrusive {
 
                     unsigned int nTable = contains( arrPos, arrHash, val, key_predicate() );
                     if ( nTable != c_nUndefTable ) {
-                        cds::unref(func)( false, *node_traits::to_value_ptr( *arrPos[nTable].itFound ), val );
+                        func( false, *node_traits::to_value_ptr( *arrPos[nTable].itFound ), val );
                         m_Stat.onEnsureExist();
                         return std::make_pair( true, false );
                     }
@@ -2484,7 +2484,7 @@ namespace cds { namespace intrusive {
                         bucket_entry& refBucket = bucket( i, arrHash[i] );
                         if ( refBucket.size() < m_nProbesetThreshold ) {
                             refBucket.insert_after( arrPos[i].itPrev, pNode );
-                            cds::unref(func)( true, val, val );
+                            func( true, val, val );
                             ++m_ItemCounter;
                             m_Stat.onEnsureSuccess();
                             return std::make_pair( true, true );
@@ -2495,7 +2495,7 @@ namespace cds { namespace intrusive {
                         bucket_entry& refBucket = bucket( i, arrHash[i] );
                         if ( refBucket.size() < m_nProbesetSize ) {
                             refBucket.insert_after( arrPos[i].itPrev, pNode );
-                            cds::unref(func)( true, val, val );
+                            func( true, val, val );
                             ++m_ItemCounter;
                             nGoalTable = i;
                             assert( refBucket.size() > 1 );
@@ -2629,7 +2629,7 @@ namespace cds { namespace intrusive {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You can pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You can pass \p f argument by reference using \p std::ref.
 
             The functor may change non-key fields of \p item.
 
@@ -2672,7 +2672,7 @@ namespace cds { namespace intrusive {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You can pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You can pass \p f argument by reference using \p std::ref.
 
             The functor may change non-key fields of \p item.
 
index bb181f9..340d802 100644 (file)
@@ -3,10 +3,10 @@
 #ifndef __CDS_INTRUSIVE_DETAILS_LAZY_LIST_BASE_H
 #define __CDS_INTRUSIVE_DETAILS_LAZY_LIST_BASE_H
 
+#include <functional>   // ref
 #include <cds/intrusive/details/base.h>
 #include <cds/opt/compare.h>
 #include <cds/details/marked_ptr.h>
-#include <cds/ref.h>
 #include <cds/details/make_const_type.h>
 #include <boost/type_traits/is_same.hpp>
 #include <cds/lock/spinlock.h>
index 696b200..bd556f3 100644 (file)
@@ -4,11 +4,11 @@
 #define __CDS_INTRUSIVE_DETAILS_MICHAEL_LIST_BASE_H
 
 #include <type_traits>
+#include <functional>   // ref
 #include <cds/intrusive/details/base.h>
 #include <cds/opt/compare.h>
 #include <cds/cxx11_atomic.h>
 #include <cds/details/marked_ptr.h>
-#include <cds/ref.h>
 #include <cds/details/make_const_type.h>
 #include <cds/urcu/options.h>
 
index 5792f7f..2fb5a06 100644 (file)
@@ -3,12 +3,12 @@
 #ifndef __CDS_INTRUSIVE_DETAILS_MICHAEL_SET_BASE_H
 #define __CDS_INTRUSIVE_DETAILS_MICHAEL_SET_BASE_H
 
+#include <functional>   // ref
 #include <cds/intrusive/details/base.h>
 #include <cds/opt/compare.h>
 #include <cds/opt/hash.h>
 #include <cds/algo/bitop.h>
 #include <cds/cxx11_atomic.h>
-#include <cds/ref.h>
 
 namespace cds { namespace intrusive {
 
index e7029da..abb9fa7 100644 (file)
@@ -4,9 +4,9 @@
 #define __CDS_INTRUSIVE_ELLEN_BINTREE_RCU_H
 
 #include <memory>
+#include <functional>   // ref
 #include <cds/intrusive/details/ellen_bintree_base.h>
 #include <cds/opt/compare.h>
-#include <cds/ref.h>
 #include <cds/details/binary_functor_wrapper.h>
 #include <cds/urcu/details/check_deadlock.h>
 #include <cds/urcu/exempt_ptr.h>
@@ -754,7 +754,7 @@ namespace cds { namespace intrusive {
             where \p val is the item inserted. User-defined functor \p f should guarantee that during changing
             \p val no any other changes could be made on this tree's item by concurrent threads.
             The user-defined functor is called only if the inserting is success and may be passed by reference
-            using <tt>boost::ref</tt>
+            using \p std::ref
 
             RCU \p synchronize method can be called. RCU should not be locked.
         */
@@ -785,7 +785,7 @@ namespace cds { namespace intrusive {
                             pNewInternal.reset( alloc_internal_node() );
 
                         if ( try_insert( val, pNewInternal.get(), res, updRetire )) {
-                            cds::unref(f)( val );
+                            f( val );
                             pNewInternal.release()  ;   // internal node is linked into the tree and should not be deleted
                             break;
                         }
@@ -821,7 +821,7 @@ namespace cds { namespace intrusive {
             The functor can change non-key fields of the \p item; however, \p func must guarantee
             that during changing no any other modifications could be made on this item by concurrent threads.
 
-            You can pass \p func argument by value or by reference using <tt>boost::ref</tt> or cds::ref.
+            You can pass \p func argument by value or by reference using \p std::ref.
 
             RCU \p synchronize method can be called. RCU should not be locked.
 
@@ -843,7 +843,7 @@ namespace cds { namespace intrusive {
                 search_result res;
                 for ( ;; ) {
                     if ( search( res, val, node_compare() )) {
-                        cds::unref(func)( false, *node_traits::to_value_ptr( res.pLeaf ), val );
+                        func( false, *node_traits::to_value_ptr( res.pLeaf ), val );
                         if ( pNewInternal.get() )
                             m_Stat.onInternalNodeDeleted() ;    // unique_internal_node_ptr deletes internal node
                         m_Stat.onEnsureExist();
@@ -857,7 +857,7 @@ namespace cds { namespace intrusive {
                             pNewInternal.reset( alloc_internal_node() );
 
                         if ( try_insert( val, pNewInternal.get(), res, updRetire )) {
-                            cds::unref(func)( true, val, val );
+                            func( true, val, val );
                             pNewInternal.release()  ;   // internal node is linked into the tree and should not be deleted
                             break;
                         }
@@ -1127,7 +1127,7 @@ namespace cds { namespace intrusive {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You can pass \p f argument by value or by reference using <tt>boost::ref</tt> or cds::ref.
+            You can pass \p f argument by value or by reference using \p std::ref.
 
             The functor can change non-key fields of \p item. Note that the functor is only guarantee
             that \p item cannot be disposed during functor is executing.
@@ -1172,7 +1172,7 @@ namespace cds { namespace intrusive {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You can pass \p f argument by value or by reference using <tt>boost::ref</tt> or cds::ref.
+            You can pass \p f argument by value or by reference using \p std::ref.
 
             The functor can change non-key fields of \p item. Note that the functor is only guarantee
             that \p item cannot be disposed during functor is executing.
@@ -1674,7 +1674,7 @@ namespace cds { namespace intrusive {
                             {
                                 if ( help_delete( pOp, updRetire )) {
                                     // res.pLeaf is not deleted yet since RCU is blocked
-                                    cds::unref(f)( *node_traits::to_value_ptr( res.pLeaf ));
+                                    f( *node_traits::to_value_ptr( res.pLeaf ));
                                     break;
                                 }
                                 pOp = nullptr;
@@ -1907,7 +1907,7 @@ namespace cds { namespace intrusive {
             search_result    res;
             if ( search( res, val, compare_functor() )) {
                 assert( res.pLeaf );
-                cds::unref(f)( *node_traits::to_value_ptr( res.pLeaf ), val );
+                f( *node_traits::to_value_ptr( res.pLeaf ), val );
 
                 m_Stat.onFindSuccess();
                 return true;
@@ -1924,7 +1924,7 @@ namespace cds { namespace intrusive {
             search_result    res;
             if ( search( res, key, node_compare() )) {
                 assert( res.pLeaf );
-                cds::unref(f)( *node_traits::to_value_ptr( res.pLeaf ), key );
+                f( *node_traits::to_value_ptr( res.pLeaf ), key );
 
                 m_Stat.onFindSuccess();
                 return true;
index 039114f..407b2e1 100644 (file)
@@ -4,9 +4,9 @@
 #define __CDS_INTRUSIVE_IMPL_ELLEN_BINTREE_H
 
 #include <memory>
+#include <functional>   // ref
 #include <cds/intrusive/details/ellen_bintree_base.h>
 #include <cds/opt/compare.h>
-#include <cds/ref.h>
 #include <cds/details/binary_functor_wrapper.h>
 #include <cds/urcu/details/check_deadlock.h>
 #include <cds/gc/guarded_ptr.h>
@@ -362,7 +362,7 @@ namespace cds { namespace intrusive {
             where \p val is the item inserted. User-defined functor \p f should guarantee that during changing
             \p val no any other changes could be made on this tree's item by concurrent threads.
             The user-defined functor is called only if the inserting is success and may be passed by reference
-            using <tt>boost::ref</tt>
+            using \p std::ref
         */
         template <typename Func>
         bool insert( value_type& val, Func f )
@@ -387,7 +387,7 @@ namespace cds { namespace intrusive {
                         pNewInternal.reset( alloc_internal_node() );
 
                     if ( try_insert( val, pNewInternal.get(), res )) {
-                        cds::unref(f)( val );
+                        f( val );
                         pNewInternal.release(); // internal node is linked into the tree and should not be deleted
                         break;
                     }
@@ -421,7 +421,7 @@ namespace cds { namespace intrusive {
             The functor can change non-key fields of the \p item; however, \p func must guarantee
             that during changing no any other modifications could be made on this item by concurrent threads.
 
-            You can pass \p func argument by value or by reference using <tt>boost::ref</tt> or cds::ref.
+            You can pass \p func argument by value or by reference using \p std::ref.
 
             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
@@ -438,7 +438,7 @@ namespace cds { namespace intrusive {
             search_result res;
             for ( ;; ) {
                 if ( search( res, val, node_compare() )) {
-                    cds::unref(func)( false, *node_traits::to_value_ptr( res.pLeaf ), val );
+                    func( false, *node_traits::to_value_ptr( res.pLeaf ), val );
                     if ( pNewInternal.get() )
                         m_Stat.onInternalNodeDeleted() ;    // unique_internal_node_ptr deletes internal node
                     m_Stat.onEnsureExist();
@@ -451,7 +451,7 @@ namespace cds { namespace intrusive {
                         pNewInternal.reset( alloc_internal_node() );
 
                     if ( try_insert( val, pNewInternal.get(), res )) {
-                        cds::unref(func)( true, val, val );
+                        func( true, val, val );
                         pNewInternal.release()  ;   // internal node has been linked into the tree and should not be deleted
                         break;
                     }
@@ -703,7 +703,7 @@ namespace cds { namespace intrusive {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You can pass \p f argument by value or by reference using <tt>boost::ref</tt> or cds::ref.
+            You can pass \p f argument by value or by reference using \p std::ref.
 
             The functor can change non-key fields of \p item. Note that the functor is only guarantee
             that \p item cannot be disposed during functor is executing.
@@ -746,7 +746,7 @@ namespace cds { namespace intrusive {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You can pass \p f argument by value or by reference using <tt>boost::ref</tt> or cds::ref.
+            You can pass \p f argument by value or by reference using \p std::ref.
 
             The functor can change non-key fields of \p item. Note that the functor is only guarantee
             that \p item cannot be disposed during functor is executing.
@@ -1353,7 +1353,7 @@ namespace cds { namespace intrusive {
                         {
                             if ( help_delete( pOp )) {
                                 // res.pLeaf is not deleted yet since it is guarded
-                                cds::unref(f)( *node_traits::to_value_ptr( res.pLeaf ));
+                                f( *node_traits::to_value_ptr( res.pLeaf ));
                                 break;
                             }
                             pOp = nullptr;
@@ -1494,7 +1494,7 @@ namespace cds { namespace intrusive {
             search_result    res;
             if ( search( res, val, node_compare() )) {
                 assert( res.pLeaf );
-                cds::unref(f)( *node_traits::to_value_ptr( res.pLeaf ), val );
+                f( *node_traits::to_value_ptr( res.pLeaf ), val );
 
                 m_Stat.onFindSuccess();
                 return true;
@@ -1517,7 +1517,7 @@ namespace cds { namespace intrusive {
             search_result    res;
             if ( search( res, val, compare_functor() )) {
                 assert( res.pLeaf );
-                cds::unref(f)( *node_traits::to_value_ptr( res.pLeaf ), val );
+                f( *node_traits::to_value_ptr( res.pLeaf ), val );
 
                 m_Stat.onFindSuccess();
                 return true;
index 943232d..c0d64a9 100644 (file)
@@ -563,7 +563,7 @@ namespace cds { namespace intrusive {
             where \p val is the item inserted.
             While the functor \p f is working the item \p val is locked.
             The user-defined functor is called only if the inserting is success and may be passed by reference
-            using <tt>boost::ref</tt>.
+            using \p std::ref
         */
         template <typename Func>
         bool insert( value_type& val, Func f )
@@ -591,7 +591,7 @@ namespace cds { namespace intrusive {
             The functor may change non-key fields of the \p item.
             While the functor \p f is working the item \p item is locked.
 
-            You may pass \p func argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p func argument by reference using \p std::ref.
 
             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
@@ -738,7 +738,7 @@ namespace cds { namespace intrusive {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p f argument by reference using \p std::ref.
 
             The functor may change non-key fields of \p item.
             While the functor \p f is calling the item \p item is locked.
@@ -778,7 +778,7 @@ namespace cds { namespace intrusive {
             \endcode
             where \p item is the item found, \p val is the \p find function argument.
 
-            You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p f argument by reference using \p std::ref.
 
             The functor may change non-key fields of \p item.
             While the functor \p f is calling the item \p item is locked.
@@ -985,7 +985,7 @@ namespace cds { namespace intrusive {
                         }
                         else {
                             link_node( node_traits::to_node_ptr( val ), pos.pPred, pos.pCur );
-                            cds::unref(f)( val );
+                            f( val );
                             ++m_ItemCounter;
                             return true;
                         }
@@ -1008,7 +1008,7 @@ namespace cds { namespace intrusive {
                         if ( pos.pCur != tail() && cmp( *node_traits::to_value_ptr( *pos.pCur ), val ) == 0 ) {
                             // key already in the list
 
-                            cds::unref(func)( false, *node_traits::to_value_ptr( *pos.pCur ) , val );
+                            func( false, *node_traits::to_value_ptr( *pos.pCur ) , val );
                             return std::make_pair( true, false );
                         }
                         else {
@@ -1016,7 +1016,7 @@ namespace cds { namespace intrusive {
                             link_checker::is_empty( node_traits::to_node_ptr( val ) );
 
                             link_node( node_traits::to_node_ptr( val ), pos.pPred, pos.pCur );
-                            cds::unref(func)( true, val, val );
+                            func( true, val, val );
                             ++m_ItemCounter;
                             return std::make_pair( true, true );
                         }
@@ -1074,7 +1074,7 @@ namespace cds { namespace intrusive {
                             if ( pos.pCur != tail() && cmp( *node_traits::to_value_ptr( *pos.pCur ), val ) == 0 ) {
                                 // key found
                                 unlink_node( pos.pPred, pos.pCur, pHead );
-                                cds::unref(f)( *node_traits::to_value_ptr( *pos.pCur ) );
+                                f( *node_traits::to_value_ptr( *pos.pCur ) );
                                 --m_ItemCounter;
                                 nResult = 1;
                             }
@@ -1130,7 +1130,7 @@ namespace cds { namespace intrusive {
                 if ( !pos.pCur->is_marked()
                     && cmp( *node_traits::to_value_ptr( *pos.pCur ), val ) == 0 )
                 {
-                    cds::unref(f)( *node_traits::to_value_ptr( *pos.pCur ), val );
+                    f( *node_traits::to_value_ptr( *pos.pCur ), val );
                     return true;
                 }
             }
index da5fba5..43addd1 100644 (file)
@@ -536,7 +536,7 @@ namespace cds { namespace intrusive {
             where \p val is the item inserted. User-defined functor \p f should guarantee that during changing
             \p val no any other changes could be made on this list's item by concurrent threads.
             The user-defined functor is called only if the inserting is success and may be passed by reference
-            using <tt>boost::ref</tt>.
+            using \p std::ref
         */
         template <typename Func>
         bool insert( value_type& val, Func f )
@@ -564,7 +564,7 @@ namespace cds { namespace intrusive {
             The functor may change non-key fields of the \p item; however, \p func must guarantee
             that during changing no any other modifications could be made on this item by concurrent threads.
 
-            You may pass \p func argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p func argument by reference using \p std::ref.
 
             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
@@ -710,7 +710,7 @@ namespace cds { namespace intrusive {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p f argument by reference using \p std::ref.
 
             The functor may change non-key fields of \p item. Note that the function is only guarantee
             that \p item cannot be disposed during functor is executing.
@@ -752,7 +752,7 @@ namespace cds { namespace intrusive {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p f argument by reference using \p std::ref.
 
             The functor may change non-key fields of \p item. Note that the function is only guarantee
             that \p item cannot be disposed during functor is executing.
@@ -948,7 +948,7 @@ namespace cds { namespace intrusive {
                 typename gc::Guard guard;
                 guard.assign( &val );
                 if ( link_node( pNode, pos ) ) {
-                    cds::unref(f)( val );
+                    f( val );
                     ++m_ItemCounter;
                     return true;
                 }
@@ -972,7 +972,7 @@ namespace cds { namespace intrusive {
                     }
                     assert( key_comparator()( val, *node_traits::to_value_ptr( *pos.pCur ) ) == 0 );
 
-                    unref(func)( false, *node_traits::to_value_ptr( *pos.pCur ) , val );
+                    func( false, *node_traits::to_value_ptr( *pos.pCur ) , val );
                     return std::make_pair( true, false );
                 }
                 else {
@@ -980,7 +980,7 @@ namespace cds { namespace intrusive {
                     guard.assign( &val );
                     if ( link_node( pNode, pos ) ) {
                         ++m_ItemCounter;
-                        unref(func)( true, val, val );
+                        func( true, val, val );
                         return std::make_pair( true, true );
                     }
                     // clear next field
@@ -1015,7 +1015,7 @@ namespace cds { namespace intrusive {
             back_off bkoff;
             while ( search( refHead, val, pos, cmp )) {
                 if ( unlink_node( pos ) ) {
-                    cds::unref(f)( *node_traits::to_value_ptr( *pos.pCur ) );
+                    f( *node_traits::to_value_ptr( *pos.pCur ) );
                     --m_ItemCounter;
                     return true;
                 }
@@ -1068,7 +1068,7 @@ namespace cds { namespace intrusive {
         {
             position pos;
             if ( search( refHead, val, pos, cmp )) {
-                cds::unref(f)( *node_traits::to_value_ptr( *pos.pCur ), val );
+                f( *node_traits::to_value_ptr( *pos.pCur ), val );
                 return true;
             }
             return false;
index de43a01..c9f2559 100644 (file)
@@ -5,9 +5,9 @@
 
 #include <type_traits>
 #include <memory>
+#include <functional>   // ref
 #include <cds/intrusive/details/skip_list_base.h>
 #include <cds/opt/compare.h>
-#include <cds/ref.h>
 #include <cds/details/binary_functor_wrapper.h>
 #include <cds/gc/guarded_ptr.h>
 
@@ -654,7 +654,7 @@ namespace cds { namespace intrusive {
                 if ( !pos.pPrev[0]->next(0).compare_exchange_strong( p, marked_node_ptr(pNode), memory_model::memory_order_release, atomics::memory_order_relaxed ) ) {
                     return false;
                 }
-                cds::unref( f )( val );
+                f( val );
             }
 
             for ( unsigned int nLevel = 1; nLevel < nHeight; ++nLevel ) {
@@ -710,7 +710,7 @@ namespace cds { namespace intrusive {
                 if ( pDel->next(0).compare_exchange_strong( p, marked_node_ptr(p.ptr(), 1),
                      memory_model::memory_order_acquire, atomics::memory_order_relaxed ))
                 {
-                    cds::unref(f)( *node_traits::to_value_ptr( pDel ));
+                    f( *node_traits::to_value_ptr( pDel ));
 
                     // Physical deletion
                     // try fast erase
@@ -786,7 +786,7 @@ namespace cds { namespace intrusive {
                         }
                         else if ( nCmp == 0 ) {
                             // found
-                            cds::unref(f)( *node_traits::to_value_ptr( pCur.ptr() ), val );
+                            f( *node_traits::to_value_ptr( pCur.ptr() ), val );
                             return find_fastpath_found;
                         }
                         else // pCur > val - go down
@@ -805,7 +805,7 @@ namespace cds { namespace intrusive {
             if ( find_position( val, pos, cmp, true )) {
                 assert( cmp( *node_traits::to_value_ptr( pos.pCur ), val ) == 0 );
 
-                cds::unref(f)( *node_traits::to_value_ptr( pos.pCur ), val );
+                f( *node_traits::to_value_ptr( pos.pCur ), val );
                 return true;
             }
             else
@@ -1053,7 +1053,7 @@ namespace cds { namespace intrusive {
             where \p val is the item inserted. User-defined functor \p f should guarantee that during changing
             \p val no any other changes could be made on this set's item by concurrent threads.
             The user-defined functor is called only if the inserting is success and may be passed by reference
-            using <tt>boost::ref</tt>
+            using \p std::ref
         */
         template <typename Func>
         bool insert( value_type& val, Func f )
@@ -1121,7 +1121,7 @@ namespace cds { namespace intrusive {
             The functor can change non-key fields of the \p item; however, \p func must guarantee
             that during changing no any other modifications could be made on this item by concurrent threads.
 
-            You can pass \p func argument by value or by reference using <tt>boost::ref</tt> or cds::ref.
+            You can pass \p func argument by value or by reference using \p std::ref.
 
             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
@@ -1148,7 +1148,7 @@ namespace cds { namespace intrusive {
                     if ( !bTowerMade )
                         scp.release();
 
-                    cds::unref(func)( false, *node_traits::to_value_ptr(pos.pCur), val );
+                    func( false, *node_traits::to_value_ptr(pos.pCur), val );
                     m_Stat.onEnsureExist();
                     return std::make_pair( true, false );
                 }
@@ -1160,7 +1160,7 @@ namespace cds { namespace intrusive {
                         bTowerOk = true;
                 }
 
-                if ( !insert_at_position( val, pNode, pos, [&func]( value_type& item ) { cds::unref(func)( true, item, item ); })) {
+                if ( !insert_at_position( val, pNode, pos, [&func]( value_type& item ) { func( true, item, item ); })) {
                     m_Stat.onInsertRetry();
                     continue;
                 }
@@ -1415,7 +1415,7 @@ namespace cds { namespace intrusive {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You can pass \p f argument by value or by reference using <tt>boost::ref</tt> or cds::ref.
+            You can pass \p f argument by value or by reference using \p std::ref.
 
             The functor can change non-key fields of \p item. Note that the functor is only guarantee
             that \p item cannot be disposed during functor is executing.
@@ -1462,7 +1462,7 @@ namespace cds { namespace intrusive {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You can pass \p f argument by value or by reference using <tt>boost::ref</tt> or cds::ref.
+            You can pass \p f argument by value or by reference using \p std::ref.
 
             The functor can change non-key fields of \p item. Note that the functor is only guarantee
             that \p item cannot be disposed during functor is executing.
index c1c40a3..a50e742 100644 (file)
@@ -159,7 +159,7 @@ namespace cds { namespace intrusive {
         void dispose_node( node_type * pNode, Disposer disp )
         {
             clear_links( pNode );
-            cds::unref(disp)( node_traits::to_value_ptr( *pNode ));
+            disp( node_traits::to_value_ptr( *pNode ));
         }
 
         template <class Disposer>
@@ -354,7 +354,7 @@ namespace cds { namespace intrusive {
             The functor may change non-key fields of the \p item.
             While the functor \p f is calling the item \p item is locked.
 
-            You may pass \p func argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p func argument by reference using \p std::ref.
 
             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
@@ -379,7 +379,7 @@ namespace cds { namespace intrusive {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p f argument by reference using \p std::ref.
 
             The functor may change non-key fields of \p item.
             While the functor \p f is calling the item found \p item is locked.
@@ -404,7 +404,7 @@ namespace cds { namespace intrusive {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p f argument by reference using \p std::ref.
 
             The functor may change non-key fields of \p item.
             While the functor \p f is calling the item found \p item is locked.
@@ -581,7 +581,7 @@ namespace cds { namespace intrusive {
                         if ( pos.pCur != &m_Tail && cmp( *node_traits::to_value_ptr( *pos.pCur ), val ) == 0 ) {
                             // key already in the list
 
-                            cds::unref(func)( false, *node_traits::to_value_ptr( *pos.pCur ) , val );
+                            func( false, *node_traits::to_value_ptr( *pos.pCur ) , val );
                             return std::make_pair( iterator( pos.pCur ), false );
                         }
                         else {
@@ -589,7 +589,7 @@ namespace cds { namespace intrusive {
                             link_checker::is_empty( node_traits::to_node_ptr( val ) );
 
                             link_node( node_traits::to_node_ptr( val ), pos.pPred, pos.pCur );
-                            cds::unref(func)( true, val, val );
+                            func( true, val, val );
                             ++m_ItemCounter;
                             return std::make_pair( iterator( node_traits::to_node_ptr( val )), true );
                         }
@@ -615,7 +615,7 @@ namespace cds { namespace intrusive {
                 cds::lock::scoped_lock< typename node_type::lock_type> al( pos.pCur->m_Lock );
                 if ( cmp( *node_traits::to_value_ptr( *pos.pCur ), val ) == 0 )
                 {
-                    cds::unref(f)( *node_traits::to_value_ptr( *pos.pCur ), val );
+                    f( *node_traits::to_value_ptr( *pos.pCur ), val );
                     return true;
                 }
             }
index c20ccda..43ddce4 100644 (file)
@@ -444,7 +444,7 @@ namespace cds { namespace intrusive {
             where \p val is the item inserted.
             While the functor \p f is working the item \p val is locked.
             The user-defined functor is called only if the inserting is success and may be passed by reference
-            using <tt>boost::ref</tt>.
+            using \p std::ref.
         */
         template <typename Func>
         bool insert( value_type& val, Func f )
@@ -474,7 +474,7 @@ namespace cds { namespace intrusive {
             The functor may change non-key fields of the \p item.
             While the functor \p f is calling the item \p item is locked.
 
-            You may pass \p func argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p func argument by reference using \p std::ref.
 
             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
@@ -658,7 +658,7 @@ namespace cds { namespace intrusive {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p f argument by reference using \p std::ref.
 
             The functor may change non-key fields of \p item.
             While the functor \p f is calling the item found \p item is locked.
@@ -696,7 +696,7 @@ namespace cds { namespace intrusive {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You may pass \p f argument by reference using <tt>boost::ref</tt> or cds::ref.
+            You may pass \p f argument by reference using \p std::ref.
 
             The functor may change non-key fields of \p item.
             While the functor \p f is calling the item found \p item is locked.
@@ -917,7 +917,7 @@ namespace cds { namespace intrusive {
                         }
                         else {
                             link_node( node_traits::to_node_ptr( val ), pos.pPred, pos.pCur );
-                            cds::unref(f)( val );
+                            f( val );
                             ++m_ItemCounter;
                             return true;
                         }
@@ -950,7 +950,7 @@ namespace cds { namespace intrusive {
                         if ( pos.pCur != &m_Tail && cmp( *node_traits::to_value_ptr( *pos.pCur ), val ) == 0 ) {
                             // key already in the list
 
-                            cds::unref(func)( false, *node_traits::to_value_ptr( *pos.pCur ) , val );
+                            func( false, *node_traits::to_value_ptr( *pos.pCur ) , val );
                             return std::make_pair( iterator( pos.pCur ), false );
                         }
                         else {
@@ -958,7 +958,7 @@ namespace cds { namespace intrusive {
                             link_checker::is_empty( node_traits::to_node_ptr( val ) );
 
                             link_node( node_traits::to_node_ptr( val ), pos.pPred, pos.pCur );
-                            cds::unref(func)( true, val, val );
+                            func( true, val, val );
                             ++m_ItemCounter;
                             return std::make_pair( iterator( node_traits::to_node_ptr( val )), true );
                         }
@@ -1030,7 +1030,7 @@ namespace cds { namespace intrusive {
                             if ( pos.pCur != &m_Tail && cmp( *node_traits::to_value_ptr( *pos.pCur ), val ) == 0 ) {
                                 // key found
                                 unlink_node( pos.pPred, pos.pCur, pHead );
-                                cds::unref(f)( *node_traits::to_value_ptr( *pos.pCur ) );
+                                f( *node_traits::to_value_ptr( *pos.pCur ) );
                                 --m_ItemCounter;
                                 nResult = 1;
                             }
@@ -1108,7 +1108,7 @@ namespace cds { namespace intrusive {
                 cds::lock::scoped_lock< typename node_type::lock_type> al( pos.pCur->m_Lock );
                 if ( cmp( *node_traits::to_value_ptr( *pos.pCur ), val ) == 0 )
                 {
-                    cds::unref(f)( *node_traits::to_value_ptr( *pos.pCur ), val );
+                    f( *node_traits::to_value_ptr( *pos.pCur ), val );
                     return true;
                 }
             }
index 6f0ace5..89a5ae6 100644 (file)
@@ -106,7 +106,7 @@ namespace cds { namespace intrusive {
         void dispose_node( node_type * pNode, Disposer disp )
         {
             clear_links( pNode );
-            cds::unref(disp)( node_traits::to_value_ptr( *pNode ));
+            disp( node_traits::to_value_ptr( *pNode ));
         }
 
         template <class Disposer>
@@ -316,7 +316,7 @@ namespace cds { namespace intrusive {
             The functor may change non-key fields of the \p item; however, \p func must guarantee
             that during changing no any other modifications could be made on this item by concurrent threads.
 
-            You can pass \p func argument by value or by reference using <tt>boost::ref</tt> or cds::ref.
+            You can pass \p func argument by value or by reference using \p std::ref.
 
             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
@@ -341,7 +341,7 @@ namespace cds { namespace intrusive {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You can pass \p f argument by value or by reference using <tt>boost::ref</tt> or cds::ref.
+            You can pass \p f argument by value or by reference using \p std::ref.
 
             The functor can change non-key fields of \p item.
             The function \p find does not serialize simultaneous access to the list \p item. If such access is
@@ -380,7 +380,7 @@ namespace cds { namespace intrusive {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
-            You can pass \p f argument by value or by reference using <tt>boost::ref</tt> or cds::ref.
+            You can pass \p f argument by value or by reference using \p std::ref.
 
             The functor can change non-key fields of \p item.
             The function \p find does not serialize simultaneous access to the list \p item. If such access is
@@ -530,7 +530,7 @@ namespace cds { namespace intrusive {
                 if ( search( refHead, val, key_comparator(), pos ) ) {
                     assert( key_comparator()( val, *node_traits::to_value_ptr( *pos.pCur ) ) == 0 );
 
-                    unref(func)( false, *node_traits::to_value_ptr( *pos.pCur ) , val );
+                    func( false, *node_traits::to_value_ptr( *pos.pCur ) , val );
                     return std::make_pair( iterator( pos.pCur ), false );
                 }
                 else {
@@ -538,7 +538,7 @@ namespace cds { namespace intrusive {
 
                     if ( link_node( node_traits::to_node_ptr( val ), pos ) ) {
                         ++m_ItemCounter;
-                        unref(func)( true, val , val );
+                        func( true, val , val );
                         return std::make_pair( iterator( node_traits::to_node_ptr( val )), true );
                     }
                 }
@@ -559,7 +559,7 @@ namespace cds { namespace intrusive {
 
             if ( search( refHead, val, cmp, pos ) ) {
                 assert( pos.pCur != nullptr );
-