Remove std::ref and boost::ref from docs

diff --git a/cds/container/cuckoo_map.h b/cds/container/cuckoo_map.h
index a6043b0a21b5c1904907fdd8b7a65fe555b43f7c..a6755b88f0c707f8ce3614e864a149e455fc3bd3 100644 (file)
--- a/cds/container/cuckoo_map.h
+++ b/cds/container/cuckoo_map.h
@@ -507,9 +507,6 @@ 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.
 
                 - <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 \p std::ref
-            and it is called only if inserting is successful.
-

             The key_type should be constructible from value of type \p K.
 
             The function allows to split creating of new item into two part:
             The key_type should be constructible from value of type \p K.
 
             The function allows to split creating of new item into two part:


@@ -571,8 +568,6 @@ namespace cds { namespace container {
 
             The functor may change any fields of the \p item.second that is \ref value_type.
 
 
             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 \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
             already is in the list.
             Returns <tt> std::pair<bool, bool> </tt> where \p first is true if operation is successfull,
             \p second is true if new item has been added or \p false if the item with \p key
             already is in the list.


@@ -636,7 +631,6 @@ namespace cds { namespace container {
                 void operator()(value_type& item) { ... }
             };
             \endcode
                 void operator()(value_type& item) { ... }
             };
             \endcode

-            The functor may be passed by reference using <tt>boost:ref</tt>

 
             Return \p true if key is found and deleted, \p false otherwise
 
 
             Return \p true if key is found and deleted, \p false otherwise
 


@@ -686,8 +680,6 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found.
 
             \endcode
             where \p item is the item found.
 

-            You can pass \p f argument by reference using \p std::ref
-

             The functor may change \p item.second.
 
             The function returns \p true if \p key is found, \p false otherwise.
             The functor may change \p item.second.
 
             The function returns \p true if \p key is found, \p false otherwise.

diff --git a/cds/container/cuckoo_set.h b/cds/container/cuckoo_set.h
index 605f2a43e6c656a77ba62edc8af3610aa94c3edb..12172e4bb1f35cfc218ee7a8883dcd125f661556 100644 (file)
--- a/cds/container/cuckoo_set.h
+++ b/cds/container/cuckoo_set.h
@@ -536,8 +536,7 @@ namespace cds { namespace container {
             The type \p Q can differ from \ref value_type of items storing in the set.
             Therefore, the \p value_type should be constructible from type \p Q.
 
             The type \p Q can differ from \ref value_type of items storing in the set.
             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 \p std::ref
+            The user-defined functor is called only if the inserting is success.

         */
         template <typename Q, typename Func>
         bool insert( Q const& val, Func f )
         */
         template <typename Q, typename Func>
         bool insert( Q const& val, Func f )


@@ -589,8 +588,6 @@ namespace cds { namespace container {
 
             The functor can change non-key fields of the \p item.
 
 
             The functor can change non-key fields of the \p item.
 

-            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
             already exists.
             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
             already exists.


@@ -659,7 +656,6 @@ namespace cds { namespace container {
                 void operator()(value_type const& val);
             };
             \endcode
                 void operator()(value_type const& val);
             };
             \endcode

-            The functor can be passed by value or by reference using <tt>boost:ref</tt>

 
             Return \p true if key is found and deleted, \p false otherwise
         */
 
             Return \p true if key is found and deleted, \p false otherwise
         */


@@ -707,8 +703,6 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
             \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 \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
             can modify both arguments.
             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
             can modify both arguments.


@@ -751,8 +745,6 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
             \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 \p std::ref
-

             The functor can change non-key fields of \p item.
 
             The type \p Q can differ from \ref value_type of items storing in the container.
             The functor can change non-key fields of \p item.
 
             The type \p Q can differ from \ref value_type of items storing in the container.

diff --git a/cds/container/ellen_bintree_map_rcu.h b/cds/container/ellen_bintree_map_rcu.h
index 00b0b646dc313293e0666616acfe1eb5c33b9211..a45a8620b4688cb21c1c481e3d2d59d48a8da018 100644 (file)
--- a/cds/container/ellen_bintree_map_rcu.h
+++ b/cds/container/ellen_bintree_map_rcu.h
@@ -212,9 +212,6 @@ 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.
 
                 - <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 \p std::ref
-            and it is called only if inserting is successful.
-

             The key_type should be constructible from value of type \p K.
 
             The function allows to split creating of new item into two part:
             The key_type should be constructible from value of type \p K.
 
             The function allows to split creating of new item into two part:


@@ -280,8 +277,6 @@ namespace cds { namespace container {
 
             The functor may change any fields of the \p item.second that is \ref value_type.
 
 
             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 \p std::ref
-

             RCU \p synchronize method can be called. RCU should not be locked.
 
             Returns <tt> std::pair<bool, bool> </tt> where \p first is true if operation is successfull,
             RCU \p synchronize method can be called. RCU should not be locked.
 
             Returns <tt> std::pair<bool, bool> </tt> where \p first is true if operation is successfull,


@@ -338,7 +333,6 @@ namespace cds { namespace container {
                 void operator()(value_type& item) { ... }
             };
             \endcode
                 void operator()(value_type& item) { ... }
             };
             \endcode

-            The functor may be passed by reference using <tt>boost:ref</tt>

 
             RCU \p synchronize method can be called. RCU should not be locked.
 
 
             RCU \p synchronize method can be called. RCU should not be locked.
 


@@ -451,8 +445,6 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found.
 
             \endcode
             where \p item is the item found.
 

-            You can pass \p f argument by reference using \p std::ref
-

             The functor may change \p item.second.
 
             The function applies RCU lock internally.
             The functor may change \p item.second.
 
             The function applies RCU lock internally.

diff --git a/cds/container/ellen_bintree_set_rcu.h b/cds/container/ellen_bintree_set_rcu.h
index ad0b9842a1d8b7ae2bf7526c94f9375ec10d58cd..1a201c0fa29a07803396daa6eae3d36cb5e46fff 100644 (file)
--- a/cds/container/ellen_bintree_set_rcu.h
+++ b/cds/container/ellen_bintree_set_rcu.h
@@ -223,8 +223,7 @@ namespace cds { namespace container {
             \endcode
             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.
             \endcode
             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 \p std::ref
+            The user-defined functor is called only if the inserting is success. 

 
             RCU \p synchronize method can be called. RCU should not be locked.
         */
 
             RCU \p synchronize method can be called. RCU should not be locked.
         */


@@ -264,8 +263,6 @@ 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.
 
             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 \p std::ref
-

             RCU \p synchronize method can be called. RCU should not be locked.
 
             Returns <tt> std::pair<bool, bool> </tt> where \p first is true if operation is successfull,
             RCU \p synchronize method can be called. RCU should not be locked.
 
             Returns <tt> std::pair<bool, bool> </tt> where \p first is true if operation is successfull,


@@ -341,7 +338,6 @@ namespace cds { namespace container {
                 void operator()(value_type const& val);
             };
             \endcode
                 void operator()(value_type const& val);
             };
             \endcode

-            The functor may be passed by reference using <tt>boost:ref</tt>

 
             Since the key of MichaelHashSet's \p value_type is not explicitly specified,
             template parameter \p Q defines the key type searching in the list.
 
             Since the key of MichaelHashSet's \p value_type is not explicitly specified,
             template parameter \p Q defines the key type searching in the list.


@@ -462,8 +458,6 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
             \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 \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.
             The functor does not serialize simultaneous access to the set's \p item. If such access is
             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.
             The functor does not serialize simultaneous access to the set's \p item. If such access is


@@ -511,8 +505,6 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
             \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 \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.
             The functor does not serialize simultaneous access to the set's \p item. If such access is
             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.
             The functor does not serialize simultaneous access to the set's \p item. If such access is

diff --git a/cds/container/impl/ellen_bintree_map.h b/cds/container/impl/ellen_bintree_map.h
index dbbe09149ff08c5cc9054750983178095ebf6c70..8f60db7506dbc8d7f9198a14f0524bd9cd5314f7 100644 (file)
--- a/cds/container/impl/ellen_bintree_map.h
+++ b/cds/container/impl/ellen_bintree_map.h
@@ -395,8 +395,6 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found.
 
             \endcode
             where \p item is the item found.
 

-            You can pass \p f argument by reference using std::ref.
-

             The functor may change \p item.second.
 
             The function returns \p true if \p key is found, \p false otherwise.
             The functor may change \p item.second.
 
             The function returns \p true if \p key is found, \p false otherwise.

diff --git a/cds/container/impl/ellen_bintree_set.h b/cds/container/impl/ellen_bintree_set.h
index 72c8f292f33bbf12a932d246ea9263dba06a8311..366ab1f03ddc429f0785707bb08e2d04bd5485d0 100644 (file)
--- a/cds/container/impl/ellen_bintree_set.h
+++ b/cds/container/impl/ellen_bintree_set.h
@@ -410,8 +410,6 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found, \p key is the <tt>find</tt> function argument.
 
             \endcode
             where \p item is the item found, \p key is the <tt>find</tt> function argument.
 

-            You may pass \p f argument by reference using \p std::ref.
-

             The functor may change non-key fields of \p item. Note that the functor is only guarantee
             that \p item cannot be disposed during functor is executing.
             The functor does not serialize simultaneous access to the set's \p item. If such access is
             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.
             The functor does not serialize simultaneous access to the set's \p item. If such access is

diff --git a/cds/container/impl/lazy_kvlist.h b/cds/container/impl/lazy_kvlist.h
index b71876e43ae1ea8adcb62e83d535f19a762bb9bc..b2a6425ba12cce8aedeab05dc261514c04e6c963 100644 (file)
--- a/cds/container/impl/lazy_kvlist.h
+++ b/cds/container/impl/lazy_kvlist.h
@@ -487,7 +487,6 @@ namespace cds { namespace container {
                 void operator()(value_type& val) { ... }
             };
             \endcode
                 void operator()(value_type& val) { ... }
             };
             \endcode

-            The functor may be passed by reference with <tt>boost:ref</tt>

 
             Returns \p true if key is found and deleted, \p false otherwise
         */
 
             Returns \p true if key is found and deleted, \p false otherwise
         */


@@ -591,8 +590,6 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found.
 
             \endcode
             where \p item is the item found.
 

-            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.
             The function does not serialize simultaneous access to the list \p item. If such access is
             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.
             The function does not serialize simultaneous access to the list \p item. If such access is

diff --git a/cds/container/impl/lazy_list.h b/cds/container/impl/lazy_list.h
index eada04e0b2044cae99e431735e21f380b2052827..6605dbfaf78ce9534edb4459994e4cfb2a64ca94 100644 (file)
--- a/cds/container/impl/lazy_list.h
+++ b/cds/container/impl/lazy_list.h
@@ -566,8 +566,6 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found, \p key is the <tt>find</tt> function argument.
 
             \endcode
             where \p item is the item found, \p key is the <tt>find</tt> function argument.
 

-            You may pass \p f argument by reference using \p std::ref.
-

             The functor may change non-key fields of \p item. Note that the function is only guarantee
             that \p item cannot be deleted during functor is executing.
             The function does not serialize simultaneous access to the list \p item. If such access is
             The functor may change non-key fields of \p item. Note that the function is only guarantee
             that \p item cannot be deleted during functor is executing.
             The function does not serialize simultaneous access to the list \p item. If such access is

diff --git a/cds/container/impl/michael_kvlist.h b/cds/container/impl/michael_kvlist.h
index 70225fbcafbbbb7a76b45246aaa7d9d9d802a81a..c6d94c8712054022cf011891f08ac293456efdc6 100644 (file)
--- a/cds/container/impl/michael_kvlist.h
+++ b/cds/container/impl/michael_kvlist.h
@@ -491,7 +491,6 @@ namespace cds { namespace container {
                 void operator()(value_type& val) { ... }
             };
             \endcode
                 void operator()(value_type& val) { ... }
             };
             \endcode

-            The functor may be passed by reference with <tt>boost:ref</tt>

 
             Return \p true if key is found and deleted, \p false otherwise
 
 
             Return \p true if key is found and deleted, \p false otherwise
 


@@ -600,8 +599,6 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found.
 
             \endcode
             where \p item is the item found.
 

-            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.
             The function does not serialize simultaneous access to the list \p item. If such access is
             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.
             The function does not serialize simultaneous access to the list \p item. If such access is

diff --git a/cds/container/impl/michael_list.h b/cds/container/impl/michael_list.h
index d9a1ab94ba3160a334f8cf5c1badb7590dcff95d..16e306a212cbd41bd0aaa257b450f89b8f3395b6 100644 (file)
--- a/cds/container/impl/michael_list.h
+++ b/cds/container/impl/michael_list.h
@@ -447,7 +447,6 @@ namespace cds { namespace container {
                 void operator()(const value_type& val) { ... }
             };
             \endcode
                 void operator()(const value_type& val) { ... }
             };
             \endcode

-            The functor may be passed by reference with <tt>boost:ref</tt>

 
             Since the key of MichaelList's item type \p value_type is not explicitly specified,
             template parameter \p Q should contain the complete key to search in the list.
 
             Since the key of MichaelList's item type \p value_type is not explicitly specified,
             template parameter \p Q should contain the complete key to search in the list.

diff --git a/cds/container/lazy_kvlist_rcu.h b/cds/container/lazy_kvlist_rcu.h
index 12e7c29715d3df2b864938664644af08666a4c50..b460c6d61277b519fcf619a1424c6e855ef42ba7 100644 (file)
--- a/cds/container/lazy_kvlist_rcu.h
+++ b/cds/container/lazy_kvlist_rcu.h
@@ -485,7 +485,6 @@ namespace cds { namespace container {
                 void operator()(value_type& val) { ... }
             };
             \endcode
                 void operator()(value_type& val) { ... }
             };
             \endcode

-            The functor may be passed by reference with <tt>boost:ref</tt>

 
             RCU \p synchronize method can be called. RCU should not be locked.
 
 
             RCU \p synchronize method can be called. RCU should not be locked.
 


@@ -607,8 +606,6 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found.
 
             \endcode
             where \p item is the item found.
 

-            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.
             The function does not serialize simultaneous access to the list \p item. If such access is
             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.
             The function does not serialize simultaneous access to the list \p item. If such access is

diff --git a/cds/container/lazy_list_rcu.h b/cds/container/lazy_list_rcu.h
index 744e7669756bc69f211dfd89091124973d39e760..0d8344279638701b2bbd41b6f3f20bcc68dd2802 100644 (file)
--- a/cds/container/lazy_list_rcu.h
+++ b/cds/container/lazy_list_rcu.h
@@ -457,7 +457,6 @@ namespace cds { namespace container {
                 void operator()(value_type const& val) { ... }
             };
             \endcode
                 void operator()(value_type const& val) { ... }
             };
             \endcode

-            The functor may be passed by reference with <tt>boost:ref</tt>

 
             Since the key of LazyList's item type \p T is not explicitly specified,
             template parameter \p Q defines the key type searching in the list.
 
             Since the key of LazyList's item type \p T is not explicitly specified,
             template parameter \p Q defines the key type searching in the list.


@@ -585,8 +584,6 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found, \p key is the \p find() function argument.
 
             \endcode
             where \p item is the item found, \p key is the \p find() function argument.
 

-            You may pass \p f argument by reference using \p std::ref.
-

             The functor may change non-key fields of \p item. Note that the function is only guarantee
             that \p item cannot be deleted during functor is executing.
             The function does not serialize simultaneous access to the list \p item. If such access is
             The functor may change non-key fields of \p item. Note that the function is only guarantee
             that \p item cannot be deleted during functor is executing.
             The function does not serialize simultaneous access to the list \p item. If such access is

diff --git a/cds/container/michael_kvlist_nogc.h b/cds/container/michael_kvlist_nogc.h
index 4a041995f5c780ebc400f00d700433a9a64522e8..755d7c534d2fbb2524413defbf9465c7e5ed7fe9 100644 (file)
--- a/cds/container/michael_kvlist_nogc.h
+++ b/cds/container/michael_kvlist_nogc.h
@@ -372,8 +372,6 @@ 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.
             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 \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.
 
 
             The key_type should be constructible from value of type \p K.
 

diff --git a/cds/container/michael_kvlist_rcu.h b/cds/container/michael_kvlist_rcu.h
index 420d367c78d105f604002cd7f97c597a087931f4..0b0e495807345f0973a7a67c47fa1efc0e7de539 100644 (file)
--- a/cds/container/michael_kvlist_rcu.h
+++ b/cds/container/michael_kvlist_rcu.h
@@ -369,8 +369,6 @@ 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.
             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 \p std::ref
-            and it is called only if inserting is successful.

 
             The key_type should be constructible from value of type \p K.
 
 
             The key_type should be constructible from value of type \p K.
 


@@ -419,8 +417,6 @@ 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.
 
             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 \p std::ref
-

             The function makes RCU lock internally.
 
             Returns <tt> std::pair<bool, bool> </tt> where \p first is true if operation is successfull,
             The function makes RCU lock internally.
 
             Returns <tt> std::pair<bool, bool> </tt> where \p first is true if operation is successfull,


@@ -484,7 +480,6 @@ namespace cds { namespace container {
                 void operator()(value_type& val) { ... }
             };
             \endcode
                 void operator()(value_type& val) { ... }
             };
             \endcode

-            The functor may be passed by reference with <tt>boost:ref</tt>

 
             RCU \p synchronize method can be called. RCU should not be locked.
 
 
             RCU \p synchronize method can be called. RCU should not be locked.
 

diff --git a/cds/container/michael_list_rcu.h b/cds/container/michael_list_rcu.h
index 18a99a0adebda7f2b13f61839e4d024405215ad1..4c3d502e7650b015edc154cd00f0fd92c3cd7b4f 100644 (file)
--- a/cds/container/michael_list_rcu.h
+++ b/cds/container/michael_list_rcu.h
@@ -341,8 +341,6 @@ 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 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 \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.
             The object of \ref value_type should be constructible from \p key of type \p Q.
 
             The type \p Q should contain the complete key of the node.
             The object of \ref value_type should be constructible from \p key of type \p Q.

diff --git a/cds/container/michael_map_rcu.h b/cds/container/michael_map_rcu.h
index e06c318ecc4bda89975862a591e210c6b4c092d2..54cd1b5710e9cd82e978c92a82e4fbd36c0f3ab1 100644 (file)
--- a/cds/container/michael_map_rcu.h
+++ b/cds/container/michael_map_rcu.h
@@ -494,7 +494,6 @@ namespace cds { namespace container {
                 void operator()(value_type& item) { ... }
             };
             \endcode
                 void operator()(value_type& item) { ... }
             };
             \endcode

-            The functor may be passed by reference using <tt>boost:ref</tt>

 
             RCU \p synchronize method can be called. RCU should not be locked.
 
 
             RCU \p synchronize method can be called. RCU should not be locked.
 

diff --git a/cds/container/michael_set.h b/cds/container/michael_set.h
index a15d7d2939faaa28dd11d91f56abcb110115794c..ff43103434c055c335cabe3d0a1e2ee12e741681 100644 (file)
--- a/cds/container/michael_set.h
+++ b/cds/container/michael_set.h
@@ -560,8 +560,6 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found, \p key is the <tt>find</tt> function argument.
 
             \endcode
             where \p item is the item found, \p key is the <tt>find</tt> function argument.
 

-            You may pass \p f argument by reference using \p std::ref.
-

             The functor may change non-key fields of \p item. Note that the functor is only guarantee
             that \p item cannot be disposed during functor is executing.
             The functor does not serialize simultaneous access to the set's \p item. If such access is
             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.
             The functor does not serialize simultaneous access to the set's \p item. If such access is

diff --git a/cds/container/skip_list_set_rcu.h b/cds/container/skip_list_set_rcu.h
index 56ceb71a9556da72736ea998f22891034756248f..b7cdfbc9056d1521facceda5f16552502bbbddec 100644 (file)
--- a/cds/container/skip_list_set_rcu.h
+++ b/cds/container/skip_list_set_rcu.h
@@ -291,8 +291,7 @@ namespace cds { namespace container {
             \endcode
             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.
             \endcode
             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 \p std::ref
+            The user-defined functor is called only if the inserting is success.

 
             RCU \p synchronize method can be called. RCU should not be locked.
         */
 
             RCU \p synchronize method can be called. RCU should not be locked.
         */


@@ -332,8 +331,6 @@ 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.
 
             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 \p std::ref
-

             RCU \p synchronize method can be called. RCU should not be locked.
 
             Returns <tt> std::pair<bool, bool> </tt> where \p first is true if operation is successfull,
             RCU \p synchronize method can be called. RCU should not be locked.
 
             Returns <tt> std::pair<bool, bool> </tt> where \p first is true if operation is successfull,


@@ -409,7 +406,6 @@ namespace cds { namespace container {
                 void operator()(value_type const& val);
             };
             \endcode
                 void operator()(value_type const& val);
             };
             \endcode

-            The functor may be passed by reference using <tt>boost:ref</tt>

 
             Since the key of MichaelHashSet's \p value_type is not explicitly specified,
             template parameter \p Q defines the key type searching in the list.
 
             Since the key of MichaelHashSet's \p value_type is not explicitly specified,
             template parameter \p Q defines the key type searching in the list.


@@ -521,8 +517,6 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
             \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 \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.
             The functor does not serialize simultaneous access to the set's \p item. If such access is
             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.
             The functor does not serialize simultaneous access to the set's \p item. If such access is


@@ -570,8 +564,6 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
             \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 \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.
             The functor does not serialize simultaneous access to the set's \p item. If such access is
             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.
             The functor does not serialize simultaneous access to the set's \p item. If such access is

diff --git a/cds/container/split_list_map.h b/cds/container/split_list_map.h
index 07d7a1c11e45ff77f23b5c68f26c897d0f82418c..05ecd615aa0458d19dce4391862444d282efa1ef 100644 (file)
--- a/cds/container/split_list_map.h
+++ b/cds/container/split_list_map.h
@@ -385,7 +385,6 @@ namespace cds { namespace container {
                 void operator()(value_type& item) { ... }
             };
             \endcode
                 void operator()(value_type& item) { ... }
             };
             \endcode

-            The functor may be passed by reference using <tt>boost:ref</tt>

 
             Return \p true if key is found and deleted, \p false otherwise
         */
 
             Return \p true if key is found and deleted, \p false otherwise
         */

diff --git a/cds/container/split_list_map_rcu.h b/cds/container/split_list_map_rcu.h
index a363c656ba4150f400192c6363bd1961184e16cc..65da621799b4108f1cbedeceb9d691ba19e64989 100644 (file)
--- a/cds/container/split_list_map_rcu.h
+++ b/cds/container/split_list_map_rcu.h
@@ -426,7 +426,6 @@ namespace cds { namespace container {
                 void operator()(value_type& item) { ... }
             };
             \endcode
                 void operator()(value_type& item) { ... }
             };
             \endcode

-            The functor may be passed by reference using <tt>boost:ref</tt>

 
             RCU \p synchronize method can be called. RCU should not be locked.
 
 
             RCU \p synchronize method can be called. RCU should not be locked.
 


@@ -519,8 +518,6 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found.
 
             \endcode
             where \p item is the item found.
 

-            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.
             The functor does not serialize simultaneous access to the map's \p item. If such access is
             The functor may change \p item.second. Note that the functor is only guarantee
             that \p item cannot be disposed during functor is executing.
             The functor does not serialize simultaneous access to the map's \p item. If such access is

diff --git a/cds/container/split_list_set.h b/cds/container/split_list_set.h
index 74702f0b9f578b9c7f61edd4470f87c0c4f5fe82..60f86b3869fdecc779e6a2164f59704af7b7fa01 100644 (file)
--- a/cds/container/split_list_set.h
+++ b/cds/container/split_list_set.h
@@ -602,8 +602,6 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found, \p key is the <tt>find</tt> function argument.
 
             \endcode
             where \p item is the item found, \p key is the <tt>find</tt> function argument.
 

-            You may pass \p f argument by reference using \p std::ref.
-

             The functor may change non-key fields of \p item. Note that the functor is only guarantee
             that \p item cannot be disposed during functor is executing.
             The functor does not serialize simultaneous access to the set's \p item. If such access is
             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.
             The functor does not serialize simultaneous access to the set's \p item. If such access is

diff --git a/cds/container/striped_map.h b/cds/container/striped_map.h
index 6bfa88384f97abe2822b3277704107694ad285bc..3c23860e55949d5a1745ea643263225993f76f40 100644 (file)
--- a/cds/container/striped_map.h
+++ b/cds/container/striped_map.h
@@ -622,9 +622,6 @@ 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.
 
                 - <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 \p std::ref
-            and it is called only if inserting is successful.
-

             The key_type should be constructible from value of type \p K.
 
             The function allows to split creating of new item into two part:
             The key_type should be constructible from value of type \p K.
 
             The function allows to split creating of new item into two part:


@@ -691,8 +688,6 @@ template <class Container, typename... Options>
 
             The functor may change any fields of the \p item.second that is \ref mapped_type.
 
 
             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 \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
             already is in the list.
             Returns <tt> std::pair<bool, bool> </tt> where \p first is true if operation is successfull,
             \p second is true if new item has been added or \p false if the item with \p key
             already is in the list.


@@ -758,7 +753,6 @@ template <class Container, typename... Options>
                 void operator()(value_type& item) { ... }
             };
             \endcode
                 void operator()(value_type& item) { ... }
             };
             \endcode

-            The functor may be passed by reference using <tt>boost:ref</tt>

 
             Return \p true if key is found and deleted, \p false otherwise
 
 
             Return \p true if key is found and deleted, \p false otherwise
 


@@ -800,8 +794,6 @@ template <class Container, typename... Options>
             \endcode
             where \p item is the item found.
 
             \endcode
             where \p item is the item found.
 

-            You can pass \p f argument by reference using \p std::ref.
-

             The functor may change \p item.second.
 
             The function returns \p true if \p key is found, \p false otherwise.
             The functor may change \p item.second.
 
             The function returns \p true if \p key is found, \p false otherwise.

diff --git a/cds/container/striped_set.h b/cds/container/striped_set.h
index 18147ba500b155d641d4f8daa6e756533688869a..720a1b5d74f5dce0e644e80c4c22e947d681c15f 100644 (file)
--- a/cds/container/striped_set.h
+++ b/cds/container/striped_set.h
@@ -588,8 +588,7 @@ namespace cds { namespace container {
             The type \p Q can differ from \ref value_type of items storing in the set.
             Therefore, the \p value_type should be constructible from type \p Q.
 
             The type \p Q can differ from \ref value_type of items storing in the set.
             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 \p std::ref
+            The user-defined functor is called only if the inserting is success.

         */
         template <typename Q, typename Func>
         bool insert( Q const& val, Func f )
         */
         template <typename Q, typename Func>
         bool insert( Q const& val, Func f )


@@ -658,8 +657,6 @@ namespace cds { namespace container {
 
             The functor can change non-key fields of the \p item.
 
 
             The functor can change non-key fields of the \p item.
 

-            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
             already exists.
             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
             already exists.


@@ -726,7 +723,6 @@ namespace cds { namespace container {
                 void operator()(value_type const& val);
             };
             \endcode
                 void operator()(value_type const& val);
             };
             \endcode

-            The functor can be passed by value or by reference using <tt>boost:ref</tt>

 
             Return \p true if key is found and deleted, \p false otherwise
         */
 
             Return \p true if key is found and deleted, \p false otherwise
         */


@@ -788,8 +784,6 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
             \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 \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
             can modify both arguments.
             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
             can modify both arguments.


@@ -835,8 +829,6 @@ namespace cds { namespace container {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
             \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 \p std::ref.
-

             The functor can change non-key fields of \p item.
 
             The type \p Q can differ from \ref value_type of items storing in the container.
             The functor can change non-key fields of \p item.
 
             The type \p Q can differ from \ref value_type of items storing in the container.

diff --git a/cds/container/striped_set/adapter.h b/cds/container/striped_set/adapter.h
index fb2a34e690e83ad235722b9e22df60d839f726be..a7da7a61133f8e90c7904d4c26809aea75357a9e 100644 (file)
--- a/cds/container/striped_set/adapter.h
+++ b/cds/container/striped_set/adapter.h
@@ -62,8 +62,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,
 
                 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,
 

-                The user-defined functor is called only if the inserting is success. It can be passed by reference
-                using \p std::ref
+                The user-defined functor is called only if the inserting is success.

                 <hr>
 
             <b>Inserts data of type \ref value_type constructed with <tt>std::forward<Args>(args)...</tt></b>
                 <hr>
 
             <b>Inserts data of type \ref value_type constructed with <tt>std::forward<Args>(args)...</tt></b>


@@ -101,8 +100,6 @@ 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,
 
                 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 \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
                 already exists.
                 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
                 already exists.


@@ -120,7 +117,6 @@ namespace cds { namespace container {
                     void operator()(value_type const& val);
                 };
                 \endcode
                     void operator()(value_type const& val);
                 };
                 \endcode

-                The functor can be passed by reference using <tt>boost:ref</tt>

 
                 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.
 
                 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.


@@ -140,8 +136,6 @@ namespace cds { namespace container {
                 \endcode
                 where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
                 \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 \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
                 can modify both arguments.
                 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
                 can modify both arguments.

diff --git a/cds/container/striped_set/boost_stable_vector.h b/cds/container/striped_set/boost_stable_vector.h
index 9a8b8062c84d1050c4f888127c8750275933cc1a..bc5e6a02dff4fa2c9b78c8873672884c2b8df5e9 100644 (file)
--- a/cds/container/striped_set/boost_stable_vector.h
+++ b/cds/container/striped_set/boost_stable_vector.h
@@ -142,8 +142,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,
 
                 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,
 

-                The user-defined functor is called only if the inserting is success. It may be passed by reference
-                using \p std::ref
+                The user-defined functor is called only if the inserting is success.

             */
             template <typename Q, typename Func>
             bool insert( const Q& val, Func f )
             */
             template <typename Q, typename Func>
             bool insert( const Q& val, Func f )


@@ -197,8 +196,6 @@ 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,
 
                 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 \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
                 already exists.
                 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
                 already exists.


@@ -232,7 +229,6 @@ namespace cds { namespace intrusive { namespace striped_set {
                     void operator()(value_type const& val);
                 };
                 \endcode
                     void operator()(value_type const& val);
                 };
                 \endcode

-                The functor may be passed by reference using <tt>boost:ref</tt>

 
                 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.
 
                 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.


@@ -276,8 +272,6 @@ namespace cds { namespace intrusive { namespace striped_set {
                 \endcode
                 where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
                 \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 \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
                 may modify both arguments.
                 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
                 may modify both arguments.

diff --git a/cds/intrusive/cuckoo_set.h b/cds/intrusive/cuckoo_set.h
index e54f8237df6a4ee819353105ff76b92fb488fd49..7b637e409c621f606ad46996e159934ee6be2c75 100644 (file)
--- a/cds/intrusive/cuckoo_set.h
+++ b/cds/intrusive/cuckoo_set.h
@@ -2365,8 +2365,7 @@ namespace cds { namespace intrusive {
             \endcode
             where \p val is the item inserted.
 
             \endcode
             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 \p std::ref
+            The user-defined functor is called only if the inserting is success.

         */
         template <typename Func>
         bool insert( value_type& val, Func f )
         */
         template <typename Func>
         bool insert( value_type& val, Func f )


@@ -2448,8 +2447,6 @@ namespace cds { namespace intrusive {
 
             The functor may change non-key fields of the \p item.
 
 
             The functor may change non-key fields of the \p item.
 

-            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
             already is in the set.
             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
             already is in the set.


@@ -2591,7 +2588,6 @@ namespace cds { namespace intrusive {
                 void operator()( value_type const& item );
             };
             \endcode
                 void operator()( value_type const& item );
             };
             \endcode

-            The functor may be passed by reference with <tt>boost:ref</tt>

 
             If the item with key equal to \p val is not found the function return \p nullptr.
 
 
             If the item with key equal to \p val is not found the function return \p nullptr.
 


@@ -2628,8 +2624,6 @@ namespace cds { namespace intrusive {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
             \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 \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
             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


@@ -2671,8 +2665,6 @@ namespace cds { namespace intrusive {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
             \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 \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
             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

diff --git a/cds/intrusive/ellen_bintree_rcu.h b/cds/intrusive/ellen_bintree_rcu.h
index 4cec1fc05fff91b28c7e6ff49b65a63b5110ae09..79b9e751c323e86fc3ab7e565a9df3d4b4e021e7 100644 (file)
--- a/cds/intrusive/ellen_bintree_rcu.h
+++ b/cds/intrusive/ellen_bintree_rcu.h
@@ -919,7 +919,6 @@ namespace cds { namespace intrusive {
                 void operator()( value_type const& item );
             };
             \endcode
                 void operator()( value_type const& item );
             };
             \endcode

-            The functor can be passed by reference with <tt>boost:ref</tt>

 
             If the item with key equal to \p key is not found the function return \p false.
 
 
             If the item with key equal to \p key is not found the function return \p false.
 

diff --git a/cds/intrusive/impl/ellen_bintree.h b/cds/intrusive/impl/ellen_bintree.h
index dc54c6192fd37e49ac09513c40d6b2e7fcb14080..06baed3b76aa96302e40f053020742c148fc1f36 100644 (file)
--- a/cds/intrusive/impl/ellen_bintree.h
+++ b/cds/intrusive/impl/ellen_bintree.h
@@ -505,7 +505,6 @@ namespace cds { namespace intrusive {
                 void operator()( value_type const& item );
             };
             \endcode
                 void operator()( value_type const& item );
             };
             \endcode

-            The functor can be passed by reference with <tt>boost:ref</tt>

 
             If the item with key equal to \p key is not found the function return \p false.
 
 
             If the item with key equal to \p key is not found the function return \p false.
 


@@ -670,8 +669,6 @@ namespace cds { namespace intrusive {
             \endcode
             where \p item is the item found, \p key is the <tt>find</tt> function argument.
 
             \endcode
             where \p item is the item found, \p key is the <tt>find</tt> function argument.
 

-            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.
             The functor does not serialize simultaneous access to the tree \p item. If such access is
             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.
             The functor does not serialize simultaneous access to the tree \p item. If such access is

diff --git a/cds/intrusive/lazy_list_rcu.h b/cds/intrusive/lazy_list_rcu.h
index adad3206aae4996d5909090de216138d75c0c5a6..38cae1d9cca56a54273c59783280ca7597acd080 100644 (file)
--- a/cds/intrusive/lazy_list_rcu.h
+++ b/cds/intrusive/lazy_list_rcu.h
@@ -653,8 +653,6 @@ namespace cds { namespace intrusive {
             \endcode
             where \p item is the item found, \p key is the <tt>find</tt> function argument.
 
             \endcode
             where \p item is the item found, \p key is the <tt>find</tt> function argument.
 

-            You may pass \p f argument by reference using \p std::ref.
-

             The functor may change non-key fields of \p item.
             While the functor \p f is calling the item found \p item is locked.
 
             The functor may change non-key fields of \p item.
             While the functor \p f is calling the item found \p item is locked.
 

diff --git a/cds/intrusive/michael_list_nogc.h b/cds/intrusive/michael_list_nogc.h
index 64f5c3dde36adc1035e2eaafcd8cff0d55d6e562..c9110290b750041abd7472ddf71ef54df4678246 100644 (file)
--- a/cds/intrusive/michael_list_nogc.h
+++ b/cds/intrusive/michael_list_nogc.h
@@ -321,8 +321,6 @@ 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.
 
             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 \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
             already is in the list.
             Returns <tt> std::pair<bool, bool>  </tt> where \p first is true if operation is successfull,
             \p second is true if new item has been added or \p false if the item with \p key
             already is in the list.

diff --git a/cds/intrusive/michael_set.h b/cds/intrusive/michael_set.h
index 6dcff726fa464e54462b1a4309d1e2f26455be18..c56ae091068b746887b51608ce526a536dc54e16 100644 (file)
--- a/cds/intrusive/michael_set.h
+++ b/cds/intrusive/michael_set.h
@@ -515,7 +515,6 @@ namespace cds { namespace intrusive {
                 void operator()( value_type const& item );
             };
             \endcode
                 void operator()( value_type const& item );
             };
             \endcode

-            The functor may be passed by reference with <tt>boost:ref</tt>

 
             If the item with key equal to \p key is not found the function return \p false.
 
 
             If the item with key equal to \p key is not found the function return \p false.
 


@@ -615,8 +614,6 @@ namespace cds { namespace intrusive {
             \endcode
             where \p item is the item found, \p key is the <tt>find</tt> function argument.
 
             \endcode
             where \p item is the item found, \p key is the <tt>find</tt> function argument.
 

-            You can 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.
             The functor does not serialize simultaneous access to the set \p item. If such access is
             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.
             The functor does not serialize simultaneous access to the set \p item. If such access is

diff --git a/cds/intrusive/michael_set_rcu.h b/cds/intrusive/michael_set_rcu.h
index 1e1859bf4b3ae1af2e3ed822e2d5af6011adf8ed..ebc00195504e565e1e85e5cf7eb9006c45744a0b 100644 (file)
--- a/cds/intrusive/michael_set_rcu.h
+++ b/cds/intrusive/michael_set_rcu.h
@@ -359,7 +359,6 @@ namespace cds { namespace intrusive {
                 void operator()( value_type const& item );
             };
             \endcode
                 void operator()( value_type const& item );
             };
             \endcode

-            The functor may be passed by reference with <tt>boost:ref</tt>

 
             If the item with key equal to \p key is not found the function return \p false.
 
 
             If the item with key equal to \p key is not found the function return \p false.
 

diff --git a/cds/intrusive/skip_list_nogc.h b/cds/intrusive/skip_list_nogc.h
index fe209b9669466fa7d2842f0e1c1cfec4a59c34b2..42594679074794edf5f60d7ce89fdf4c9becdbfc 100644 (file)
--- a/cds/intrusive/skip_list_nogc.h
+++ b/cds/intrusive/skip_list_nogc.h
@@ -697,8 +697,6 @@ 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.
 
             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 \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
             already is in the set.
             Returns std::pair<bool, bool> where \p first is \p true if operation is successfull,
             \p second is \p true if new item has been added or \p false if the item with \p key
             already is in the set.


@@ -760,8 +758,6 @@ namespace cds { namespace intrusive {
             \endcode
             where \p item is the item found, \p key is the <tt>find</tt> function argument.
 
             \endcode
             where \p item is the item found, \p key is the <tt>find</tt> function argument.
 

-            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.
             The functor does not serialize simultaneous access to the set \p item. If such access is
             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.
             The functor does not serialize simultaneous access to the set \p item. If such access is

diff --git a/cds/intrusive/skip_list_rcu.h b/cds/intrusive/skip_list_rcu.h
index 189276002bfa700958c38c3c39d4071a164d585a..5569052a9789d9e6f4513cb53dfa2005dc612dcb 100644 (file)
--- a/cds/intrusive/skip_list_rcu.h
+++ b/cds/intrusive/skip_list_rcu.h
@@ -1442,8 +1442,7 @@ retry:
             \endcode
             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.
             \endcode
             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 \p std::ref.
+            The user-defined functor is called only if the inserting is success.

 
             RCU \p synchronize method can be called. RCU should not be locked.
         */
 
             RCU \p synchronize method can be called. RCU should not be locked.
         */


@@ -1840,8 +1839,6 @@ retry:
             \endcode
             where \p item is the item found, \p key is the <tt>find</tt> function argument.
 
             \endcode
             where \p item is the item found, \p key is the <tt>find</tt> function argument.
 

-            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.
             The functor does not serialize simultaneous access to the set \p item. If such access is
             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.
             The functor does not serialize simultaneous access to the set \p item. If such access is

diff --git a/cds/intrusive/split_list.h b/cds/intrusive/split_list.h
index 8225b147bda0f08a2b451c25b8f2ed48976fc0ff..e19e483dabb03f0cd2c30aedb94ca5d661557f61 100644 (file)
--- a/cds/intrusive/split_list.h
+++ b/cds/intrusive/split_list.h
@@ -782,7 +782,6 @@ namespace cds { namespace intrusive {
                 void operator()( value_type const& item );
             };
             \endcode
                 void operator()( value_type const& item );
             };
             \endcode

-            The functor can be passed by reference with <tt>boost:ref</tt>

 
             If the item with key equal to \p key is not found the function return \p false.
 
 
             If the item with key equal to \p key is not found the function return \p false.
 


@@ -866,8 +865,6 @@ namespace cds { namespace intrusive {
             \endcode
             where \p item is the item found, \p key is the <tt>find</tt> function argument.
 
             \endcode
             where \p item is the item found, \p key is the <tt>find</tt> function argument.
 

-            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.
             The functor does not serialize simultaneous access to the set \p item. If such access is
             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.
             The functor does not serialize simultaneous access to the set \p item. If such access is

diff --git a/cds/intrusive/split_list_rcu.h b/cds/intrusive/split_list_rcu.h
index 603500f55043bd6601b28d114a0039245714268a..12fae063dbb365a3ccefe4ff50225af8c77561cb 100644 (file)
--- a/cds/intrusive/split_list_rcu.h
+++ b/cds/intrusive/split_list_rcu.h
@@ -663,7 +663,6 @@ namespace cds { namespace intrusive {
                 void operator()( value_type const& item );
             };
             \endcode
                 void operator()( value_type const& item );
             };
             \endcode

-            The functor can be passed by reference with <tt>boost:ref</tt>

 
             If the item with key equal to \p key is not found the function return \p false.
 
 
             If the item with key equal to \p key is not found the function return \p false.
 


@@ -769,8 +768,6 @@ namespace cds { namespace intrusive {
             \endcode
             where \p item is the item found, \p key is the <tt>find</tt> function argument.
 
             \endcode
             where \p item is the item found, \p key is the <tt>find</tt> function argument.
 

-            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.
             The functor does not serialize simultaneous access to the set \p item. If such access is
             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.
             The functor does not serialize simultaneous access to the set \p item. If such access is

diff --git a/cds/intrusive/striped_set.h b/cds/intrusive/striped_set.h
index 4f799d3de62e6b6f7a7246e153a90f0c90a30f28..f9990d1f913e5425f5fd86a4462d46a53c38ad6a 100644 (file)
--- a/cds/intrusive/striped_set.h
+++ b/cds/intrusive/striped_set.h
@@ -486,9 +486,6 @@ namespace cds { namespace intrusive {
                 void func( value_type& val );
             \endcode
             where \p val is the item inserted.
                 void func( value_type& val );
             \endcode
             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 \p std::ref.

         */
         template <typename Func>
         bool insert( value_type& val, Func f )
         */
         template <typename Func>
         bool insert( value_type& val, Func f )


@@ -528,8 +525,6 @@ namespace cds { namespace intrusive {
 
             The functor may change non-key fields of the \p item.
 
 
             The functor may change non-key fields of the \p item.
 

-            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
             already is in the set.
             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
             already is in the set.


@@ -617,7 +612,6 @@ namespace cds { namespace intrusive {
                 void operator()( value_type const& item );
             };
             \endcode
                 void operator()( value_type const& item );
             };
             \endcode

-            The functor may be passed by reference with <tt>boost:ref</tt>

 
             If the item with key equal to \p val is not found the function return \p false.
 
 
             If the item with key equal to \p val is not found the function return \p false.
 


@@ -671,8 +665,6 @@ namespace cds { namespace intrusive {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
             \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 \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
             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


@@ -713,8 +705,6 @@ namespace cds { namespace intrusive {
             \endcode
             where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
             \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 \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
             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

diff --git a/cds/intrusive/striped_set/adapter.h b/cds/intrusive/striped_set/adapter.h
index fa18554f57b7fc2749c92de7ac77f7fb3ebe1206..7811ba885e987e67f7e97edd72f41363dd76e20d 100644 (file)
--- a/cds/intrusive/striped_set/adapter.h
+++ b/cds/intrusive/striped_set/adapter.h
@@ -47,8 +47,7 @@ namespace cds { namespace intrusive {
                 \endcode
                 where \p item is the item inserted.
 
                 \endcode
                 where \p item is the item inserted.
 

-                The user-defined functor \p f is called only if the inserting is success. It can be passed by reference
-                using \p std::ref
+                The user-defined functor \p f is called only if the inserting is success.

                 <hr>
 
             <b>Ensures that the \p item exists in the container</b>
                 <hr>
 
             <b>Ensures that the \p item exists in the container</b>


@@ -79,8 +78,6 @@ namespace cds { namespace intrusive {
 
                 The functor can change non-key fields of the \p item.
 
 
                 The functor can change non-key fields of the \p item.
 

-                You can pass \p f 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
                 already exists.
                 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
                 already exists.


@@ -102,7 +99,6 @@ namespace cds { namespace intrusive {
                     void operator()(value_type& val);
                 };
                 \endcode
                     void operator()(value_type& val);
                 };
                 \endcode

-                The functor can be passed by reference using <tt>boost:ref</tt>

 
                 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.
 
                 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.


@@ -125,8 +121,6 @@ namespace cds { namespace intrusive {
                 \endcode
                 where \p item is the item found, \p val is the <tt>find</tt> function argument.
 
                 \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 \p std::ref.
-

                 The functor can change non-key fields of \p item.
                 The \p val argument may be non-const since it can be used as \p f functor destination i.e., the functor
                 can modify both arguments.
                 The functor can change non-key fields of \p item.
                 The \p val argument may be non-const since it can be used as \p f functor destination i.e., the functor
                 can modify both arguments.

diff --git a/cds/intrusive/vyukov_mpmc_cycle_queue.h b/cds/intrusive/vyukov_mpmc_cycle_queue.h
index 3b4ccdd012d627d8f4cb1045b7fcf222ccef8f4c..9bf03c8bf2476b4905dece2e6c03fb230577ad65 100644 (file)
--- a/cds/intrusive/vyukov_mpmc_cycle_queue.h
+++ b/cds/intrusive/vyukov_mpmc_cycle_queue.h
@@ -181,7 +181,6 @@ namespace cds { namespace intrusive {
                 void operator ()( T * val );
             };
             \endcode
                 void operator ()( T * val );
             };
             \endcode

-            You can pass \p disposer by reference using \p std::ref.

             The disposer will be called immediately for each item.
         */
         template <typename Disposer>
             The disposer will be called immediately for each item.
         */
         template <typename Disposer>