- <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 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.
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
\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 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 )
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.
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
*/
\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.
\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.
- <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 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,
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.
\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.
\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.
*/
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,
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.
\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
\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
\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.
\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
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
*/
\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
\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
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
\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
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.
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.
\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
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.
\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
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.
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.
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,
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.
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.
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.
\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
\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.
*/
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,
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.
\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
\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
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
*/
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.
\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
\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
- <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 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.
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
\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 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 )
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.
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
*/
\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.
\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 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>
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.
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.
\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 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 )
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.
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.
\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.
\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 )
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.
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.
\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
\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
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.
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.
\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
\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 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.
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.
\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
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.
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.
\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
\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.
*/
\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
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.
\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
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.
\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
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 )
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.
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.
\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
\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
\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>
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.
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.
\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.
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>
projects / libcds.git / commitdiff