Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r78591 - in branches/release/boost/intrusive: . detail
From: igaztanaga_at_[hidden]
Date: 2012-05-24 12:57:58

Next message: igaztanaga_at_[hidden]: "[Boost-commit] svn:boost r78592 - branches/release/boost/move"
Previous message: igaztanaga_at_[hidden]: "[Boost-commit] svn:boost r78590 - in branches/release/boost/interprocess: . allocators allocators/detail detail indexes ipc mem_algo mem_algo/detail smart_ptr smart_ptr/detail streams sync sync/detail sync/posix sync/shm sync/spin sync/windows sync/xsi"

Author: igaztanaga
Date: 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
New Revision: 78591
URL: http://svn.boost.org/trac/boost/changeset/78591

Log:
Merged revision(s) 78115-78590 from trunk/boost/intrusive
Properties modified:
   branches/release/boost/intrusive/ (props changed)
Text files modified:
   branches/release/boost/intrusive/any_hook.hpp | 84 +-
   branches/release/boost/intrusive/avl_set.hpp | 894 +++++++++++++++++-----------------
   branches/release/boost/intrusive/avl_set_hook.hpp | 130 ++--
   branches/release/boost/intrusive/avltree.hpp | 462 +++++++++---------
   branches/release/boost/intrusive/avltree_algorithms.hpp | 226 ++++----
   branches/release/boost/intrusive/bs_set_hook.hpp | 130 ++--
   branches/release/boost/intrusive/circular_list_algorithms.hpp | 172 +++---
   branches/release/boost/intrusive/circular_slist_algorithms.hpp | 134 ++--
   branches/release/boost/intrusive/derivation_value_traits.hpp | 6
   branches/release/boost/intrusive/detail/any_node_and_algorithms.hpp | 18
   branches/release/boost/intrusive/detail/assert.hpp | 2
   branches/release/boost/intrusive/detail/avltree_node.hpp | 6
   branches/release/boost/intrusive/detail/common_slist_algorithms.hpp | 16
   branches/release/boost/intrusive/detail/config_begin.hpp | 4
   branches/release/boost/intrusive/detail/function_detector.hpp | 4
   branches/release/boost/intrusive/detail/generic_hook.hpp | 14
   branches/release/boost/intrusive/detail/has_member_function_callable_with.hpp | 16
   branches/release/boost/intrusive/detail/hashtable_node.hpp | 8
   branches/release/boost/intrusive/detail/list_node.hpp | 26
   branches/release/boost/intrusive/detail/mpl.hpp | 10
   branches/release/boost/intrusive/detail/parent_from_member.hpp | 16
   branches/release/boost/intrusive/detail/preprocessor.hpp | 2
   branches/release/boost/intrusive/detail/rbtree_node.hpp | 6
   branches/release/boost/intrusive/detail/slist_node.hpp | 22
   branches/release/boost/intrusive/detail/transform_iterator.hpp | 2
   branches/release/boost/intrusive/detail/tree_algorithms.hpp | 244 ++++----
   branches/release/boost/intrusive/detail/tree_node.hpp | 28
   branches/release/boost/intrusive/detail/utilities.hpp | 16
   branches/release/boost/intrusive/hashtable.hpp | 478 +++++++++---------
   branches/release/boost/intrusive/linear_slist_algorithms.hpp | 106 ++--
   branches/release/boost/intrusive/link_mode.hpp | 4
   branches/release/boost/intrusive/list.hpp | 518 ++++++++++----------
   branches/release/boost/intrusive/list_hook.hpp | 132 ++--
   branches/release/boost/intrusive/member_value_traits.hpp | 8
   branches/release/boost/intrusive/options.hpp | 10
   branches/release/boost/intrusive/parent_from_member.hpp | 4
   branches/release/boost/intrusive/pointer_plus_bits.hpp | 6
   branches/release/boost/intrusive/pointer_traits.hpp | 6
   branches/release/boost/intrusive/rbtree.hpp | 468 +++++++++---------
   branches/release/boost/intrusive/rbtree_algorithms.hpp | 248 ++++----
   branches/release/boost/intrusive/set.hpp | 906 ++++++++++++++++++------------------
   branches/release/boost/intrusive/set_hook.hpp | 134 ++--
   branches/release/boost/intrusive/sg_set.hpp | 934 ++++++++++++++++++------------------
   branches/release/boost/intrusive/sgtree.hpp | 494 +++++++++---------
   branches/release/boost/intrusive/sgtree_algorithms.hpp | 220 ++++----
   branches/release/boost/intrusive/slist.hpp | 678 +++++++++++++-------------
   branches/release/boost/intrusive/slist_hook.hpp | 138 ++--
   branches/release/boost/intrusive/splay_set.hpp | 924 ++++++++++++++++++------------------
   branches/release/boost/intrusive/splay_set_hook.hpp | 134 ++--
   branches/release/boost/intrusive/splaytree.hpp | 476 +++++++++---------
   branches/release/boost/intrusive/splaytree_algorithms.hpp | 204 ++++----
   branches/release/boost/intrusive/treap.hpp | 494 +++++++++---------
   branches/release/boost/intrusive/treap_algorithms.hpp | 214 ++++----
   branches/release/boost/intrusive/treap_set.hpp | 994 ++++++++++++++++++++--------------------
   branches/release/boost/intrusive/trivial_value_traits.hpp | 4
   branches/release/boost/intrusive/unordered_set.hpp | 852 +++++++++++++++++-----------------
   branches/release/boost/intrusive/unordered_set_hook.hpp | 144 ++--
   57 files changed, 6321 insertions(+), 6309 deletions(-)

Modified: branches/release/boost/intrusive/any_hook.hpp
==============================================================================
--- branches/release/boost/intrusive/any_hook.hpp (original)
+++ branches/release/boost/intrusive/any_hook.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -50,7 +50,7 @@
 Options...
 #endif
>::type packed_options;
-
+
 typedef detail::generic_hook
 < get_any_node_algo<typename packed_options::void_pointer>
 , typename packed_options::tag
@@ -63,13 +63,13 @@

//! Derive a class from this hook in order to store objects of that class
//! in an intrusive container.
-//!
+//!
//! The hook admits the following options: \c tag<>, \c void_pointer<> and
//! \c link_mode<>.
//!
-//! \c tag<> defines a tag to identify the node.
-//! The same tag value can be used in different classes, but if a class is
-//! derived from more than one \c any_base_hook, then each \c any_base_hook needs its
+//! \c tag<> defines a tag to identify the node.
+//! The same tag value can be used in different classes, but if a class is
+//! derived from more than one \c any_base_hook, then each \c any_base_hook needs its
//! unique tag.
//!
//! \c link_mode<> will specify the linking mode of the hook (\c normal_link, \c safe_link).
@@ -94,27 +94,27 @@
 public:
 //! Effects: If link_mode is or \c safe_link
 //! initializes the node to an unlinked state.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 any_base_hook();

 //! Effects: If link_mode is or \c safe_link
 //! initializes the node to an unlinked state. The argument is ignored.
- //!
- //! Throws: Nothing.
- //!
+ //!
+ //! Throws: Nothing.
+ //!
 //! Rationale: Providing a copy-constructor
- //! makes classes using the hook STL-compliant without forcing the
+ //! makes classes using the hook STL-compliant without forcing the
 //! user to do some additional work. \c swap can be used to emulate
 //! move-semantics.
 any_base_hook(const any_base_hook& );

 //! Effects: Empty function. The argument is ignored.
- //!
- //! Throws: Nothing.
- //!
- //! Rationale: Providing an assignment operator
- //! makes classes using the hook STL-compliant without forcing the
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Rationale: Providing an assignment operator
+ //! makes classes using the hook STL-compliant without forcing the
 //! user to do some additional work. \c swap can be used to emulate
 //! move-semantics.
 any_base_hook& operator=(const any_base_hook& );
@@ -122,17 +122,17 @@
 //! Effects: If link_mode is \c normal_link, the destructor does
 //! nothing (ie. no code is generated). If link_mode is \c safe_link and the
 //! object is stored in a container an assertion is raised.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 ~any_base_hook();

 //! Precondition: link_mode must be \c safe_link.
 //!
 //! Returns: true, if the node belongs to a container, false
- //! otherwise. This function can be used to test whether \c container::iterator_to
- //! will return a valid iterator.
+ //! otherwise. This function can be used to test whether \c container::iterator_to
+ //! will return a valid iterator.
 //!
- //! Complexity: Constant
+ //! Complexity: Constant
 bool is_linked() const;
 #endif
};
@@ -148,7 +148,7 @@
{
 /// @cond
 typedef typename pack_options
- < hook_defaults,
+ < hook_defaults,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3
 #else
@@ -168,10 +168,10 @@

//! Store this hook in a class to be inserted
//! in an intrusive container.
-//!
+//!
//! The hook admits the following options: \c void_pointer<> and
//! \c link_mode<>.
-//!
+//!
//! \c link_mode<> will specify the linking mode of the hook (\c normal_link or \c safe_link).
//!
//! \c void_pointer<> is the pointer type that will be used internally in the hook
@@ -194,27 +194,27 @@
 public:
 //! Effects: If link_mode is or \c safe_link
 //! initializes the node to an unlinked state.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 any_member_hook();

 //! Effects: If link_mode is or \c safe_link
 //! initializes the node to an unlinked state. The argument is ignored.
- //!
- //! Throws: Nothing.
- //!
+ //!
+ //! Throws: Nothing.
+ //!
 //! Rationale: Providing a copy-constructor
- //! makes classes using the hook STL-compliant without forcing the
+ //! makes classes using the hook STL-compliant without forcing the
 //! user to do some additional work. \c swap can be used to emulate
 //! move-semantics.
 any_member_hook(const any_member_hook& );

 //! Effects: Empty function. The argument is ignored.
- //!
- //! Throws: Nothing.
- //!
- //! Rationale: Providing an assignment operator
- //! makes classes using the hook STL-compliant without forcing the
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Rationale: Providing an assignment operator
+ //! makes classes using the hook STL-compliant without forcing the
 //! user to do some additional work. \c swap can be used to emulate
 //! move-semantics.
 any_member_hook& operator=(const any_member_hook& );
@@ -222,17 +222,17 @@
 //! Effects: If link_mode is \c normal_link, the destructor does
 //! nothing (ie. no code is generated). If link_mode is \c safe_link and the
 //! object is stored in a container an assertion is raised.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 ~any_member_hook();

 //! Precondition: link_mode must be \c safe_link.
 //!
 //! Returns: true, if the node belongs to a container, false
- //! otherwise. This function can be used to test whether \c container::iterator_to
- //! will return a valid iterator.
+ //! otherwise. This function can be used to test whether \c container::iterator_to
+ //! will return a valid iterator.
 //!
- //! Complexity: Constant
+ //! Complexity: Constant
 bool is_linked() const;
 #endif
};
@@ -336,8 +336,8 @@
{};

-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Modified: branches/release/boost/intrusive/avl_set.hpp
==============================================================================
--- branches/release/boost/intrusive/avl_set.hpp (original)
+++ branches/release/boost/intrusive/avl_set.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -22,9 +22,9 @@
namespace boost {
namespace intrusive {

-//! The class template avl_set is an intrusive container, that mimics most of
+//! The class template avl_set is an intrusive container, that mimics most of
//! the interface of std::set as described in the C++ standard.
-//!
+//!
//! The template parameter \c T is the type to be managed by the container.
//! The user can specify additional options and if no options are provided
//! default options are used.
@@ -79,30 +79,30 @@
 /// @endcond

 public:
- //! Effects: Constructs an empty avl_set.
- //!
- //! Complexity: Constant.
- //!
+ //! Effects: Constructs an empty avl_set.
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: If value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
- //! or the copy constructor of the value_compare object throws.
+ //! or the copy constructor of the value_compare object throws.
 avl_set_impl( const value_compare &cmp = value_compare()
- , const value_traits &v_traits = value_traits())
+ , const value_traits &v_traits = value_traits())
 : tree_(cmp, v_traits)
 {}

- //! Requires: Dereferencing iterator must yield an lvalue of type value_type.
+ //! Requires: Dereferencing iterator must yield an lvalue of type value_type.
 //! cmp must be a comparison function that induces a strict weak ordering.
- //!
- //! Effects: Constructs an empty avl_set and inserts elements from
+ //!
+ //! Effects: Constructs an empty avl_set and inserts elements from
 //! [b, e).
- //!
- //! Complexity: Linear in N if [b, e) is already sorted using
+ //!
+ //! Complexity: Linear in N if [b, e) is already sorted using
 //! comp and otherwise N * log N, where N is std::distance(last, first).
- //!
+ //!
 //! Throws: If value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
- //! or the copy constructor/operator() of the value_compare object throws.
+ //! or the copy constructor/operator() of the value_compare object throws.
 template<class Iterator>
 avl_set_impl( Iterator b, Iterator e
 , const value_compare &cmp = value_compare()
@@ -111,135 +111,135 @@
 {}

 //! Effects: to-do
- //!
- avl_set_impl(BOOST_RV_REF(avl_set_impl) x)
+ //!
+ avl_set_impl(BOOST_RV_REF(avl_set_impl) x)
 : tree_(::boost::move(x.tree_))
 {}

 //! Effects: to-do
- //!
- avl_set_impl& operator=(BOOST_RV_REF(avl_set_impl) x)
+ //!
+ avl_set_impl& operator=(BOOST_RV_REF(avl_set_impl) x)
 { tree_ = ::boost::move(x.tree_); return *this; }

- //! Effects: Detaches all elements from this. The objects in the avl_set
+ //! Effects: Detaches all elements from this. The objects in the avl_set
 //! are not deleted (i.e. no destructors are called).
- //!
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
- //!
+ //!
 //! Throws: Nothing.
- ~avl_set_impl()
+ ~avl_set_impl()
 {}

 //! Effects: Returns an iterator pointing to the beginning of the avl_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator begin()
 { return tree_.begin(); }

 //! Effects: Returns a const_iterator pointing to the beginning of the avl_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator begin() const
 { return tree_.begin(); }

 //! Effects: Returns a const_iterator pointing to the beginning of the avl_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator cbegin() const
 { return tree_.cbegin(); }

 //! Effects: Returns an iterator pointing to the end of the avl_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator end()
 { return tree_.end(); }

 //! Effects: Returns a const_iterator pointing to the end of the avl_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator end() const
 { return tree_.end(); }

 //! Effects: Returns a const_iterator pointing to the end of the avl_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator cend() const
 { return tree_.cend(); }

 //! Effects: Returns a reverse_iterator pointing to the beginning of the
 //! reversed avl_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 reverse_iterator rbegin()
 { return tree_.rbegin(); }

 //! Effects: Returns a const_reverse_iterator pointing to the beginning
 //! of the reversed avl_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator rbegin() const
 { return tree_.rbegin(); }

 //! Effects: Returns a const_reverse_iterator pointing to the beginning
 //! of the reversed avl_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator crbegin() const
 { return tree_.crbegin(); }

 //! Effects: Returns a reverse_iterator pointing to the end
 //! of the reversed avl_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 reverse_iterator rend()
 { return tree_.rend(); }

 //! Effects: Returns a const_reverse_iterator pointing to the end
 //! of the reversed avl_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator rend() const
 { return tree_.rend(); }

 //! Effects: Returns a const_reverse_iterator pointing to the end
 //! of the reversed avl_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator crend() const
 { return tree_.crend(); }

 //! Precondition: end_iterator must be a valid end iterator
 //! of avl_set.
- //!
+ //!
 //! Effects: Returns a const reference to the avl_set associated to the end iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 static avl_set_impl &container_from_end_iterator(iterator end_iterator)
 {
@@ -250,11 +250,11 @@

 //! Precondition: end_iterator must be a valid end const_iterator
 //! of avl_set.
- //!
+ //!
 //! Effects: Returns a const reference to the set associated to the end iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 static const avl_set_impl &container_from_end_iterator(const_iterator end_iterator)
 {
@@ -264,11 +264,11 @@
 }

 //! Precondition: it must be a valid iterator of set.
- //!
+ //!
 //! Effects: Returns a reference to the set associated to the iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Logarithmic.
 static avl_set_impl &container_from_iterator(iterator it)
 {
@@ -278,11 +278,11 @@
 }

 //! Precondition: it must be a valid const_iterator of set.
- //!
+ //!
 //! Effects: Returns a const reference to the set associated to the iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Logarithmic.
 static const avl_set_impl &container_from_iterator(const_iterator it)
 {
@@ -292,42 +292,42 @@
 }

 //! Effects: Returns the key_compare object used by the avl_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If key_compare copy-constructor throws.
 key_compare key_comp() const
 { return tree_.value_comp(); }

 //! Effects: Returns the value_compare object used by the avl_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If value_compare copy-constructor throws.
 value_compare value_comp() const
 { return tree_.value_comp(); }

 //! Effects: Returns true is the container is empty.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 bool empty() const
 { return tree_.empty(); }

 //! Effects: Returns the number of elements stored in the avl_set.
- //!
+ //!
 //! Complexity: Linear to elements contained in *this if,
 //! constant-time size option is enabled. Constant-time otherwise.
- //!
+ //!
 //! Throws: Nothing.
 size_type size() const
 { return tree_.size(); }

 //! Effects: Swaps the contents of two sets.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If the swap() call for the comparison functor
 //! found using ADL throws. Strong guarantee.
 void swap(avl_set_impl& other)
@@ -337,22 +337,22 @@
 //! Cloner should yield to nodes equivalent to the original nodes.
 //!
 //! Effects: Erases all the elements from *this
- //! calling Disposer::operator()(pointer), clones all the
+ //! calling Disposer::operator()(pointer), clones all the
 //! elements from src calling Cloner::operator()(const_reference )
 //! and inserts them on *this. Copies the predicate from the source container.
 //!
 //! If cloner throws, all cloned elements are unlinked and disposed
 //! calling Disposer::operator()(pointer).
- //!
+ //!
 //! Complexity: Linear to erased plus inserted elements.
- //!
+ //!
 //! Throws: If cloner throws or predicate copy assignment throws. Basic guarantee.
 template <class Cloner, class Disposer>
 void clone_from(const avl_set_impl &src, Cloner cloner, Disposer disposer)
 { tree_.clone_from(src.tree_, cloner, disposer); }

 //! Requires: value must be an lvalue
- //!
+ //!
 //! Effects: Treaps to inserts value into the avl_set.
 //!
 //! Returns: If the value
@@ -360,39 +360,39 @@
 //! iterator to the new value and true. If there is an equivalent value
 //! returns a pair containing an iterator to the already present value
 //! and false.
- //!
+ //!
 //! Complexity: Average complexity for insert element is at
 //! most logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Strong guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 std::pair<iterator, bool> insert(reference value)
 { return tree_.insert_unique(value); }

 //! Requires: value must be an lvalue
- //!
- //! Effects: Treaps to to insert x into the avl_set, using "hint"
+ //!
+ //! Effects: Treaps to to insert x into the avl_set, using "hint"
 //! as a hint to where it will be inserted.
 //!
- //! Returns: An iterator that points to the position where the
+ //! Returns: An iterator that points to the position where the
 //! new element was inserted into the avl_set.
- //!
+ //!
 //! Complexity: Logarithmic in general, but it's amortized
 //! constant time if t is inserted immediately before hint.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Strong guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 iterator insert(const_iterator hint, reference value)
 { return tree_.insert_unique(hint, value); }

- //! Requires: key_value_comp must be a comparison function that induces
+ //! Requires: key_value_comp must be a comparison function that induces
 //! the same strict weak ordering as value_compare. The difference is that
 //! key_value_comp compares an arbitrary key with the contained values.
- //!
+ //!
 //! Effects: Checks if a value can be inserted in the avl_set, using
 //! a user provided key instead of the value itself.
 //!
@@ -401,16 +401,16 @@
 //! and false. If the value can be inserted returns true in the returned
 //! pair boolean and fills "commit_data" that is meant to be used with
 //! the "insert_commit" function.
- //!
+ //!
 //! Complexity: Average complexity is at most logarithmic.
 //!
 //! Throws: If the key_value_comp ordering function throws. Strong guarantee.
- //!
+ //!
 //! Notes: This function is used to improve performance when constructing
 //! a value_type is expensive: if there is an equivalent value
 //! the constructed object must be discarded. Many times, the part of the
 //! node that is used to impose the order is much cheaper to construct
- //! than the value_type and this function offers the possibility to use that
+ //! than the value_type and this function offers the possibility to use that
 //! part to check if the insertion will be successful.
 //!
 //! If the check is successful, the user can construct the value_type and use
@@ -424,12 +424,12 @@
 (const KeyType &key, KeyValueCompare key_value_comp, insert_commit_data &commit_data)
 { return tree_.insert_unique_check(key, key_value_comp, commit_data); }

- //! Requires: key_value_comp must be a comparison function that induces
+ //! Requires: key_value_comp must be a comparison function that induces
 //! the same strict weak ordering as value_compare. The difference is that
 //! key_value_comp compares an arbitrary key with the contained values.
- //!
+ //!
 //! Effects: Checks if a value can be inserted in the avl_set, using
- //! a user provided key instead of the value itself, using "hint"
+ //! a user provided key instead of the value itself, using "hint"
 //! as a hint to where it will be inserted.
 //!
 //! Returns: If there is an equivalent value
@@ -437,23 +437,23 @@
 //! and false. If the value can be inserted returns true in the returned
 //! pair boolean and fills "commit_data" that is meant to be used with
 //! the "insert_commit" function.
- //!
+ //!
 //! Complexity: Logarithmic in general, but it's amortized
 //! constant time if t is inserted immediately before hint.
 //!
 //! Throws: If the key_value_comp ordering function throws. Strong guarantee.
- //!
+ //!
 //! Notes: This function is used to improve performance when constructing
 //! a value_type is expensive: if there is an equivalent value
 //! the constructed object must be discarded. Many times, the part of the
 //! constructing that is used to impose the order is much cheaper to construct
- //! than the value_type and this function offers the possibility to use that key
+ //! than the value_type and this function offers the possibility to use that key
 //! to check if the insertion will be successful.
 //!
 //! If the check is successful, the user can construct the value_type and use
 //! "insert_commit" to insert the object in constant-time. This can give a total
 //! constant-time complexity to the insertion: check(O(1)) + commit(O(1)).
- //!
+ //!
 //! "commit_data" remains valid for a subsequent "insert_commit" only if no more
 //! objects are inserted or erased from the avl_set.
 template<class KeyType, class KeyValueCompare>
@@ -466,33 +466,33 @@
 //! must have been obtained from a previous call to "insert_check".
 //! No objects should have been inserted or erased from the avl_set between
 //! the "insert_check" that filled "commit_data" and the call to "insert_commit".
- //!
+ //!
 //! Effects: Inserts the value in the avl_set using the information obtained
 //! from the "commit_data" that a previous "insert_check" filled.
 //!
 //! Returns: An iterator to the newly inserted object.
- //!
+ //!
 //! Complexity: Constant time.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Notes: This function has only sense if a "insert_check" has been
 //! previously executed to fill "commit_data". No value should be inserted or
 //! erased between the "insert_check" and "insert_commit" calls.
 iterator insert_commit(reference value, const insert_commit_data &commit_data)
 { return tree_.insert_unique_commit(value, commit_data); }

- //! Requires: Dereferencing iterator must yield an lvalue
+ //! Requires: Dereferencing iterator must yield an lvalue
 //! of type value_type.
- //!
+ //!
 //! Effects: Inserts a range into the avl_set.
- //!
+ //!
 //! Complexity: Insert range is in general O(N * log(N)), where N is the
 //! size of the range. However, it is linear in N if the range is already sorted
 //! by value_comp().
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Basic guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 template<class Iterator>
@@ -505,11 +505,11 @@
 //! inserted key according to the predicate.
 //!
 //! Effects: Inserts x into the tree before "pos".
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function does not check preconditions so if "pos" is not
 //! the successor of "value" or "value" is not unique tree ordering and uniqueness
 //! invariants will be broken respectively.
@@ -522,11 +522,11 @@
 //! any inserted key according to the predicate.
 //!
 //! Effects: Inserts x into the tree in the last position.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function does not check preconditions so if value is
 //! less than or equal to the greatest inserted key tree ordering invariant will be broken.
 //! This function is slightly more efficient than using "insert_before".
@@ -539,11 +539,11 @@
 //! than any inserted key according to the predicate.
 //!
 //! Effects: Inserts x into the tree in the first position.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function does not check preconditions so if value is
 //! greater than or equal to the the mimum inserted key tree ordering or uniqueness
 //! invariants will be broken.
@@ -553,41 +553,41 @@
 void push_front(reference value)
 { tree_.push_front(value); }

- //! Effects: Erases the element pointed to by pos.
- //!
+ //! Effects: Erases the element pointed to by pos.
+ //!
 //! Complexity: Average complexity is constant time.
- //!
+ //!
 //! Returns: An iterator to the element after the erased element.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 iterator erase(const_iterator i)
 { return tree_.erase(i); }

- //! Effects: Erases the range pointed to by b end e.
- //!
- //! Complexity: Average complexity for erase range is at most
+ //! Effects: Erases the range pointed to by b end e.
+ //!
+ //! Complexity: Average complexity for erase range is at most
 //! O(log(size() + N)), where N is the number of elements in the range.
- //!
+ //!
 //! Returns: An iterator to the element after the erased elements.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 iterator erase(const_iterator b, const_iterator e)
 { return tree_.erase(b, e); }

 //! Effects: Erases all the elements with the given value.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size()) + this->count(value)).
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 size_type erase(const_reference value)
@@ -595,13 +595,13 @@

 //! Effects: Erases all the elements that compare equal with
 //! the given key and the given comparison functor.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size() + this->count(key, comp)).
- //!
+ //!
 //! Throws: If the comp ordering function throws. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class KeyType, class KeyValueCompare>
@@ -614,16 +614,16 @@

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
 //!
- //! Effects: Erases the element pointed to by pos.
+ //! Effects: Erases the element pointed to by pos.
 //! Disposer::operator()(pointer) is called for the removed element.
- //!
- //! Complexity: Average complexity for erase element is constant time.
- //!
+ //!
+ //! Complexity: Average complexity for erase element is constant time.
+ //!
 //! Returns: An iterator to the element after the erased element.
- //!
+ //!
 //! Throws: Nothing.
- //!
- //! Note: Invalidates the iterators
+ //!
+ //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
 iterator erase_and_dispose(const_iterator i, Disposer disposer)
@@ -639,14 +639,14 @@
 //!
 //! Effects: Erases the range pointed to by b end e.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
- //! Complexity: Average complexity for erase range is at most
+ //!
+ //! Complexity: Average complexity for erase range is at most
 //! O(log(size() + N)), where N is the number of elements in the range.
- //!
+ //!
 //! Returns: An iterator to the element after the erased elements.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
@@ -657,13 +657,13 @@
 //!
 //! Effects: Erases all the elements with the given value.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
- //!
+ //!
 //! Complexity: O(log(size() + this->count(value)). Basic guarantee.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class Disposer>
@@ -677,11 +677,11 @@
 //! Disposer::operator()(pointer) is called for the removed elements.
 //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size() + this->count(key, comp)).
- //!
+ //!
 //! Throws: If comp ordering function throws. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class KeyType, class KeyValueCompare, class Disposer>
@@ -693,26 +693,26 @@
 { return tree_.erase_and_dispose(key, comp, disposer); }

 //! Effects: Erases all the elements of the container.
- //!
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 void clear()
 { return tree_.clear(); }

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
- //!
+ //!
 //! Effects: Erases all the elements of the container.
- //!
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class Disposer>
@@ -720,20 +720,20 @@
 { return tree_.clear_and_dispose(disposer); }

 //! Effects: Returns the number of contained elements with the given key
- //!
+ //!
 //! Complexity: Logarithmic to the number of elements contained plus lineal
 //! to number of objects with the given key.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 size_type count(const_reference value) const
 { return tree_.find(value) != end(); }

 //! Effects: Returns the number of contained elements with the same key
 //! compared with the given comparison functor.
- //!
+ //!
 //! Complexity: Logarithmic to the number of elements contained plus lineal
 //! to number of objects with the given key.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 template<class KeyType, class KeyValueCompare>
 size_type count(const KeyType& key, KeyValueCompare comp) const
@@ -741,9 +741,9 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is not less than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 iterator lower_bound(const_reference value)
 { return tree_.lower_bound(value); }
@@ -753,13 +753,13 @@
 //! that is used in the ordering functor.
 //!
 //! Effects: Returns an iterator to the first element whose
- //! key according to the comparison functor is not less than k or
+ //! key according to the comparison functor is not less than k or
 //! end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
- //!
+ //!
 //! Note: This function is used when constructing a value_type
 //! is expensive and the value_type can be compared with a cheaper
 //! key type. Usually this key is part of the value_type.
@@ -769,9 +769,9 @@

 //! Effects: Returns a const iterator to the first element whose
 //! key is not less than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 const_iterator lower_bound(const_reference value) const
 { return tree_.lower_bound(value); }
@@ -781,13 +781,13 @@
 //! that is used in the ordering functor.
 //!
 //! Effects: Returns a const_iterator to the first element whose
- //! key according to the comparison functor is not less than k or
+ //! key according to the comparison functor is not less than k or
 //! end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
- //!
+ //!
 //! Note: This function is used when constructing a value_type
 //! is expensive and the value_type can be compared with a cheaper
 //! key type. Usually this key is part of the value_type.
@@ -797,9 +797,9 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is greater than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 iterator upper_bound(const_reference value)
 { return tree_.upper_bound(value); }
@@ -809,11 +809,11 @@
 //! that is used in the ordering functor.
 //!
 //! Effects: Returns an iterator to the first element whose
- //! key according to the comparison functor is greater than key or
+ //! key according to the comparison functor is greater than key or
 //! end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -825,9 +825,9 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is greater than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 const_iterator upper_bound(const_reference value) const
 { return tree_.upper_bound(value); }
@@ -837,11 +837,11 @@
 //! that is used in the ordering functor.
 //!
 //! Effects: Returns a const_iterator to the first element whose
- //! key according to the comparison functor is greater than key or
+ //! key according to the comparison functor is greater than key or
 //! end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -851,11 +851,11 @@
 const_iterator upper_bound(const KeyType& key, KeyValueCompare comp) const
 { return tree_.upper_bound(key, comp); }

- //! Effects: Finds an iterator to the first element whose value is
+ //! Effects: Finds an iterator to the first element whose value is
 //! "value" or end() if that element does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 iterator find(const_reference value)
 { return tree_.find(value); }
@@ -864,12 +864,12 @@
 //! value_compare. Usually key is the part of the value_type
 //! that is used in the ordering functor.
 //!
- //! Effects: Finds an iterator to the first element whose key is
- //! "key" according to the comparison functor or end() if that element
+ //! Effects: Finds an iterator to the first element whose key is
+ //! "key" according to the comparison functor or end() if that element
 //! does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -879,11 +879,11 @@
 iterator find(const KeyType& key, KeyValueCompare comp)
 { return tree_.find(key, comp); }

- //! Effects: Finds a const_iterator to the first element whose value is
+ //! Effects: Finds a const_iterator to the first element whose value is
 //! "value" or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 const_iterator find(const_reference value) const
 { return tree_.find(value); }
@@ -892,12 +892,12 @@
 //! value_compare. Usually key is the part of the value_type
 //! that is used in the ordering functor.
 //!
- //! Effects: Finds a const_iterator to the first element whose key is
- //! "key" according to the comparison functor or end() if that element
+ //! Effects: Finds a const_iterator to the first element whose key is
+ //! "key" according to the comparison functor or end() if that element
 //! does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -910,9 +910,9 @@
 //! Effects: Finds a range containing all elements whose key is k or
 //! an empty range that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 std::pair<iterator,iterator> equal_range(const_reference value)
 { return tree_.equal_range(value); }
@@ -921,13 +921,13 @@
 //! value_compare. Usually key is the part of the value_type
 //! that is used in the ordering functor.
 //!
- //! Effects: Finds a range containing all elements whose key is k
- //! according to the comparison functor or an empty range
+ //! Effects: Finds a range containing all elements whose key is k
+ //! according to the comparison functor or an empty range
 //! that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -940,9 +940,9 @@
 //! Effects: Finds a range containing all elements whose key is k or
 //! an empty range that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 std::pair<const_iterator, const_iterator>
 equal_range(const_reference value) const
@@ -952,13 +952,13 @@
 //! value_compare. Usually key is the part of the value_type
 //! that is used in the ordering functor.
 //!
- //! Effects: Finds a range containing all elements whose key is k
- //! according to the comparison functor or an empty range
+ //! Effects: Finds a range containing all elements whose key is k
+ //! according to the comparison functor or an empty range
 //! that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -971,14 +971,14 @@

 //! Requires: value must be an lvalue and shall be in a avl_set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid iterator i belonging to the avl_set
 //! that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This static function is available only if the value traits
 //! is stateless.
 static iterator s_iterator_to(reference value)
@@ -986,14 +986,14 @@

 //! Requires: value must be an lvalue and shall be in a avl_set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid const_iterator i belonging to the
 //! avl_set that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This static function is available only if the value traits
 //! is stateless.
 static const_iterator s_iterator_to(const_reference value)
@@ -1001,48 +1001,48 @@

 //! Requires: value must be an lvalue and shall be in a avl_set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid iterator i belonging to the avl_set
 //! that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator iterator_to(reference value)
 { return tree_.iterator_to(value); }

 //! Requires: value must be an lvalue and shall be in a avl_set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid const_iterator i belonging to the
 //! avl_set that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator iterator_to(const_reference value) const
 { return tree_.iterator_to(value); }

 //! Requires: value shall not be in a avl_set/avl_multiset.
- //!
+ //!
 //! Effects: init_node puts the hook of a value in a well-known default
 //! state.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Note: This function puts the hook in the well-known default state
 //! used by auto_unlink and safe hooks.
 static void init_node(reference value)
 { tree_type::init_node(value); }

 //! Effects: Unlinks the leftmost node from the tree.
- //!
+ //!
 //! Complexity: Average complexity is constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Notes: This function breaks the tree and the tree can
 //! only be used for more unlink_leftmost_without_rebalance calls.
 //! This function is normally used to achieve a step by step
@@ -1052,14 +1052,14 @@

 //! Requires: replace_this must be a valid iterator of *this
 //! and with_this must not be inserted in any tree.
- //!
+ //!
 //! Effects: Replaces replace_this in its position in the
 //! tree with with_this. The tree does not need to be rebalanced.
- //!
- //! Complexity: Constant.
- //!
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function will break container ordering invariants if
 //! with_this is not equivalent to *replace_this according to the
 //! ordering rules. This function is faster than erasing and inserting
@@ -1233,9 +1233,9 @@

#endif

-//! The class template avl_multiset is an intrusive container, that mimics most of
+//! The class template avl_multiset is an intrusive container, that mimics most of
//! the interface of std::avl_multiset as described in the C++ standard.
-//!
+//!
//! The template parameter \c T is the type to be managed by the container.
//! The user can specify additional options and if no options are provided
//! default options are used.
@@ -1289,30 +1289,30 @@
 /// @endcond

 public:
- //! Effects: Constructs an empty avl_multiset.
- //!
- //! Complexity: Constant.
- //!
+ //! Effects: Constructs an empty avl_multiset.
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: If value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
- //! or the copy constructor/operator() of the value_compare object throws.
+ //! or the copy constructor/operator() of the value_compare object throws.
 avl_multiset_impl( const value_compare &cmp = value_compare()
- , const value_traits &v_traits = value_traits())
+ , const value_traits &v_traits = value_traits())
 : tree_(cmp, v_traits)
 {}

- //! Requires: Dereferencing iterator must yield an lvalue of type value_type.
+ //! Requires: Dereferencing iterator must yield an lvalue of type value_type.
 //! cmp must be a comparison function that induces a strict weak ordering.
- //!
- //! Effects: Constructs an empty avl_multiset and inserts elements from
+ //!
+ //! Effects: Constructs an empty avl_multiset and inserts elements from
 //! [b, e).
- //!
+ //!
 //! Complexity: Linear in N if [b, e) is already sorted using
 //! comp and otherwise N * log N, where N is the distance between first and last
- //!
+ //!
 //! Throws: If value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
- //! or the copy constructor/operator() of the value_compare object throws.
+ //! or the copy constructor/operator() of the value_compare object throws.
 template<class Iterator>
 avl_multiset_impl( Iterator b, Iterator e
 , const value_compare &cmp = value_compare()
@@ -1321,135 +1321,135 @@
 {}

 //! Effects: to-do
- //!
- avl_multiset_impl(BOOST_RV_REF(avl_multiset_impl) x)
+ //!
+ avl_multiset_impl(BOOST_RV_REF(avl_multiset_impl) x)
 : tree_(::boost::move(x.tree_))
 {}

 //! Effects: to-do
- //!
- avl_multiset_impl& operator=(BOOST_RV_REF(avl_multiset_impl) x)
+ //!
+ avl_multiset_impl& operator=(BOOST_RV_REF(avl_multiset_impl) x)
 { tree_ = ::boost::move(x.tree_); return *this; }

- //! Effects: Detaches all elements from this. The objects in the avl_multiset
+ //! Effects: Detaches all elements from this. The objects in the avl_multiset
 //! are not deleted (i.e. no destructors are called).
- //!
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
- //!
+ //!
 //! Throws: Nothing.
- ~avl_multiset_impl()
+ ~avl_multiset_impl()
 {}

 //! Effects: Returns an iterator pointing to the beginning of the avl_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator begin()
 { return tree_.begin(); }

 //! Effects: Returns a const_iterator pointing to the beginning of the avl_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator begin() const
 { return tree_.begin(); }

 //! Effects: Returns a const_iterator pointing to the beginning of the avl_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator cbegin() const
 { return tree_.cbegin(); }

 //! Effects: Returns an iterator pointing to the end of the avl_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator end()
 { return tree_.end(); }

 //! Effects: Returns a const_iterator pointing to the end of the avl_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator end() const
 { return tree_.end(); }

 //! Effects: Returns a const_iterator pointing to the end of the avl_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator cend() const
 { return tree_.cend(); }

 //! Effects: Returns a reverse_iterator pointing to the beginning of the
 //! reversed avl_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 reverse_iterator rbegin()
 { return tree_.rbegin(); }

 //! Effects: Returns a const_reverse_iterator pointing to the beginning
 //! of the reversed avl_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator rbegin() const
 { return tree_.rbegin(); }

 //! Effects: Returns a const_reverse_iterator pointing to the beginning
 //! of the reversed avl_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator crbegin() const
 { return tree_.crbegin(); }

 //! Effects: Returns a reverse_iterator pointing to the end
 //! of the reversed avl_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 reverse_iterator rend()
 { return tree_.rend(); }

 //! Effects: Returns a const_reverse_iterator pointing to the end
 //! of the reversed avl_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator rend() const
 { return tree_.rend(); }

 //! Effects: Returns a const_reverse_iterator pointing to the end
 //! of the reversed avl_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator crend() const
 { return tree_.crend(); }

 //! Precondition: end_iterator must be a valid end iterator
 //! of avl_multiset.
- //!
+ //!
 //! Effects: Returns a const reference to the avl_multiset associated to the end iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 static avl_multiset_impl &container_from_end_iterator(iterator end_iterator)
 {
@@ -1460,11 +1460,11 @@

 //! Precondition: end_iterator must be a valid end const_iterator
 //! of avl_multiset.
- //!
+ //!
 //! Effects: Returns a const reference to the avl_multiset associated to the end iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 static const avl_multiset_impl &container_from_end_iterator(const_iterator end_iterator)
 {
@@ -1474,11 +1474,11 @@
 }

 //! Precondition: it must be a valid iterator of multiset.
- //!
+ //!
 //! Effects: Returns a const reference to the multiset associated to the iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Logarithmic.
 static avl_multiset_impl &container_from_iterator(iterator it)
 {
@@ -1488,11 +1488,11 @@
 }

 //! Precondition: it must be a valid const_iterator of multiset.
- //!
+ //!
 //! Effects: Returns a const reference to the multiset associated to the iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Logarithmic.
 static const avl_multiset_impl &container_from_iterator(const_iterator it)
 {
@@ -1502,42 +1502,42 @@
 }

 //! Effects: Returns the key_compare object used by the avl_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If key_compare copy-constructor throws.
 key_compare key_comp() const
 { return tree_.value_comp(); }

 //! Effects: Returns the value_compare object used by the avl_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If value_compare copy-constructor throws.
 value_compare value_comp() const
 { return tree_.value_comp(); }

 //! Effects: Returns true is the container is empty.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 bool empty() const
 { return tree_.empty(); }

 //! Effects: Returns the number of elements stored in the avl_multiset.
- //!
+ //!
 //! Complexity: Linear to elements contained in *this if,
 //! constant-time size option is enabled. Constant-time otherwise.
- //!
+ //!
 //! Throws: Nothing.
 size_type size() const
 { return tree_.size(); }

 //! Effects: Swaps the contents of two avl_multisets.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If the swap() call for the comparison functor
 //! found using ADL throws. Strong guarantee.
 void swap(avl_multiset_impl& other)
@@ -1547,69 +1547,69 @@
 //! Cloner should yield to nodes equivalent to the original nodes.
 //!
 //! Effects: Erases all the elements from *this
- //! calling Disposer::operator()(pointer), clones all the
+ //! calling Disposer::operator()(pointer), clones all the
 //! elements from src calling Cloner::operator()(const_reference )
 //! and inserts them on *this. Copies the predicate from the source container.
 //!
 //! If cloner throws, all cloned elements are unlinked and disposed
 //! calling Disposer::operator()(pointer).
- //!
+ //!
 //! Complexity: Linear to erased plus inserted elements.
- //!
+ //!
 //! Throws: If cloner throws or predicate copy assignment throws. Basic guarantee.
 template <class Cloner, class Disposer>
 void clone_from(const avl_multiset_impl &src, Cloner cloner, Disposer disposer)
 { tree_.clone_from(src.tree_, cloner, disposer); }

 //! Requires: value must be an lvalue
- //!
+ //!
 //! Effects: Inserts value into the avl_multiset.
- //!
+ //!
 //! Returns: An iterator that points to the position where the new
 //! element was inserted.
- //!
+ //!
 //! Complexity: Average complexity for insert element is at
 //! most logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Strong guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 iterator insert(reference value)
 { return tree_.insert_equal(value); }

 //! Requires: value must be an lvalue
- //!
+ //!
 //! Effects: Inserts x into the avl_multiset, using pos as a hint to
 //! where it will be inserted.
- //!
+ //!
 //! Returns: An iterator that points to the position where the new
 //! element was inserted.
- //!
+ //!
 //! Complexity: Logarithmic in general, but it is amortized
 //! constant time if t is inserted immediately before hint.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Strong guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 iterator insert(const_iterator hint, reference value)
 { return tree_.insert_equal(hint, value); }

- //! Requires: Dereferencing iterator must yield an lvalue
+ //! Requires: Dereferencing iterator must yield an lvalue
 //! of type value_type.
- //!
+ //!
 //! Effects: Inserts a range into the avl_multiset.
- //!
+ //!
 //! Returns: An iterator that points to the position where the new
 //! element was inserted.
- //!
+ //!
 //! Complexity: Insert range is in general O(N * log(N)), where N is the
 //! size of the range. However, it is linear in N if the range is already sorted
 //! by value_comp().
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Basic guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 template<class Iterator>
@@ -1622,11 +1622,11 @@
 //! inserted key according to the predicate.
 //!
 //! Effects: Inserts x into the tree before "pos".
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function does not check preconditions so if "pos" is not
 //! the successor of "value" or "value" is not unique tree ordering and uniqueness
 //! invariants will be broken respectively.
@@ -1639,11 +1639,11 @@
 //! any inserted key according to the predicate.
 //!
 //! Effects: Inserts x into the tree in the last position.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function does not check preconditions so if value is
 //! less than or equal to the greatest inserted key tree ordering invariant will be broken.
 //! This function is slightly more efficient than using "insert_before".
@@ -1656,11 +1656,11 @@
 //! than any inserted key according to the predicate.
 //!
 //! Effects: Inserts x into the tree in the first position.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function does not check preconditions so if value is
 //! greater than or equal to the the mimum inserted key tree ordering or uniqueness
 //! invariants will be broken.
@@ -1670,41 +1670,41 @@
 void push_front(reference value)
 { tree_.push_front(value); }

- //! Effects: Erases the element pointed to by pos.
- //!
+ //! Effects: Erases the element pointed to by pos.
+ //!
 //! Complexity: Average complexity is constant time.
- //!
+ //!
 //! Returns: An iterator to the element after the erased element.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 iterator erase(const_iterator i)
 { return tree_.erase(i); }

- //! Effects: Erases the range pointed to by b end e.
+ //! Effects: Erases the range pointed to by b end e.
 //!
 //! Returns: An iterator to the element after the erased elements.
- //!
- //! Complexity: Average complexity for erase range is at most
+ //!
+ //! Complexity: Average complexity for erase range is at most
 //! O(log(size() + N)), where N is the number of elements in the range.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 iterator erase(const_iterator b, const_iterator e)
 { return tree_.erase(b, e); }

 //! Effects: Erases all the elements with the given value.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size() + this->count(value)).
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 size_type erase(const_reference value)
@@ -1712,13 +1712,13 @@

 //! Effects: Erases all the elements that compare equal with
 //! the given key and the given comparison functor.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size() + this->count(key, comp)).
- //!
+ //!
 //! Throws: If comp ordering function throws. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class KeyType, class KeyValueCompare>
@@ -1733,14 +1733,14 @@
 //!
 //! Returns: An iterator to the element after the erased element.
 //!
- //! Effects: Erases the element pointed to by pos.
+ //! Effects: Erases the element pointed to by pos.
 //! Disposer::operator()(pointer) is called for the removed element.
- //!
- //! Complexity: Average complexity for erase element is constant time.
- //!
+ //!
+ //! Complexity: Average complexity for erase element is constant time.
+ //!
 //! Throws: Nothing.
- //!
- //! Note: Invalidates the iterators
+ //!
+ //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
 iterator erase_and_dispose(const_iterator i, Disposer disposer)
@@ -1758,12 +1758,12 @@
 //!
 //! Effects: Erases the range pointed to by b end e.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
- //! Complexity: Average complexity for erase range is at most
+ //!
+ //! Complexity: Average complexity for erase range is at most
 //! O(log(size() + N)), where N is the number of elements in the range.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
@@ -1774,13 +1774,13 @@
 //!
 //! Effects: Erases all the elements with the given value.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size() + this->count(value)).
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class Disposer>
@@ -1794,11 +1794,11 @@
 //! Disposer::operator()(pointer) is called for the removed elements.
 //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size() + this->count(key, comp)).
- //!
+ //!
 //! Throws: If comp ordering function throws. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class KeyType, class KeyValueCompare, class Disposer>
@@ -1810,26 +1810,26 @@
 { return tree_.erase_and_dispose(key, comp, disposer); }

 //! Effects: Erases all the elements of the container.
- //!
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 void clear()
 { return tree_.clear(); }

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
- //!
+ //!
 //! Effects: Erases all the elements of the container.
- //!
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class Disposer>
@@ -1837,20 +1837,20 @@
 { return tree_.clear_and_dispose(disposer); }

 //! Effects: Returns the number of contained elements with the given key
- //!
+ //!
 //! Complexity: Logarithmic to the number of elements contained plus lineal
 //! to number of objects with the given key.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 size_type count(const_reference value) const
 { return tree_.count(value); }

 //! Effects: Returns the number of contained elements with the same key
 //! compared with the given comparison functor.
- //!
+ //!
 //! Complexity: Logarithmic to the number of elements contained plus lineal
 //! to number of objects with the given key.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 template<class KeyType, class KeyValueCompare>
 size_type count(const KeyType& key, KeyValueCompare comp) const
@@ -1858,9 +1858,9 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is not less than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 iterator lower_bound(const_reference value)
 { return tree_.lower_bound(value); }
@@ -1870,13 +1870,13 @@
 //! that is used in the ordering functor.
 //!
 //! Effects: Returns an iterator to the first element whose
- //! key according to the comparison functor is not less than k or
+ //! key according to the comparison functor is not less than k or
 //! end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
- //!
+ //!
 //! Note: This function is used when constructing a value_type
 //! is expensive and the value_type can be compared with a cheaper
 //! key type. Usually this key is part of the value_type.
@@ -1886,9 +1886,9 @@

 //! Effects: Returns a const iterator to the first element whose
 //! key is not less than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 const_iterator lower_bound(const_reference value) const
 { return tree_.lower_bound(value); }
@@ -1898,13 +1898,13 @@
 //! that is used in the ordering functor.
 //!
 //! Effects: Returns a const_iterator to the first element whose
- //! key according to the comparison functor is not less than k or
+ //! key according to the comparison functor is not less than k or
 //! end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
- //!
+ //!
 //! Note: This function is used when constructing a value_type
 //! is expensive and the value_type can be compared with a cheaper
 //! key type. Usually this key is part of the value_type.
@@ -1914,9 +1914,9 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is greater than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 iterator upper_bound(const_reference value)
 { return tree_.upper_bound(value); }
@@ -1926,11 +1926,11 @@
 //! that is used in the ordering functor.
 //!
 //! Effects: Returns an iterator to the first element whose
- //! key according to the comparison functor is greater than key or
+ //! key according to the comparison functor is greater than key or
 //! end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -1942,9 +1942,9 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is greater than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 const_iterator upper_bound(const_reference value) const
 { return tree_.upper_bound(value); }
@@ -1954,11 +1954,11 @@
 //! that is used in the ordering functor.
 //!
 //! Effects: Returns a const_iterator to the first element whose
- //! key according to the comparison functor is greater than key or
+ //! key according to the comparison functor is greater than key or
 //! end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -1968,11 +1968,11 @@
 const_iterator upper_bound(const KeyType& key, KeyValueCompare comp) const
 { return tree_.upper_bound(key, comp); }

- //! Effects: Finds an iterator to the first element whose value is
+ //! Effects: Finds an iterator to the first element whose value is
 //! "value" or end() if that element does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 iterator find(const_reference value)
 { return tree_.find(value); }
@@ -1981,12 +1981,12 @@
 //! value_compare. Usually key is the part of the value_type
 //! that is used in the ordering functor.
 //!
- //! Effects: Finds an iterator to the first element whose key is
- //! "key" according to the comparison functor or end() if that element
+ //! Effects: Finds an iterator to the first element whose key is
+ //! "key" according to the comparison functor or end() if that element
 //! does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -1996,11 +1996,11 @@
 iterator find(const KeyType& key, KeyValueCompare comp)
 { return tree_.find(key, comp); }

- //! Effects: Finds a const_iterator to the first element whose value is
+ //! Effects: Finds a const_iterator to the first element whose value is
 //! "value" or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 const_iterator find(const_reference value) const
 { return tree_.find(value); }
@@ -2009,12 +2009,12 @@
 //! value_compare. Usually key is the part of the value_type
 //! that is used in the ordering functor.
 //!
- //! Effects: Finds a const_iterator to the first element whose key is
- //! "key" according to the comparison functor or end() if that element
+ //! Effects: Finds a const_iterator to the first element whose key is
+ //! "key" according to the comparison functor or end() if that element
 //! does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -2027,9 +2027,9 @@
 //! Effects: Finds a range containing all elements whose key is k or
 //! an empty range that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 std::pair<iterator,iterator> equal_range(const_reference value)
 { return tree_.equal_range(value); }
@@ -2038,13 +2038,13 @@
 //! value_compare. Usually key is the part of the value_type
 //! that is used in the ordering functor.
 //!
- //! Effects: Finds a range containing all elements whose key is k
- //! according to the comparison functor or an empty range
+ //! Effects: Finds a range containing all elements whose key is k
+ //! according to the comparison functor or an empty range
 //! that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -2057,9 +2057,9 @@
 //! Effects: Finds a range containing all elements whose key is k or
 //! an empty range that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 std::pair<const_iterator, const_iterator>
 equal_range(const_reference value) const
@@ -2069,13 +2069,13 @@
 //! value_compare. Usually key is the part of the value_type
 //! that is used in the ordering functor.
 //!
- //! Effects: Finds a range containing all elements whose key is k
- //! according to the comparison functor or an empty range
+ //! Effects: Finds a range containing all elements whose key is k
+ //! according to the comparison functor or an empty range
 //! that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -2088,14 +2088,14 @@

 //! Requires: value must be an lvalue and shall be in a avl_multiset of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid iterator i belonging to the avl_multiset
 //! that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This static function is available only if the value traits
 //! is stateless.
 static iterator s_iterator_to(reference value)
@@ -2103,14 +2103,14 @@

 //! Requires: value must be an lvalue and shall be in a avl_multiset of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid const_iterator i belonging to the
 //! avl_multiset that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This static function is available only if the value traits
 //! is stateless.
 static const_iterator s_iterator_to(const_reference value)
@@ -2118,48 +2118,48 @@

 //! Requires: value must be an lvalue and shall be in a avl_multiset of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid iterator i belonging to the avl_multiset
 //! that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator iterator_to(reference value)
 { return tree_.iterator_to(value); }

 //! Requires: value must be an lvalue and shall be in a avl_multiset of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid const_iterator i belonging to the
 //! avl_multiset that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator iterator_to(const_reference value) const
 { return tree_.iterator_to(value); }

 //! Requires: value shall not be in a avl_multiset/avl_multiset.
- //!
+ //!
 //! Effects: init_node puts the hook of a value in a well-known default
 //! state.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Note: This function puts the hook in the well-known default state
 //! used by auto_unlink and safe hooks.
 static void init_node(reference value)
 { tree_type::init_node(value); }

 //! Effects: Unlinks the leftmost node from the tree.
- //!
+ //!
 //! Complexity: Average complexity is constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Notes: This function breaks the tree and the tree can
 //! only be used for more unlink_leftmost_without_rebalance calls.
 //! This function is normally used to achieve a step by step
@@ -2169,14 +2169,14 @@

 //! Requires: replace_this must be a valid iterator of *this
 //! and with_this must not be inserted in any tree.
- //!
+ //!
 //! Effects: Replaces replace_this in its position in the
 //! tree with with_this. The tree does not need to be rebalanced.
- //!
- //! Complexity: Constant.
- //!
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function will break container ordering invariants if
 //! with_this is not equivalent to *replace_this according to the
 //! ordering rules. This function is faster than erasing and inserting
@@ -2290,7 +2290,7 @@
template<class T, class ...Options>
#endif
class avl_multiset
- : public make_avl_multiset<T,
+ : public make_avl_multiset<T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
@@ -2350,8 +2350,8 @@

#endif

-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Modified: branches/release/boost/intrusive/avl_set_hook.hpp
==============================================================================
--- branches/release/boost/intrusive/avl_set_hook.hpp (original)
+++ branches/release/boost/intrusive/avl_set_hook.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -61,16 +61,16 @@
 typedef implementation_defined type;
};

-//! Derive a class from avl_set_base_hook in order to store objects in
-//! in an avl_set/avl_multiset. avl_set_base_hook holds the data necessary to maintain
+//! Derive a class from avl_set_base_hook in order to store objects in
+//! in an avl_set/avl_multiset. avl_set_base_hook holds the data necessary to maintain
//! the avl_set/avl_multiset and provides an appropriate value_traits class for avl_set/avl_multiset.
-//!
+//!
//! The hook admits the following options: \c tag<>, \c void_pointer<>,
//! \c link_mode<> and \c optimize_size<>.
//!
-//! \c tag<> defines a tag to identify the node.
-//! The same tag value can be used in different classes, but if a class is
-//! derived from more than one \c list_base_hook, then each \c list_base_hook needs its
+//! \c tag<> defines a tag to identify the node.
+//! The same tag value can be used in different classes, but if a class is
+//! derived from more than one \c list_base_hook, then each \c list_base_hook needs its
//! unique tag.
//!
//! \c void_pointer<> is the pointer type that will be used internally in the hook
@@ -99,27 +99,27 @@
 public:
 //! Effects: If link_mode is \c auto_unlink or \c safe_link
 //! initializes the node to an unlinked state.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 avl_set_base_hook();

 //! Effects: If link_mode is \c auto_unlink or \c safe_link
 //! initializes the node to an unlinked state. The argument is ignored.
- //!
- //! Throws: Nothing.
- //!
+ //!
+ //! Throws: Nothing.
+ //!
 //! Rationale: Providing a copy-constructor
- //! makes classes using the hook STL-compliant without forcing the
+ //! makes classes using the hook STL-compliant without forcing the
 //! user to do some additional work. \c swap can be used to emulate
 //! move-semantics.
 avl_set_base_hook(const avl_set_base_hook& );

 //! Effects: Empty function. The argument is ignored.
- //!
- //! Throws: Nothing.
- //!
- //! Rationale: Providing an assignment operator
- //! makes classes using the hook STL-compliant without forcing the
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Rationale: Providing an assignment operator
+ //! makes classes using the hook STL-compliant without forcing the
 //! user to do some additional work. \c swap can be used to emulate
 //! move-semantics.
 avl_set_base_hook& operator=(const avl_set_base_hook& );
@@ -128,37 +128,37 @@
 //! nothing (ie. no code is generated). If link_mode is \c safe_link and the
 //! object is stored in a set an assertion is raised. If link_mode is
 //! \c auto_unlink and \c is_linked() is true, the node is unlinked.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 ~avl_set_base_hook();

- //! Effects: Swapping two nodes swaps the position of the elements
- //! related to those nodes in one or two containers. That is, if the node
- //! this is part of the element e1, the node x is part of the element e2
- //! and both elements are included in the containers s1 and s2, then after
- //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1
- //! at the position of e1. If one element is not in a container, then
- //! after the swap-operation the other element is not in a container.
- //! Iterators to e1 and e2 related to those nodes are invalidated.
+ //! Effects: Swapping two nodes swaps the position of the elements
+ //! related to those nodes in one or two containers. That is, if the node
+ //! this is part of the element e1, the node x is part of the element e2
+ //! and both elements are included in the containers s1 and s2, then after
+ //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1
+ //! at the position of e1. If one element is not in a container, then
+ //! after the swap-operation the other element is not in a container.
+ //! Iterators to e1 and e2 related to those nodes are invalidated.
 //!
- //! Complexity: Constant
+ //! Complexity: Constant
 //!
- //! Throws: Nothing.
+ //! Throws: Nothing.
 void swap_nodes(avl_set_base_hook &other);

 //! Precondition: link_mode must be \c safe_link or \c auto_unlink.
 //!
 //! Returns: true, if the node belongs to a container, false
- //! otherwise. This function can be used to test whether \c set::iterator_to
- //! will return a valid iterator.
+ //! otherwise. This function can be used to test whether \c set::iterator_to
+ //! will return a valid iterator.
 //!
- //! Complexity: Constant
+ //! Complexity: Constant
 bool is_linked() const;

 //! Effects: Removes the node if it's inserted in a container.
 //! This function is only allowed if link_mode is \c auto_unlink.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 void unlink();
 #endif
};
@@ -195,7 +195,7 @@
//! Put a public data member avl_set_member_hook in order to store objects of this class in
//! an avl_set/avl_multiset. avl_set_member_hook holds the data necessary for maintaining the
//! avl_set/avl_multiset and provides an appropriate value_traits class for avl_set/avl_multiset.
-//!
+//!
//! The hook admits the following options: \c void_pointer<>,
//! \c link_mode<> and \c optimize_size<>.
//!
@@ -225,27 +225,27 @@
 public:
 //! Effects: If link_mode is \c auto_unlink or \c safe_link
 //! initializes the node to an unlinked state.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 avl_set_member_hook();

 //! Effects: If link_mode is \c auto_unlink or \c safe_link
 //! initializes the node to an unlinked state. The argument is ignored.
- //!
- //! Throws: Nothing.
- //!
+ //!
+ //! Throws: Nothing.
+ //!
 //! Rationale: Providing a copy-constructor
- //! makes classes using the hook STL-compliant without forcing the
+ //! makes classes using the hook STL-compliant without forcing the
 //! user to do some additional work. \c swap can be used to emulate
 //! move-semantics.
 avl_set_member_hook(const avl_set_member_hook& );

 //! Effects: Empty function. The argument is ignored.
- //!
- //! Throws: Nothing.
- //!
- //! Rationale: Providing an assignment operator
- //! makes classes using the hook STL-compliant without forcing the
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Rationale: Providing an assignment operator
+ //! makes classes using the hook STL-compliant without forcing the
 //! user to do some additional work. \c swap can be used to emulate
 //! move-semantics.
 avl_set_member_hook& operator=(const avl_set_member_hook& );
@@ -254,43 +254,43 @@
 //! nothing (ie. no code is generated). If link_mode is \c safe_link and the
 //! object is stored in a set an assertion is raised. If link_mode is
 //! \c auto_unlink and \c is_linked() is true, the node is unlinked.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 ~avl_set_member_hook();

- //! Effects: Swapping two nodes swaps the position of the elements
- //! related to those nodes in one or two containers. That is, if the node
- //! this is part of the element e1, the node x is part of the element e2
- //! and both elements are included in the containers s1 and s2, then after
- //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1
- //! at the position of e1. If one element is not in a container, then
- //! after the swap-operation the other element is not in a container.
- //! Iterators to e1 and e2 related to those nodes are invalidated.
+ //! Effects: Swapping two nodes swaps the position of the elements
+ //! related to those nodes in one or two containers. That is, if the node
+ //! this is part of the element e1, the node x is part of the element e2
+ //! and both elements are included in the containers s1 and s2, then after
+ //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1
+ //! at the position of e1. If one element is not in a container, then
+ //! after the swap-operation the other element is not in a container.
+ //! Iterators to e1 and e2 related to those nodes are invalidated.
 //!
- //! Complexity: Constant
+ //! Complexity: Constant
 //!
- //! Throws: Nothing.
+ //! Throws: Nothing.
 void swap_nodes(avl_set_member_hook &other);

 //! Precondition: link_mode must be \c safe_link or \c auto_unlink.
 //!
 //! Returns: true, if the node belongs to a container, false
- //! otherwise. This function can be used to test whether \c set::iterator_to
- //! will return a valid iterator.
+ //! otherwise. This function can be used to test whether \c set::iterator_to
+ //! will return a valid iterator.
 //!
- //! Complexity: Constant
+ //! Complexity: Constant
 bool is_linked() const;

 //! Effects: Removes the node if it's inserted in a container.
 //! This function is only allowed if link_mode is \c auto_unlink.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 void unlink();
 #endif
};

-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Modified: branches/release/boost/intrusive/avltree.hpp
==============================================================================
--- branches/release/boost/intrusive/avltree.hpp (original)
+++ branches/release/boost/intrusive/avltree.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -65,7 +65,7 @@

//! The class template avltree is an intrusive AVL tree container, that
//! is used to construct intrusive avl_set and avl_multiset containers.
-//! The no-throw guarantee holds only, if the value_compare object
+//! The no-throw guarantee holds only, if the value_compare object
//! doesn't throw.
//!
//! The template parameter \c T is the type to be managed by the container.
@@ -134,7 +134,7 @@
 //noncopyable, movable
 BOOST_MOVABLE_BUT_NOT_COPYABLE(avltree_impl)

- enum { safemode_or_autounlink =
+ enum { safemode_or_autounlink =
 (int)real_value_traits::link_mode == (int)auto_unlink ||
 (int)real_value_traits::link_mode == (int)safe_link };

@@ -160,7 +160,7 @@
 {}
 node_plus_pred_t node_plus_pred_;
 } data_;
-
+
 const value_compare &priv_comp() const
 { return data_.node_plus_pred_.get(); }

@@ -212,18 +212,18 @@

 typedef typename node_algorithms::insert_commit_data insert_commit_data;

- //! Effects: Constructs an empty tree.
- //!
- //! Complexity: Constant.
- //!
+ //! Effects: Constructs an empty tree.
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: If value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
 //! or the copy constructor of the value_compare object throws. Basic guarantee.
 avltree_impl( const value_compare &cmp = value_compare()
- , const value_traits &v_traits = value_traits())
+ , const value_traits &v_traits = value_traits())
 : data_(cmp, v_traits)
- {
- node_algorithms::init_header(this->priv_header_ptr());
+ {
+ node_algorithms::init_header(this->priv_header_ptr());
 this->priv_size_traits().set_size(size_type(0));
 }

@@ -235,7 +235,7 @@
 //!
 //! Complexity: Linear in N if [b, e) is already sorted using
 //! comp and otherwise N * log N, where N is the distance between first and last.
- //!
+ //!
 //! Throws: If value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
 //! or the copy constructor/operator() of the value_compare object throws. Basic guarantee.
@@ -254,58 +254,58 @@
 }

 //! Effects: to-do
- //!
+ //!
 avltree_impl(BOOST_RV_REF(avltree_impl) x)
 : data_(::boost::move(x.priv_comp()), ::boost::move(x.priv_value_traits()))
 {
- node_algorithms::init_header(this->priv_header_ptr());
+ node_algorithms::init_header(this->priv_header_ptr());
 this->priv_size_traits().set_size(size_type(0));
 this->swap(x);
 }

 //! Effects: to-do
- //!
- avltree_impl& operator=(BOOST_RV_REF(avltree_impl) x)
+ //!
+ avltree_impl& operator=(BOOST_RV_REF(avltree_impl) x)
 { this->swap(x); return *this; }

- //! Effects: Detaches all elements from this. The objects in the set
- //! are not deleted (i.e. no destructors are called), but the nodes according to
- //! the value_traits template parameter are reinitialized and thus can be reused.
- //!
+ //! Effects: Detaches all elements from this. The objects in the set
+ //! are not deleted (i.e. no destructors are called), but the nodes according to
+ //! the value_traits template parameter are reinitialized and thus can be reused.
+ //!
 //! Complexity: Linear to elements contained in *this.
- //!
+ //!
 //! Throws: Nothing.
- ~avltree_impl()
+ ~avltree_impl()
 {}

 //! Effects: Returns an iterator pointing to the beginning of the tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator begin()
 { return iterator (node_traits::get_left(this->priv_header_ptr()), this); }

 //! Effects: Returns a const_iterator pointing to the beginning of the tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator begin() const
 { return cbegin(); }

 //! Effects: Returns a const_iterator pointing to the beginning of the tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator cbegin() const
 { return const_iterator (node_traits::get_left(this->priv_header_ptr()), this); }

 //! Effects: Returns an iterator pointing to the end of the tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator end()
 { return iterator (this->priv_header_ptr(), this); }
@@ -313,138 +313,138 @@
 //! Effects: Returns a const_iterator pointing to the end of the tree.
 //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator end() const
 { return cend(); }

 //! Effects: Returns a const_iterator pointing to the end of the tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator cend() const
 { return const_iterator (uncast(this->priv_header_ptr()), this); }

 //! Effects: Returns a reverse_iterator pointing to the beginning of the
 //! reversed tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 reverse_iterator rbegin()
 { return reverse_iterator(end()); }

 //! Effects: Returns a const_reverse_iterator pointing to the beginning
 //! of the reversed tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator rbegin() const
 { return const_reverse_iterator(end()); }

 //! Effects: Returns a const_reverse_iterator pointing to the beginning
 //! of the reversed tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator crbegin() const
 { return const_reverse_iterator(end()); }

 //! Effects: Returns a reverse_iterator pointing to the end
 //! of the reversed tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 reverse_iterator rend()
 { return reverse_iterator(begin()); }

 //! Effects: Returns a const_reverse_iterator pointing to the end
 //! of the reversed tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator rend() const
 { return const_reverse_iterator(begin()); }

 //! Effects: Returns a const_reverse_iterator pointing to the end
 //! of the reversed tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator crend() const
 { return const_reverse_iterator(begin()); }

 //! Precondition: end_iterator must be a valid end iterator
 //! of avltree.
- //!
+ //!
 //! Effects: Returns a const reference to the avltree associated to the end iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 static avltree_impl &container_from_end_iterator(iterator end_iterator)
 { return priv_container_from_end_iterator(end_iterator); }

 //! Precondition: end_iterator must be a valid end const_iterator
 //! of avltree.
- //!
+ //!
 //! Effects: Returns a const reference to the avltree associated to the end iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 static const avltree_impl &container_from_end_iterator(const_iterator end_iterator)
 { return priv_container_from_end_iterator(end_iterator); }

 //! Precondition: it must be a valid iterator
 //! of rbtree.
- //!
+ //!
 //! Effects: Returns a const reference to the tree associated to the iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Logarithmic.
 static avltree_impl &container_from_iterator(iterator it)
 { return priv_container_from_iterator(it); }

 //! Precondition: it must be a valid end const_iterator
 //! of rbtree.
- //!
+ //!
 //! Effects: Returns a const reference to the tree associated to the iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Logarithmic.
 static const avltree_impl &container_from_iterator(const_iterator it)
 { return priv_container_from_iterator(it); }

 //! Effects: Returns the value_compare object used by the tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If value_compare copy-constructor throws.
 value_compare value_comp() const
 { return priv_comp(); }

 //! Effects: Returns true if the container is empty.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 bool empty() const
 { return node_algorithms::unique(this->priv_header_ptr()); }

 //! Effects: Returns the number of elements stored in the tree.
- //!
+ //!
 //! Complexity: Linear to elements contained in *this
 //! if constant-time size option is disabled. Constant time otherwise.
- //!
+ //!
 //! Throws: Nothing.
 size_type size() const
 {
@@ -456,9 +456,9 @@
 }

 //! Effects: Swaps the contents of two avltrees.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If the comparison functor's swap call throws.
 void swap(avltree_impl& other)
 {
@@ -475,14 +475,14 @@
 }

 //! Requires: value must be an lvalue
- //!
+ //!
 //! Effects: Inserts value into the tree before the upper bound.
- //!
+ //!
 //! Complexity: Average complexity for insert element is at
 //! most logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Strong guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 iterator insert_equal(reference value)
@@ -500,16 +500,16 @@

 //! Requires: value must be an lvalue, and "hint" must be
 //! a valid iterator.
- //!
+ //!
 //! Effects: Inserts x into the tree, using "hint" as a hint to
 //! where it will be inserted. If "hint" is the upper_bound
 //! the insertion takes constant time (two comparisons in the worst case)
- //!
+ //!
 //! Complexity: Logarithmic in general, but it is amortized
 //! constant time if t is inserted immediately before hint.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Strong guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 iterator insert_equal(const_iterator hint, reference value)
@@ -525,18 +525,18 @@
 return ret;
 }

- //! Requires: Dereferencing iterator must yield an lvalue
+ //! Requires: Dereferencing iterator must yield an lvalue
 //! of type value_type.
- //!
+ //!
 //! Effects: Inserts a each element of a range into the tree
 //! before the upper bound of the key of each element.
- //!
+ //!
 //! Complexity: Insert range is in general O(N * log(N)), where N is the
 //! size of the range. However, it is linear in N if the range is already sorted
 //! by value_comp().
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 template<class Iterator>
@@ -548,15 +548,15 @@
 }

 //! Requires: value must be an lvalue
- //!
+ //!
 //! Effects: Inserts value into the tree if the value
 //! is not already present.
- //!
+ //!
 //! Complexity: Average complexity for insert element is at
 //! most logarithmic.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 std::pair<iterator, bool> insert_unique(reference value)
@@ -570,16 +570,16 @@

 //! Requires: value must be an lvalue, and "hint" must be
 //! a valid iterator
- //!
+ //!
 //! Effects: Tries to insert x into the tree, using "hint" as a hint
 //! to where it will be inserted.
- //!
+ //!
 //! Complexity: Logarithmic in general, but it is amortized
 //! constant time (two comparisons in the worst case)
 //! if t is inserted immediately before hint.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 iterator insert_unique(const_iterator hint, reference value)
@@ -591,17 +591,17 @@
 return insert_unique_commit(value, commit_data);
 }

- //! Requires: Dereferencing iterator must yield an lvalue
+ //! Requires: Dereferencing iterator must yield an lvalue
 //! of type value_type.
- //!
+ //!
 //! Effects: Tries to insert each element of a range into the tree.
- //!
- //! Complexity: Insert range is in general O(N * log(N)), where N is the
- //! size of the range. However, it is linear in N if the range is already sorted
+ //!
+ //! Complexity: Insert range is in general O(N * log(N)), where N is the
+ //! size of the range. However, it is linear in N if the range is already sorted
 //! by value_comp().
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 template<class Iterator>
@@ -618,10 +618,10 @@
 }
 }

- //! Requires: key_value_comp must be a comparison function that induces
+ //! Requires: key_value_comp must be a comparison function that induces
 //! the same strict weak ordering as value_compare. The difference is that
 //! key_value_comp compares an arbitrary key with the contained values.
- //!
+ //!
 //! Effects: Checks if a value can be inserted in the container, using
 //! a user provided key instead of the value itself.
 //!
@@ -630,16 +630,16 @@
 //! and false. If the value can be inserted returns true in the returned
 //! pair boolean and fills "commit_data" that is meant to be used with
 //! the "insert_commit" function.
- //!
+ //!
 //! Complexity: Average complexity is at most logarithmic.
 //!
 //! Throws: If the key_value_comp ordering function throws. Strong guarantee.
- //!
+ //!
 //! Notes: This function is used to improve performance when constructing
 //! a value_type is expensive: if there is an equivalent value
 //! the constructed object must be discarded. Many times, the part of the
 //! node that is used to impose the order is much cheaper to construct
- //! than the value_type and this function offers the possibility to use that
+ //! than the value_type and this function offers the possibility to use that
 //! part to check if the insertion will be successful.
 //!
 //! If the check is successful, the user can construct the value_type and use
@@ -654,18 +654,18 @@
 {
 detail::key_nodeptr_comp<KeyValueCompare, avltree_impl>
 comp(key_value_comp, this);
- std::pair<node_ptr, bool> ret =
+ std::pair<node_ptr, bool> ret =
 (node_algorithms::insert_unique_check
 (this->priv_header_ptr(), key, comp, commit_data));
 return std::pair<iterator, bool>(iterator(ret.first, this), ret.second);
 }

- //! Requires: key_value_comp must be a comparison function that induces
+ //! Requires: key_value_comp must be a comparison function that induces
 //! the same strict weak ordering as value_compare. The difference is that
 //! key_value_comp compares an arbitrary key with the contained values.
- //!
+ //!
 //! Effects: Checks if a value can be inserted in the container, using
- //! a user provided key instead of the value itself, using "hint"
+ //! a user provided key instead of the value itself, using "hint"
 //! as a hint to where it will be inserted.
 //!
 //! Returns: If there is an equivalent value
@@ -673,23 +673,23 @@
 //! and false. If the value can be inserted returns true in the returned
 //! pair boolean and fills "commit_data" that is meant to be used with
 //! the "insert_commit" function.
- //!
+ //!
 //! Complexity: Logarithmic in general, but it's amortized
 //! constant time if t is inserted immediately before hint.
 //!
 //! Throws: If the key_value_comp ordering function throws. Strong guarantee.
- //!
+ //!
 //! Notes: This function is used to improve performance when constructing
 //! a value_type is expensive: if there is an equivalent value
 //! the constructed object must be discarded. Many times, the part of the
 //! constructing that is used to impose the order is much cheaper to construct
- //! than the value_type and this function offers the possibility to use that key
+ //! than the value_type and this function offers the possibility to use that key
 //! to check if the insertion will be successful.
 //!
 //! If the check is successful, the user can construct the value_type and use
 //! "insert_commit" to insert the object in constant-time. This can give a total
 //! constant-time complexity to the insertion: check(O(1)) + commit(O(1)).
- //!
+ //!
 //! "commit_data" remains valid for a subsequent "insert_commit" only if no more
 //! objects are inserted or erased from the container.
 template<class KeyType, class KeyValueCompare>
@@ -699,7 +699,7 @@
 {
 detail::key_nodeptr_comp<KeyValueCompare, avltree_impl>
 comp(key_value_comp, this);
- std::pair<node_ptr, bool> ret =
+ std::pair<node_ptr, bool> ret =
 (node_algorithms::insert_unique_check
 (this->priv_header_ptr(), hint.pointed_node(), key, comp, commit_data));
 return std::pair<iterator, bool>(iterator(ret.first, this), ret.second);
@@ -709,16 +709,16 @@
 //! must have been obtained from a previous call to "insert_check".
 //! No objects should have been inserted or erased from the container between
 //! the "insert_check" that filled "commit_data" and the call to "insert_commit".
- //!
+ //!
 //! Effects: Inserts the value in the avl_set using the information obtained
 //! from the "commit_data" that a previous "insert_check" filled.
 //!
 //! Returns: An iterator to the newly inserted object.
- //!
+ //!
 //! Complexity: Constant time.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Notes: This function has only sense if a "insert_check" has been
 //! previously executed to fill "commit_data". No value should be inserted or
 //! erased between the "insert_check" and "insert_commit" calls.
@@ -738,11 +738,11 @@
 //! once inserted according to the predicate
 //!
 //! Effects: Inserts x into the tree before "pos".
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function does not check preconditions so if "pos" is not
 //! the successor of "value" tree ordering invariant will be broken.
 //! This is a low-level function to be used only for performance reasons
@@ -762,11 +762,11 @@
 //! than the greatest inserted key
 //!
 //! Effects: Inserts x into the tree in the last position.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function does not check preconditions so if value is
 //! less than the greatest inserted key tree ordering invariant will be broken.
 //! This function is slightly more efficient than using "insert_before".
@@ -785,11 +785,11 @@
 //! than the minimum inserted key
 //!
 //! Effects: Inserts x into the tree in the first position.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function does not check preconditions so if value is
 //! greater than the minimum inserted key tree ordering invariant will be broken.
 //! This function is slightly more efficient than using "insert_before".
@@ -804,12 +804,12 @@
 this->priv_size_traits().increment();
 }

- //! Effects: Erases the element pointed to by pos.
- //!
- //! Complexity: Average complexity for erase element is constant time.
- //!
+ //! Effects: Erases the element pointed to by pos.
+ //!
+ //! Complexity: Average complexity for erase element is constant time.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 iterator erase(const_iterator i)
@@ -826,26 +826,26 @@
 return ret.unconst();
 }

- //! Effects: Erases the range pointed to by b end e.
- //!
- //! Complexity: Average complexity for erase range is at most
+ //! Effects: Erases the range pointed to by b end e.
+ //!
+ //! Complexity: Average complexity for erase range is at most
 //! O(log(size() + N)), where N is the number of elements in the range.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 iterator erase(const_iterator b, const_iterator e)
 { size_type n; return private_erase(b, e, n); }

 //! Effects: Erases all the elements with the given value.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size() + N).
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 size_type erase(const_reference value)
@@ -855,11 +855,11 @@
 //! according to the comparison functor "comp".
 //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size() + N).
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class KeyType, class KeyValueCompare>
@@ -877,14 +877,14 @@

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
 //!
- //! Effects: Erases the element pointed to by pos.
+ //! Effects: Erases the element pointed to by pos.
 //! Disposer::operator()(pointer) is called for the removed element.
- //!
- //! Complexity: Average complexity for erase element is constant time.
- //!
+ //!
+ //! Complexity: Average complexity for erase element is constant time.
+ //!
 //! Throws: Nothing.
- //!
- //! Note: Invalidates the iterators
+ //!
+ //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
 iterator erase_and_dispose(const_iterator i, Disposer disposer)
@@ -905,12 +905,12 @@
 //!
 //! Effects: Erases the range pointed to by b end e.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
- //! Complexity: Average complexity for erase range is at most
+ //!
+ //! Complexity: Average complexity for erase range is at most
 //! O(log(size() + N)), where N is the number of elements in the range.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
@@ -921,13 +921,13 @@
 //!
 //! Effects: Erases all the elements with the given value.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size() + N).
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class Disposer>
@@ -946,11 +946,11 @@
 //! Disposer::operator()(pointer) is called for the removed elements.
 //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size() + N).
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class KeyType, class KeyValueCompare, class Disposer>
@@ -966,13 +966,13 @@
 return n;
 }

- //! Effects: Erases all of the elements.
- //!
+ //! Effects: Erases all of the elements.
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 void clear()
@@ -990,9 +990,9 @@
 //! each node to be erased.
 //! Complexity: Average complexity for is at most O(log(size() + N)),
 //! where N is the number of elements in the container.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. Calls N times to disposer functor.
 template<class Disposer>
@@ -1005,19 +1005,19 @@
 }

 //! Effects: Returns the number of contained elements with the given value
- //!
+ //!
 //! Complexity: Logarithmic to the number of elements contained plus lineal
 //! to number of objects with the given value.
- //!
+ //!
 //! Throws: Nothing.
 size_type count(const_reference value) const
 { return this->count(value, priv_comp()); }

 //! Effects: Returns the number of contained elements with the given key
- //!
+ //!
 //! Complexity: Logarithmic to the number of elements contained plus lineal
 //! to number of objects with the given key.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 size_type count(const KeyType &key, KeyValueCompare comp) const
@@ -1028,27 +1028,27 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is not less than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 iterator lower_bound(const_reference value)
 { return this->lower_bound(value, priv_comp()); }

 //! Effects: Returns an iterator to the first element whose
 //! key is not less than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator lower_bound(const_reference value) const
 { return this->lower_bound(value, priv_comp()); }

 //! Effects: Returns an iterator to the first element whose
 //! key is not less than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 iterator lower_bound(const KeyType &key, KeyValueCompare comp)
@@ -1061,9 +1061,9 @@

 //! Effects: Returns a const iterator to the first element whose
 //! key is not less than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 const_iterator lower_bound(const KeyType &key, KeyValueCompare comp) const
@@ -1076,9 +1076,9 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is greater than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 iterator upper_bound(const_reference value)
 { return this->upper_bound(value, priv_comp()); }
@@ -1088,7 +1088,7 @@
 //! does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 iterator upper_bound(const KeyType &key, KeyValueCompare comp)
@@ -1101,9 +1101,9 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is greater than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator upper_bound(const_reference value) const
 { return this->upper_bound(value, priv_comp()); }
@@ -1113,7 +1113,7 @@
 //! does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 const_iterator upper_bound(const KeyType &key, KeyValueCompare comp) const
@@ -1124,20 +1124,20 @@
 (this->priv_header_ptr(), key, key_node_comp), this);
 }

- //! Effects: Finds an iterator to the first element whose key is
+ //! Effects: Finds an iterator to the first element whose key is
 //! k or end() if that element does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 iterator find(const_reference value)
 { return this->find(value, priv_comp()); }

- //! Effects: Finds an iterator to the first element whose key is
+ //! Effects: Finds an iterator to the first element whose key is
 //! k or end() if that element does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 iterator find(const KeyType &key, KeyValueCompare comp)
@@ -1148,20 +1148,20 @@
 (node_algorithms::find(this->priv_header_ptr(), key, key_node_comp), this);
 }

- //! Effects: Finds a const_iterator to the first element whose key is
+ //! Effects: Finds a const_iterator to the first element whose key is
 //! k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator find(const_reference value) const
 { return this->find(value, priv_comp()); }

- //! Effects: Finds a const_iterator to the first element whose key is
+ //! Effects: Finds a const_iterator to the first element whose key is
 //! k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 const_iterator find(const KeyType &key, KeyValueCompare comp) const
@@ -1175,9 +1175,9 @@
 //! Effects: Finds a range containing all elements whose key is k or
 //! an empty range that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 std::pair<iterator,iterator> equal_range(const_reference value)
 { return this->equal_range(value, priv_comp()); }
@@ -1185,9 +1185,9 @@
 //! Effects: Finds a range containing all elements whose key is k or
 //! an empty range that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 std::pair<iterator,iterator> equal_range(const KeyType &key, KeyValueCompare comp)
@@ -1202,9 +1202,9 @@
 //! Effects: Finds a range containing all elements whose key is k or
 //! an empty range that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 std::pair<const_iterator, const_iterator>
 equal_range(const_reference value) const
@@ -1213,9 +1213,9 @@
 //! Effects: Finds a range containing all elements whose key is k or
 //! an empty range that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 std::pair<const_iterator, const_iterator>
@@ -1232,15 +1232,15 @@
 //! Cloner should yield to nodes equivalent to the original nodes.
 //!
 //! Effects: Erases all the elements from *this
- //! calling Disposer::operator()(pointer), clones all the
+ //! calling Disposer::operator()(pointer), clones all the
 //! elements from src calling Cloner::operator()(const_reference )
 //! and inserts them on *this. Copies the predicate from the source container.
 //!
 //! If cloner throws, all cloned elements are unlinked and disposed
 //! calling Disposer::operator()(pointer).
- //!
+ //!
 //! Complexity: Linear to erased plus inserted elements.
- //!
+ //!
 //! Throws: If cloner throws or predicate copy assignment throws. Basic guarantee.
 template <class Cloner, class Disposer>
 void clone_from(const avltree_impl &src, Cloner cloner, Disposer disposer)
@@ -1261,11 +1261,11 @@
 }

 //! Effects: Unlinks the leftmost node from the tree.
- //!
+ //!
 //! Complexity: Average complexity is constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Notes: This function breaks the tree and the tree can
 //! only be used for more unlink_leftmost_without_rebalance calls.
 //! This function is normally used to achieve a step by step
@@ -1284,14 +1284,14 @@

 //! Requires: replace_this must be a valid iterator of *this
 //! and with_this must not be inserted in any tree.
- //!
+ //!
 //! Effects: Replaces replace_this in its position in the
 //! tree with with_this. The tree does not need to be rebalanced.
- //!
- //! Complexity: Constant.
- //!
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function will break container ordering invariants if
 //! with_this is not equivalent to *replace_this according to the
 //! ordering rules. This function is faster than erasing and inserting
@@ -1307,14 +1307,14 @@

 //! Requires: value must be an lvalue and shall be in a set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid iterator i belonging to the set
 //! that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This static function is available only if the value traits
 //! is stateless.
 static iterator s_iterator_to(reference value)
@@ -1325,17 +1325,17 @@

 //! Requires: value must be an lvalue and shall be in a set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid const_iterator i belonging to the
 //! set that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This static function is available only if the value traits
 //! is stateless.
- static const_iterator s_iterator_to(const_reference value)
+ static const_iterator s_iterator_to(const_reference value)
 {
 BOOST_STATIC_ASSERT((!stateful_value_traits));
 return const_iterator (value_traits::to_node_ptr(const_cast<reference> (value)), 0);
@@ -1343,37 +1343,37 @@

 //! Requires: value must be an lvalue and shall be in a set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid iterator i belonging to the set
 //! that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator iterator_to(reference value)
 { return iterator (value_traits::to_node_ptr(value), this); }

 //! Requires: value must be an lvalue and shall be in a set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid const_iterator i belonging to the
 //! set that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator iterator_to(const_reference value) const
 { return const_iterator (value_traits::to_node_ptr(const_cast<reference> (value)), this); }

 //! Requires: value shall not be in a tree.
- //!
+ //!
 //! Effects: init_node puts the hook of a value in a well-known default
 //! state.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Note: This function puts the hook in the well-known default state
 //! used by auto_unlink and safe hooks.
 static void init_node(reference value)
@@ -1381,12 +1381,12 @@

/*
 //! Effects: removes x from a tree of the appropriate type. It has no effect,
- //! if x is not in such a tree.
- //!
+ //! if x is not in such a tree.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Note: This static function is only usable with the "safe mode"
 //! hook and non-constant time size lists. Otherwise, the user must use
 //! the non-static "erase(reference )" member. If the user calls
@@ -1396,7 +1396,7 @@
 static void remove_node(T& value)
 {
 //This function is only usable for safe mode hooks and non-constant
- //time lists.
+ //time lists.
 //BOOST_STATIC_ASSERT((!(safemode_or_autounlink && constant_time_size)));
 BOOST_STATIC_ASSERT((!constant_time_size));
 BOOST_STATIC_ASSERT((boost::is_convertible<T, value_type>::value));
@@ -1680,8 +1680,8 @@
#endif

-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Modified: branches/release/boost/intrusive/avltree_algorithms.hpp
==============================================================================
--- branches/release/boost/intrusive/avltree_algorithms.hpp (original)
+++ branches/release/boost/intrusive/avltree_algorithms.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -45,25 +45,25 @@
//! Static functions:
//!
//! <tt>static node_ptr get_parent(const_node_ptr n);</tt>
-//!
+//!
//! <tt>static void set_parent(node_ptr n, node_ptr parent);</tt>
//!
//! <tt>static node_ptr get_left(const_node_ptr n);</tt>
-//!
+//!
//! <tt>static void set_left(node_ptr n, node_ptr left);</tt>
//!
//! <tt>static node_ptr get_right(const_node_ptr n);</tt>
-//!
+//!
//! <tt>static void set_right(node_ptr n, node_ptr right);</tt>
-//!
+//!
//! <tt>static balance get_balance(const_node_ptr n);</tt>
-//!
+//!
//! <tt>static void set_balance(node_ptr n, balance b);</tt>
-//!
+//!
//! <tt>static balance negative();</tt>
-//!
+//!
//! <tt>static balance zero();</tt>
-//!
+//!
//! <tt>static balance positive();</tt>
template<class NodeTraits>
class avltree_algorithms
@@ -88,7 +88,7 @@
 avltree_node_cloner(F f)
 : base_t(f)
 {}
-
+
 node_ptr operator()(const node_ptr &p)
 {
 node_ptr n = base_t::get()(p);
@@ -120,27 +120,27 @@

 //! Requires: header1 and header2 must be the header nodes
 //! of two trees.
- //!
- //! Effects: Swaps two trees. After the function header1 will contain
+ //!
+ //! Effects: Swaps two trees. After the function header1 will contain
 //! links to the second tree and header2 will have links to the first tree.
- //!
- //! Complexity: Constant.
- //!
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: Nothing.
 static void swap_tree(const node_ptr & header1, const node_ptr & header2)
 { return tree_algorithms::swap_tree(header1, header2); }

 //! Requires: node1 and node2 can't be header nodes
 //! of two trees.
- //!
+ //!
 //! Effects: Swaps two nodes. After the function node1 will be inserted
 //! in the position node2 before the function. node2 will be inserted in the
 //! position node1 had before the function.
- //!
- //! Complexity: Logarithmic.
- //!
+ //!
+ //! Complexity: Logarithmic.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function will break container ordering invariants if
 //! node1 and node2 are not equivalent according to the ordering rules.
 //!
@@ -149,22 +149,22 @@
 {
 if(node1 == node2)
 return;
-
+
 node_ptr header1(tree_algorithms::get_header(node1)), header2(tree_algorithms::get_header(node2));
 swap_nodes(node1, header1, node2, header2);
 }

 //! Requires: node1 and node2 can't be header nodes
 //! of two trees with header header1 and header2.
- //!
+ //!
 //! Effects: Swaps two nodes. After the function node1 will be inserted
 //! in the position node2 before the function. node2 will be inserted in the
 //! position node1 had before the function.
- //!
- //! Complexity: Constant.
- //!
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function will break container ordering invariants if
 //! node1 and node2 are not equivalent according to the ordering rules.
 //!
@@ -176,20 +176,20 @@
 tree_algorithms::swap_nodes(node1, header1, node2, header2);
 //Swap balance
 balance c = NodeTraits::get_balance(node1);
- NodeTraits::set_balance(node1, NodeTraits::get_balance(node2));
- NodeTraits::set_balance(node2, c);
+ NodeTraits::set_balance(node1, NodeTraits::get_balance(node2));
+ NodeTraits::set_balance(node2, c);
 }

 //! Requires: node_to_be_replaced must be inserted in a tree
 //! and new_node must not be inserted in a tree.
- //!
+ //!
 //! Effects: Replaces node_to_be_replaced in its position in the
 //! tree with new_node. The tree does not need to be rebalanced
- //!
- //! Complexity: Logarithmic.
- //!
+ //!
+ //! Complexity: Logarithmic.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function will break container ordering invariants if
 //! new_node is not equivalent to node_to_be_replaced according to the
 //! ordering rules. This function is faster than erasing and inserting
@@ -205,14 +205,14 @@

 //! Requires: node_to_be_replaced must be inserted in a tree
 //! with header "header" and new_node must not be inserted in a tree.
- //!
+ //!
 //! Effects: Replaces node_to_be_replaced in its position in the
 //! tree with new_node. The tree does not need to be rebalanced
- //!
- //! Complexity: Constant.
- //!
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function will break container ordering invariants if
 //! new_node is not equivalent to node_to_be_replaced according to the
 //! ordering rules. This function is faster than erasing and inserting
@@ -222,15 +222,15 @@
 static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & header, const node_ptr & new_node)
 {
 tree_algorithms::replace_node(node_to_be_replaced, header, new_node);
- NodeTraits::set_balance(new_node, NodeTraits::get_balance(node_to_be_replaced));
+ NodeTraits::set_balance(new_node, NodeTraits::get_balance(node_to_be_replaced));
 }

 //! Requires: node is a tree node but not the header.
- //!
+ //!
 //! Effects: Unlinks the node and rebalances the tree.
- //!
+ //!
 //! Complexity: Average complexity is constant time.
- //!
+ //!
 //! Throws: Nothing.
 static void unlink(const node_ptr & node)
 {
@@ -243,14 +243,14 @@
 }

 //! Requires: header is the header of a tree.
- //!
+ //!
 //! Effects: Unlinks the leftmost node from the tree, and
 //! updates the header link to the new leftmost node.
- //!
+ //!
 //! Complexity: Average complexity is constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Notes: This function breaks the tree and the tree can
 //! only be used for more unlink_leftmost_without_rebalance calls.
 //! This function is normally used to achieve a step by step
@@ -260,51 +260,51 @@

 //! Requires: node is a node of the tree or an node initialized
 //! by init(...).
- //!
+ //!
 //! Effects: Returns true if the node is initialized by init().
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: Nothing.
 static bool unique(const const_node_ptr & node)
 { return tree_algorithms::unique(node); }

 //! Requires: node is a node of the tree but it's not the header.
- //!
+ //!
 //! Effects: Returns the number of nodes of the subtree.
- //!
+ //!
 //! Complexity: Linear time.
- //!
+ //!
 //! Throws: Nothing.
 static std::size_t count(const const_node_ptr & node)
 { return tree_algorithms::count(node); }

 //! Requires: header is the header node of the tree.
- //!
+ //!
 //! Effects: Returns the number of nodes above the header.
- //!
+ //!
 //! Complexity: Linear time.
- //!
+ //!
 //! Throws: Nothing.
 static std::size_t size(const const_node_ptr & header)
 { return tree_algorithms::size(header); }

 //! Requires: p is a node from the tree except the header.
- //!
+ //!
 //! Effects: Returns the next node of the tree.
- //!
+ //!
 //! Complexity: Average constant time.
- //!
+ //!
 //! Throws: Nothing.
 static node_ptr next_node(const node_ptr & p)
 { return tree_algorithms::next_node(p); }

 //! Requires: p is a node from the tree except the leftmost node.
- //!
+ //!
 //! Effects: Returns the previous node of the tree.
- //!
+ //!
 //! Complexity: Average constant time.
- //!
+ //!
 //! Throws: Nothing.
 static node_ptr prev_node(const node_ptr & p)
 { return tree_algorithms::prev_node(p); }
@@ -312,9 +312,9 @@
 //! Requires: node must not be part of any tree.
 //!
 //! Effects: After the function unique(node) == true.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 //!
 //! Nodes: If node is inserted in a tree, this function corrupts the tree.
@@ -325,25 +325,25 @@
 //!
 //! Effects: Initializes the header to represent an empty tree.
 //! unique(header) == true.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 //!
 //! Nodes: If node is inserted in a tree, this function corrupts the tree.
 static void init_header(const node_ptr & header)
 {
 tree_algorithms::init_header(header);
- NodeTraits::set_balance(header, NodeTraits::zero());
+ NodeTraits::set_balance(header, NodeTraits::zero());
 }

 //! Requires: header must be the header of a tree, z a node
 //! of that tree and z != header.
 //!
 //! Effects: Erases node "z" from the tree with header "header".
- //!
+ //!
 //! Complexity: Amortized constant time.
- //!
+ //!
 //! Throws: Nothing.
 static node_ptr erase(const node_ptr & header, const node_ptr & z)
 {
@@ -361,18 +361,18 @@
 //! object taking a node_ptr and returning a new cloned node of it. "disposer" must
 //! take a node_ptr and shouldn't throw.
 //!
- //! Effects: First empties target tree calling
+ //! Effects: First empties target tree calling
 //! <tt>void disposer::operator()(const node_ptr &)</tt> for every node of the tree
 //! except the header.
- //!
+ //!
 //! Then, duplicates the entire tree pointed by "source_header" cloning each
- //! source node with <tt>node_ptr Cloner::operator()(const node_ptr &)</tt> to obtain
+ //! source node with <tt>node_ptr Cloner::operator()(const node_ptr &)</tt> to obtain
 //! the nodes of the target tree. If "cloner" throws, the cloned target nodes
 //! are disposed using <tt>void disposer(const node_ptr &)</tt>.
- //!
+ //!
 //! Complexity: Linear to the number of element of the source tree plus the.
 //! number of elements of tree target tree when calling this function.
- //!
+ //!
 //! Throws: If cloner functor throws. If this happens target nodes are disposed.
 template <class Cloner, class Disposer>
 static void clone
@@ -385,13 +385,13 @@
 //! Requires: "disposer" must be an object function
 //! taking a node_ptr parameter and shouldn't throw.
 //!
- //! Effects: Empties the target tree calling
+ //! Effects: Empties the target tree calling
 //! <tt>void disposer::operator()(const node_ptr &)</tt> for every node of the tree
 //! except the header.
- //!
+ //!
 //! Complexity: Linear to the number of element of the source tree plus the.
 //! number of elements of tree target tree when calling this function.
- //!
+ //!
 //! Throws: If cloner functor throws. If this happens target nodes are disposed.
 template<class Disposer>
 static void clear_and_dispose(const node_ptr & header, Disposer disposer)
@@ -407,7 +407,7 @@
 //! not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static node_ptr lower_bound
@@ -423,7 +423,7 @@
 //! than "key" according to "comp" or "header" if that element does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static node_ptr upper_bound
@@ -439,7 +439,7 @@
 //! "key" according to "comp" or "header" if that element does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static node_ptr find
@@ -457,7 +457,7 @@
 //! if they there are no equivalent elements.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static std::pair<node_ptr, node_ptr> equal_range
@@ -471,10 +471,10 @@
 //!
 //! Effects: Inserts new_node into the tree before the upper bound
 //! according to "comp".
- //!
+ //!
 //! Complexity: Average complexity for insert element is at
 //! most logarithmic.
- //!
+ //!
 //! Throws: If "comp" throws.
 template<class NodePtrCompare>
 static node_ptr insert_equal_upper_bound
@@ -492,10 +492,10 @@
 //!
 //! Effects: Inserts new_node into the tree before the lower bound
 //! according to "comp".
- //!
+ //!
 //! Complexity: Average complexity for insert element is at
 //! most logarithmic.
- //!
+ //!
 //! Throws: If "comp" throws.
 template<class NodePtrCompare>
 static node_ptr insert_equal_lower_bound
@@ -511,14 +511,14 @@
 //! ordering compatible with the strict weak ordering used to create the
 //! the tree. NodePtrCompare compares two node_ptrs. "hint" is node from
 //! the "header"'s tree.
- //!
+ //!
 //! Effects: Inserts new_node into the tree, using "hint" as a hint to
 //! where it will be inserted. If "hint" is the upper_bound
 //! the insertion takes constant time (two comparisons in the worst case).
 //!
 //! Complexity: Logarithmic in general, but it is amortized
 //! constant time if new_node is inserted immediately before "hint".
- //!
+ //!
 //! Throws: If "comp" throws.
 template<class NodePtrCompare>
 static node_ptr insert_equal
@@ -534,13 +534,13 @@
 //! "pos" must be an iterator pointing to the successor to "new_node"
 //! once inserted according to the order of already inserted nodes. This function does not
 //! check "pos" and this precondition must be guaranteed by the caller.
- //!
+ //!
 //! Effects: Inserts new_node into the tree before "pos".
 //!
 //! Complexity: Constant-time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: If "pos" is not the successor of the newly inserted "new_node"
 //! tree invariants might be broken.
 static node_ptr insert_before
@@ -554,13 +554,13 @@
 //! Requires: "header" must be the header node of a tree.
 //! "new_node" must be, according to the used ordering no less than the
 //! greatest inserted key.
- //!
+ //!
 //! Effects: Inserts new_node into the tree before "pos".
 //!
 //! Complexity: Constant-time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: If "new_node" is less than the greatest inserted key
 //! tree invariants are broken. This function is slightly faster than
 //! using "insert_before".
@@ -573,13 +573,13 @@
 //! Requires: "header" must be the header node of a tree.
 //! "new_node" must be, according to the used ordering, no greater than the
 //! lowest inserted key.
- //!
+ //!
 //! Effects: Inserts new_node into the tree before "pos".
 //!
 //! Complexity: Constant-time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: If "new_node" is greater than the lowest inserted key
 //! tree invariants are broken. This function is slightly faster than
 //! using "insert_before".
@@ -593,7 +593,7 @@
 //! KeyNodePtrCompare is a function object that induces a strict weak
 //! ordering compatible with the strict weak ordering used to create the
 //! the tree. NodePtrCompare compares KeyType with a node_ptr.
- //!
+ //!
 //! Effects: Checks if there is an equivalent node to "key" in the
 //! tree according to "comp" and obtains the needed information to realize
 //! a constant-time node insertion if there is no equivalent node.
@@ -604,11 +604,11 @@
 //! in the returned pair's boolean and fills "commit_data" that is meant to
 //! be used with the "insert_commit" function to achieve a constant-time
 //! insertion function.
- //!
+ //!
 //! Complexity: Average complexity is at most logarithmic.
 //!
 //! Throws: If "comp" throws.
- //!
+ //!
 //! Notes: This function is used to improve performance when constructing
 //! a node is expensive and the user does not want to have two equivalent nodes
 //! in the tree: if there is an equivalent value
@@ -634,12 +634,12 @@
 //! ordering compatible with the strict weak ordering used to create the
 //! the tree. NodePtrCompare compares KeyType with a node_ptr.
 //! "hint" is node from the "header"'s tree.
- //!
+ //!
 //! Effects: Checks if there is an equivalent node to "key" in the
 //! tree according to "comp" using "hint" as a hint to where it should be
 //! inserted and obtains the needed information to realize
- //! a constant-time node insertion if there is no equivalent node.
- //! If "hint" is the upper_bound the function has constant time
+ //! a constant-time node insertion if there is no equivalent node.
+ //! If "hint" is the upper_bound the function has constant time
 //! complexity (two comparisons in the worst case).
 //!
 //! Returns: If there is an equivalent value
@@ -648,12 +648,12 @@
 //! in the returned pair's boolean and fills "commit_data" that is meant to
 //! be used with the "insert_commit" function to achieve a constant-time
 //! insertion function.
- //!
+ //!
 //! Complexity: Average complexity is at most logarithmic, but it is
 //! amortized constant time if new_node should be inserted immediately before "hint".
 //!
 //! Throws: If "comp" throws.
- //!
+ //!
 //! Notes: This function is used to improve performance when constructing
 //! a node is expensive and the user does not want to have two equivalent nodes
 //! in the tree: if there is an equivalent value
@@ -678,16 +678,16 @@
 //! "commit_data" must have been obtained from a previous call to
 //! "insert_unique_check". No objects should have been inserted or erased
 //! from the set between the "insert_unique_check" that filled "commit_data"
- //! and the call to "insert_commit".
- //!
- //!
+ //! and the call to "insert_commit".
+ //!
+ //!
 //! Effects: Inserts new_node in the set using the information obtained
 //! from the "commit_data" that a previous "insert_check" filled.
 //!
 //! Complexity: Constant time.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Notes: This function has only sense if a "insert_unique_check" has been
 //! previously executed to fill "commit_data". No value should be inserted or
 //! erased between the "insert_check" and "insert_commit" calls.
@@ -703,7 +703,7 @@
 //! Effects: Returns a pointer to the header node of the tree.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 static node_ptr get_header(const node_ptr & n)
 { return tree_algorithms::get_header(n); }
@@ -712,11 +712,11 @@
 private:

 //! Requires: p is a node of a tree.
- //!
+ //!
 //! Effects: Returns true if p is the header of the tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 static bool is_header(const const_node_ptr & p)
 { return NodeTraits::get_balance(p) == NodeTraits::zero() && tree_algorithms::is_header(p); }
@@ -727,7 +727,7 @@
 for (node_ptr root = NodeTraits::get_parent(header); x != root; root = NodeTraits::get_parent(header)) {
 const balance x_parent_balance = NodeTraits::get_balance(x_parent);
 if(x_parent_balance == NodeTraits::zero()){
- NodeTraits::set_balance(x_parent,
+ NodeTraits::set_balance(x_parent,
 (x == NodeTraits::get_right(x_parent) ? NodeTraits::negative() : NodeTraits::positive()));
 break; // the height didn't change, let's stop here
 }
@@ -935,8 +935,8 @@
 /// @endcond
};

-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Modified: branches/release/boost/intrusive/bs_set_hook.hpp
==============================================================================
--- branches/release/boost/intrusive/bs_set_hook.hpp (original)
+++ branches/release/boost/intrusive/bs_set_hook.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -63,16 +63,16 @@
 typedef implementation_defined type;
};

-//! Derive a class from bs_set_base_hook in order to store objects in
-//! in a bs_set/bs_multiset. bs_set_base_hook holds the data necessary to maintain
+//! Derive a class from bs_set_base_hook in order to store objects in
+//! in a bs_set/bs_multiset. bs_set_base_hook holds the data necessary to maintain
//! the bs_set/bs_multiset and provides an appropriate value_traits class for bs_set/bs_multiset.
-//!
+//!
//! The hook admits the following options: \c tag<>, \c void_pointer<>,
//! \c link_mode<>.
//!
-//! \c tag<> defines a tag to identify the node.
-//! The same tag value can be used in different classes, but if a class is
-//! derived from more than one \c list_base_hook, then each \c list_base_hook needs its
+//! \c tag<> defines a tag to identify the node.
+//! The same tag value can be used in different classes, but if a class is
+//! derived from more than one \c list_base_hook, then each \c list_base_hook needs its
//! unique tag.
//!
//! \c void_pointer<> is the pointer type that will be used internally in the hook
@@ -99,27 +99,27 @@
 public:
 //! Effects: If link_mode is \c auto_unlink or \c safe_link
 //! initializes the node to an unlinked state.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 bs_set_base_hook();

 //! Effects: If link_mode is \c auto_unlink or \c safe_link
 //! initializes the node to an unlinked state. The argument is ignored.
- //!
- //! Throws: Nothing.
- //!
+ //!
+ //! Throws: Nothing.
+ //!
 //! Rationale: Providing a copy-constructor
- //! makes classes using the hook STL-compliant without forcing the
+ //! makes classes using the hook STL-compliant without forcing the
 //! user to do some additional work. \c swap can be used to emulate
 //! move-semantics.
 bs_set_base_hook(const bs_set_base_hook& );

 //! Effects: Empty function. The argument is ignored.
- //!
- //! Throws: Nothing.
- //!
- //! Rationale: Providing an assignment operator
- //! makes classes using the hook STL-compliant without forcing the
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Rationale: Providing an assignment operator
+ //! makes classes using the hook STL-compliant without forcing the
 //! user to do some additional work. \c swap can be used to emulate
 //! move-semantics.
 bs_set_base_hook& operator=(const bs_set_base_hook& );
@@ -128,37 +128,37 @@
 //! nothing (ie. no code is generated). If link_mode is \c safe_link and the
 //! object is stored in a set an assertion is raised. If link_mode is
 //! \c auto_unlink and \c is_linked() is true, the node is unlinked.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 ~bs_set_base_hook();

- //! Effects: Swapping two nodes swaps the position of the elements
- //! related to those nodes in one or two containers. That is, if the node
- //! this is part of the element e1, the node x is part of the element e2
- //! and both elements are included in the containers s1 and s2, then after
- //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1
- //! at the position of e1. If one element is not in a container, then
- //! after the swap-operation the other element is not in a container.
- //! Iterators to e1 and e2 related to those nodes are invalidated.
+ //! Effects: Swapping two nodes swaps the position of the elements
+ //! related to those nodes in one or two containers. That is, if the node
+ //! this is part of the element e1, the node x is part of the element e2
+ //! and both elements are included in the containers s1 and s2, then after
+ //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1
+ //! at the position of e1. If one element is not in a container, then
+ //! after the swap-operation the other element is not in a container.
+ //! Iterators to e1 and e2 related to those nodes are invalidated.
 //!
- //! Complexity: Constant
+ //! Complexity: Constant
 //!
- //! Throws: Nothing.
+ //! Throws: Nothing.
 void swap_nodes(bs_set_base_hook &other);

 //! Precondition: link_mode must be \c safe_link or \c auto_unlink.
 //!
 //! Returns: true, if the node belongs to a container, false
- //! otherwise. This function can be used to test whether \c set::iterator_to
- //! will return a valid iterator.
+ //! otherwise. This function can be used to test whether \c set::iterator_to
+ //! will return a valid iterator.
 //!
- //! Complexity: Constant
+ //! Complexity: Constant
 bool is_linked() const;

 //! Effects: Removes the node if it's inserted in a container.
 //! This function is only allowed if link_mode is \c auto_unlink.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 void unlink();
 #endif
};
@@ -198,7 +198,7 @@
//! Put a public data member bs_set_member_hook in order to store objects of this class in
//! a bs_set/bs_multiset. bs_set_member_hook holds the data necessary for maintaining the
//! bs_set/bs_multiset and provides an appropriate value_traits class for bs_set/bs_multiset.
-//!
+//!
//! The hook admits the following options: \c void_pointer<>, \c link_mode<>.
//!
//! \c void_pointer<> is the pointer type that will be used internally in the hook
@@ -224,27 +224,27 @@
 public:
 //! Effects: If link_mode is \c auto_unlink or \c safe_link
 //! initializes the node to an unlinked state.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 bs_set_member_hook();

 //! Effects: If link_mode is \c auto_unlink or \c safe_link
 //! initializes the node to an unlinked state. The argument is ignored.
- //!
- //! Throws: Nothing.
- //!
+ //!
+ //! Throws: Nothing.
+ //!
 //! Rationale: Providing a copy-constructor
- //! makes classes using the hook STL-compliant without forcing the
+ //! makes classes using the hook STL-compliant without forcing the
 //! user to do some additional work. \c swap can be used to emulate
 //! move-semantics.
 bs_set_member_hook(const bs_set_member_hook& );

 //! Effects: Empty function. The argument is ignored.
- //!
- //! Throws: Nothing.
- //!
- //! Rationale: Providing an assignment operator
- //! makes classes using the hook STL-compliant without forcing the
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Rationale: Providing an assignment operator
+ //! makes classes using the hook STL-compliant without forcing the
 //! user to do some additional work. \c swap can be used to emulate
 //! move-semantics.
 bs_set_member_hook& operator=(const bs_set_member_hook& );
@@ -253,43 +253,43 @@
 //! nothing (ie. no code is generated). If link_mode is \c safe_link and the
 //! object is stored in a set an assertion is raised. If link_mode is
 //! \c auto_unlink and \c is_linked() is true, the node is unlinked.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 ~bs_set_member_hook();

- //! Effects: Swapping two nodes swaps the position of the elements
- //! related to those nodes in one or two containers. That is, if the node
- //! this is part of the element e1, the node x is part of the element e2
- //! and both elements are included in the containers s1 and s2, then after
- //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1
- //! at the position of e1. If one element is not in a container, then
- //! after the swap-operation the other element is not in a container.
- //! Iterators to e1 and e2 related to those nodes are invalidated.
+ //! Effects: Swapping two nodes swaps the position of the elements
+ //! related to those nodes in one or two containers. That is, if the node
+ //! this is part of the element e1, the node x is part of the element e2
+ //! and both elements are included in the containers s1 and s2, then after
+ //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1
+ //! at the position of e1. If one element is not in a container, then
+ //! after the swap-operation the other element is not in a container.
+ //! Iterators to e1 and e2 related to those nodes are invalidated.
 //!
- //! Complexity: Constant
+ //! Complexity: Constant
 //!
- //! Throws: Nothing.
+ //! Throws: Nothing.
 void swap_nodes(bs_set_member_hook &other);

 //! Precondition: link_mode must be \c safe_link or \c auto_unlink.
 //!
 //! Returns: true, if the node belongs to a container, false
- //! otherwise. This function can be used to test whether \c set::iterator_to
- //! will return a valid iterator.
+ //! otherwise. This function can be used to test whether \c set::iterator_to
+ //! will return a valid iterator.
 //!
- //! Complexity: Constant
+ //! Complexity: Constant
 bool is_linked() const;

 //! Effects: Removes the node if it's inserted in a container.
 //! This function is only allowed if link_mode is \c auto_unlink.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 void unlink();
 #endif
};

-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Modified: branches/release/boost/intrusive/circular_list_algorithms.hpp
==============================================================================
--- branches/release/boost/intrusive/circular_list_algorithms.hpp (original)
+++ branches/release/boost/intrusive/circular_list_algorithms.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -40,11 +40,11 @@
//! Static functions:
//!
//! <tt>static node_ptr get_previous(const_node_ptr n);</tt>
-//!
+//!
//! <tt>static void set_previous(node_ptr n, node_ptr prev);</tt>
-//!
+//!
//! <tt>static node_ptr get_next(const_node_ptr n);</tt>
-//!
+//!
//! <tt>static void set_next(node_ptr n, node_ptr next);</tt>
template<class NodeTraits>
class circular_list_algorithms
@@ -57,9 +57,9 @@

 //! Effects: Constructs an non-used list element, so that
 //! inited(this_node) == true
- //!
- //! Complexity: Constant
- //!
+ //!
+ //! Complexity: Constant
+ //!
 //! Throws: Nothing.
 static void init(const node_ptr &this_node)
 {
@@ -69,20 +69,20 @@

 //! Effects: Returns true is "this_node" is in a non-used state
 //! as if it was initialized by the "init" function.
- //!
- //! Complexity: Constant
- //!
+ //!
+ //! Complexity: Constant
+ //!
 //! Throws: Nothing.
- static bool inited(const const_node_ptr &this_node)
+ static bool inited(const const_node_ptr &this_node)
 { return !NodeTraits::get_next(this_node); }

 //! Effects: Constructs an empty list, making this_node the only
 //! node of the circular list:
 //! <tt>NodeTraits::get_next(this_node) == NodeTraits::get_previous(this_node)
 //! == this_node</tt>.
- //!
- //! Complexity: Constant
- //!
+ //!
+ //! Complexity: Constant
+ //!
 //! Throws: Nothing.
 static void init_header(const node_ptr &this_node)
 {
@@ -92,12 +92,12 @@

 //! Requires: this_node must be in a circular list or be an empty circular list.
- //!
+ //!
 //! Effects: Returns true is "this_node" is the only node of a circular list:
 //! <tt>return NodeTraits::get_next(this_node) == this_node</tt>
- //!
- //! Complexity: Constant
- //!
+ //!
+ //! Complexity: Constant
+ //!
 //! Throws: Nothing.
 static bool unique(const const_node_ptr &this_node)
 {
@@ -106,14 +106,14 @@
 }

 //! Requires: this_node must be in a circular list or be an empty circular list.
- //!
+ //!
 //! Effects: Returns the number of nodes in a circular list. If the circular list
 //! is empty, returns 1.
- //!
- //! Complexity: Linear
- //!
+ //!
+ //! Complexity: Linear
+ //!
 //! Throws: Nothing.
- static std::size_t count(const const_node_ptr &this_node)
+ static std::size_t count(const const_node_ptr &this_node)
 {
 std::size_t result = 0;
 const_node_ptr p = this_node;
@@ -125,11 +125,11 @@
 }

 //! Requires: this_node must be in a circular list or be an empty circular list.
- //!
+ //!
 //! Effects: Unlinks the node from the circular list.
- //!
- //! Complexity: Constant
- //!
+ //!
+ //! Complexity: Constant
+ //!
 //! Throws: Nothing.
 static node_ptr unlink(const node_ptr &this_node)
 {
@@ -146,11 +146,11 @@
 }

 //! Requires: b and e must be nodes of the same circular list or an empty range.
- //!
+ //!
 //! Effects: Unlinks the node [b, e) from the circular list.
- //!
- //! Complexity: Constant
- //!
+ //!
+ //! Complexity: Constant
+ //!
 //! Throws: Nothing.
 static void unlink(const node_ptr &b, const node_ptr &e)
 {
@@ -162,11 +162,11 @@
 }

 //! Requires: nxt_node must be a node of a circular list.
- //!
+ //!
 //! Effects: Links this_node before nxt_node in the circular list.
- //!
- //! Complexity: Constant
- //!
+ //!
+ //! Complexity: Constant
+ //!
 //! Throws: Nothing.
 static void link_before(const node_ptr &nxt_node, const node_ptr &this_node)
 {
@@ -181,11 +181,11 @@
 }

 //! Requires: prev_node must be a node of a circular list.
- //!
+ //!
 //! Effects: Links this_node after prev_node in the circular list.
- //!
- //! Complexity: Constant
- //!
+ //!
+ //! Complexity: Constant
+ //!
 //! Throws: Nothing.
 static void link_after(const node_ptr &prev_node, const node_ptr &this_node)
 {
@@ -201,13 +201,13 @@

 //! Requires: this_node and other_node must be nodes inserted
 //! in circular lists or be empty circular lists.
- //!
+ //!
 //! Effects: Swaps the position of the nodes: this_node is inserted in
 //! other_nodes position in the second circular list and the other_node is inserted
 //! in this_node's position in the first circular list.
- //!
- //! Complexity: Constant
- //!
+ //!
+ //! Complexity: Constant
+ //!
 //! Throws: Nothing.
/*
 static void swap_nodes(const node_ptr &this_node, const node_ptr &other_node)
@@ -248,22 +248,22 @@
*/

 //Watanabe version
- private:
- static void swap_prev(const node_ptr &this_node, const node_ptr &other_node)
- {
- node_ptr temp(NodeTraits::get_previous(this_node));
- NodeTraits::set_previous(this_node, NodeTraits::get_previous(other_node));
- NodeTraits::set_previous(other_node, temp);
- }
- static void swap_next(const node_ptr &this_node, const node_ptr &other_node)
- {
- node_ptr temp(NodeTraits::get_next(this_node));
- NodeTraits::set_next(this_node, NodeTraits::get_next(other_node));
- NodeTraits::set_next(other_node, temp);
- }
+ private:
+ static void swap_prev(const node_ptr &this_node, const node_ptr &other_node)
+ {
+ node_ptr temp(NodeTraits::get_previous(this_node));
+ NodeTraits::set_previous(this_node, NodeTraits::get_previous(other_node));
+ NodeTraits::set_previous(other_node, temp);
+ }
+ static void swap_next(const node_ptr &this_node, const node_ptr &other_node)
+ {
+ node_ptr temp(NodeTraits::get_next(this_node));
+ NodeTraits::set_next(this_node, NodeTraits::get_next(other_node));
+ NodeTraits::set_next(other_node, temp);
+ }

- public:
- static void swap_nodes(const node_ptr &this_node, const node_ptr &other_node)
+ public:
+ static void swap_nodes(const node_ptr &this_node, const node_ptr &other_node)
 {
 if (other_node == this_node)
 return;
@@ -276,15 +276,15 @@
 init_header(other_node);
 }

- node_ptr next_this(NodeTraits::get_next(this_node));
- node_ptr prev_this(NodeTraits::get_previous(this_node));
- node_ptr next_other(NodeTraits::get_next(other_node));
- node_ptr prev_other(NodeTraits::get_previous(other_node));
- //these first two swaps must happen before the other two
- swap_prev(next_this, next_other);
- swap_next(prev_this, prev_other);
- swap_next(this_node, other_node);
- swap_prev(this_node, other_node);
+ node_ptr next_this(NodeTraits::get_next(this_node));
+ node_ptr prev_this(NodeTraits::get_previous(this_node));
+ node_ptr next_other(NodeTraits::get_next(other_node));
+ node_ptr prev_other(NodeTraits::get_previous(other_node));
+ //these first two swaps must happen before the other two
+ swap_prev(next_this, next_other);
+ swap_next(prev_this, prev_other);
+ swap_next(this_node, other_node);
+ swap_prev(this_node, other_node);

 if(this_inited){
 init(other_node);
@@ -295,14 +295,14 @@
 }

 //! Requires: b and e must be nodes of the same circular list or an empty range.
- //! and p must be a node of a different circular list or may not be an iterator in
+ //! and p must be a node of a different circular list or may not be an iterator in
 // [b, e).
- //!
+ //!
 //! Effects: Removes the nodes from [b, e) range from their circular list and inserts
 //! them before p in p's circular list.
- //!
- //! Complexity: Constant
- //!
+ //!
+ //! Complexity: Constant
+ //!
 //! Throws: Nothing.
 static void transfer(const node_ptr &p, const node_ptr &b, const node_ptr &e)
 {
@@ -321,13 +321,13 @@

 //! Requires: i must a node of a circular list
 //! and p must be a node of a different circular list.
- //!
+ //!
 //! Effects: Removes the node i from its circular list and inserts
- //! it before p in p's circular list.
+ //! it before p in p's circular list.
 //! If p == i or p == NodeTraits::get_next(i), this function is a null operation.
- //!
- //! Complexity: Constant
- //!
+ //!
+ //! Complexity: Constant
+ //!
 //! Throws: Nothing.
 static void transfer(const node_ptr &p, const node_ptr &i)
 {
@@ -345,16 +345,16 @@
 }
 }

- //! Effects: Reverses the order of elements in the list.
- //!
+ //! Effects: Reverses the order of elements in the list.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: This function is linear time.
 static void reverse(const node_ptr &p)
 {
 node_ptr f(NodeTraits::get_next(p));
 node_ptr i(NodeTraits::get_next(f)), e(p);
-
+
 while(i != e) {
 node_ptr n = i;
 i = NodeTraits::get_next(i);
@@ -364,9 +364,9 @@
 }

 //! Effects: Moves the node p n positions towards the end of the list.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the number of moved positions.
 static void move_backwards(const node_ptr &p, std::size_t n)
 {
@@ -384,9 +384,9 @@
 }

 //! Effects: Moves the node p n positions towards the beginning of the list.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the number of moved positions.
 static void move_forward(const node_ptr &p, std::size_t n)
 {
@@ -405,8 +405,8 @@
 }
};

-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Modified: branches/release/boost/intrusive/circular_slist_algorithms.hpp
==============================================================================
--- branches/release/boost/intrusive/circular_slist_algorithms.hpp (original)
+++ branches/release/boost/intrusive/circular_slist_algorithms.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -42,7 +42,7 @@
//! Static functions:
//!
//! <tt>static node_ptr get_next(const_node_ptr n);</tt>
-//!
+//!
//! <tt>static void set_next(node_ptr n, node_ptr next);</tt>
template<class NodeTraits>
class circular_slist_algorithms
@@ -64,37 +64,37 @@
 //! Effects: Constructs an non-used list element, putting the next
 //! pointer to null:
 //! <tt>NodeTraits::get_next(this_node) == node_ptr()</tt>
- //!
- //! Complexity: Constant
- //!
+ //!
+ //! Complexity: Constant
+ //!
 //! Throws: Nothing.
 static void init(node_ptr this_node);

 //! Requires: this_node must be in a circular list or be an empty circular list.
- //!
+ //!
 //! Effects: Returns true is "this_node" is the only node of a circular list:
 //! or it's a not inserted node:
 //! <tt>return node_ptr() == NodeTraits::get_next(this_node) || NodeTraits::get_next(this_node) == this_node</tt>
- //!
+ //!
 //! Complexity: Constant
- //!
+ //!
 //! Throws: Nothing.
 static bool unique(const_node_ptr this_node);

 //! Effects: Returns true is "this_node" has the same state as
 //! if it was inited using "init(node_ptr)"
- //!
- //! Complexity: Constant
- //!
+ //!
+ //! Complexity: Constant
+ //!
 //! Throws: Nothing.
 static bool inited(const_node_ptr this_node);

 //! Requires: prev_node must be in a circular list or be an empty circular list.
- //!
+ //!
 //! Effects: Unlinks the next node of prev_node from the circular list.
- //!
- //! Complexity: Constant
- //!
+ //!
+ //! Complexity: Constant
+ //!
 //! Throws: Nothing.
 static void unlink_after(node_ptr prev_node);

@@ -103,28 +103,28 @@
 //!
 //! Effects: Unlinks the range (prev_node, last_node) from the circular list.
 //!
- //! Complexity: Constant
+ //! Complexity: Constant
 //!
 //! Throws: Nothing.
 static void unlink_after(node_ptr prev_node, node_ptr last_node);

 //! Requires: prev_node must be a node of a circular list.
- //!
+ //!
 //! Effects: Links this_node after prev_node in the circular list.
- //!
- //! Complexity: Constant
- //!
+ //!
+ //! Complexity: Constant
+ //!
 //! Throws: Nothing.
 static void link_after(node_ptr prev_node, node_ptr this_node);

 //! Requires: b and e must be nodes of the same circular list or an empty range.
 //! and p must be a node of a different circular list.
- //!
+ //!
 //! Effects: Removes the nodes from (b, e] range from their circular list and inserts
 //! them after p in p's circular list.
- //!
- //! Complexity: Constant
- //!
+ //!
+ //! Complexity: Constant
+ //!
 //! Throws: Nothing.
 static void transfer_after(node_ptr p, node_ptr b, node_ptr e);

@@ -133,53 +133,53 @@
 //! Effects: Constructs an empty list, making this_node the only
 //! node of the circular list:
 //! <tt>NodeTraits::get_next(this_node) == this_node</tt>.
- //!
- //! Complexity: Constant
- //!
+ //!
+ //! Complexity: Constant
+ //!
 //! Throws: Nothing.
 static void init_header(const node_ptr &this_node)
- { NodeTraits::set_next(this_node, this_node); }
+ { NodeTraits::set_next(this_node, this_node); }

 //! Requires: this_node and prev_init_node must be in the same circular list.
- //!
+ //!
 //! Effects: Returns the previous node of this_node in the circular list starting.
 //! the search from prev_init_node. The first node checked for equality
 //! is NodeTraits::get_next(prev_init_node).
- //!
+ //!
 //! Complexity: Linear to the number of elements between prev_init_node and this_node.
- //!
+ //!
 //! Throws: Nothing.
 static node_ptr get_previous_node(const node_ptr &prev_init_node, const node_ptr &this_node)
 { return base_t::get_previous_node(prev_init_node, this_node); }

 //! Requires: this_node must be in a circular list or be an empty circular list.
- //!
+ //!
 //! Effects: Returns the previous node of this_node in the circular list.
- //!
+ //!
 //! Complexity: Linear to the number of elements in the circular list.
- //!
+ //!
 //! Throws: Nothing.
 static node_ptr get_previous_node(const node_ptr & this_node)
 { return base_t::get_previous_node(this_node, this_node); }

 //! Requires: this_node must be in a circular list or be an empty circular list.
- //!
+ //!
 //! Effects: Returns the previous node of the previous node of this_node in the circular list.
- //!
+ //!
 //! Complexity: Linear to the number of elements in the circular list.
- //!
+ //!
 //! Throws: Nothing.
 static node_ptr get_previous_previous_node(const node_ptr & this_node)
 { return get_previous_previous_node(this_node, this_node); }

 //! Requires: this_node and prev_prev_init_node must be in the same circular list.
- //!
+ //!
 //! Effects: Returns the previous node of the previous node of this_node in the
 //! circular list starting. the search from prev_init_node. The first node checked
 //! for equality is NodeTraits::get_next((NodeTraits::get_next(prev_prev_init_node)).
- //!
+ //!
 //! Complexity: Linear to the number of elements in the circular list.
- //!
+ //!
 //! Throws: Nothing.
 static node_ptr get_previous_previous_node(const node_ptr & prev_prev_init_node, const node_ptr & this_node)
 {
@@ -195,14 +195,14 @@
 }

 //! Requires: this_node must be in a circular list or be an empty circular list.
- //!
+ //!
 //! Effects: Returns the number of nodes in a circular list. If the circular list
 //! is empty, returns 1.
- //!
- //! Complexity: Linear
- //!
+ //!
+ //! Complexity: Linear
+ //!
 //! Throws: Nothing.
- static std::size_t count(const const_node_ptr & this_node)
+ static std::size_t count(const const_node_ptr & this_node)
 {
 std::size_t result = 0;
 const_node_ptr p = this_node;
@@ -214,11 +214,11 @@
 }

 //! Requires: this_node must be in a circular list, be an empty circular list or be inited.
- //!
+ //!
 //! Effects: Unlinks the node from the circular list.
- //!
- //! Complexity: Linear to the number of elements in the circular list
- //!
+ //!
+ //! Complexity: Linear to the number of elements in the circular list
+ //!
 //! Throws: Nothing.
 static void unlink(const node_ptr & this_node)
 {
@@ -227,24 +227,24 @@
 }

 //! Requires: nxt_node must be a node of a circular list.
- //!
+ //!
 //! Effects: Links this_node before nxt_node in the circular list.
- //!
- //! Complexity: Linear to the number of elements in the circular list.
- //!
+ //!
+ //! Complexity: Linear to the number of elements in the circular list.
+ //!
 //! Throws: Nothing.
 static void link_before (const node_ptr & nxt_node, const node_ptr & this_node)
 { base_t::link_after(get_previous_node(nxt_node), this_node); }

 //! Requires: this_node and other_node must be nodes inserted
 //! in circular lists or be empty circular lists.
- //!
+ //!
 //! Effects: Swaps the position of the nodes: this_node is inserted in
 //! other_nodes position in the second circular list and the other_node is inserted
 //! in this_node's position in the first circular list.
- //!
- //! Complexity: Linear to number of elements of both lists
- //!
+ //!
+ //! Complexity: Linear to number of elements of both lists
+ //!
 //! Throws: Nothing.
 static void swap_nodes(const node_ptr & this_node, const node_ptr & other_node)
 {
@@ -279,14 +279,14 @@
 }
 }

- //! Effects: Reverses the order of elements in the list.
- //!
+ //! Effects: Reverses the order of elements in the list.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: This function is linear to the contained elements.
 static void reverse(const node_ptr & p)
 {
- node_ptr i = NodeTraits::get_next(p), e(p);
+ node_ptr i = NodeTraits::get_next(p), e(p);
 for (;;) {
 node_ptr nxt(NodeTraits::get_next(i));
 if (nxt == e)
@@ -301,7 +301,7 @@
 //! Null if n leads to no movement.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the number of elements plus the number moved positions.
 static node_ptr move_backwards(const node_ptr & p, std::size_t n)
 {
@@ -348,12 +348,12 @@
 }

 //! Effects: Moves the node p n positions towards the beginning of the list.
- //!
+ //!
 //! Returns: The previous node of p after the function if there has been any movement,
 //! Null if n leads equals to no movement.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the number of elements plus the number moved positions.
 static node_ptr move_forward(const node_ptr & p, std::size_t n)
 {
@@ -382,7 +382,7 @@
 std::size_t new_before_last_pos = (distance - (n % distance))% distance;
 //If the shift is a multiple of the size there is nothing to do
 if(!new_before_last_pos) return node_ptr();
-
+
 for( new_last = p
 ; new_before_last_pos--
 ; new_last = node_traits::get_next(new_last)){
@@ -397,8 +397,8 @@
 }
};

-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Modified: branches/release/boost/intrusive/derivation_value_traits.hpp
==============================================================================
--- branches/release/boost/intrusive/derivation_value_traits.hpp (original)
+++ branches/release/boost/intrusive/derivation_value_traits.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -47,7 +47,7 @@
 static const_node_ptr to_node_ptr(const_reference value)
 { return node_ptr(&value); }

- static pointer to_value_ptr(const node_ptr &n)
+ static pointer to_value_ptr(const node_ptr &n)
 {
// This still fails in gcc < 4.4 so forget about it
// using ::boost::static_pointer_cast;
@@ -64,7 +64,7 @@
 }
};

-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#endif //BOOST_INTRUSIVE_DERIVATION_VALUE_TRAITS_HPP

Modified: branches/release/boost/intrusive/detail/any_node_and_algorithms.hpp
==============================================================================
--- branches/release/boost/intrusive/detail/any_node_and_algorithms.hpp (original)
+++ branches/release/boost/intrusive/detail/any_node_and_algorithms.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -18,7 +18,7 @@
#include <boost/intrusive/detail/assert.hpp>
#include <boost/intrusive/pointer_traits.hpp>
#include <cstddef>
-#include <boost/intrusive/detail/mpl.hpp>
+#include <boost/intrusive/detail/mpl.hpp>
#include <boost/pointer_cast.hpp>

namespace boost {
@@ -100,10 +100,10 @@
 { n->node_ptr_2 = prev; }

 static std::size_t get_hash(const const_node_ptr & n)
- { return n->size_t_1; }
+ { return n->size_t_1; }

 static void set_hash(const node_ptr & n, std::size_t h)
- { n->size_t_1 = h; }
+ { n->size_t_1 = h; }
};

@@ -255,9 +255,9 @@
 //! Requires: node must not be part of any tree.
 //!
 //! Effects: After the function unique(node) == true.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 //!
 //! Nodes: If node is inserted in a tree, this function corrupts the tree.
@@ -265,9 +265,9 @@
 { node->node_ptr_1 = 0; };

 //! Effects: Returns true if node is in the same state as if called init(node)
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 static bool inited(const const_node_ptr & node)
 { return !node->node_ptr_1; };
@@ -289,8 +289,8 @@
 }
};

-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Modified: branches/release/boost/intrusive/detail/assert.hpp
==============================================================================
--- branches/release/boost/intrusive/detail/assert.hpp (original)
+++ branches/release/boost/intrusive/detail/assert.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -11,7 +11,7 @@
/////////////////////////////////////////////////////////////////////////////

#ifndef BOOST_INTRUSIVE_DETAIL_ASSERT_HPP
-#define BOOST_INTRUSIVE_DETAIL_ASSERT_HPP
+#define BOOST_INTRUSIVE_DETAIL_ASSERT_HPP

#if defined(_MSC_VER)&&(_MSC_VER>=1200)
#pragma once

Modified: branches/release/boost/intrusive/detail/avltree_node.hpp
==============================================================================
--- branches/release/boost/intrusive/detail/avltree_node.hpp (original)
+++ branches/release/boost/intrusive/detail/avltree_node.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -172,13 +172,13 @@
 , OptimizeSize &&
 max_pointer_plus_bits
 < VoidPointer
- , detail::alignment_of<compact_avltree_node<VoidPointer> >::value
+ , detail::alignment_of<compact_avltree_node<VoidPointer> >::value
>::value >= 2u
>
{};

-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Modified: branches/release/boost/intrusive/detail/common_slist_algorithms.hpp
==============================================================================
--- branches/release/boost/intrusive/detail/common_slist_algorithms.hpp (original)
+++ branches/release/boost/intrusive/detail/common_slist_algorithms.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -44,11 +44,11 @@
 return p;
 }

- static void init_header(const node_ptr & this_node)
- { NodeTraits::set_next(this_node, this_node); }
+ static void init_header(const node_ptr & this_node)
+ { NodeTraits::set_next(this_node, this_node); }

- static void init(const node_ptr & this_node)
- { NodeTraits::set_next(this_node, node_ptr()); }
+ static void init(const node_ptr & this_node)
+ { NodeTraits::set_next(this_node, node_ptr()); }

 static bool unique(const const_node_ptr & this_node)
 {
@@ -56,7 +56,7 @@
 return !next || next == this_node;
 }

- static bool inited(const const_node_ptr & this_node)
+ static bool inited(const const_node_ptr & this_node)
 { return !NodeTraits::get_next(this_node); }

 static void unlink_after(const node_ptr & prev_node)
@@ -80,7 +80,7 @@
 NodeTraits::set_next(bp, b);
 NodeTraits::set_next(be, p);
 }
-
+
 static void transfer_after(const node_ptr & bp, const node_ptr & bb, const node_ptr & be)
 {
 if (bp != bb && bp != be && bb != be) {
@@ -95,8 +95,8 @@
};

} //namespace detail
-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Modified: branches/release/boost/intrusive/detail/config_begin.hpp
==============================================================================
--- branches/release/boost/intrusive/detail/config_begin.hpp (original)
+++ branches/release/boost/intrusive/detail/config_begin.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -20,10 +20,10 @@
    #pragma warning (push)
    //
    //'function' : resolved overload was found by argument-dependent lookup
- //A function found by argument-dependent lookup (Koenig lookup) was eventually
+ //A function found by argument-dependent lookup (Koenig lookup) was eventually
    //chosen by overload resolution.
    //
- //In Visual C++ .NET and earlier compilers, a different function would have
+ //In Visual C++ .NET and earlier compilers, a different function would have
    //been called. To pick the original function, use an explicitly qualified name.
    //

Modified: branches/release/boost/intrusive/detail/function_detector.hpp
==============================================================================
--- branches/release/boost/intrusive/detail/function_detector.hpp (original)
+++ branches/release/boost/intrusive/detail/function_detector.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -15,7 +15,7 @@
///////////////////////////////////////////////////////////////////////////////
// Copyright 2007 Alexandre Courpron
//
-// Permission to use, copy, modify, redistribute and sell this software,
+// Permission to use, copy, modify, redistribute and sell this software,
// provided that this copyright notice appears on all copies of the software.
///////////////////////////////////////////////////////////////////////////////

@@ -74,7 +74,7 @@
 public : \
 static const int check = NotFound + (sizeof(Test<T>(0, 0)) - sizeof(NotFoundType));\
 };\
-}}} //namespace boost::intrusive::function_detector {
+}}} //namespace boost::intrusive::function_detector {

#define BOOST_INTRUSIVE_DETECT_FUNCTION(Class, InstantiationKey, ReturnType, Identifier, Params) \
 ::boost::intrusive::function_detector::DetectMember_##InstantiationKey_##Identifier< Class,\

Modified: branches/release/boost/intrusive/detail/generic_hook.hpp
==============================================================================
--- branches/release/boost/intrusive/detail/generic_hook.hpp (original)
+++ branches/release/boost/intrusive/detail/generic_hook.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -143,7 +143,7 @@
 typedef Tag tag;
 typedef typename GetNodeAlgorithms::type::node_traits node_traits;
 static const bool is_base_hook = !detail::is_same<Tag, member_tag>::value;
- static const bool safemode_or_autounlink =
+ static const bool safemode_or_autounlink =
 (int)link_mode == (int)auto_unlink || (int)link_mode == (int)safe_link;
 };

@@ -163,14 +163,14 @@
 }
 }

- generic_hook(const generic_hook& )
+ generic_hook(const generic_hook& )
 {
 if(boost_intrusive_tags::safemode_or_autounlink){
 node_algorithms::init(this->this_ptr());
 }
 }

- generic_hook& operator=(const generic_hook& )
+ generic_hook& operator=(const generic_hook& )
 { return *this; }

 ~generic_hook()
@@ -179,13 +179,13 @@
 (*this, detail::link_dispatch<boost_intrusive_tags::link_mode>());
 }

- void swap_nodes(generic_hook &other)
+ void swap_nodes(generic_hook &other)
 {
 node_algorithms::swap_nodes
 (this->this_ptr(), other.this_ptr());
 }

- bool is_linked() const
+ bool is_linked() const
 {
 //is_linked() can be only used in safe-mode or auto-unlink
 BOOST_STATIC_ASSERT(( boost_intrusive_tags::safemode_or_autounlink ));
@@ -201,8 +201,8 @@
};

} //namespace detail
-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Modified: branches/release/boost/intrusive/detail/has_member_function_callable_with.hpp
==============================================================================
--- branches/release/boost/intrusive/detail/has_member_function_callable_with.hpp (original)
+++ branches/release/boost/intrusive/detail/has_member_function_callable_with.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -21,7 +21,7 @@
 #include <boost/static_assert.hpp>
 #include <boost/move/move.hpp>

- //Mark that we don't support 0 arg calls due to compiler ICE in GCC 3.4/4.0/4.1 and
+ //Mark that we don't support 0 arg calls due to compiler ICE in GCC 3.4/4.0/4.1 and
 //wrong SFINAE for GCC 4.2/4.3
 #if defined(__GNUC__) && !defined(__clang__) && ((__GNUC__*100 + __GNUC_MINOR__*10) >= 340) && ((__GNUC__*100 + __GNUC_MINOR__*10) <= 430)
 #define BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED
@@ -121,7 +121,7 @@
 struct BOOST_PP_CAT(BOOST_PP_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME),_impl)
 <Fun, true BOOST_PP_ENUM_TRAILING(BOOST_PP_SUB(BOOST_PP_ITERATION_FINISH(), BOOST_PP_ITERATION()), BOOST_INTRUSIVE_PP_IDENTITY, void)>
 {
- //Mark that we don't support 0 arg calls due to compiler ICE in GCC 3.4/4.0/4.1 and
+ //Mark that we don't support 0 arg calls due to compiler ICE in GCC 3.4/4.0/4.1 and
 //wrong SFINAE for GCC 4.2/4.3
 static const bool value = true;
 };
@@ -130,7 +130,7 @@

 //Special case for 0 args
 template< class F
- , std::size_t N =
+ , std::size_t N =
 sizeof((boost::move_detail::declval<F>().
 BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME (), 0))>
 struct BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
@@ -156,9 +156,9 @@
 static BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
 Test(BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)*);

- template <class U>
+ template <class U>
 static boost_intrusive_has_member_function_callable_with::no_type Test(...);
-
+
 static const bool value = sizeof(Test< Fun >(0))
 == sizeof(boost_intrusive_has_member_function_callable_with::yes_type);
 };
@@ -196,7 +196,7 @@

 //Special case for 0 args
 template< class F
- , std::size_t N =
+ , std::size_t N =
 sizeof((boost::move_detail::declval<F>().
 BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME (), 0))>
 struct BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
@@ -222,9 +222,9 @@
 static BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
 Test(BOOST_PP_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)*);

- template <class U>
+ template <class U>
 static boost_intrusive_has_member_function_callable_with::no_type Test(...);
-
+
 static const bool value = sizeof(Test< Fun >(0))
 == sizeof(boost_intrusive_has_member_function_callable_with::yes_type);
 };

Modified: branches/release/boost/intrusive/detail/hashtable_node.hpp
==============================================================================
--- branches/release/boost/intrusive/detail/hashtable_node.hpp (original)
+++ branches/release/boost/intrusive/detail/hashtable_node.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -40,7 +40,7 @@

template<int Dummy>
const std::size_t prime_list_holder<Dummy>::prime_list[] = {
- 3ul, 7ul, 11ul, 17ul, 29ul,
+ 3ul, 7ul, 11ul, 17ul, 29ul,
 53ul, 97ul, 193ul, 389ul, 769ul,
 1543ul, 3079ul, 6151ul, 12289ul, 24593ul,
 49157ul, 98317ul, 196613ul, 393241ul, 786433ul,
@@ -180,9 +180,9 @@
 { return hashtable_iterator<Container, false>(this->slist_it(), this->get_container()); }

 public:
- hashtable_iterator& operator++()
+ hashtable_iterator& operator++()
 { this->increment(); return *this; }
-
+
 hashtable_iterator operator++(int)
 {
 hashtable_iterator result (*this);
@@ -219,7 +219,7 @@
 size_type buckets_len = cont->bucket_count();

 ++slist_it_;
- if(buckets[0].cend().pointed_node() <= slist_it_.pointed_node() &&
+ if(buckets[0].cend().pointed_node() <= slist_it_.pointed_node() &&
 slist_it_.pointed_node()<= buckets[buckets_len].cend().pointed_node() ){
 //Now get the bucket_impl from the iterator
 const bucket_type &b = static_cast<const bucket_type&>

Modified: branches/release/boost/intrusive/detail/list_node.hpp
==============================================================================
--- branches/release/boost/intrusive/detail/list_node.hpp (original)
+++ branches/release/boost/intrusive/detail/list_node.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -57,7 +57,7 @@
 { n->next_ = next; }
};

-// list_iterator provides some basic functions for a
+// list_iterator provides some basic functions for a
// node oriented bidirectional iterator:
template<class Container, bool IsConst>
class list_iterator
@@ -76,7 +76,7 @@
 typedef typename node_traits::node_ptr node_ptr;
 typedef typename pointer_traits<node_ptr>::
 template rebind_pointer<void>::type void_pointer;
- static const bool store_container_ptr =
+ static const bool store_container_ptr =
 detail::store_cont_ptr_on_it<Container>::value;

 public:
@@ -103,14 +103,14 @@
 { members_.nodeptr_ = node; return static_cast<list_iterator&>(*this); }

 public:
- list_iterator& operator++()
+ list_iterator& operator++()
 {
 node_ptr p = node_traits::get_next(members_.nodeptr_);
 members_.nodeptr_ = p;
- //members_.nodeptr_ = node_traits::get_next(members_.nodeptr_);
- return static_cast<list_iterator&> (*this);
+ //members_.nodeptr_ = node_traits::get_next(members_.nodeptr_);
+ return static_cast<list_iterator&> (*this);
 }
-
+
 list_iterator operator++(int)
 {
 list_iterator result (*this);
@@ -118,12 +118,12 @@
 return result;
 }

- list_iterator& operator--()
- {
- members_.nodeptr_ = node_traits::get_previous(members_.nodeptr_);
- return static_cast<list_iterator&> (*this);
+ list_iterator& operator--()
+ {
+ members_.nodeptr_ = node_traits::get_previous(members_.nodeptr_);
+ return static_cast<list_iterator&> (*this);
 }
-
+
 list_iterator operator--(int)
 {
 list_iterator result (*this);
@@ -182,8 +182,8 @@
 } members_;
};

-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Modified: branches/release/boost/intrusive/detail/mpl.hpp
==============================================================================
--- branches/release/boost/intrusive/detail/mpl.hpp (original)
+++ branches/release/boost/intrusive/detail/mpl.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -127,10 +127,10 @@
#if defined(BOOST_MSVC) || defined(__BORLANDC_)
#define BOOST_INTRUSIVE_TT_DECL __cdecl
#else
-#define BOOST_INTRUSIVE_TT_DECL
+#define BOOST_INTRUSIVE_TT_DECL
#endif

-#if defined(_MSC_EXTENSIONS) && !defined(__BORLAND__) && !defined(_WIN64)
+#if defined(_MSC_EXTENSIONS) && !defined(__BORLAND__) && !defined(_WIN64) && !defined(UNDER_CE)
#define BOOST_INTRUSIVE_TT_TEST_MSC_FUNC_SIGS
#endif

@@ -346,9 +346,9 @@
static const std::size_t value = 0;
};

-} //namespace detail
-} //namespace intrusive
-} //namespace boost
+} //namespace detail
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Modified: branches/release/boost/intrusive/detail/parent_from_member.hpp
==============================================================================
--- branches/release/boost/intrusive/detail/parent_from_member.hpp (original)
+++ branches/release/boost/intrusive/detail/parent_from_member.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -47,13 +47,25 @@
template<class Parent, class Member>
inline Parent *parent_from_member(Member *member, const Member Parent::* ptr_to_member)
{
- return (Parent*)((char*)member - offset_from_pointer_to_member(ptr_to_member));
+ return static_cast<Parent*>
+ (
+ static_cast<void*>
+ (
+ static_cast<char*>(static_cast<void*>(member)) - offset_from_pointer_to_member(ptr_to_member)
+ )
+ );
}

template<class Parent, class Member>
inline const Parent *parent_from_member(const Member *member, const Member Parent::* ptr_to_member)
{
- return (const Parent*)((const char*)member - offset_from_pointer_to_member(ptr_to_member));
+ return static_cast<const Parent*>
+ (
+ static_cast<const void*>
+ (
+ static_cast<const char*>(static_cast<const void*>(member)) - offset_from_pointer_to_member(ptr_to_member)
+ )
+ );
}

} //namespace detail {

Modified: branches/release/boost/intrusive/detail/preprocessor.hpp
==============================================================================
--- branches/release/boost/intrusive/detail/preprocessor.hpp (original)
+++ branches/release/boost/intrusive/detail/preprocessor.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -18,7 +18,7 @@
#include <boost/intrusive/detail/config_begin.hpp>
#include <boost/intrusive/detail/workaround.hpp>

-#include <boost/preprocessor/iteration/local.hpp>
+#include <boost/preprocessor/iteration/local.hpp>
#include <boost/preprocessor/punctuation/paren_if.hpp>
#include <boost/preprocessor/punctuation/comma_if.hpp>
#include <boost/preprocessor/control/expr_if.hpp>

Modified: branches/release/boost/intrusive/detail/rbtree_node.hpp
==============================================================================
--- branches/release/boost/intrusive/detail/rbtree_node.hpp (original)
+++ branches/release/boost/intrusive/detail/rbtree_node.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -164,13 +164,13 @@
 , OptimizeSize &&
 (max_pointer_plus_bits
 < VoidPointer
- , detail::alignment_of<compact_rbtree_node<VoidPointer> >::value
+ , detail::alignment_of<compact_rbtree_node<VoidPointer> >::value
>::value >= 1)
>
{};

-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Modified: branches/release/boost/intrusive/detail/slist_node.hpp
==============================================================================
--- branches/release/boost/intrusive/detail/slist_node.hpp (original)
+++ branches/release/boost/intrusive/detail/slist_node.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -43,13 +43,13 @@
 <VoidPointer>::template rebind_pointer<const node>::type const_node_ptr;

 static const node_ptr &get_next(const const_node_ptr & n)
- { return n->next_; }
+ { return n->next_; }

 static void set_next(const node_ptr & n, const node_ptr & next)
- { n->next_ = next; }
+ { n->next_ = next; }
};

-// slist_iterator provides some basic functions for a
+// slist_iterator provides some basic functions for a
// node oriented bidirectional iterator:
template<class Container, bool IsConst>
class slist_iterator
@@ -68,7 +68,7 @@
 typedef typename node_traits::node_ptr node_ptr;
 typedef typename pointer_traits
 <node_ptr>::template rebind_pointer <void>::type void_pointer;
- static const bool store_container_ptr =
+ static const bool store_container_ptr =
 detail::store_cont_ptr_on_it<Container>::value;

 public:
@@ -95,12 +95,12 @@
 { members_.nodeptr_ = node; return static_cast<slist_iterator&>(*this); }

 public:
- slist_iterator& operator++()
- {
- members_.nodeptr_ = node_traits::get_next(members_.nodeptr_);
- return static_cast<slist_iterator&> (*this);
+ slist_iterator& operator++()
+ {
+ members_.nodeptr_ = node_traits::get_next(members_.nodeptr_);
+ return static_cast<slist_iterator&> (*this);
 }
-
+
 slist_iterator operator++(int)
 {
 slist_iterator result (*this);
@@ -155,8 +155,8 @@
 } members_;
};

-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Modified: branches/release/boost/intrusive/detail/transform_iterator.hpp
==============================================================================
--- branches/release/boost/intrusive/detail/transform_iterator.hpp (original)
+++ branches/release/boost/intrusive/detail/transform_iterator.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -71,7 +71,7 @@
    { return members_.m_it; }

    //Constructors
- transform_iterator& operator++()
+ transform_iterator& operator++()
    { increment(); return *this; }

    transform_iterator operator++(int)

Modified: branches/release/boost/intrusive/detail/tree_algorithms.hpp
==============================================================================
--- branches/release/boost/intrusive/detail/tree_algorithms.hpp (original)
+++ branches/release/boost/intrusive/detail/tree_algorithms.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -25,20 +25,20 @@
namespace detail {

//! This is an implementation of a binary search tree.
-//! A node in the search tree has references to its children and its parent. This
-//! is to allow traversal of the whole tree from a given node making the
+//! A node in the search tree has references to its children and its parent. This
+//! is to allow traversal of the whole tree from a given node making the
//! implementation of iterator a pointer to a node.
-//! At the top of the tree a node is used specially. This node's parent pointer
-//! is pointing to the root of the tree. Its left pointer points to the
+//! At the top of the tree a node is used specially. This node's parent pointer
+//! is pointing to the root of the tree. Its left pointer points to the
//! leftmost node in the tree and the right pointer to the rightmost one.
//! This node is used to represent the end-iterator.
//!
-//! +---------+
-//! header------------------------------>| |
-//! | |
-//! +----------(left)--------| |--------(right)---------+
-//! | +---------+ |
-//! | | |
+//! +---------+
+//! header------------------------------>| |
+//! | |
+//! +----------(left)--------| |--------(right)---------+
+//! | +---------+ |
+//! | | |
//! | | (parent) |
//! | | |
//! | | |
@@ -61,10 +61,10 @@
//! | | | | | |
//! | | | | | |
//! | +---+-----+ +-----+---+ +---+-----+ +-----+---+ |
-//! +-->| | | | | | | |<--+
-//! | A | | C | | E | | G |
-//! | | | | | | | |
-//! +---------+ +---------+ +---------+ +---------+
+//! +-->| | | | | | | |<--+
+//! | A | | C | | E | | G |
+//! | | | | | | | |
+//! +---------+ +---------+ +---------+ +---------+
//!

//! tree_algorithms is configured with a NodeTraits class, which encapsulates the
@@ -82,15 +82,15 @@
//! Static functions:
//!
//! <tt>static node_ptr get_parent(const_node_ptr n);</tt>
-//!
+//!
//! <tt>static void set_parent(node_ptr n, node_ptr parent);</tt>
//!
//! <tt>static node_ptr get_left(const_node_ptr n);</tt>
-//!
+//!
//! <tt>static void set_left(node_ptr n, node_ptr left);</tt>
//!
//! <tt>static node_ptr get_right(const_node_ptr n);</tt>
-//!
+//!
//! <tt>static void set_right(node_ptr n, node_ptr right);</tt>
template<class NodeTraits>
class tree_algorithms
@@ -153,11 +153,11 @@

 //! Requires: 'node' is a node of the tree or an node initialized
 //! by init(...) or init_node.
- //!
+ //!
 //! Effects: Returns true if the node is initialized by init() or init_node().
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: Nothing.
 static bool unique(const const_node_ptr & node)
 { return !NodeTraits::get_parent(node); }
@@ -175,15 +175,15 @@

 //! Requires: node1 and node2 can't be header nodes
 //! of two trees.
- //!
+ //!
 //! Effects: Swaps two nodes. After the function node1 will be inserted
 //! in the position node2 before the function. node2 will be inserted in the
 //! position node1 had before the function.
- //!
- //! Complexity: Logarithmic.
- //!
+ //!
+ //! Complexity: Logarithmic.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function will break container ordering invariants if
 //! node1 and node2 are not equivalent according to the ordering rules.
 //!
@@ -192,22 +192,22 @@
 {
 if(node1 == node2)
 return;
-
+
 node_ptr header1(get_header(node1)), header2(get_header(node2));
 swap_nodes(node1, header1, node2, header2);
 }

 //! Requires: node1 and node2 can't be header nodes
 //! of two trees with header header1 and header2.
- //!
+ //!
 //! Effects: Swaps two nodes. After the function node1 will be inserted
 //! in the position node2 before the function. node2 will be inserted in the
 //! position node1 had before the function.
- //!
- //! Complexity: Constant.
- //!
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function will break container ordering invariants if
 //! node1 and node2 are not equivalent according to the ordering rules.
 //!
@@ -216,8 +216,8 @@
 {
 if(node1 == node2)
 return;
-
- //node1 and node2 must not be header nodes
+
+ //node1 and node2 must not be header nodes
 //BOOST_INTRUSIVE_INVARIANT_ASSERT((header1 != node1 && header2 != node2));
 if(header1 != header2){
 //Update header1 if necessary
@@ -347,14 +347,14 @@

 //! Requires: node_to_be_replaced must be inserted in a tree
 //! and new_node must not be inserted in a tree.
- //!
+ //!
 //! Effects: Replaces node_to_be_replaced in its position in the
 //! tree with new_node. The tree does not need to be rebalanced
- //!
- //! Complexity: Logarithmic.
- //!
+ //!
+ //! Complexity: Logarithmic.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function will break container ordering invariants if
 //! new_node is not equivalent to node_to_be_replaced according to the
 //! ordering rules. This function is faster than erasing and inserting
@@ -370,14 +370,14 @@

 //! Requires: node_to_be_replaced must be inserted in a tree
 //! with header "header" and new_node must not be inserted in a tree.
- //!
+ //!
 //! Effects: Replaces node_to_be_replaced in its position in the
 //! tree with new_node. The tree does not need to be rebalanced
- //!
- //! Complexity: Constant.
- //!
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function will break container ordering invariants if
 //! new_node is not equivalent to node_to_be_replaced according to the
 //! ordering rules. This function is faster than erasing and inserting
@@ -388,7 +388,7 @@
 {
 if(node_to_be_replaced == new_node)
 return;
-
+
 //Update header if necessary
 if(node_to_be_replaced == NodeTraits::get_left(header)){
 NodeTraits::set_left(header, new_node);
@@ -428,11 +428,11 @@
 }

 //! Requires: 'node' is a node from the tree except the header.
- //!
+ //!
 //! Effects: Returns the next node of the tree.
- //!
+ //!
 //! Complexity: Average constant time.
- //!
+ //!
 //! Throws: Nothing.
 static node_ptr next_node(const node_ptr & node)
 {
@@ -452,11 +452,11 @@
 }

 //! Requires: 'node' is a node from the tree except the leftmost node.
- //!
+ //!
 //! Effects: Returns the previous node of the tree.
- //!
+ //!
 //! Complexity: Average constant time.
- //!
+ //!
 //! Throws: Nothing.
 static node_ptr prev_node(const node_ptr & node)
 {
@@ -479,11 +479,11 @@
 }

 //! Requires: 'node' is a node of a tree but not the header.
- //!
+ //!
 //! Effects: Returns the minimum node of the subtree starting at p.
- //!
+ //!
 //! Complexity: Logarithmic to the size of the subtree.
- //!
+ //!
 //! Throws: Nothing.
 static node_ptr minimum (const node_ptr & node)
 {
@@ -497,11 +497,11 @@
 }

 //! Requires: 'node' is a node of a tree but not the header.
- //!
+ //!
 //! Effects: Returns the maximum node of the subtree starting at p.
- //!
+ //!
 //! Complexity: Logarithmic to the size of the subtree.
- //!
+ //!
 //! Throws: Nothing.
 static node_ptr maximum(const node_ptr & node)
 {
@@ -517,9 +517,9 @@
 //! Requires: 'node' must not be part of any tree.
 //!
 //! Effects: After the function unique(node) == true.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 //!
 //! Nodes: If node is inserted in a tree, this function corrupts the tree.
@@ -527,17 +527,17 @@
 {
 NodeTraits::set_parent(node, node_ptr());
 NodeTraits::set_left(node, node_ptr());
- NodeTraits::set_right(node, node_ptr());
+ NodeTraits::set_right(node, node_ptr());
 };

 //! Effects: Returns true if node is in the same state as if called init(node)
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 static bool inited(const const_node_ptr & node)
 {
- return !NodeTraits::get_parent(node) &&
+ return !NodeTraits::get_parent(node) &&
 !NodeTraits::get_left(node) &&
 !NodeTraits::get_right(node) ;
 };
@@ -546,9 +546,9 @@
 //!
 //! Effects: Initializes the header to represent an empty tree.
 //! unique(header) == true.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 //!
 //! Nodes: If node is inserted in a tree, this function corrupts the tree.
@@ -556,19 +556,19 @@
 {
 NodeTraits::set_parent(header, node_ptr());
 NodeTraits::set_left(header, header);
- NodeTraits::set_right(header, header);
+ NodeTraits::set_right(header, header);
 }

 //! Requires: "disposer" must be an object function
 //! taking a node_ptr parameter and shouldn't throw.
 //!
- //! Effects: Empties the target tree calling
+ //! Effects: Empties the target tree calling
 //! <tt>void disposer::operator()(const node_ptr &)</tt> for every node of the tree
 //! except the header.
- //!
+ //!
 //! Complexity: Linear to the number of element of the source tree plus the.
 //! number of elements of tree target tree when calling this function.
- //!
+ //!
 //! Throws: If cloner functor throws. If this happens target nodes are disposed.
 template<class Disposer>
 static void clear_and_dispose(const node_ptr & header, Disposer disposer)
@@ -581,14 +581,14 @@
 }

 //! Requires: header is the header of a tree.
- //!
+ //!
 //! Effects: Unlinks the leftmost node from the tree, and
 //! updates the header link to the new leftmost node.
- //!
+ //!
 //! Complexity: Average complexity is constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Notes: This function breaks the tree and the tree can
 //! only be used for more unlink_leftmost_without_rebalance calls.
 //! This function is normally used to achieve a step by step
@@ -624,11 +624,11 @@
 }

 //! Requires: node is a node of the tree but it's not the header.
- //!
+ //!
 //! Effects: Returns the number of nodes of the subtree.
- //!
+ //!
 //! Complexity: Linear time.
- //!
+ //!
 //! Throws: Nothing.
 static std::size_t count(const const_node_ptr & subtree)
 {
@@ -660,11 +660,11 @@
 }

 //! Requires: node is a node of the tree but it's not the header.
- //!
+ //!
 //! Effects: Returns the number of nodes of the subtree.
- //!
+ //!
 //! Complexity: Linear time.
- //!
+ //!
 //! Throws: Nothing.
 static std::size_t size(const const_node_ptr & header)
 {
@@ -677,18 +677,18 @@

 //! Requires: header1 and header2 must be the header nodes
 //! of two trees.
- //!
- //! Effects: Swaps two trees. After the function header1 will contain
+ //!
+ //! Effects: Swaps two trees. After the function header1 will contain
 //! links to the second tree and header2 will have links to the first tree.
- //!
- //! Complexity: Constant.
- //!
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: Nothing.
 static void swap_tree(const node_ptr & header1, const node_ptr & header2)
 {
 if(header1 == header2)
 return;
-
+
 node_ptr tmp;

 //Parent swap
@@ -734,7 +734,7 @@
 (NodeTraits::get_parent(p_left) != p ||
 NodeTraits::get_parent(p_right) != p ))
 //When tree size > 1 headers can't be leftmost's
- //and rightmost's parent
+ //and rightmost's parent
 )){
 return true;
 }
@@ -750,7 +750,7 @@
 //! "key" according to "comp" or "header" if that element does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static node_ptr find
@@ -772,7 +772,7 @@
 //! if they there are no equivalent elements.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static std::pair<node_ptr, node_ptr> equal_range
@@ -829,7 +829,7 @@
 //! not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static node_ptr lower_bound
@@ -858,7 +858,7 @@
 //! than "key" according to "comp" or "header" if that element does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static node_ptr upper_bound
@@ -882,16 +882,16 @@
 //! "commit_data" must have been obtained from a previous call to
 //! "insert_unique_check". No objects should have been inserted or erased
 //! from the set between the "insert_unique_check" that filled "commit_data"
- //! and the call to "insert_commit".
- //!
- //!
+ //! and the call to "insert_commit".
+ //!
+ //!
 //! Effects: Inserts new_node in the set using the information obtained
 //! from the "commit_data" that a previous "insert_check" filled.
 //!
 //! Complexity: Constant time.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Notes: This function has only sense if a "insert_unique_check" has been
 //! previously executed to fill "commit_data". No value should be inserted or
 //! erased between the "insert_check" and "insert_commit" calls.
@@ -929,7 +929,7 @@
 //! KeyNodePtrCompare is a function object that induces a strict weak
 //! ordering compatible with the strict weak ordering used to create the
 //! the tree. NodePtrCompare compares KeyType with a node_ptr.
- //!
+ //!
 //! Effects: Checks if there is an equivalent node to "key" in the
 //! tree according to "comp" and obtains the needed information to realize
 //! a constant-time node insertion if there is no equivalent node.
@@ -940,11 +940,11 @@
 //! in the returned pair's boolean and fills "commit_data" that is meant to
 //! be used with the "insert_commit" function to achieve a constant-time
 //! insertion function.
- //!
+ //!
 //! Complexity: Average complexity is at most logarithmic.
 //!
 //! Throws: If "comp" throws.
- //!
+ //!
 //! Notes: This function is used to improve performance when constructing
 //! a node is expensive and the user does not want to have two equivalent nodes
 //! in the tree: if there is an equivalent value
@@ -976,7 +976,7 @@
 while(x){
 ++depth;
 y = x;
- x = (left_child = comp(key, x)) ?
+ x = (left_child = comp(key, x)) ?
 NodeTraits::get_left(x) : (prev = y, NodeTraits::get_right(x));
 }

@@ -1026,7 +1026,7 @@
 {
 if(hint == header || !comp(hint, new_node)){
 node_ptr prev(hint);
- if(hint == NodeTraits::get_left(header) ||
+ if(hint == NodeTraits::get_left(header) ||
 !comp(new_node, (prev = prev_node(hint)))){
 bool link_left = unique(header) || !NodeTraits::get_left(hint);
 commit_data.link_left = link_left;
@@ -1147,13 +1147,13 @@
 }

 //! Requires: 'node' can't be a header node.
- //!
+ //!
 //! Effects: Calculates the depth of a node: the depth of a
 //! node is the length (number of edges) of the path from the root
 //! to that node. (The root node is at depth 0.)
- //!
- //! Complexity: Logarithmic to the number of nodes in the tree.
- //!
+ //!
+ //! Complexity: Logarithmic to the number of nodes in the tree.
+ //!
 //! Throws: Nothing.
 static std::size_t depth(const const_node_ptr & node)
 {
@@ -1171,18 +1171,18 @@
 //! object taking a node_ptr and returning a new cloned node of it. "disposer" must
 //! take a node_ptr and shouldn't throw.
 //!
- //! Effects: First empties target tree calling
+ //! Effects: First empties target tree calling
 //! <tt>void disposer::operator()(const node_ptr &)</tt> for every node of the tree
 //! except the header.
- //!
+ //!
 //! Then, duplicates the entire tree pointed by "source_header" cloning each
- //! source node with <tt>node_ptr Cloner::operator()(const node_ptr &)</tt> to obtain
+ //! source node with <tt>node_ptr Cloner::operator()(const node_ptr &)</tt> to obtain
 //! the nodes of the target tree. If "cloner" throws, the cloned target nodes
 //! are disposed using <tt>void disposer(const node_ptr &)</tt>.
- //!
+ //!
 //! Complexity: Linear to the number of element of the source tree plus the.
 //! number of elements of tree target tree when calling this function.
- //!
+ //!
 //! Throws: If cloner functor throws. If this happens target nodes are disposed.
 template <class Cloner, class Disposer>
 static void clone
@@ -1247,7 +1247,7 @@
 leftmost = insertion_point;
 }
 //Then clone right nodes
- else if( NodeTraits::get_right(current) &&
+ else if( NodeTraits::get_right(current) &&
 !NodeTraits::get_right(insertion_point)){
 current = NodeTraits::get_right(current);
 node_ptr temp = insertion_point;
@@ -1300,21 +1300,21 @@
 }

 //! Requires: p is a node of a tree.
- //!
+ //!
 //! Effects: Returns true if p is a left child.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 static bool is_left_child(const node_ptr & p)
 { return NodeTraits::get_left(NodeTraits::get_parent(p)) == p; }

 //! Requires: p is a node of a tree.
- //!
+ //!
 //! Effects: Returns true if p is a right child.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 static bool is_right_child(const node_ptr & p)
 { return NodeTraits::get_right(NodeTraits::get_parent(p)) == p; }
@@ -1449,7 +1449,7 @@
 if(!old_root) return node_ptr();

 //To avoid irregularities in the algorithm (old_root can be a
- //left or right child or even the root of the tree) just put the
+ //left or right child or even the root of the tree) just put the
 //root as the right child of its parent. Before doing this backup
 //information to restore the original relationship after
 //the algorithm is applied.
@@ -1521,7 +1521,7 @@
 if(!old_root) return old_root;

 //To avoid irregularities in the algorithm (old_root can be
- //left or right child or even the root of the tree) just put the
+ //left or right child or even the root of the tree) just put the
 //root as the right child of its parent. First obtain
 //information to restore the original relationship after
 //the algorithm is applied.
@@ -1536,7 +1536,7 @@
 //Put old_root as right child
 NodeTraits::set_right(super_root, old_root);

- //Start the compression algorithm
+ //Start the compression algorithm
 node_ptr even_parent = super_root;
 node_ptr new_root = old_root;

@@ -1578,7 +1578,7 @@
 //! Effects: Returns a pointer to the header node of the tree.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 static node_ptr get_root(const node_ptr & node)
 {
@@ -1609,7 +1609,7 @@
 while(x){
 ++depth;
 y = x;
- x = comp(new_node, x) ?
+ x = comp(new_node, x) ?
 NodeTraits::get_left(x) : NodeTraits::get_right(x);
 }
 link_left = (y == h) || comp(new_node, y);
@@ -1618,7 +1618,7 @@
 while(x){
 ++depth;
 y = x;
- x = !comp(x, new_node) ?
+ x = !comp(x, new_node) ?
 NodeTraits::get_left(x) : NodeTraits::get_right(x);
 }
 link_left = (y == h) || !comp(y, new_node);
@@ -1689,8 +1689,8 @@
};

} //namespace detail {
-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Modified: branches/release/boost/intrusive/detail/tree_node.hpp
==============================================================================
--- branches/release/boost/intrusive/detail/tree_node.hpp (original)
+++ branches/release/boost/intrusive/detail/tree_node.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -66,7 +66,7 @@
// //
/////////////////////////////////////////////////////////////////////////////

-// tree_iterator provides some basic functions for a
+// tree_iterator provides some basic functions for a
// node oriented bidirectional iterator:
template<class Container, bool IsConst>
class tree_iterator
@@ -86,7 +86,7 @@
 typedef typename node_traits::node_ptr node_ptr;
 typedef typename pointer_traits<node_ptr>::template
 rebind_pointer<void>::type void_pointer;
- static const bool store_container_ptr =
+ static const bool store_container_ptr =
 detail::store_cont_ptr_on_it<Container>::value;

 public:
@@ -114,12 +114,12 @@
 { members_.nodeptr_ = nodeptr; return static_cast<tree_iterator&>(*this); }

 public:
- tree_iterator& operator++()
- {
- members_.nodeptr_ = node_algorithms::next_node(members_.nodeptr_);
- return static_cast<tree_iterator&> (*this);
+ tree_iterator& operator++()
+ {
+ members_.nodeptr_ = node_algorithms::next_node(members_.nodeptr_);
+ return static_cast<tree_iterator&> (*this);
 }
-
+
 tree_iterator operator++(int)
 {
 tree_iterator result (*this);
@@ -127,12 +127,12 @@
 return result;
 }

- tree_iterator& operator--()
- {
- members_.nodeptr_ = node_algorithms::prev_node(members_.nodeptr_);
- return static_cast<tree_iterator&> (*this);
+ tree_iterator& operator--()
+ {
+ members_.nodeptr_ = node_algorithms::prev_node(members_.nodeptr_);
+ return static_cast<tree_iterator&> (*this);
 }
-
+
 tree_iterator operator--(int)
 {
 tree_iterator result (*this);
@@ -182,8 +182,8 @@
 } members_;
};

-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Modified: branches/release/boost/intrusive/detail/utilities.hpp
==============================================================================
--- branches/release/boost/intrusive/detail/utilities.hpp (original)
+++ branches/release/boost/intrusive/detail/utilities.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -200,7 +200,7 @@
 key_nodeptr_comp(KeyValueCompare kcomp, const Container *cont)
 : base_t(kcomp), cont_(cont)
 {}
-
+
 template<class T>
 struct is_node_ptr
 {
@@ -236,7 +236,7 @@
 typedef typename real_value_traits::node_ptr node_ptr;
 typedef typename real_value_traits::const_node_ptr const_node_ptr;
 typedef detail::ebo_functor_holder<F> base_t;
- enum { safemode_or_autounlink =
+ enum { safemode_or_autounlink =
 (int)real_value_traits::link_mode == (int)auto_unlink ||
 (int)real_value_traits::link_mode == (int)safe_link };

@@ -270,7 +270,7 @@
 typedef typename real_value_traits::node_ptr node_ptr;
 typedef detail::ebo_functor_holder<F> base_t;
 typedef typename Container::node_algorithms node_algorithms;
- enum { safemode_or_autounlink =
+ enum { safemode_or_autounlink =
 (int)real_value_traits::link_mode == (int)auto_unlink ||
 (int)real_value_traits::link_mode == (int)safe_link };

@@ -378,7 +378,7 @@

 static const link_mode_type link_mode = LinkMode;

- static pointer to_value_ptr(const node_ptr & n)
+ static pointer to_value_ptr(const node_ptr & n)
 {
 return pointer_traits<pointer>::pointer_to
 (static_cast<reference>(static_cast<node_holder_reference>(*n)));
@@ -504,7 +504,7 @@

 std::size_t n = x;
 std::size_t log2 = 0;
-
+
 for(std::size_t shift = Bits >> 1; shift; shift >>= 1){
 std::size_t tmp = n >> shift;
 if (tmp)
@@ -655,7 +655,7 @@
 , detail::store_cont_ptr_on_it<Container>::value
>::type
{
- static const bool store_container_ptr =
+ static const bool store_container_ptr =
 detail::store_cont_ptr_on_it<Container>::value;

 typedef typename Container::real_value_traits real_value_traits;
@@ -871,8 +871,8 @@
};

} //namespace detail
-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Modified: branches/release/boost/intrusive/hashtable.hpp
==============================================================================
--- branches/release/boost/intrusive/hashtable.hpp (original)
+++ branches/release/boost/intrusive/hashtable.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -57,7 +57,7 @@
 static const std::size_t incremental_pos = 32u;
};

-template
+template
 < class ValueTraits
 , class Hash
 , class Equal
@@ -161,7 +161,7 @@
template<class SupposedValueTraits>
struct unordered_bucket_impl
{
- typedef typename
+ typedef typename
 get_slist_impl_from_supposed_value_traits
 <SupposedValueTraits>::type slist_impl;
 typedef detail::bucket_impl<slist_impl> implementation_defined;
@@ -490,7 +490,7 @@
 //itself, as group list does not link bucket
 node_ptr prev_in_group(group_traits::get_next(elem));
 bool first_in_group = node_traits::get_next(prev_in_group) != elem;
-
+
 if(first_in_group){
 node_ptr start_pos;
 if(last_in_group){
@@ -810,7 +810,7 @@
 node_cast_adaptor(const ConvertibleToF &c2f, const hashtable_impl *cont)
 : base_t(base_t(c2f, cont))
 {}
-
+
 typename base_t::node_ptr operator()(const typename slist_impl::node &to_clone)
 { return base_t::operator()(static_cast<const node &>(to_clone)); }

@@ -824,7 +824,7 @@
 //noncopyable, movable
 BOOST_MOVABLE_BUT_NOT_COPYABLE(hashtable_impl)

- enum { safemode_or_autounlink =
+ enum { safemode_or_autounlink =
 (int)real_value_traits::link_mode == (int)auto_unlink ||
 (int)real_value_traits::link_mode == (int)safe_link };

@@ -879,19 +879,19 @@
 //!
 //! Effects: Constructs an empty unordered_set, storing a reference
 //! to the bucket array and copies of the key_hasher and equal_func functors.
- //!
- //! Complexity: Constant.
- //!
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: If value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
- //! or the copy constructor or invocation of hash_func or equal_func throws.
+ //! or the copy constructor or invocation of hash_func or equal_func throws.
 //!
 //! Notes: buckets array must be disposed only after
 //! *this is disposed.
 hashtable_impl ( const bucket_traits &b_traits
 , const hasher & hash_func = hasher()
 , const key_equal &equal_func = key_equal()
- , const value_traits &v_traits = value_traits())
+ , const value_traits &v_traits = value_traits())
 : data_(b_traits, hash_func, equal_func, v_traits)
 {
 priv_initialize_buckets();
@@ -905,7 +905,7 @@
 }

 //! Effects: to-do
- //!
+ //!
 hashtable_impl(BOOST_RV_REF(hashtable_impl) x)
 : data_( ::boost::move(x.priv_bucket_traits())
 , ::boost::move(x.priv_hasher())
@@ -927,25 +927,25 @@
 }

 //! Effects: to-do
- //!
- hashtable_impl& operator=(BOOST_RV_REF(hashtable_impl) x)
+ //!
+ hashtable_impl& operator=(BOOST_RV_REF(hashtable_impl) x)
 { this->swap(x); return *this; }

- //! Effects: Detaches all elements from this. The objects in the unordered_set
+ //! Effects: Detaches all elements from this. The objects in the unordered_set
 //! are not deleted (i.e. no destructors are called).
- //!
- //! Complexity: Linear to the number of elements in the unordered_set, if
+ //!
+ //! Complexity: Linear to the number of elements in the unordered_set, if
 //! it's a safe-mode or auto-unlink value. Otherwise constant.
- //!
+ //!
 //! Throws: Nothing.
- ~hashtable_impl()
+ ~hashtable_impl()
 {}

 //! Effects: Returns an iterator pointing to the beginning of the unordered_set.
- //!
+ //!
 //! Complexity: Amortized constant time.
 //! Worst case (empty unordered_set): O(this->bucket_count())
- //!
+ //!
 //! Throws: Nothing.
 iterator begin()
 { return iterator(this->priv_begin(), this); }
@@ -955,7 +955,7 @@
 //!
 //! Complexity: Amortized constant time.
 //! Worst case (empty unordered_set): O(this->bucket_count())
- //!
+ //!
 //! Throws: Nothing.
 const_iterator begin() const
 { return this->cbegin(); }
@@ -965,57 +965,57 @@
 //!
 //! Complexity: Amortized constant time.
 //! Worst case (empty unordered_set): O(this->bucket_count())
- //!
+ //!
 //! Throws: Nothing.
 const_iterator cbegin() const
 { return const_iterator(this->priv_begin(), this); }

 //! Effects: Returns an iterator pointing to the end of the unordered_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator end()
 { return iterator(priv_invalid_local_it(), 0); }

 //! Effects: Returns a const_iterator pointing to the end of the unordered_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator end() const
 { return this->cend(); }

 //! Effects: Returns a const_iterator pointing to the end of the unordered_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator cend() const
 { return const_iterator(priv_invalid_local_it(), 0); }

 //! Effects: Returns the hasher object used by the unordered_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If hasher copy-constructor throws.
 hasher hash_function() const
 { return this->priv_hasher(); }

 //! Effects: Returns the key_equal object used by the unordered_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If key_equal copy-constructor throws.
 key_equal key_eq() const
 { return this->priv_equal(); }

 //! Effects: Returns true if the container is empty.
- //!
+ //!
 //! Complexity: if constant-time size and cache_begin options are disabled,
 //! average constant time (worst case, with empty() == true: O(this->bucket_count()).
 //! Otherwise constant.
- //!
+ //!
 //! Throws: Nothing.
 bool empty() const
 {
@@ -1038,10 +1038,10 @@
 }

 //! Effects: Returns the number of elements stored in the unordered_set.
- //!
+ //!
 //! Complexity: Linear to elements contained in *this if
 //! constant_time_size is false. Constant-time otherwise.
- //!
+ //!
 //! Throws: Nothing.
 size_type size() const
 {
@@ -1060,10 +1060,10 @@

 //! Requires: the hasher and the equality function unqualified swap
 //! call should not throw.
- //!
+ //!
 //! Effects: Swaps the contents of two unordered_sets.
 //! Swaps also the contained bucket array and equality and hasher functors.
- //!
+ //!
 //! Complexity: Constant.
 //!
 //! Throws: If the swap() call for the comparison or hash functors
@@ -1095,7 +1095,7 @@
 //! hash than the original node.
 //!
 //! Effects: Erases all the elements from *this
- //! calling Disposer::operator()(pointer), clones all the
+ //! calling Disposer::operator()(pointer), clones all the
 //! elements from src calling Cloner::operator()(const_reference )
 //! and inserts them on *this. The hash function and the equality
 //! predicate are copied from the source.
@@ -1106,7 +1106,7 @@
 //! calling Disposer::operator()(pointer).
 //!
 //! Complexity: Linear to erased plus inserted elements.
- //!
+ //!
 //! Throws: If cloner or hasher throw or hash or equality predicate copying
 //! throws. Basic guarantee.
 template <class Cloner, class Disposer>
@@ -1131,7 +1131,7 @@
 typedef node_cast_adaptor<detail::node_disposer<Disposer, hashtable_impl> > NodeDisposer;
 typedef node_cast_adaptor<detail::node_cloner<Cloner, hashtable_impl> > NodeCloner;
 NodeDisposer node_disp(disposer, this);
-
+
 detail::exception_array_disposer<bucket_type, NodeDisposer, size_type>
 rollback(dst_buckets[0], node_disp, constructed);
 for( constructed = 0
@@ -1191,15 +1191,15 @@
 }

 //! Requires: value must be an lvalue
- //!
+ //!
 //! Effects: Inserts the value into the unordered_set.
 //!
 //! Returns: An iterator to the inserted value.
- //!
+ //!
 //! Complexity: Average case O(1), worst case O(this->size()).
- //!
+ //!
 //! Throws: If the internal hasher or the equality functor throws. Strong guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 iterator insert_equal(reference value)
@@ -1212,16 +1212,16 @@
 return priv_insert_equal_find(value, bucket_num, hash_value, it);
 }

- //! Requires: Dereferencing iterator must yield an lvalue
+ //! Requires: Dereferencing iterator must yield an lvalue
 //! of type value_type.
- //!
+ //!
 //! Effects: Equivalent to this->insert_equal(t) for each element in [b, e).
- //!
+ //!
 //! Complexity: Average case O(N), where N is std::distance(b, e).
 //! Worst case O(N*this->size()).
- //!
+ //!
 //! Throws: If the internal hasher or the equality functor throws. Basic guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 template<class Iterator>
@@ -1232,7 +1232,7 @@
 }

 //! Requires: value must be an lvalue
- //!
+ //!
 //! Effects: Tries to inserts value into the unordered_set.
 //!
 //! Returns: If the value
@@ -1240,11 +1240,11 @@
 //! iterator to the new value and true. If there is an equivalent value
 //! returns a pair containing an iterator to the already present value
 //! and false.
- //!
+ //!
 //! Complexity: Average case O(1), worst case O(this->size()).
- //!
+ //!
 //! Throws: If the internal hasher or the equality functor throws. Strong guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 std::pair<iterator, bool> insert_unique(reference value)
@@ -1254,20 +1254,20 @@
 (value, this->priv_hasher(), this->priv_equal(), commit_data);
 if(!ret.second)
 return ret;
- return std::pair<iterator, bool>
+ return std::pair<iterator, bool>
 (this->insert_unique_commit(value, commit_data), true);
 }

- //! Requires: Dereferencing iterator must yield an lvalue
+ //! Requires: Dereferencing iterator must yield an lvalue
 //! of type value_type.
- //!
+ //!
 //! Effects: Equivalent to this->insert_unique(t) for each element in [b, e).
- //!
+ //!
 //! Complexity: Average case O(N), where N is std::distance(b, e).
 //! Worst case O(N*this->size()).
- //!
+ //!
 //! Throws: If the internal hasher or the equality functor throws. Basic guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 template<class Iterator>
@@ -1277,14 +1277,14 @@
 this->insert_unique(*b);
 }

- //! Requires: "hash_func" must be a hash function that induces
+ //! Requires: "hash_func" must be a hash function that induces
 //! the same hash values as the stored hasher. The difference is that
 //! "hash_func" hashes the given key instead of the value_type.
 //!
- //! "equal_func" must be a equality function that induces
+ //! "equal_func" must be a equality function that induces
 //! the same equality as key_equal. The difference is that
 //! "equal_func" compares an arbitrary key with the contained values.
- //!
+ //!
 //! Effects: Checks if a value can be inserted in the unordered_set, using
 //! a user provided key instead of the value itself.
 //!
@@ -1293,11 +1293,11 @@
 //! and false. If the value can be inserted returns true in the returned
 //! pair boolean and fills "commit_data" that is meant to be used with
 //! the "insert_commit" function.
- //!
+ //!
 //! Complexity: Average case O(1), worst case O(this->size()).
 //!
 //! Throws: If hash_func or equal_func throw. Strong guarantee.
- //!
+ //!
 //! Notes: This function is used to improve performance when constructing
 //! a value_type is expensive: if there is an equivalent value
 //! the constructed object must be discarded. Many times, the part of the
@@ -1334,16 +1334,16 @@
 //! must have been obtained from a previous call to "insert_check".
 //! No objects should have been inserted or erased from the unordered_set between
 //! the "insert_check" that filled "commit_data" and the call to "insert_commit".
- //!
+ //!
 //! Effects: Inserts the value in the unordered_set using the information obtained
 //! from the "commit_data" that a previous "insert_check" filled.
 //!
 //! Returns: An iterator to the newly inserted object.
- //!
+ //!
 //! Complexity: Constant time.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Notes: This function has only sense if a "insert_check" has been
 //! previously executed to fill "commit_data". No value should be inserted or
 //! erased between the "insert_check" and "insert_commit" calls.
@@ -1363,62 +1363,62 @@
 return iterator(b.insert_after(b.before_begin(), *n), this);
 }

- //! Effects: Erases the element pointed to by i.
- //!
+ //! Effects: Erases the element pointed to by i.
+ //!
 //! Complexity: Average case O(1), worst case O(this->size()).
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased element. No destructors are called.
 void erase(const_iterator i)
 { this->erase_and_dispose(i, detail::null_disposer()); }

- //! Effects: Erases the range pointed to by b end e.
- //!
+ //! Effects: Erases the range pointed to by b end e.
+ //!
 //! Complexity: Average case O(std::distance(b, e)),
 //! worst case O(this->size()).
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 void erase(const_iterator b, const_iterator e)
 { this->erase_and_dispose(b, e, detail::null_disposer()); }

 //! Effects: Erases all the elements with the given value.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: Average case O(this->count(value)).
 //! Worst case O(this->size()).
- //!
- //! Throws: If the internal hasher or the equality functor throws.
+ //!
+ //! Throws: If the internal hasher or the equality functor throws.
 //! Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 size_type erase(const_reference value)
 { return this->erase(value, this->priv_hasher(), this->priv_equal()); }

- //! Requires: "hash_func" must be a hash function that induces
+ //! Requires: "hash_func" must be a hash function that induces
 //! the same hash values as the stored hasher. The difference is that
 //! "hash_func" hashes the given key instead of the value_type.
 //!
- //! "equal_func" must be a equality function that induces
+ //! "equal_func" must be a equality function that induces
 //! the same equality as key_equal. The difference is that
 //! "equal_func" compares an arbitrary key with the contained values.
 //!
 //! Effects: Erases all the elements that have the same hash and
 //! compare equal with the given key.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: Average case O(this->count(value)).
 //! Worst case O(this->size()).
- //!
+ //!
 //! Throws: If hash_func or equal_func throw. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class KeyType, class KeyHasher, class KeyValueEqual>
@@ -1427,14 +1427,14 @@

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
 //!
- //! Effects: Erases the element pointed to by i.
+ //! Effects: Erases the element pointed to by i.
 //! Disposer::operator()(pointer) is called for the removed element.
- //!
+ //!
 //! Complexity: Average case O(1), worst case O(this->size()).
- //!
+ //!
 //! Throws: Nothing.
- //!
- //! Note: Invalidates the iterators
+ //!
+ //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
 void erase_and_dispose(const_iterator i, Disposer disposer
@@ -1452,12 +1452,12 @@
 //!
 //! Effects: Erases the range pointed to by b end e.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
+ //!
 //! Complexity: Average case O(std::distance(b, e)),
 //! worst case O(this->size()).
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
@@ -1492,15 +1492,15 @@
 //!
 //! Effects: Erases all the elements with the given value.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: Average case O(this->count(value)).
 //! Worst case O(this->size()).
- //!
+ //!
 //! Throws: If the internal hasher or the equality functor throws.
 //! Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class Disposer>
@@ -1514,12 +1514,12 @@
 //! Disposer::operator()(pointer) is called for the removed elements.
 //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: Average case O(this->count(value)).
 //! Worst case O(this->size()).
- //!
+ //!
 //! Throws: If hash_func or equal_func throw. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class KeyType, class KeyHasher, class KeyValueEqual, class Disposer>
@@ -1565,13 +1565,13 @@
 return count;
 }

- //! Effects: Erases all of the elements.
- //!
+ //! Effects: Erases all of the elements.
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 void clear()
@@ -1581,14 +1581,14 @@
 }

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
- //!
- //! Effects: Erases all of the elements.
- //!
+ //!
+ //! Effects: Erases all of the elements.
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class Disposer>
@@ -1606,25 +1606,25 @@
 }

 //! Effects: Returns the number of contained elements with the given value
- //!
+ //!
 //! Complexity: Average case O(1), worst case O(this->size()).
- //!
+ //!
 //! Throws: If the internal hasher or the equality functor throws.
 size_type count(const_reference value) const
 { return this->count(value, this->priv_hasher(), this->priv_equal()); }

- //! Requires: "hash_func" must be a hash function that induces
+ //! Requires: "hash_func" must be a hash function that induces
 //! the same hash values as the stored hasher. The difference is that
 //! "hash_func" hashes the given key instead of the value_type.
 //!
- //! "equal_func" must be a equality function that induces
+ //! "equal_func" must be a equality function that induces
 //! the same equality as key_equal. The difference is that
 //! "equal_func" compares an arbitrary key with the contained values.
 //!
 //! Effects: Returns the number of contained elements with the given key
 //!
 //! Complexity: Average case O(1), worst case O(this->size()).
- //!
+ //!
 //! Throws: If hash_func or equal throw.
 template<class KeyType, class KeyHasher, class KeyValueEqual>
 size_type count(const KeyType &key, const KeyHasher &hash_func, const KeyValueEqual &equal_func) const
@@ -1638,25 +1638,25 @@
 //! "value" or end() if that element does not exist.
 //!
 //! Complexity: Average case O(1), worst case O(this->size()).
- //!
+ //!
 //! Throws: If the internal hasher or the equality functor throws.
 iterator find(const_reference value)
 { return this->find(value, this->priv_hasher(), this->priv_equal()); }

- //! Requires: "hash_func" must be a hash function that induces
+ //! Requires: "hash_func" must be a hash function that induces
 //! the same hash values as the stored hasher. The difference is that
 //! "hash_func" hashes the given key instead of the value_type.
 //!
- //! "equal_func" must be a equality function that induces
+ //! "equal_func" must be a equality function that induces
 //! the same equality as key_equal. The difference is that
 //! "equal_func" compares an arbitrary key with the contained values.
 //!
- //! Effects: Finds an iterator to the first element whose key is
+ //! Effects: Finds an iterator to the first element whose key is
 //! "key" according to the given hash and equality functor or end() if
 //! that element does not exist.
 //!
 //! Complexity: Average case O(1), worst case O(this->size()).
- //!
+ //!
 //! Throws: If hash_func or equal_func throw.
 //!
 //! Note: This function is used when constructing a value_type
@@ -1672,29 +1672,29 @@
 return iterator(local_it, this);
 }

- //! Effects: Finds a const_iterator to the first element whose key is
+ //! Effects: Finds a const_iterator to the first element whose key is
 //! "key" or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Average case O(1), worst case O(this->size()).
- //!
+ //!
 //! Throws: If the internal hasher or the equality functor throws.
 const_iterator find(const_reference value) const
 { return this->find(value, this->priv_hasher(), this->priv_equal()); }

- //! Requires: "hash_func" must be a hash function that induces
+ //! Requires: "hash_func" must be a hash function that induces
 //! the same hash values as the stored hasher. The difference is that
 //! "hash_func" hashes the given key instead of the value_type.
 //!
- //! "equal_func" must be a equality function that induces
+ //! "equal_func" must be a equality function that induces
 //! the same equality as key_equal. The difference is that
 //! "equal_func" compares an arbitrary key with the contained values.
 //!
- //! Effects: Finds an iterator to the first element whose key is
+ //! Effects: Finds an iterator to the first element whose key is
 //! "key" according to the given hasher and equality functor or end() if
 //! that element does not exist.
- //!
+ //!
 //! Complexity: Average case O(1), worst case O(this->size()).
- //!
+ //!
 //! Throws: If hash_func or equal_func throw.
 //!
 //! Note: This function is used when constructing a value_type
@@ -1712,30 +1712,30 @@
 }

 //! Effects: Returns a range containing all elements with values equivalent
- //! to value. Returns std::make_pair(this->end(), this->end()) if no such
+ //! to value. Returns std::make_pair(this->end(), this->end()) if no such
 //! elements exist.
- //!
+ //!
 //! Complexity: Average case O(this->count(value)). Worst case O(this->size()).
- //!
+ //!
 //! Throws: If the internal hasher or the equality functor throws.
 std::pair<iterator,iterator> equal_range(const_reference value)
 { return this->equal_range(value, this->priv_hasher(), this->priv_equal()); }

- //! Requires: "hash_func" must be a hash function that induces
+ //! Requires: "hash_func" must be a hash function that induces
 //! the same hash values as the stored hasher. The difference is that
 //! "hash_func" hashes the given key instead of the value_type.
 //!
- //! "equal_func" must be a equality function that induces
+ //! "equal_func" must be a equality function that induces
 //! the same equality as key_equal. The difference is that
 //! "equal_func" compares an arbitrary key with the contained values.
 //!
 //! Effects: Returns a range containing all elements with equivalent
- //! keys. Returns std::make_pair(this->end(), this->end()) if no such
+ //! keys. Returns std::make_pair(this->end(), this->end()) if no such
 //! elements exist.
- //!
+ //!
 //! Complexity: Average case O(this->count(key, hash_func, equal_func)).
 //! Worst case O(this->size()).
- //!
+ //!
 //! Throws: If hash_func or the equal_func throw.
 //!
 //! Note: This function is used when constructing a value_type
@@ -1753,31 +1753,31 @@
 }

 //! Effects: Returns a range containing all elements with values equivalent
- //! to value. Returns std::make_pair(this->end(), this->end()) if no such
+ //! to value. Returns std::make_pair(this->end(), this->end()) if no such
 //! elements exist.
- //!
+ //!
 //! Complexity: Average case O(this->count(value)). Worst case O(this->size()).
- //!
+ //!
 //! Throws: If the internal hasher or the equality functor throws.
 std::pair<const_iterator, const_iterator>
 equal_range(const_reference value) const
 { return this->equal_range(value, this->priv_hasher(), this->priv_equal()); }

- //! Requires: "hash_func" must be a hash function that induces
+ //! Requires: "hash_func" must be a hash function that induces
 //! the same hash values as the stored hasher. The difference is that
 //! "hash_func" hashes the given key instead of the value_type.
 //!
- //! "equal_func" must be a equality function that induces
+ //! "equal_func" must be a equality function that induces
 //! the same equality as key_equal. The difference is that
 //! "equal_func" compares an arbitrary key with the contained values.
 //!
 //! Effects: Returns a range containing all elements with equivalent
- //! keys. Returns std::make_pair(this->end(), this->end()) if no such
+ //! keys. Returns std::make_pair(this->end(), this->end()) if no such
 //! elements exist.
- //!
+ //!
 //! Complexity: Average case O(this->count(key, hash_func, equal_func)).
 //! Worst case O(this->size()).
- //!
+ //!
 //! Throws: If the hasher or equal_func throw.
 //!
 //! Note: This function is used when constructing a value_type
@@ -1796,12 +1796,12 @@

 //! Requires: value must be an lvalue and shall be in a unordered_set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid iterator belonging to the unordered_set
 //! that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If the internal hash function throws.
 iterator iterator_to(reference value)
 {
@@ -1810,12 +1810,12 @@

 //! Requires: value must be an lvalue and shall be in a unordered_set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid const_iterator belonging to the
 //! unordered_set that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If the internal hash function throws.
 const_iterator iterator_to(const_reference value) const
 {
@@ -1825,78 +1825,78 @@

 //! Requires: value must be an lvalue and shall be in a unordered_set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid local_iterator belonging to the unordered_set
 //! that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This static function is available only if the value traits
 //! is stateless.
 static local_iterator s_local_iterator_to(reference value)
 {
 BOOST_STATIC_ASSERT((!stateful_value_traits));
 siterator sit = bucket_type::s_iterator_to(((hashtable_impl*)0)->priv_value_to_node(value));
- return local_iterator(sit, (hashtable_impl*)0);
+ return local_iterator(sit, (hashtable_impl*)0);
 }

 //! Requires: value must be an lvalue and shall be in a unordered_set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid const_local_iterator belonging to
 //! the unordered_set that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This static function is available only if the value traits
 //! is stateless.
 static const_local_iterator s_local_iterator_to(const_reference value)
 {
 BOOST_STATIC_ASSERT((!stateful_value_traits));
 siterator sit = bucket_type::s_iterator_to(((hashtable_impl*)0)->priv_value_to_node(const_cast<value_type&>(value)));
- return const_local_iterator(sit, (hashtable_impl*)0);
+ return const_local_iterator(sit, (hashtable_impl*)0);
 }

 //! Requires: value must be an lvalue and shall be in a unordered_set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid local_iterator belonging to the unordered_set
 //! that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 local_iterator local_iterator_to(reference value)
 {
 siterator sit = bucket_type::s_iterator_to(this->priv_value_to_node(value));
- return local_iterator(sit, this);
+ return local_iterator(sit, this);
 }

 //! Requires: value must be an lvalue and shall be in a unordered_set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid const_local_iterator belonging to
 //! the unordered_set that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_local_iterator local_iterator_to(const_reference value) const
 {
 siterator sit = bucket_type::s_iterator_to
 (const_cast<node &>(this->priv_value_to_node(value)));
- return const_local_iterator(sit, this);
+ return const_local_iterator(sit, this);
 }

 //! Effects: Returns the number of buckets passed in the constructor
 //! or the last rehash function.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 size_type bucket_count() const
 { return this->priv_buckets_len(); }
@@ -1904,33 +1904,33 @@
 //! Requires: n is in the range [0, this->bucket_count()).
 //!
 //! Effects: Returns the number of elements in the nth bucket.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 size_type bucket_size(size_type n) const
 { return this->priv_buckets()[n].size(); }

 //! Effects: Returns the index of the bucket in which elements
 //! with keys equivalent to k would be found, if any such element existed.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If the hash functor throws.
 //!
 //! Note: the return value is in the range [0, this->bucket_count()).
 size_type bucket(const key_type& k) const
 { return this->bucket(k, this->priv_hasher()); }

- //! Requires: "hash_func" must be a hash function that induces
+ //! Requires: "hash_func" must be a hash function that induces
 //! the same hash values as the stored hasher. The difference is that
 //! "hash_func" hashes the given key instead of the value_type.
 //!
 //! Effects: Returns the index of the bucket in which elements
 //! with keys equivalent to k would be found, if any such element existed.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If hash_func throws.
 //!
 //! Note: the return value is in the range [0, this->bucket_count()).
@@ -1940,9 +1940,9 @@

 //! Effects: Returns the bucket array pointer passed in the constructor
 //! or the last rehash function.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 bucket_ptr bucket_pointer() const
 { return this->priv_buckets(); }
@@ -1951,13 +1951,13 @@
 //!
 //! Effects: Returns a local_iterator pointing to the beginning
 //! of the sequence stored in the bucket n.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: [this->begin(n), this->end(n)) is a valid range
- //! containing all of the elements in the nth bucket.
+ //! containing all of the elements in the nth bucket.
 local_iterator begin(size_type n)
 { return local_iterator(this->priv_buckets()[n].begin(), this); }

@@ -1965,13 +1965,13 @@
 //!
 //! Effects: Returns a const_local_iterator pointing to the beginning
 //! of the sequence stored in the bucket n.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: [this->begin(n), this->end(n)) is a valid range
- //! containing all of the elements in the nth bucket.
+ //! containing all of the elements in the nth bucket.
 const_local_iterator begin(size_type n) const
 { return this->cbegin(n); }

@@ -1979,13 +1979,13 @@
 //!
 //! Effects: Returns a const_local_iterator pointing to the beginning
 //! of the sequence stored in the bucket n.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: [this->begin(n), this->end(n)) is a valid range
- //! containing all of the elements in the nth bucket.
+ //! containing all of the elements in the nth bucket.
 const_local_iterator cbegin(size_type n) const
 {
 siterator sit = const_cast<bucket_type&>(this->priv_buckets()[n]).begin();
@@ -1996,13 +1996,13 @@
 //!
 //! Effects: Returns a local_iterator pointing to the end
 //! of the sequence stored in the bucket n.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: [this->begin(n), this->end(n)) is a valid range
- //! containing all of the elements in the nth bucket.
+ //! containing all of the elements in the nth bucket.
 local_iterator end(size_type n)
 { return local_iterator(this->priv_buckets()[n].end(), this); }

@@ -2010,11 +2010,11 @@
 //!
 //! Effects: Returns a const_local_iterator pointing to the end
 //! of the sequence stored in the bucket n.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: [this->begin(n), this->end(n)) is a valid range
 //! containing all of the elements in the nth bucket.
 const_local_iterator end(size_type n) const
@@ -2024,13 +2024,13 @@
 //!
 //! Effects: Returns a const_local_iterator pointing to the end
 //! of the sequence stored in the bucket n.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: [this->begin(n), this->end(n)) is a valid range
- //! containing all of the elements in the nth bucket.
+ //! containing all of the elements in the nth bucket.
 const_local_iterator cend(size_type n) const
 { return const_local_iterator(const_cast<bucket_type&>(this->priv_buckets()[n]).end(), this); }

@@ -2044,12 +2044,12 @@
 //! the values from the old bucket and inserts then in the new one.
 //! Bucket traits hold by *this is assigned from new_bucket_traits.
 //! If the container is configured as incremental<>, the split bucket is set
- //! to the new bucket_len().
+ //! to the new bucket_len().
 //!
 //! If store_hash option is true, this method does not use the hash function.
- //!
+ //!
 //! Complexity: Average case linear in this->size(), worst case quadratic.
- //!
+ //!
 //! Throws: If the hasher functor throws. Basic guarantee.
 void rehash(const bucket_traits &new_bucket_traits)
 {
@@ -2058,7 +2058,7 @@
 bucket_ptr old_buckets = this->priv_buckets();
 size_type old_buckets_len = this->priv_buckets_len();

- //Check power of two bucket array if the option is activated
+ //Check power of two bucket array if the option is activated
 BOOST_INTRUSIVE_INVARIANT_ASSERT
 (!power_2_buckets || (0 == (new_buckets_len & (new_buckets_len-1u))));

@@ -2066,7 +2066,7 @@
 const bool same_buffer = old_buckets == new_buckets;
 //If the new bucket length is a common factor
 //of the old one we can avoid hash calculations.
- const bool fast_shrink = (!incremental) && (old_buckets_len > new_buckets_len) &&
+ const bool fast_shrink = (!incremental) && (old_buckets_len > new_buckets_len) &&
 (power_2_buckets ||(old_buckets_len % new_buckets_len) == 0);
 //If we are shrinking the same bucket array and it's
 //is a fast shrink, just rehash the last nodes
@@ -2147,11 +2147,11 @@

 //! Requires:
 //!
- //! Effects:
- //!
- //! Complexity:
- //!
- //! Throws:
+ //! Effects:
+ //!
+ //! Complexity:
+ //!
+ //! Throws:
 //!
 //! Note: this method is only available if incremental<true> option is activated.
 bool incremental_rehash(bool grow = true)
@@ -2214,15 +2214,15 @@
 }

 //! Effects: If new_bucket_traits.bucket_count() is not
- //! this->bucket_count()/2 or this->bucket_count()*2, or
+ //! this->bucket_count()/2 or this->bucket_count()*2, or
 //! this->split_bucket() != new_bucket_traits.bucket_count() returns false
 //! and does nothing.
 //!
 //! Otherwise, copy assigns new_bucket_traits to the internal bucket_traits
 //! and transfers all the objects from old buckets to the new ones.
- //!
+ //!
 //! Complexity: Linear to size().
- //!
+ //!
 //! Throws: Nothing
 //!
 //! Note: this method is only available if incremental<true> option is activated.
@@ -2267,11 +2267,11 @@

 //! Requires:
 //!
- //! Effects:
- //!
- //! Complexity:
- //!
- //! Throws:
+ //! Effects:
+ //!
+ //! Complexity:
+ //!
+ //! Throws:
 size_type split_count() const
 {
 //This function is only available if incremental hashing is activated
@@ -2282,11 +2282,11 @@
 //! Effects: Returns the nearest new bucket count optimized for
 //! the container that is bigger or equal than n. This suggestion can be
 //! used to create bucket arrays with a size that will usually improve
- //! container's performance. If such value does not exist, the
+ //! container's performance. If such value does not exist, the
 //! higher possible value is returned.
- //!
+ //!
 //! Complexity: Amortized constant time.
- //!
+ //!
 //! Throws: Nothing.
 static size_type suggested_upper_bucket_count(size_type n)
 {
@@ -2301,11 +2301,11 @@
 //! Effects: Returns the nearest new bucket count optimized for
 //! the container that is smaller or equal than n. This suggestion can be
 //! used to create bucket arrays with a size that will usually improve
- //! container's performance. If such value does not exist, the
+ //! container's performance. If such value does not exist, the
 //! lowest possible value is returned.
- //!
+ //!
 //! Complexity: Amortized constant time.
- //!
+ //!
 //! Throws: Nothing.
 static size_type suggested_lower_bucket_count(size_type n)
 {
@@ -2613,7 +2613,7 @@
 bool last_in_group = (first_end_ptr <= nxt && nxt <= last_end_ptr) ||
 (group_traits::get_next(nxt) != elem);
 bool first_in_group = node_traits::get_next(prev_in_group) != elem;
-
+
 if(first_in_group){
 node_ptr start_pos;
 if(last_in_group){
@@ -2684,7 +2684,7 @@
 slist_node_ptr elem(i.slist_it().pointed_node());
 slist_node_ptr f_bucket_end, l_bucket_end;
 if(store_hash){
- f_bucket_end = l_bucket_end =
+ f_bucket_end = l_bucket_end =
 (this->priv_buckets()
 [this->priv_hash_to_bucket
 (this->priv_stored_hash(elem, store_hash_t()))
@@ -2720,7 +2720,7 @@
 const real_bucket_traits &rbt = this->priv_real_bucket_traits();
 return rbt.bucket_begin() + rbt.bucket_count();
 }
-
+
 siterator priv_invalid_local_it() const
 { return priv_invalid_bucket()->end(); }

@@ -2887,7 +2887,7 @@
 if(constant_time_size && this->empty()){
 return priv_invalid_local_it();
 }
-
+
 siterator it = previt;
 ++it;

@@ -3008,7 +3008,7 @@
 ++count;
 }
 }
-
+
 //If we reached the end, find the first, non-empty bucket
 for(bucket_number_second = bucket_number_first+1
 ; bucket_number_second != this->priv_buckets_len()
@@ -3043,7 +3043,7 @@
struct make_hashtable_opt
{
 typedef typename pack_options
- < uset_defaults<T>,
+ < uset_defaults<T>,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4, O5, O6, O7, O8, O9, O10
 #else
@@ -3061,7 +3061,7 @@
 , detail::eval_value_traits<value_traits>
 , detail::identity<value_traits>
>::type real_value_traits;
- typedef typename packed_options::bucket_traits specified_bucket_traits;
+ typedef typename packed_options::bucket_traits specified_bucket_traits;

 //Real bucket traits must be calculated from options and calculated value_traits
 typedef typename detail::get_slist_impl
@@ -3111,7 +3111,7 @@
 /// @cond
 typedef hashtable_impl
 < typename make_hashtable_opt
- <T, false,
+ <T, false,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4, O5, O6, O7, O8, O9, O10
 #else
@@ -3132,7 +3132,7 @@
template<class T, class O1, class O2, class O3, class O4, class O5, class O6, class O7, class O8, class O9, class O10>
#endif
class hashtable
- : public make_hashtable<T,
+ : public make_hashtable<T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4, O5, O6, O7, O8, O9, O10
 #else
@@ -3140,7 +3140,7 @@
 #endif
>::type
{
- typedef typename make_hashtable<T,
+ typedef typename make_hashtable<T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4, O5, O6, O7, O8, O9, O10
 #else
@@ -3180,8 +3180,8 @@

#endif

-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Modified: branches/release/boost/intrusive/linear_slist_algorithms.hpp
==============================================================================
--- branches/release/boost/intrusive/linear_slist_algorithms.hpp (original)
+++ branches/release/boost/intrusive/linear_slist_algorithms.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -41,7 +41,7 @@
//! Static functions:
//!
//! <tt>static node_ptr get_next(const_node_ptr n);</tt>
-//!
+//!
//! <tt>static void set_next(node_ptr n, node_ptr next);</tt>
template<class NodeTraits>
class linear_slist_algorithms
@@ -63,37 +63,37 @@
 //! Effects: Constructs an non-used list element, putting the next
 //! pointer to null:
 //! <tt>NodeTraits::get_next(this_node) == node_ptr()</tt>
- //!
- //! Complexity: Constant
- //!
+ //!
+ //! Complexity: Constant
+ //!
 //! Throws: Nothing.
 static void init(const node_ptr & this_node);

 //! Requires: this_node must be in a circular list or be an empty circular list.
- //!
+ //!
 //! Effects: Returns true is "this_node" is the only node of a circular list:
 //! or it's a not inserted node:
 //! <tt>return node_ptr() == NodeTraits::get_next(this_node) || NodeTraits::get_next(this_node) == this_node</tt>
- //!
- //! Complexity: Constant
- //!
+ //!
+ //! Complexity: Constant
+ //!
 //! Throws: Nothing.
 static bool unique(const_node_ptr this_node);

 //! Effects: Returns true is "this_node" has the same state as if
 //! it was inited using "init(node_ptr)"
- //!
- //! Complexity: Constant
- //!
+ //!
+ //! Complexity: Constant
+ //!
 //! Throws: Nothing.
 static bool inited(const_node_ptr this_node);

 //! Requires: prev_node must be in a circular list or be an empty circular list.
- //!
+ //!
 //! Effects: Unlinks the next node of prev_node from the circular list.
- //!
- //! Complexity: Constant
- //!
+ //!
+ //! Complexity: Constant
+ //!
 //! Throws: Nothing.
 static void unlink_after(const node_ptr & prev_node);

@@ -102,28 +102,28 @@
 //!
 //! Effects: Unlinks the range (prev_node, last_node) from the linear list.
 //!
- //! Complexity: Constant
+ //! Complexity: Constant
 //!
 //! Throws: Nothing.
 static void unlink_after(const node_ptr & prev_node, const node_ptr & last_node);

 //! Requires: prev_node must be a node of a linear list.
- //!
+ //!
 //! Effects: Links this_node after prev_node in the linear list.
- //!
- //! Complexity: Constant
- //!
+ //!
+ //! Complexity: Constant
+ //!
 //! Throws: Nothing.
 static void link_after(const node_ptr & prev_node, const node_ptr & this_node);

 //! Requires: b and e must be nodes of the same linear list or an empty range.
 //! and p must be a node of a different linear list.
- //!
+ //!
 //! Effects: Removes the nodes from (b, e] range from their linear list and inserts
 //! them after p in p's linear list.
- //!
- //! Complexity: Constant
- //!
+ //!
+ //! Complexity: Constant
+ //!
 //! Throws: Nothing.
 static void transfer_after(const node_ptr & p, const node_ptr & b, const node_ptr & e);

@@ -132,34 +132,34 @@
 //! Effects: Constructs an empty list, making this_node the only
 //! node of the circular list:
 //! <tt>NodeTraits::get_next(this_node) == this_node</tt>.
- //!
- //! Complexity: Constant
- //!
+ //!
+ //! Complexity: Constant
+ //!
 //! Throws: Nothing.
 static void init_header(const node_ptr & this_node)
 { NodeTraits::set_next(this_node, node_ptr ()); }

 //! Requires: this_node and prev_init_node must be in the same linear list.
- //!
+ //!
 //! Effects: Returns the previous node of this_node in the linear list starting.
 //! the search from prev_init_node. The first node checked for equality
 //! is NodeTraits::get_next(prev_init_node).
- //!
+ //!
 //! Complexity: Linear to the number of elements between prev_init_node and this_node.
- //!
+ //!
 //! Throws: Nothing.
 static node_ptr get_previous_node(const node_ptr & prev_init_node, const node_ptr & this_node)
 { return base_t::get_previous_node(prev_init_node, this_node); }

 //! Requires: this_node must be in a linear list or be an empty linear list.
- //!
+ //!
 //! Effects: Returns the number of nodes in a linear list. If the linear list
 //! is empty, returns 1.
- //!
- //! Complexity: Linear
- //!
+ //!
+ //! Complexity: Linear
+ //!
 //! Throws: Nothing.
- static std::size_t count(const const_node_ptr & this_node)
+ static std::size_t count(const const_node_ptr & this_node)
 {
 std::size_t result = 0;
 const_node_ptr p = this_node;
@@ -172,12 +172,12 @@

 //! Requires: this_node and other_node must be nodes inserted
 //! in linear lists or be empty linear lists.
- //!
+ //!
 //! Effects: Moves all the nodes previously chained after this_node after other_node
 //! and vice-versa.
- //!
- //! Complexity: Constant
- //!
+ //!
+ //! Complexity: Constant
+ //!
 //! Throws: Nothing.
 static void swap_trailing_nodes(const node_ptr & this_node, const node_ptr & other_node)
 {
@@ -187,17 +187,17 @@
 NodeTraits::set_next(other_node, this_nxt);
 }

- //! Effects: Reverses the order of elements in the list.
- //!
- //! Returns: The new first node of the list.
- //!
+ //! Effects: Reverses the order of elements in the list.
+ //!
+ //! Returns: The new first node of the list.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: This function is linear to the contained elements.
 static node_ptr reverse(const node_ptr & p)
 {
 if(!p) return node_ptr();
- node_ptr i = NodeTraits::get_next(p);
+ node_ptr i = NodeTraits::get_next(p);
 node_ptr first(p);
 while(i){
 node_ptr nxti(NodeTraits::get_next(i));
@@ -213,9 +213,9 @@
 //!
 //! Returns: A pair containing the new first and last node of the list or
 //! if there has been any movement, a null pair if n leads to no movement.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the number of elements plus the number moved positions.
 static std::pair<node_ptr, node_ptr> move_first_n_backwards(const node_ptr & p, std::size_t n)
 {
@@ -255,7 +255,7 @@
 if(!end_found){
 old_last = base_t::get_previous_node(first, node_ptr());
 }
-
+
 //Now link p after the new last node
 NodeTraits::set_next(old_last, p);
 NodeTraits::set_next(new_last, node_ptr());
@@ -268,9 +268,9 @@
 //!
 //! Returns: A pair containing the new first and last node of the list or
 //! if there has been any movement, a null pair if n leads to no movement.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the number of elements plus the number moved positions.
 static std::pair<node_ptr, node_ptr> move_first_n_forward(const node_ptr & p, std::size_t n)
 {
@@ -300,7 +300,7 @@
 //If the shift is a multiple of the size there is nothing to do
 if(!new_before_last_pos)
 return ret;
-
+
 for( new_last = p
 ; --new_before_last_pos
 ; new_last = node_traits::get_next(new_last)){
@@ -319,8 +319,8 @@
 }
};

-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Modified: branches/release/boost/intrusive/link_mode.hpp
==============================================================================
--- branches/release/boost/intrusive/link_mode.hpp (original)
+++ branches/release/boost/intrusive/link_mode.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -40,7 +40,7 @@
//!the container without using any function provided by the containers.
auto_unlink
};
-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#endif //BOOST_INTRUSIVE_VALUE_LINK_TYPE_HPP

Modified: branches/release/boost/intrusive/list.hpp
==============================================================================
--- branches/release/boost/intrusive/list.hpp (original)
+++ branches/release/boost/intrusive/list.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -59,7 +59,7 @@

/// @endcond

-//! The class template list is an intrusive container that mimics most of the
+//! The class template list is an intrusive container that mimics most of the
//! interface of std::list as described in the C++ standard.
//!
//! The template parameter \c T is the type to be managed by the container.
@@ -118,12 +118,12 @@
 //noncopyable
 BOOST_MOVABLE_BUT_NOT_COPYABLE(list_impl)

- enum { safemode_or_autounlink =
+ enum { safemode_or_autounlink =
 (int)real_value_traits::link_mode == (int)auto_unlink ||
 (int)real_value_traits::link_mode == (int)safe_link };

 //Constant-time size is incompatible with auto-unlink hooks!
- BOOST_STATIC_ASSERT(!(constant_time_size &&
+ BOOST_STATIC_ASSERT(!(constant_time_size &&
 ((int)real_value_traits::link_mode == (int)auto_unlink)
 ));

@@ -196,25 +196,25 @@
 real_value_traits &get_real_value_traits()
 { return this->get_real_value_traits(detail::bool_<external_value_traits>()); }

- //! Effects: constructs an empty list.
- //!
- //! Complexity: Constant
- //!
+ //! Effects: constructs an empty list.
+ //!
+ //! Complexity: Constant
+ //!
 //! Throws: If real_value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks).
 list_impl(const value_traits &v_traits = value_traits())
 : data_(v_traits)
- {
+ {
 this->priv_size_traits().set_size(size_type(0));
- node_algorithms::init_header(this->get_root_node());
+ node_algorithms::init_header(this->get_root_node());
 }

 //! Requires: Dereferencing iterator must yield an lvalue of type value_type.
- //!
+ //!
 //! Effects: Constructs a list equal to the range [first,last).
- //!
- //! Complexity: Linear in std::distance(b, e). No copy constructors are called.
- //!
+ //!
+ //! Complexity: Linear in std::distance(b, e). No copy constructors are called.
+ //!
 //! Throws: If real_value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks).
 template<class Iterator>
@@ -227,43 +227,43 @@
 }

 //! Effects: to-do
- //!
+ //!
 list_impl(BOOST_RV_REF(list_impl) x)
 : data_(::boost::move(x.priv_value_traits()))
 {
 this->priv_size_traits().set_size(size_type(0));
- node_algorithms::init_header(this->get_root_node());
+ node_algorithms::init_header(this->get_root_node());
 this->swap(x);
 }

 //! Effects: to-do
- //!
- list_impl& operator=(BOOST_RV_REF(list_impl) x)
+ //!
+ list_impl& operator=(BOOST_RV_REF(list_impl) x)
 { this->swap(x); return *this; }

- //! Effects: If it's not a safe-mode or an auto-unlink value_type
+ //! Effects: If it's not a safe-mode or an auto-unlink value_type
 //! the destructor does nothing
- //! (ie. no code is generated). Otherwise it detaches all elements from this.
- //! In this case the objects in the list are not deleted (i.e. no destructors
+ //! (ie. no code is generated). Otherwise it detaches all elements from this.
+ //! In this case the objects in the list are not deleted (i.e. no destructors
 //! are called), but the hooks according to the ValueTraits template parameter
 //! are set to their default value.
- //!
- //! Complexity: Linear to the number of elements in the list, if
- //! it's a safe-mode or auto-unlink value . Otherwise constant.
- ~list_impl()
+ //!
+ //! Complexity: Linear to the number of elements in the list, if
+ //! it's a safe-mode or auto-unlink value . Otherwise constant.
+ ~list_impl()
 {}

 //! Requires: value must be an lvalue.
- //!
+ //!
 //! Effects: Inserts the value in the back of the list.
 //! No copy constructors are called.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
- void push_back(reference value)
+ void push_back(reference value)
 {
 node_ptr to_insert = get_real_value_traits().to_node_ptr(value);
 if(safemode_or_autounlink)
@@ -273,31 +273,31 @@
 }

 //! Requires: value must be an lvalue.
- //!
+ //!
 //! Effects: Inserts the value in the front of the list.
 //! No copy constructors are called.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
- void push_front(reference value)
+ void push_front(reference value)
 {
 node_ptr to_insert = get_real_value_traits().to_node_ptr(value);
 if(safemode_or_autounlink)
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::inited(to_insert));
- node_algorithms::link_before(node_traits::get_next(this->get_root_node()), to_insert);
+ node_algorithms::link_before(node_traits::get_next(this->get_root_node()), to_insert);
 this->priv_size_traits().increment();
 }

 //! Effects: Erases the last element of the list.
 //! No destructors are called.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references) to the erased element.
 void pop_back()
 { return this->pop_back_and_dispose(detail::null_disposer()); }
@@ -307,11 +307,11 @@
 //! Effects: Erases the last element of the list.
 //! No destructors are called.
 //! Disposer::operator()(pointer) is called for the removed element.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Note: Invalidates the iterators to the erased element.
 template<class Disposer>
 void pop_back_and_dispose(Disposer disposer)
@@ -326,11 +326,11 @@

 //! Effects: Erases the first element of the list.
 //! No destructors are called.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references) to the erased element.
 void pop_front()
 { return this->pop_front_and_dispose(detail::null_disposer()); }
@@ -340,15 +340,15 @@
 //! Effects: Erases the first element of the list.
 //! No destructors are called.
 //! Disposer::operator()(pointer) is called for the removed element.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Note: Invalidates the iterators to the erased element.
 template<class Disposer>
 void pop_front_and_dispose(Disposer disposer)
- {
+ {
 node_ptr to_erase = node_traits::get_next(this->get_root_node());
 node_algorithms::unlink(to_erase);
 this->priv_size_traits().decrement();
@@ -358,197 +358,197 @@
 }

 //! Effects: Returns a reference to the first element of the list.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- reference front()
+ reference front()
 { return *get_real_value_traits().to_value_ptr(node_traits::get_next(this->get_root_node())); }

 //! Effects: Returns a const_reference to the first element of the list.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- const_reference front() const
+ const_reference front() const
 { return *get_real_value_traits().to_value_ptr(uncast(node_traits::get_next(this->get_root_node()))); }

 //! Effects: Returns a reference to the last element of the list.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- reference back()
+ reference back()
 { return *get_real_value_traits().to_value_ptr(node_traits::get_previous(this->get_root_node())); }

 //! Effects: Returns a const_reference to the last element of the list.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- const_reference back() const
+ const_reference back() const
 { return *get_real_value_traits().to_value_ptr(uncast(node_traits::get_previous(this->get_root_node()))); }

 //! Effects: Returns an iterator to the first element contained in the list.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- iterator begin()
+ iterator begin()
 { return iterator(node_traits::get_next(this->get_root_node()), this); }

 //! Effects: Returns a const_iterator to the first element contained in the list.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- const_iterator begin() const
+ const_iterator begin() const
 { return this->cbegin(); }

 //! Effects: Returns a const_iterator to the first element contained in the list.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- const_iterator cbegin() const
+ const_iterator cbegin() const
 { return const_iterator(node_traits::get_next(this->get_root_node()), this); }

 //! Effects: Returns an iterator to the end of the list.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- iterator end()
+ iterator end()
 { return iterator(this->get_root_node(), this); }

 //! Effects: Returns a const_iterator to the end of the list.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- const_iterator end() const
+ const_iterator end() const
 { return this->cend(); }

 //! Effects: Returns a constant iterator to the end of the list.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 const_iterator cend() const
 { return const_iterator(uncast(this->get_root_node()), this); }

- //! Effects: Returns a reverse_iterator pointing to the beginning
- //! of the reversed list.
- //!
+ //! Effects: Returns a reverse_iterator pointing to the beginning
+ //! of the reversed list.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 reverse_iterator rbegin()
 { return reverse_iterator(this->end()); }

- //! Effects: Returns a const_reverse_iterator pointing to the beginning
- //! of the reversed list.
- //!
+ //! Effects: Returns a const_reverse_iterator pointing to the beginning
+ //! of the reversed list.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- const_reverse_iterator rbegin() const
+ const_reverse_iterator rbegin() const
 { return this->crbegin(); }

- //! Effects: Returns a const_reverse_iterator pointing to the beginning
- //! of the reversed list.
- //!
+ //! Effects: Returns a const_reverse_iterator pointing to the beginning
+ //! of the reversed list.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- const_reverse_iterator crbegin() const
+ const_reverse_iterator crbegin() const
 { return const_reverse_iterator(end()); }

 //! Effects: Returns a reverse_iterator pointing to the end
- //! of the reversed list.
- //!
+ //! of the reversed list.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- reverse_iterator rend()
+ reverse_iterator rend()
 { return reverse_iterator(begin()); }

 //! Effects: Returns a const_reverse_iterator pointing to the end
- //! of the reversed list.
- //!
+ //! of the reversed list.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- const_reverse_iterator rend() const
+ const_reverse_iterator rend() const
 { return this->crend(); }

 //! Effects: Returns a const_reverse_iterator pointing to the end
- //! of the reversed list.
- //!
+ //! of the reversed list.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- const_reverse_iterator crend() const
+ const_reverse_iterator crend() const
 { return const_reverse_iterator(this->begin()); }

 //! Precondition: end_iterator must be a valid end iterator
 //! of list.
- //!
+ //!
 //! Effects: Returns a const reference to the list associated to the end iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 static list_impl &container_from_end_iterator(iterator end_iterator)
 { return list_impl::priv_container_from_end_iterator(end_iterator); }

 //! Precondition: end_iterator must be a valid end const_iterator
 //! of list.
- //!
+ //!
 //! Effects: Returns a const reference to the list associated to the end iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 static const list_impl &container_from_end_iterator(const_iterator end_iterator)
 { return list_impl::priv_container_from_end_iterator(end_iterator); }

 //! Effects: Returns the number of the elements contained in the list.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the number of elements contained in the list.
 //! if constant-time size option is disabled. Constant time otherwise.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 size_type size() const
 {
 if(constant_time_size)
 return this->priv_size_traits().get_size();
 else
- return node_algorithms::count(this->get_root_node()) - 1;
+ return node_algorithms::count(this->get_root_node()) - 1;
 }

 //! Effects: Returns true if the list contains no elements.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 bool empty() const
 { return node_algorithms::unique(this->get_root_node()); }

 //! Effects: Swaps the elements of x and *this.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 void swap(list_impl& other)
 {
- node_algorithms::swap_nodes(this->get_root_node(), other.get_root_node());
+ node_algorithms::swap_nodes(this->get_root_node(), other.get_root_node());
 if(constant_time_size){
 size_type backup = this->priv_size_traits().get_size();
 this->priv_size_traits().set_size(other.priv_size_traits().get_size());
@@ -559,11 +559,11 @@
 //! Effects: Moves backwards all the elements, so that the first
 //! element becomes the second, the second becomes the third...
 //! the last element becomes the first one.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the number of shifts.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 void shift_backwards(size_type n = 1)
 { node_algorithms::move_forward(this->get_root_node(), n); }
@@ -571,11 +571,11 @@
 //! Effects: Moves forward all the elements, so that the second
 //! element becomes the first, the third becomes the second...
 //! the first element becomes the last one.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the number of shifts.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 void shift_forward(size_type n = 1)
 { node_algorithms::move_backwards(this->get_root_node(), n); }
@@ -587,9 +587,9 @@
 //! or end() if no such element exists.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references) to the
 //! erased element.
 iterator erase(const_iterator i)
@@ -602,13 +602,13 @@
 //!
 //! Returns: the first element remaining beyond the removed elements,
 //! or end() if no such element exists.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the number of erased elements if it's a safe-mode
 //! or auto-unlink value, or constant-time size is enabled. Constant-time otherwise.
- //!
- //! Note: Invalidates the iterators (but not the references) to the
+ //!
+ //! Note: Invalidates the iterators (but not the references) to the
 //! erased elements.
 iterator erase(const_iterator b, const_iterator e)
 {
@@ -629,13 +629,13 @@
 //!
 //! Returns: the first element remaining beyond the removed elements,
 //! or end() if no such element exists.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the number of erased elements if it's a safe-mode
 //! or auto-unlink value is enabled. Constant-time otherwise.
- //!
- //! Note: Invalidates the iterators (but not the references) to the
+ //!
+ //! Note: Invalidates the iterators (but not the references) to the
 //! erased elements.
 iterator erase(const_iterator b, const_iterator e, difference_type n)
 {
@@ -662,9 +662,9 @@
 //! or end() if no such element exists.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Note: Invalidates the iterators to the erased element.
 template <class Disposer>
 iterator erase_and_dispose(const_iterator i, Disposer disposer)
@@ -693,11 +693,11 @@
 //!
 //! Returns: the first element remaining beyond the removed elements,
 //! or end() if no such element exists.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the number of elements erased.
- //!
+ //!
 //! Note: Invalidates the iterators to the erased elements.
 template <class Disposer>
 iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer)
@@ -717,17 +717,17 @@

 //! Effects: Erases all the elements of the container.
 //! No destructors are called.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the number of elements of the list.
 //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references) to the erased elements.
 void clear()
 {
 if(safemode_or_autounlink){
- this->clear_and_dispose(detail::null_disposer());
+ this->clear_and_dispose(detail::null_disposer());
 }
 else{
 node_algorithms::init_header(this->get_root_node());
@@ -740,11 +740,11 @@
 //! Effects: Erases all the elements of the container.
 //! No destructors are called.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the number of elements of the list.
- //!
+ //!
 //! Note: Invalidates the iterators to the erased elements.
 template <class Disposer>
 void clear_and_dispose(Disposer disposer)
@@ -765,15 +765,15 @@
 //! Cloner should yield to nodes equivalent to the original nodes.
 //!
 //! Effects: Erases all the elements from *this
- //! calling Disposer::operator()(pointer), clones all the
+ //! calling Disposer::operator()(pointer), clones all the
 //! elements from src calling Cloner::operator()(const_reference )
 //! and inserts them on *this.
 //!
 //! If cloner throws, all cloned elements are unlinked and disposed
 //! calling Disposer::operator()(pointer).
- //!
+ //!
 //! Complexity: Linear to erased plus inserted elements.
- //!
+ //!
 //! Throws: If cloner throws. Basic guarantee.
 template <class Cloner, class Disposer>
 void clone_from(const list_impl &src, Cloner cloner, Disposer disposer)
@@ -793,11 +793,11 @@
 //! Effects: Inserts the value before the position pointed by p.
 //!
 //! Returns: An iterator to the inserted element.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant time. No copy constructors are called.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 iterator insert(const_iterator p, reference value)
 {
@@ -809,16 +809,16 @@
 return iterator(to_insert, this);
 }

- //! Requires: Dereferencing iterator must yield
+ //! Requires: Dereferencing iterator must yield
 //! an lvalue of type value_type and p must be a valid iterator of *this.
- //!
+ //!
 //! Effects: Inserts the range pointed by b and e before the position p.
 //! No copy constructors are called.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the number of elements inserted.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 template<class Iterator>
 void insert(const_iterator p, Iterator b, Iterator e)
@@ -827,19 +827,19 @@
 this->insert(p, *b);
 }

- //! Requires: Dereferencing iterator must yield
+ //! Requires: Dereferencing iterator must yield
 //! an lvalue of type value_type.
- //!
+ //!
 //! Effects: Clears the list and inserts the range pointed by b and e.
 //! No destructors or copy constructors are called.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the number of elements inserted plus
 //! linear to the elements contained in the list if it's a safe-mode
 //! or auto-unlink value.
 //! Linear to the number of elements inserted in the list otherwise.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements.
 template<class Iterator>
@@ -851,18 +851,18 @@

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
 //!
- //! Requires: Dereferencing iterator must yield
+ //! Requires: Dereferencing iterator must yield
 //! an lvalue of type value_type.
- //!
+ //!
 //! Effects: Clears the list and inserts the range pointed by b and e.
 //! No destructors or copy constructors are called.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the number of elements inserted plus
 //! linear to the elements contained in the list.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements.
 template<class Iterator, class Disposer>
@@ -880,7 +880,7 @@
 //! Throws: Nothing.
 //!
 //! Complexity: Constant.
- //!
+ //!
 //! Note: Iterators of values obtained from list x now point to elements of
 //! this list. Iterators of this list and all the references are not invalidated.
 void splice(const_iterator p, list_impl& x)
@@ -897,15 +897,15 @@

 //! Requires: p must be a valid iterator of *this.
 //! new_ele must point to an element contained in list x.
- //!
- //! Effects: Transfers the value pointed by new_ele, from list x to this list,
+ //!
+ //! Effects: Transfers the value pointed by new_ele, from list x to this list,
 //! before the the element pointed by p. No destructors or copy constructors are called.
- //! If p == new_ele or p == ++new_ele, this function is a null operation.
- //!
+ //! If p == new_ele or p == ++new_ele, this function is a null operation.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Note: Iterators of values obtained from list x now point to elements of this
 //! list. Iterators of this list and all the references are not invalidated.
 void splice(const_iterator p, list_impl&x, const_iterator new_ele)
@@ -917,15 +917,15 @@

 //! Requires: p must be a valid iterator of *this.
 //! start and end must point to elements contained in list x.
- //!
- //! Effects: Transfers the range pointed by start and end from list x to this list,
+ //!
+ //! Effects: Transfers the range pointed by start and end from list x to this list,
 //! before the the element pointed by p. No destructors or copy constructors are called.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the number of elements transferred
 //! if constant-time size option is enabled. Constant-time otherwise.
- //!
+ //!
 //! Note: Iterators of values obtained from list x now point to elements of this
 //! list. Iterators of this list and all the references are not invalidated.
 void splice(const_iterator p, list_impl&x, const_iterator start, const_iterator end)
@@ -939,14 +939,14 @@
 //! Requires: p must be a valid iterator of *this.
 //! start and end must point to elements contained in list x.
 //! n == std::distance(start, end)
- //!
- //! Effects: Transfers the range pointed by start and end from list x to this list,
+ //!
+ //! Effects: Transfers the range pointed by start and end from list x to this list,
 //! before the the element pointed by p. No destructors or copy constructors are called.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Note: Iterators of values obtained from list x now point to elements of this
 //! list. Iterators of this list and all the references are not invalidated.
 void splice(const_iterator p, list_impl&x, const_iterator start, const_iterator end, difference_type n)
@@ -966,25 +966,25 @@
 }
 }

- //! Effects: This function sorts the list *this according to std::less<value_type>.
+ //! Effects: This function sorts the list *this according to std::less<value_type>.
 //! The sort is stable, that is, the relative order of equivalent elements is preserved.
- //!
+ //!
 //! Throws: If real_value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
 //! or std::less<value_type> throws. Basic guarantee.
 //!
 //! Notes: Iterators and references are not invalidated.
- //!
+ //!
 //! Complexity: The number of comparisons is approximately N log N, where N
 //! is the list's size.
- void sort()
+ void sort()
 { this->sort(std::less<value_type>()); }

 //! Requires: p must be a comparison function that induces a strict weak ordering
- //!
- //! Effects: This function sorts the list *this according to p. The sort is
+ //!
+ //! Effects: This function sorts the list *this according to p. The sort is
 //! stable, that is, the relative order of equivalent elements is preserved.
- //!
+ //!
 //! Throws: If real_value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
 //! or the predicate throws. Basic guarantee.
@@ -992,13 +992,13 @@
 //! Notes: This won't throw if list_base_hook<> or
 //! list_member_hook are used.
 //! Iterators and references are not invalidated.
- //!
+ //!
 //! Complexity: The number of comparisons is approximately N log N, where N
 //! is the list's size.
 template<class Predicate>
 void sort(Predicate p)
 {
- if(node_traits::get_next(this->get_root_node())
+ if(node_traits::get_next(this->get_root_node())
 != node_traits::get_previous(this->get_root_node())){
 list_impl carry(this->priv_value_traits());
 detail::array_initializer<list_impl, 64> counter(this->priv_value_traits());
@@ -1021,32 +1021,32 @@
 }

 //! Effects: This function removes all of x's elements and inserts them
- //! in order into *this according to std::less<value_type>. The merge is stable;
- //! that is, if an element from *this is equivalent to one from x, then the element
- //! from *this will precede the one from x.
- //!
+ //! in order into *this according to std::less<value_type>. The merge is stable;
+ //! that is, if an element from *this is equivalent to one from x, then the element
+ //! from *this will precede the one from x.
+ //!
 //! Throws: If std::less<value_type> throws. Basic guarantee.
- //!
+ //!
 //! Complexity: This function is linear time: it performs at most
 //! size() + x.size() - 1 comparisons.
- //!
+ //!
 //! Note: Iterators and references are not invalidated
 void merge(list_impl& x)
 { this->merge(x, std::less<value_type>()); }

 //! Requires: p must be a comparison function that induces a strict weak
 //! ordering and both *this and x must be sorted according to that ordering
- //! The lists x and *this must be distinct.
- //!
+ //! The lists x and *this must be distinct.
+ //!
 //! Effects: This function removes all of x's elements and inserts them
- //! in order into *this. The merge is stable; that is, if an element from *this is
- //! equivalent to one from x, then the element from *this will precede the one from x.
- //!
+ //! in order into *this. The merge is stable; that is, if an element from *this is
+ //! equivalent to one from x, then the element from *this will precede the one from x.
+ //!
 //! Throws: If the predicate throws. Basic guarantee.
- //!
+ //!
 //! Complexity: This function is linear time: it performs at most
 //! size() + x.size() - 1 comparisons.
- //!
+ //!
 //! Note: Iterators and references are not invalidated.
 template<class Predicate>
 void merge(list_impl& x, Predicate p)
@@ -1073,23 +1073,23 @@
 }
 }

- //! Effects: Reverses the order of elements in the list.
- //!
+ //! Effects: Reverses the order of elements in the list.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: This function is linear time.
- //!
+ //!
 //! Note: Iterators and references are not invalidated
 void reverse()
 { node_algorithms::reverse(this->get_root_node()); }

 //! Effects: Removes all the elements that compare equal to value.
 //! No destructors are called.
- //!
+ //!
 //! Throws: If std::equal_to<value_type> throws. Basic guarantee.
- //!
+ //!
 //! Complexity: Linear time. It performs exactly size() comparisons for equality.
- //!
+ //!
 //! Note: The relative order of elements that are not removed is unchanged,
 //! and iterators to elements that are not removed remain valid.
 void remove(const_reference value)
@@ -1101,9 +1101,9 @@
 //! Disposer::operator()(pointer) is called for every removed element.
 //!
 //! Throws: If std::equal_to<value_type> throws. Basic guarantee.
- //!
+ //!
 //! Complexity: Linear time. It performs exactly size() comparisons for equality.
- //!
+ //!
 //! Note: The relative order of elements that are not removed is unchanged,
 //! and iterators to elements that are not removed remain valid.
 template<class Disposer>
@@ -1112,11 +1112,11 @@

 //! Effects: Removes all the elements for which a specified
 //! predicate is satisfied. No destructors are called.
- //!
+ //!
 //! Throws: If pred throws. Basic guarantee.
- //!
+ //!
 //! Complexity: Linear time. It performs exactly size() calls to the predicate.
- //!
+ //!
 //! Note: The relative order of elements that are not removed is unchanged,
 //! and iterators to elements that are not removed remain valid.
 template<class Pred>
@@ -1130,7 +1130,7 @@
 //! Disposer::operator()(pointer) is called for every removed element.
 //!
 //! Throws: If pred throws. Basic guarantee.
- //!
+ //!
 //! Complexity: Linear time. It performs exactly size() comparisons for equality.
 //!
 //! Note: The relative order of elements that are not removed is unchanged,
@@ -1150,26 +1150,26 @@
 }
 }

- //! Effects: Removes adjacent duplicate elements or adjacent
+ //! Effects: Removes adjacent duplicate elements or adjacent
 //! elements that are equal from the list. No destructors are called.
- //!
+ //!
 //! Throws: If std::equal_to<value_type throws. Basic guarantee.
- //!
+ //!
 //! Complexity: Linear time (size()-1 comparisons calls to pred()).
- //!
+ //!
 //! Note: The relative order of elements that are not removed is unchanged,
 //! and iterators to elements that are not removed remain valid.
 void unique()
 { this->unique_and_dispose(std::equal_to<value_type>(), detail::null_disposer()); }

- //! Effects: Removes adjacent duplicate elements or adjacent
+ //! Effects: Removes adjacent duplicate elements or adjacent
 //! elements that satisfy some binary predicate from the list.
 //! No destructors are called.
- //!
+ //!
 //! Throws: If pred throws. Basic guarantee.
- //!
+ //!
 //! Complexity: Linear time (size()-1 comparisons equality comparisons).
- //!
+ //!
 //! Note: The relative order of elements that are not removed is unchanged,
 //! and iterators to elements that are not removed remain valid.
 template<class BinaryPredicate>
@@ -1178,14 +1178,14 @@

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
 //!
- //! Effects: Removes adjacent duplicate elements or adjacent
+ //! Effects: Removes adjacent duplicate elements or adjacent
 //! elements that are equal from the list.
 //! Disposer::operator()(pointer) is called for every removed element.
- //!
+ //!
 //! Throws: If std::equal_to<value_type throws. Basic guarantee.
- //!
+ //!
 //! Complexity: Linear time (size()-1) comparisons equality comparisons.
- //!
+ //!
 //! Note: The relative order of elements that are not removed is unchanged,
 //! and iterators to elements that are not removed remain valid.
 template<class Disposer>
@@ -1194,14 +1194,14 @@

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
 //!
- //! Effects: Removes adjacent duplicate elements or adjacent
+ //! Effects: Removes adjacent duplicate elements or adjacent
 //! elements that satisfy some binary predicate from the list.
 //! Disposer::operator()(pointer) is called for every removed element.
- //!
+ //!
 //! Throws: If pred throws. Basic guarantee.
- //!
+ //!
 //! Complexity: Linear time (size()-1) comparisons equality comparisons.
- //!
+ //!
 //! Note: The relative order of elements that are not removed is unchanged,
 //! and iterators to elements that are not removed remain valid.
 template<class BinaryPredicate, class Disposer>
@@ -1226,13 +1226,13 @@
 }

 //! Requires: value must be a reference to a value inserted in a list.
- //!
+ //!
 //! Effects: This function returns a const_iterator pointing to the element
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Note: Iterators and references are not invalidated.
 //! This static function is available only if the value traits
 //! is stateless.
@@ -1244,17 +1244,17 @@
 }

 //! Requires: value must be a const reference to a value inserted in a list.
- //!
+ //!
 //! Effects: This function returns an iterator pointing to the element.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Note: Iterators and references are not invalidated.
 //! This static function is available only if the value traits
 //! is stateless.
- static const_iterator s_iterator_to(const_reference value)
+ static const_iterator s_iterator_to(const_reference value)
 {
 BOOST_STATIC_ASSERT((!stateful_value_traits));
 BOOST_INTRUSIVE_INVARIANT_ASSERT(!node_algorithms::inited(real_value_traits::to_node_ptr(const_cast<reference> (value))));
@@ -1262,13 +1262,13 @@
 }

 //! Requires: value must be a reference to a value inserted in a list.
- //!
+ //!
 //! Effects: This function returns a const_iterator pointing to the element
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Note: Iterators and references are not invalidated.
 iterator iterator_to(reference value)
 {
@@ -1277,13 +1277,13 @@
 }

 //! Requires: value must be a const reference to a value inserted in a list.
- //!
+ //!
 //! Effects: This function returns an iterator pointing to the element.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Note: Iterators and references are not invalidated.
 const_iterator iterator_to(const_reference value) const
 {
@@ -1434,7 +1434,7 @@
{
 /// @cond
 typedef typename pack_options
- < list_defaults<T>,
+ < list_defaults<T>,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3
 #else
@@ -1466,7 +1466,7 @@
template<class T, class ...Options>
#endif
class list
- : public make_list<T,
+ : public make_list<T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3
 #else
@@ -1475,7 +1475,7 @@
>::type
{
 typedef typename make_list
- <T,
+ <T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3
 #else
@@ -1517,8 +1517,8 @@

#endif

-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Modified: branches/release/boost/intrusive/list_hook.hpp
==============================================================================
--- branches/release/boost/intrusive/list_hook.hpp (original)
+++ branches/release/boost/intrusive/list_hook.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -44,7 +44,7 @@
{
 /// @cond
 typedef typename pack_options
- < hook_defaults,
+ < hook_defaults,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3
 #else
@@ -64,13 +64,13 @@

//! Derive a class from this hook in order to store objects of that class
//! in an list.
-//!
+//!
//! The hook admits the following options: \c tag<>, \c void_pointer<> and
//! \c link_mode<>.
//!
-//! \c tag<> defines a tag to identify the node.
-//! The same tag value can be used in different classes, but if a class is
-//! derived from more than one \c list_base_hook, then each \c list_base_hook needs its
+//! \c tag<> defines a tag to identify the node.
+//! The same tag value can be used in different classes, but if a class is
+//! derived from more than one \c list_base_hook, then each \c list_base_hook needs its
//! unique tag.
//!
//! \c link_mode<> will specify the linking mode of the hook (\c normal_link,
@@ -96,27 +96,27 @@
 public:
 //! Effects: If link_mode is \c auto_unlink or \c safe_link
 //! initializes the node to an unlinked state.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 list_base_hook();

 //! Effects: If link_mode is \c auto_unlink or \c safe_link
 //! initializes the node to an unlinked state. The argument is ignored.
- //!
- //! Throws: Nothing.
- //!
+ //!
+ //! Throws: Nothing.
+ //!
 //! Rationale: Providing a copy-constructor
- //! makes classes using the hook STL-compliant without forcing the
+ //! makes classes using the hook STL-compliant without forcing the
 //! user to do some additional work. \c swap can be used to emulate
 //! move-semantics.
 list_base_hook(const list_base_hook& );

 //! Effects: Empty function. The argument is ignored.
- //!
- //! Throws: Nothing.
- //!
- //! Rationale: Providing an assignment operator
- //! makes classes using the hook STL-compliant without forcing the
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Rationale: Providing an assignment operator
+ //! makes classes using the hook STL-compliant without forcing the
 //! user to do some additional work. \c swap can be used to emulate
 //! move-semantics.
 list_base_hook& operator=(const list_base_hook& );
@@ -125,37 +125,37 @@
 //! nothing (ie. no code is generated). If link_mode is \c safe_link and the
 //! object is stored in an list an assertion is raised. If link_mode is
 //! \c auto_unlink and \c is_linked() is true, the node is unlinked.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 ~list_base_hook();

- //! Effects: Swapping two nodes swaps the position of the elements
- //! related to those nodes in one or two containers. That is, if the node
- //! this is part of the element e1, the node x is part of the element e2
- //! and both elements are included in the containers s1 and s2, then after
- //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1
- //! at the position of e1. If one element is not in a container, then
- //! after the swap-operation the other element is not in a container.
- //! Iterators to e1 and e2 related to those nodes are invalidated.
+ //! Effects: Swapping two nodes swaps the position of the elements
+ //! related to those nodes in one or two containers. That is, if the node
+ //! this is part of the element e1, the node x is part of the element e2
+ //! and both elements are included in the containers s1 and s2, then after
+ //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1
+ //! at the position of e1. If one element is not in a container, then
+ //! after the swap-operation the other element is not in a container.
+ //! Iterators to e1 and e2 related to those nodes are invalidated.
 //!
- //! Complexity: Constant
+ //! Complexity: Constant
 //!
- //! Throws: Nothing.
+ //! Throws: Nothing.
 void swap_nodes(list_base_hook &other);

 //! Precondition: link_mode must be \c safe_link or \c auto_unlink.
 //!
 //! Returns: true, if the node belongs to a container, false
- //! otherwise. This function can be used to test whether \c list::iterator_to
- //! will return a valid iterator.
+ //! otherwise. This function can be used to test whether \c list::iterator_to
+ //! will return a valid iterator.
 //!
- //! Complexity: Constant
+ //! Complexity: Constant
 bool is_linked() const;

 //! Effects: Removes the node if it's inserted in a container.
 //! This function is only allowed if link_mode is \c auto_unlink.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 void unlink();
 #endif
};
@@ -171,7 +171,7 @@
{
 /// @cond
 typedef typename pack_options
- < hook_defaults,
+ < hook_defaults,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3
 #else
@@ -191,10 +191,10 @@

//! Store this hook in a class to be inserted
//! in an list.
-//!
+//!
//! The hook admits the following options: \c void_pointer<> and
//! \c link_mode<>.
-//!
+//!
//! \c link_mode<> will specify the linking mode of the hook (\c normal_link,
//! \c auto_unlink or \c safe_link).
//!
@@ -218,27 +218,27 @@
 public:
 //! Effects: If link_mode is \c auto_unlink or \c safe_link
 //! initializes the node to an unlinked state.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 list_member_hook();

 //! Effects: If link_mode is \c auto_unlink or \c safe_link
 //! initializes the node to an unlinked state. The argument is ignored.
- //!
- //! Throws: Nothing.
- //!
+ //!
+ //! Throws: Nothing.
+ //!
 //! Rationale: Providing a copy-constructor
- //! makes classes using the hook STL-compliant without forcing the
+ //! makes classes using the hook STL-compliant without forcing the
 //! user to do some additional work. \c swap can be used to emulate
 //! move-semantics.
 list_member_hook(const list_member_hook& );

 //! Effects: Empty function. The argument is ignored.
- //!
- //! Throws: Nothing.
- //!
- //! Rationale: Providing an assignment operator
- //! makes classes using the hook STL-compliant without forcing the
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Rationale: Providing an assignment operator
+ //! makes classes using the hook STL-compliant without forcing the
 //! user to do some additional work. \c swap can be used to emulate
 //! move-semantics.
 list_member_hook& operator=(const list_member_hook& );
@@ -247,43 +247,43 @@
 //! nothing (ie. no code is generated). If link_mode is \c safe_link and the
 //! object is stored in an list an assertion is raised. If link_mode is
 //! \c auto_unlink and \c is_linked() is true, the node is unlinked.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 ~list_member_hook();

- //! Effects: Swapping two nodes swaps the position of the elements
- //! related to those nodes in one or two containers. That is, if the node
- //! this is part of the element e1, the node x is part of the element e2
- //! and both elements are included in the containers s1 and s2, then after
- //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1
- //! at the position of e1. If one element is not in a container, then
- //! after the swap-operation the other element is not in a container.
- //! Iterators to e1 and e2 related to those nodes are invalidated.
+ //! Effects: Swapping two nodes swaps the position of the elements
+ //! related to those nodes in one or two containers. That is, if the node
+ //! this is part of the element e1, the node x is part of the element e2
+ //! and both elements are included in the containers s1 and s2, then after
+ //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1
+ //! at the position of e1. If one element is not in a container, then
+ //! after the swap-operation the other element is not in a container.
+ //! Iterators to e1 and e2 related to those nodes are invalidated.
 //!
- //! Complexity: Constant
+ //! Complexity: Constant
 //!
- //! Throws: Nothing.
+ //! Throws: Nothing.
 void swap_nodes(list_member_hook &other);

 //! Precondition: link_mode must be \c safe_link or \c auto_unlink.
 //!
 //! Returns: true, if the node belongs to a container, false
- //! otherwise. This function can be used to test whether \c list::iterator_to
- //! will return a valid iterator.
+ //! otherwise. This function can be used to test whether \c list::iterator_to
+ //! will return a valid iterator.
 //!
- //! Complexity: Constant
+ //! Complexity: Constant
 bool is_linked() const;

 //! Effects: Removes the node if it's inserted in a container.
 //! This function is only allowed if link_mode is \c auto_unlink.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 void unlink();
 #endif
};

-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Modified: branches/release/boost/intrusive/member_value_traits.hpp
==============================================================================
--- branches/release/boost/intrusive/member_value_traits.hpp (original)
+++ branches/release/boost/intrusive/member_value_traits.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -54,17 +54,17 @@
 static pointer to_value_ptr(const node_ptr &n)
 {
 return pointer(detail::parent_from_member<value_type, node>
- (boost::intrusive::detail::to_raw_pointer(n), PtrToMember));
+ (boost::intrusive::detail::to_raw_pointer(n), PtrToMember));
 }

 static const_pointer to_value_ptr(const const_node_ptr &n)
 {
 return pointer(detail::parent_from_member<value_type, node>
- (boost::intrusive::detail::to_raw_pointer(n), PtrToMember));
+ (boost::intrusive::detail::to_raw_pointer(n), PtrToMember));
 }
};

-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#endif //BOOST_INTRUSIVE_MEMBER_VALUE_TRAITS_HPP

Modified: branches/release/boost/intrusive/options.hpp
==============================================================================
--- branches/release/boost/intrusive/options.hpp (original)
+++ branches/release/boost/intrusive/options.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -245,7 +245,7 @@
//!alpha value that does not need floating-point operations.
//!
//!If activated, the fixed alpha value is 1/sqrt(2). This
-//!option also saves some space in the container since
+//!option also saves some space in the container since
//!the alpha value and some additional data does not need
//!to be stored in the container.
//!
@@ -567,7 +567,7 @@

//!This option setter specifies if the hash container will use incremental
//!hashing. With incremental hashing the cost of hash table expansion is spread
-//!out across each hash table insertion operation, as opposed to be incurred all at once.
+//!out across each hash table insertion operation, as opposed to be incurred all at once.
//!Therefore linear hashing is well suited for interactive applications or real-time
//!appplications where the worst-case insertion time of non-incremental hash containers
//!(rehashing the whole bucket array) is not admisible.
@@ -651,9 +651,9 @@
 , O9
>::type
 , O10
- >::type
+ >::type
 , O11
- >::type
+ >::type
 type;
};
#else
@@ -666,7 +666,7 @@
template<std::size_t Num, typename Tuple = index_tuple<> >
struct build_number_seq;

-template<std::size_t Num, int... Indexes>
+template<std::size_t Num, int... Indexes>
struct build_number_seq<Num, index_tuple<Indexes...> >
 : build_number_seq<Num - 1, index_tuple<Indexes..., sizeof...(Indexes)> >
{};

Modified: branches/release/boost/intrusive/parent_from_member.hpp
==============================================================================
--- branches/release/boost/intrusive/parent_from_member.hpp (original)
+++ branches/release/boost/intrusive/parent_from_member.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -20,7 +20,7 @@

//! Given a pointer to a member and its corresponding pointer to data member,
//! this function returns the pointer of the parent containing that member.
-//! Note: this function does not work with pointer to members that rely on
+//! Note: this function does not work with pointer to members that rely on
//! virtual inheritance.
template<class Parent, class Member>
inline Parent *get_parent_from_member(Member *member, const Member Parent::* ptr_to_member)
@@ -28,7 +28,7 @@

//! Given a const pointer to a member and its corresponding const pointer to data member,
//! this function returns the const pointer of the parent containing that member.
-//! Note: this function does not work with pointer to members that rely on
+//! Note: this function does not work with pointer to members that rely on
//! virtual inheritance.
template<class Parent, class Member>
inline const Parent *get_parent_from_member(const Member *member, const Member Parent::* ptr_to_member)

Modified: branches/release/boost/intrusive/pointer_plus_bits.hpp
==============================================================================
--- branches/release/boost/intrusive/pointer_plus_bits.hpp (original)
+++ branches/release/boost/intrusive/pointer_plus_bits.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -63,7 +63,7 @@
    static void set_pointer(pointer &n, pointer p)
    {
       BOOST_INTRUSIVE_INVARIANT_ASSERT(0 == (std::size_t(p) & Mask));
- n = pointer(std::size_t(p) | (std::size_t(n) & Mask));
+ n = pointer(std::size_t(p) | (std::size_t(n) & Mask));
    }

    static std::size_t get_bits(pointer n)
@@ -76,7 +76,7 @@
    }
};

-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#endif //BOOST_INTRUSIVE_POINTER_PLUS_BITS_HPP

Modified: branches/release/boost/intrusive/pointer_traits.hpp
==============================================================================
--- branches/release/boost/intrusive/pointer_traits.hpp (original)
+++ branches/release/boost/intrusive/pointer_traits.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -52,7 +52,7 @@
 typedef unspecified_type difference_type;

 //!Ptr::rebind if such a type exists; otherwise, SomePointer<U, Args> if Ptr is
- //!a class template instantiation of the form SomePointer<T, Args>, where Args is zero or
+ //!a class template instantiation of the form SomePointer<T, Args>, where Args is zero or
 //!more type arguments ; otherwise, the instantiation of rebind is ill-formed.
 //!
 //!For portable code for C++03 and C++11, <pre>typename rebind_pointer::type</pre>
@@ -60,7 +60,7 @@
 template <class U> using rebind = unspecified;

 //!Ptr::rebind if such a type exists; otherwise, SomePointer<U, Args> if Ptr is
- //!a class template instantiation of the form SomePointer<T, Args>, where Args is zero or
+ //!a class template instantiation of the form SomePointer<T, Args>, where Args is zero or
 //!more type arguments ; otherwise, the instantiation of rebind is ill-formed.
 //!
 typedef element_type &reference;
@@ -232,7 +232,7 @@

 template <class U> struct rebind_pointer
 { typedef U* type; };
-
+
 //! Returns: addressof(r)
 //!
 static pointer pointer_to(reference r)

Modified: branches/release/boost/intrusive/rbtree.hpp
==============================================================================
--- branches/release/boost/intrusive/rbtree.hpp (original)
+++ branches/release/boost/intrusive/rbtree.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -64,8 +64,8 @@
/// @endcond

//! The class template rbtree is an intrusive red-black tree container, that
-//! is used to construct intrusive set and multiset containers. The no-throw
-//! guarantee holds only, if the value_compare object
+//! is used to construct intrusive set and multiset containers. The no-throw
+//! guarantee holds only, if the value_compare object
//! doesn't throw.
//!
//! The template parameter \c T is the type to be managed by the container.
@@ -126,7 +126,7 @@
 //noncopyable
 BOOST_MOVABLE_BUT_NOT_COPYABLE(rbtree_impl)

- enum { safemode_or_autounlink =
+ enum { safemode_or_autounlink =
 (int)real_value_traits::link_mode == (int)auto_unlink ||
 (int)real_value_traits::link_mode == (int)safe_link };

@@ -217,18 +217,18 @@

 typedef typename node_algorithms::insert_commit_data insert_commit_data;

- //! Effects: Constructs an empty tree.
- //!
- //! Complexity: Constant.
- //!
+ //! Effects: Constructs an empty tree.
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: If value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
 //! or the copy constructorof the value_compare object throws. Basic guarantee.
 rbtree_impl( const value_compare &cmp = value_compare()
- , const value_traits &v_traits = value_traits())
+ , const value_traits &v_traits = value_traits())
 : data_(cmp, v_traits)
- {
- node_algorithms::init_header(this->priv_header_ptr());
+ {
+ node_algorithms::init_header(this->priv_header_ptr());
 this->priv_size_traits().set_size(size_type(0));
 }

@@ -240,7 +240,7 @@
 //!
 //! Complexity: Linear in N if [b, e) is already sorted using
 //! comp and otherwise N * log N, where N is the distance between first and last.
- //!
+ //!
 //! Throws: If value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
 //! or the copy constructor/operator() of the value_compare object throws. Basic guarantee.
@@ -259,58 +259,58 @@
 }

 //! Effects: to-do
- //!
+ //!
 rbtree_impl(BOOST_RV_REF(rbtree_impl) x)
 : data_(::boost::move(x.priv_comp()), ::boost::move(x.priv_value_traits()))
 {
- node_algorithms::init_header(this->priv_header_ptr());
+ node_algorithms::init_header(this->priv_header_ptr());
 this->priv_size_traits().set_size(size_type(0));
 this->swap(x);
 }

 //! Effects: to-do
- //!
- rbtree_impl& operator=(BOOST_RV_REF(rbtree_impl) x)
+ //!
+ rbtree_impl& operator=(BOOST_RV_REF(rbtree_impl) x)
 { this->swap(x); return *this; }

- //! Effects: Detaches all elements from this. The objects in the set
- //! are not deleted (i.e. no destructors are called), but the nodes according to
- //! the value_traits template parameter are reinitialized and thus can be reused.
- //!
- //! Complexity: Linear to elements contained in *this.
- //!
+ //! Effects: Detaches all elements from this. The objects in the set
+ //! are not deleted (i.e. no destructors are called), but the nodes according to
+ //! the value_traits template parameter are reinitialized and thus can be reused.
+ //!
+ //! Complexity: Linear to elements contained in *this.
+ //!
 //! Throws: Nothing.
- ~rbtree_impl()
+ ~rbtree_impl()
 {}

 //! Effects: Returns an iterator pointing to the beginning of the tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator begin()
 { return iterator (node_traits::get_left(this->priv_header_ptr()), this); }

 //! Effects: Returns a const_iterator pointing to the beginning of the tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator begin() const
 { return cbegin(); }

 //! Effects: Returns a const_iterator pointing to the beginning of the tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator cbegin() const
 { return const_iterator (node_traits::get_left(this->priv_header_ptr()), this); }

 //! Effects: Returns an iterator pointing to the end of the tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator end()
 { return iterator (this->priv_header_ptr(), this); }
@@ -318,138 +318,138 @@
 //! Effects: Returns a const_iterator pointing to the end of the tree.
 //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator end() const
 { return cend(); }

 //! Effects: Returns a const_iterator pointing to the end of the tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator cend() const
 { return const_iterator (uncast(this->priv_header_ptr()), this); }

 //! Effects: Returns a reverse_iterator pointing to the beginning of the
 //! reversed tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 reverse_iterator rbegin()
 { return reverse_iterator(end()); }

 //! Effects: Returns a const_reverse_iterator pointing to the beginning
 //! of the reversed tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator rbegin() const
 { return const_reverse_iterator(end()); }

 //! Effects: Returns a const_reverse_iterator pointing to the beginning
 //! of the reversed tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator crbegin() const
 { return const_reverse_iterator(end()); }

 //! Effects: Returns a reverse_iterator pointing to the end
 //! of the reversed tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 reverse_iterator rend()
 { return reverse_iterator(begin()); }

 //! Effects: Returns a const_reverse_iterator pointing to the end
 //! of the reversed tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator rend() const
 { return const_reverse_iterator(begin()); }

 //! Effects: Returns a const_reverse_iterator pointing to the end
 //! of the reversed tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator crend() const
 { return const_reverse_iterator(begin()); }

 //! Precondition: end_iterator must be a valid end iterator
 //! of rbtree.
- //!
+ //!
 //! Effects: Returns a const reference to the rbtree associated to the end iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 static rbtree_impl &container_from_end_iterator(iterator end_iterator)
 { return priv_container_from_end_iterator(end_iterator); }

 //! Precondition: end_iterator must be a valid end const_iterator
 //! of rbtree.
- //!
+ //!
 //! Effects: Returns a const reference to the rbtree associated to the iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 static const rbtree_impl &container_from_end_iterator(const_iterator end_iterator)
 { return priv_container_from_end_iterator(end_iterator); }

 //! Precondition: it must be a valid iterator
 //! of rbtree.
- //!
+ //!
 //! Effects: Returns a const reference to the tree associated to the iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Logarithmic.
 static rbtree_impl &container_from_iterator(iterator it)
 { return priv_container_from_iterator(it); }

 //! Precondition: it must be a valid end const_iterator
 //! of rbtree.
- //!
+ //!
 //! Effects: Returns a const reference to the tree associated to the end iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Logarithmic.
 static const rbtree_impl &container_from_iterator(const_iterator it)
 { return priv_container_from_iterator(it); }

 //! Effects: Returns the value_compare object used by the tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If value_compare copy-constructor throws.
 value_compare value_comp() const
 { return priv_comp(); }

 //! Effects: Returns true if the container is empty.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 bool empty() const
 { return node_algorithms::unique(this->priv_header_ptr()); }

 //! Effects: Returns the number of elements stored in the tree.
- //!
+ //!
 //! Complexity: Linear to elements contained in *this
 //! if constant-time size option is disabled. Constant time otherwise.
- //!
+ //!
 //! Throws: Nothing.
 size_type size() const
 {
@@ -461,9 +461,9 @@
 }

 //! Effects: Swaps the contents of two rbtrees.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If the comparison functor's swap call throws.
 void swap(rbtree_impl& other)
 {
@@ -480,14 +480,14 @@
 }

 //! Requires: value must be an lvalue
- //!
+ //!
 //! Effects: Inserts value into the tree before the upper bound.
- //!
+ //!
 //! Complexity: Average complexity for insert element is at
 //! most logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Strong guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 iterator insert_equal(reference value)
@@ -505,16 +505,16 @@

 //! Requires: value must be an lvalue, and "hint" must be
 //! a valid iterator.
- //!
+ //!
 //! Effects: Inserts x into the tree, using "hint" as a hint to
 //! where it will be inserted. If "hint" is the upper_bound
 //! the insertion takes constant time (two comparisons in the worst case)
- //!
+ //!
 //! Complexity: Logarithmic in general, but it is amortized
 //! constant time if t is inserted immediately before hint.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Strong guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 iterator insert_equal(const_iterator hint, reference value)
@@ -530,18 +530,18 @@
 return ret;
 }

- //! Requires: Dereferencing iterator must yield an lvalue
+ //! Requires: Dereferencing iterator must yield an lvalue
 //! of type value_type.
- //!
+ //!
 //! Effects: Inserts a each element of a range into the tree
 //! before the upper bound of the key of each element.
- //!
+ //!
 //! Complexity: Insert range is in general O(N * log(N)), where N is the
 //! size of the range. However, it is linear in N if the range is already sorted
 //! by value_comp().
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 template<class Iterator>
@@ -553,15 +553,15 @@
 }

 //! Requires: value must be an lvalue
- //!
+ //!
 //! Effects: Inserts value into the tree if the value
 //! is not already present.
- //!
+ //!
 //! Complexity: Average complexity for insert element is at
 //! most logarithmic.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 std::pair<iterator, bool> insert_unique(reference value)
@@ -575,16 +575,16 @@

 //! Requires: value must be an lvalue, and "hint" must be
 //! a valid iterator
- //!
+ //!
 //! Effects: Tries to insert x into the tree, using "hint" as a hint
 //! to where it will be inserted.
- //!
+ //!
 //! Complexity: Logarithmic in general, but it is amortized
 //! constant time (two comparisons in the worst case)
 //! if t is inserted immediately before hint.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 iterator insert_unique(const_iterator hint, reference value)
@@ -596,17 +596,17 @@
 return insert_unique_commit(value, commit_data);
 }

- //! Requires: Dereferencing iterator must yield an lvalue
+ //! Requires: Dereferencing iterator must yield an lvalue
 //! of type value_type.
- //!
+ //!
 //! Effects: Tries to insert each element of a range into the tree.
- //!
- //! Complexity: Insert range is in general O(N * log(N)), where N is the
- //! size of the range. However, it is linear in N if the range is already sorted
+ //!
+ //! Complexity: Insert range is in general O(N * log(N)), where N is the
+ //! size of the range. However, it is linear in N if the range is already sorted
 //! by value_comp().
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 template<class Iterator>
@@ -623,10 +623,10 @@
 }
 }

- //! Requires: key_value_comp must be a comparison function that induces
+ //! Requires: key_value_comp must be a comparison function that induces
 //! the same strict weak ordering as value_compare. The difference is that
 //! key_value_comp compares an arbitrary key with the contained values.
- //!
+ //!
 //! Effects: Checks if a value can be inserted in the container, using
 //! a user provided key instead of the value itself.
 //!
@@ -635,16 +635,16 @@
 //! and false. If the value can be inserted returns true in the returned
 //! pair boolean and fills "commit_data" that is meant to be used with
 //! the "insert_commit" function.
- //!
+ //!
 //! Complexity: Average complexity is at most logarithmic.
 //!
 //! Throws: If the key_value_comp ordering function throws. Strong guarantee.
- //!
+ //!
 //! Notes: This function is used to improve performance when constructing
 //! a value_type is expensive: if there is an equivalent value
 //! the constructed object must be discarded. Many times, the part of the
 //! node that is used to impose the order is much cheaper to construct
- //! than the value_type and this function offers the possibility to use that
+ //! than the value_type and this function offers the possibility to use that
 //! part to check if the insertion will be successful.
 //!
 //! If the check is successful, the user can construct the value_type and use
@@ -659,18 +659,18 @@
 {
 detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl>
 comp(key_value_comp, this);
- std::pair<node_ptr, bool> ret =
+ std::pair<node_ptr, bool> ret =
 (node_algorithms::insert_unique_check
 (this->priv_header_ptr(), key, comp, commit_data));
 return std::pair<iterator, bool>(iterator(ret.first, this), ret.second);
 }

- //! Requires: key_value_comp must be a comparison function that induces
+ //! Requires: key_value_comp must be a comparison function that induces
 //! the same strict weak ordering as value_compare. The difference is that
 //! key_value_comp compares an arbitrary key with the contained values.
- //!
+ //!
 //! Effects: Checks if a value can be inserted in the container, using
- //! a user provided key instead of the value itself, using "hint"
+ //! a user provided key instead of the value itself, using "hint"
 //! as a hint to where it will be inserted.
 //!
 //! Returns: If there is an equivalent value
@@ -678,23 +678,23 @@
 //! and false. If the value can be inserted returns true in the returned
 //! pair boolean and fills "commit_data" that is meant to be used with
 //! the "insert_commit" function.
- //!
+ //!
 //! Complexity: Logarithmic in general, but it's amortized
 //! constant time if t is inserted immediately before hint.
 //!
 //! Throws: If the key_value_comp ordering function throws. Strong guarantee.
- //!
+ //!
 //! Notes: This function is used to improve performance when constructing
 //! a value_type is expensive: if there is an equivalent value
 //! the constructed object must be discarded. Many times, the part of the
 //! constructing that is used to impose the order is much cheaper to construct
- //! than the value_type and this function offers the possibility to use that key
+ //! than the value_type and this function offers the possibility to use that key
 //! to check if the insertion will be successful.
 //!
 //! If the check is successful, the user can construct the value_type and use
 //! "insert_commit" to insert the object in constant-time. This can give a total
 //! constant-time complexity to the insertion: check(O(1)) + commit(O(1)).
- //!
+ //!
 //! "commit_data" remains valid for a subsequent "insert_commit" only if no more
 //! objects are inserted or erased from the container.
 template<class KeyType, class KeyValueCompare>
@@ -704,7 +704,7 @@
 {
 detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl>
 comp(key_value_comp, this);
- std::pair<node_ptr, bool> ret =
+ std::pair<node_ptr, bool> ret =
 (node_algorithms::insert_unique_check
 (this->priv_header_ptr(), hint.pointed_node(), key, comp, commit_data));
 return std::pair<iterator, bool>(iterator(ret.first, this), ret.second);
@@ -714,16 +714,16 @@
 //! must have been obtained from a previous call to "insert_check".
 //! No objects should have been inserted or erased from the container between
 //! the "insert_check" that filled "commit_data" and the call to "insert_commit".
- //!
+ //!
 //! Effects: Inserts the value in the avl_set using the information obtained
 //! from the "commit_data" that a previous "insert_check" filled.
 //!
 //! Returns: An iterator to the newly inserted object.
- //!
+ //!
 //! Complexity: Constant time.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Notes: This function has only sense if a "insert_check" has been
 //! previously executed to fill "commit_data". No value should be inserted or
 //! erased between the "insert_check" and "insert_commit" calls.
@@ -743,11 +743,11 @@
 //! once inserted according to the predicate
 //!
 //! Effects: Inserts x into the tree before "pos".
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function does not check preconditions so if "pos" is not
 //! the successor of "value" tree ordering invariant will be broken.
 //! This is a low-level function to be used only for performance reasons
@@ -766,11 +766,11 @@
 //! than the greatest inserted key
 //!
 //! Effects: Inserts x into the tree in the last position.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function does not check preconditions so if value is
 //! less than the greatest inserted key tree ordering invariant will be broken.
 //! This function is slightly more efficient than using "insert_before".
@@ -789,11 +789,11 @@
 //! than the minimum inserted key
 //!
 //! Effects: Inserts x into the tree in the first position.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function does not check preconditions so if value is
 //! greater than the minimum inserted key tree ordering invariant will be broken.
 //! This function is slightly more efficient than using "insert_before".
@@ -808,12 +808,12 @@
 node_algorithms::push_front(this->priv_header_ptr(), to_insert);
 }

- //! Effects: Erases the element pointed to by pos.
- //!
- //! Complexity: Average complexity for erase element is constant time.
- //!
+ //! Effects: Erases the element pointed to by pos.
+ //!
+ //! Complexity: Average complexity for erase element is constant time.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 iterator erase(const_iterator i)
@@ -830,26 +830,26 @@
 return ret.unconst();
 }

- //! Effects: Erases the range pointed to by b end e.
- //!
- //! Complexity: Average complexity for erase range is at most
+ //! Effects: Erases the range pointed to by b end e.
+ //!
+ //! Complexity: Average complexity for erase range is at most
 //! O(log(size() + N)), where N is the number of elements in the range.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 iterator erase(const_iterator b, const_iterator e)
 { size_type n; return private_erase(b, e, n); }

 //! Effects: Erases all the elements with the given value.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size() + N).
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 size_type erase(const_reference value)
@@ -859,11 +859,11 @@
 //! according to the comparison functor "comp".
 //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size() + N).
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class KeyType, class KeyValueCompare>
@@ -881,14 +881,14 @@

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
 //!
- //! Effects: Erases the element pointed to by pos.
+ //! Effects: Erases the element pointed to by pos.
 //! Disposer::operator()(pointer) is called for the removed element.
- //!
- //! Complexity: Average complexity for erase element is constant time.
- //!
+ //!
+ //! Complexity: Average complexity for erase element is constant time.
+ //!
 //! Throws: Nothing.
- //!
- //! Note: Invalidates the iterators
+ //!
+ //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
 iterator erase_and_dispose(const_iterator i, Disposer disposer)
@@ -909,13 +909,13 @@
 //!
 //! Effects: Erases all the elements with the given value.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size() + N).
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class Disposer>
@@ -931,12 +931,12 @@
 //!
 //! Effects: Erases the range pointed to by b end e.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
- //! Complexity: Average complexity for erase range is at most
+ //!
+ //! Complexity: Average complexity for erase range is at most
 //! O(log(size() + N)), where N is the number of elements in the range.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
@@ -950,11 +950,11 @@
 //! Disposer::operator()(pointer) is called for the removed elements.
 //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size() + N).
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class KeyType, class KeyValueCompare, class Disposer>
@@ -970,13 +970,13 @@
 return n;
 }

- //! Effects: Erases all of the elements.
- //!
+ //! Effects: Erases all of the elements.
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 void clear()
@@ -994,9 +994,9 @@
 //! each node to be erased.
 //! Complexity: Average complexity for is at most O(log(size() + N)),
 //! where N is the number of elements in the container.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. Calls N times to disposer functor.
 template<class Disposer>
@@ -1009,19 +1009,19 @@
 }

 //! Effects: Returns the number of contained elements with the given value
- //!
+ //!
 //! Complexity: Logarithmic to the number of elements contained plus lineal
 //! to number of objects with the given value.
- //!
+ //!
 //! Throws: Nothing.
 size_type count(const_reference value) const
 { return this->count(value, priv_comp()); }

 //! Effects: Returns the number of contained elements with the given key
- //!
+ //!
 //! Complexity: Logarithmic to the number of elements contained plus lineal
 //! to number of objects with the given key.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 size_type count(const KeyType &key, KeyValueCompare comp) const
@@ -1032,27 +1032,27 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is not less than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 iterator lower_bound(const_reference value)
 { return this->lower_bound(value, priv_comp()); }

 //! Effects: Returns an iterator to the first element whose
 //! key is not less than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator lower_bound(const_reference value) const
 { return this->lower_bound(value, priv_comp()); }

 //! Effects: Returns an iterator to the first element whose
 //! key is not less than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 iterator lower_bound(const KeyType &key, KeyValueCompare comp)
@@ -1065,9 +1065,9 @@

 //! Effects: Returns a const iterator to the first element whose
 //! key is not less than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 const_iterator lower_bound(const KeyType &key, KeyValueCompare comp) const
@@ -1080,9 +1080,9 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is greater than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 iterator upper_bound(const_reference value)
 { return this->upper_bound(value, priv_comp()); }
@@ -1092,7 +1092,7 @@
 //! does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 iterator upper_bound(const KeyType &key, KeyValueCompare comp)
@@ -1105,9 +1105,9 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is greater than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator upper_bound(const_reference value) const
 { return this->upper_bound(value, priv_comp()); }
@@ -1117,7 +1117,7 @@
 //! does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 const_iterator upper_bound(const KeyType &key, KeyValueCompare comp) const
@@ -1128,20 +1128,20 @@
 (this->priv_header_ptr(), key, key_node_comp), this);
 }

- //! Effects: Finds an iterator to the first element whose key is
+ //! Effects: Finds an iterator to the first element whose key is
 //! k or end() if that element does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 iterator find(const_reference value)
 { return this->find(value, priv_comp()); }

- //! Effects: Finds an iterator to the first element whose key is
+ //! Effects: Finds an iterator to the first element whose key is
 //! k or end() if that element does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 iterator find(const KeyType &key, KeyValueCompare comp)
@@ -1152,20 +1152,20 @@
 (node_algorithms::find(this->priv_header_ptr(), key, key_node_comp), this);
 }

- //! Effects: Finds a const_iterator to the first element whose key is
+ //! Effects: Finds a const_iterator to the first element whose key is
 //! k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator find(const_reference value) const
 { return this->find(value, priv_comp()); }

- //! Effects: Finds a const_iterator to the first element whose key is
+ //! Effects: Finds a const_iterator to the first element whose key is
 //! k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 const_iterator find(const KeyType &key, KeyValueCompare comp) const
@@ -1179,9 +1179,9 @@
 //! Effects: Finds a range containing all elements whose key is k or
 //! an empty range that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 std::pair<iterator,iterator> equal_range(const_reference value)
 { return this->equal_range(value, priv_comp()); }
@@ -1189,9 +1189,9 @@
 //! Effects: Finds a range containing all elements whose key is k or
 //! an empty range that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 std::pair<iterator,iterator> equal_range(const KeyType &key, KeyValueCompare comp)
@@ -1206,9 +1206,9 @@
 //! Effects: Finds a range containing all elements whose key is k or
 //! an empty range that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 std::pair<const_iterator, const_iterator>
 equal_range(const_reference value) const
@@ -1217,9 +1217,9 @@
 //! Effects: Finds a range containing all elements whose key is k or
 //! an empty range that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 std::pair<const_iterator, const_iterator>
@@ -1236,15 +1236,15 @@
 //! Cloner should yield to nodes equivalent to the original nodes.
 //!
 //! Effects: Erases all the elements from *this
- //! calling Disposer::operator()(pointer), clones all the
+ //! calling Disposer::operator()(pointer), clones all the
 //! elements from src calling Cloner::operator()(const_reference )
 //! and inserts them on *this. Copies the predicate from the source container.
 //!
 //! If cloner throws, all cloned elements are unlinked and disposed
 //! calling Disposer::operator()(pointer).
- //!
+ //!
 //! Complexity: Linear to erased plus inserted elements.
- //!
+ //!
 //! Throws: If cloner throws or predicate copy assignment throws. Basic guarantee.
 template <class Cloner, class Disposer>
 void clone_from(const rbtree_impl &src, Cloner cloner, Disposer disposer)
@@ -1265,11 +1265,11 @@
 }

 //! Effects: Unlinks the leftmost node from the tree.
- //!
+ //!
 //! Complexity: Average complexity is constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Notes: This function breaks the tree and the tree can
 //! only be used for more unlink_leftmost_without_rebalance calls.
 //! This function is normally used to achieve a step by step
@@ -1288,14 +1288,14 @@

 //! Requires: replace_this must be a valid iterator of *this
 //! and with_this must not be inserted in any tree.
- //!
+ //!
 //! Effects: Replaces replace_this in its position in the
 //! tree with with_this. The tree does not need to be rebalanced.
- //!
- //! Complexity: Constant.
- //!
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function will break container ordering invariants if
 //! with_this is not equivalent to *replace_this according to the
 //! ordering rules. This function is faster than erasing and inserting
@@ -1311,14 +1311,14 @@

 //! Requires: value must be an lvalue and shall be in a set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid iterator i belonging to the set
 //! that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This static function is available only if the value traits
 //! is stateless.
 static iterator s_iterator_to(reference value)
@@ -1329,17 +1329,17 @@

 //! Requires: value must be an lvalue and shall be in a set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid const_iterator i belonging to the
 //! set that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This static function is available only if the value traits
 //! is stateless.
- static const_iterator s_iterator_to(const_reference value)
+ static const_iterator s_iterator_to(const_reference value)
 {
 BOOST_STATIC_ASSERT((!stateful_value_traits));
 return const_iterator (value_traits::to_node_ptr(const_cast<reference> (value)), 0);
@@ -1347,48 +1347,48 @@

 //! Requires: value must be an lvalue and shall be in a set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid iterator i belonging to the set
 //! that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator iterator_to(reference value)
 { return iterator (value_traits::to_node_ptr(value), this); }

 //! Requires: value must be an lvalue and shall be in a set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid const_iterator i belonging to the
 //! set that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator iterator_to(const_reference value) const
 { return const_iterator (value_traits::to_node_ptr(const_cast<reference> (value)), this); }

 //! Requires: value shall not be in a tree.
- //!
+ //!
 //! Effects: init_node puts the hook of a value in a well-known default
 //! state.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Note: This function puts the hook in the well-known default state
 //! used by auto_unlink and safe hooks.
 static void init_node(reference value)
 { node_algorithms::init(value_traits::to_node_ptr(value)); }

 //! Effects: removes "value" from the container.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Logarithmic time.
- //!
+ //!
 //! Note: This static function is only usable with non-constant
 //! time size containers that have stateless comparison functors.
 //!
@@ -1565,7 +1565,7 @@
struct make_rbtree_opt
{
 typedef typename pack_options
- < set_defaults<T>,
+ < set_defaults<T>,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
@@ -1596,7 +1596,7 @@
{
 /// @cond
 typedef rbtree_impl
- < typename make_rbtree_opt<T,
+ < typename make_rbtree_opt<T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
@@ -1616,7 +1616,7 @@
template<class T, class ...Options>
#endif
class rbtree
- : public make_rbtree<T,
+ : public make_rbtree<T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
@@ -1625,7 +1625,7 @@
>::type
{
 typedef typename make_rbtree
- <T,
+ <T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
@@ -1679,8 +1679,8 @@
#endif

-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Modified: branches/release/boost/intrusive/rbtree_algorithms.hpp
==============================================================================
--- branches/release/boost/intrusive/rbtree_algorithms.hpp (original)
+++ branches/release/boost/intrusive/rbtree_algorithms.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -11,7 +11,7 @@
//
/////////////////////////////////////////////////////////////////////////////
// The internal implementation of red-black trees is based on that of SGI STL
-// stl_tree.h file:
+// stl_tree.h file:
//
// Copyright (c) 1996,1997
// Silicon Graphics Computer Systems, Inc.
@@ -36,14 +36,14 @@
// representations about the suitability of this software for any
// purpose. It is provided "as is" without express or implied warranty.
//
-// The tree destruction algorithm is based on Julienne Walker and The EC Team code:
-//
+// The tree destruction algorithm is based on Julienne Walker and The EC Team code:
+//
// This code is in the public domain. Anyone may use it or change it in any way that
// they see fit. The author assumes no responsibility for damages incurred through
-// use of the original code or any variations thereof.
-//
+// use of the original code or any variations thereof.
+//
// It is requested, but not required, that due credit is given to the original author
-// and anyone who has modified the code through a header comment, such as this one.
+// and anyone who has modified the code through a header comment, such as this one.

#ifndef BOOST_INTRUSIVE_RBTREE_ALGORITHMS_HPP
#define BOOST_INTRUSIVE_RBTREE_ALGORITHMS_HPP
@@ -61,17 +61,17 @@
namespace boost {
namespace intrusive {

-//! rbtree_algorithms provides basic algorithms to manipulate
-//! nodes forming a red-black tree. The insertion and deletion algorithms are
-//! based on those in Cormen, Leiserson, and Rivest, Introduction to Algorithms
+//! rbtree_algorithms provides basic algorithms to manipulate
+//! nodes forming a red-black tree. The insertion and deletion algorithms are
+//! based on those in Cormen, Leiserson, and Rivest, Introduction to Algorithms
//! (MIT Press, 1990), except that
-//!
+//!
//! (1) the header node is maintained with links not only to the root
//! but also to the leftmost node of the tree, to enable constant time
//! begin(), and to the rightmost node of the tree, to enable linear time
//! performance when used with the generic set algorithms (set_union,
//! etc.);
-//!
+//!
//! (2) when a node being deleted has two children its successor node is
//! relinked into its place, rather than copied, so that the only
//! pointers invalidated are those referring to the deleted node.
@@ -93,23 +93,23 @@
//! Static functions:
//!
//! <tt>static node_ptr get_parent(const_node_ptr n);</tt>
-//!
+//!
//! <tt>static void set_parent(node_ptr n, node_ptr parent);</tt>
//!
//! <tt>static node_ptr get_left(const_node_ptr n);</tt>
-//!
+//!
//! <tt>static void set_left(node_ptr n, node_ptr left);</tt>
//!
//! <tt>static node_ptr get_right(const_node_ptr n);</tt>
-//!
+//!
//! <tt>static void set_right(node_ptr n, node_ptr right);</tt>
-//!
+//!
//! <tt>static color get_color(const_node_ptr n);</tt>
-//!
+//!
//! <tt>static void set_color(node_ptr n, color c);</tt>
-//!
+//!
//! <tt>static color black();</tt>
-//!
+//!
//! <tt>static color red();</tt>
template<class NodeTraits>
class rbtree_algorithms
@@ -135,7 +135,7 @@
 rbtree_node_cloner(F f)
 : base_t(f)
 {}
-
+
 node_ptr operator()(const node_ptr & p)
 {
 node_ptr n = base_t::get()(p);
@@ -172,27 +172,27 @@

 //! Requires: header1 and header2 must be the header nodes
 //! of two trees.
- //!
- //! Effects: Swaps two trees. After the function header1 will contain
+ //!
+ //! Effects: Swaps two trees. After the function header1 will contain
 //! links to the second tree and header2 will have links to the first tree.
- //!
- //! Complexity: Constant.
- //!
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: Nothing.
 static void swap_tree(const node_ptr & header1, const node_ptr & header2)
 { return tree_algorithms::swap_tree(header1, header2); }

 //! Requires: node1 and node2 can't be header nodes
 //! of two trees.
- //!
+ //!
 //! Effects: Swaps two nodes. After the function node1 will be inserted
 //! in the position node2 before the function. node2 will be inserted in the
 //! position node1 had before the function.
- //!
- //! Complexity: Logarithmic.
- //!
+ //!
+ //! Complexity: Logarithmic.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function will break container ordering invariants if
 //! node1 and node2 are not equivalent according to the ordering rules.
 //!
@@ -201,22 +201,22 @@
 {
 if(node1 == node2)
 return;
-
+
 node_ptr header1(tree_algorithms::get_header(node1)), header2(tree_algorithms::get_header(node2));
 swap_nodes(node1, header1, node2, header2);
 }

 //! Requires: node1 and node2 can't be header nodes
 //! of two trees with header header1 and header2.
- //!
+ //!
 //! Effects: Swaps two nodes. After the function node1 will be inserted
 //! in the position node2 before the function. node2 will be inserted in the
 //! position node1 had before the function.
- //!
- //! Complexity: Constant.
- //!
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function will break container ordering invariants if
 //! node1 and node2 are not equivalent according to the ordering rules.
 //!
@@ -228,20 +228,20 @@
 tree_algorithms::swap_nodes(node1, header1, node2, header2);
 //Swap color
 color c = NodeTraits::get_color(node1);
- NodeTraits::set_color(node1, NodeTraits::get_color(node2));
- NodeTraits::set_color(node2, c);
+ NodeTraits::set_color(node1, NodeTraits::get_color(node2));
+ NodeTraits::set_color(node2, c);
 }

 //! Requires: node_to_be_replaced must be inserted in a tree
 //! and new_node must not be inserted in a tree.
- //!
+ //!
 //! Effects: Replaces node_to_be_replaced in its position in the
 //! tree with new_node. The tree does not need to be rebalanced
- //!
- //! Complexity: Logarithmic.
- //!
+ //!
+ //! Complexity: Logarithmic.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function will break container ordering invariants if
 //! new_node is not equivalent to node_to_be_replaced according to the
 //! ordering rules. This function is faster than erasing and inserting
@@ -257,14 +257,14 @@

 //! Requires: node_to_be_replaced must be inserted in a tree
 //! with header "header" and new_node must not be inserted in a tree.
- //!
+ //!
 //! Effects: Replaces node_to_be_replaced in its position in the
 //! tree with new_node. The tree does not need to be rebalanced
- //!
- //! Complexity: Constant.
- //!
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function will break container ordering invariants if
 //! new_node is not equivalent to node_to_be_replaced according to the
 //! ordering rules. This function is faster than erasing and inserting
@@ -274,15 +274,15 @@
 static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & header, const node_ptr & new_node)
 {
 tree_algorithms::replace_node(node_to_be_replaced, header, new_node);
- NodeTraits::set_color(new_node, NodeTraits::get_color(node_to_be_replaced));
+ NodeTraits::set_color(new_node, NodeTraits::get_color(node_to_be_replaced));
 }

 //! Requires: node is a tree node but not the header.
- //!
+ //!
 //! Effects: Unlinks the node and rebalances the tree.
- //!
+ //!
 //! Complexity: Average complexity is constant time.
- //!
+ //!
 //! Throws: Nothing.
 static void unlink(const node_ptr & node)
 {
@@ -295,14 +295,14 @@
 }

 //! Requires: header is the header of a tree.
- //!
+ //!
 //! Effects: Unlinks the leftmost node from the tree, and
 //! updates the header link to the new leftmost node.
- //!
+ //!
 //! Complexity: Average complexity is constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Notes: This function breaks the tree and the tree can
 //! only be used for more unlink_leftmost_without_rebalance calls.
 //! This function is normally used to achieve a step by step
@@ -312,51 +312,51 @@

 //! Requires: node is a node of the tree or an node initialized
 //! by init(...).
- //!
+ //!
 //! Effects: Returns true if the node is initialized by init().
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: Nothing.
 static bool unique(const const_node_ptr & node)
 { return tree_algorithms::unique(node); }

 //! Requires: node is a node of the tree but it's not the header.
- //!
+ //!
 //! Effects: Returns the number of nodes of the subtree.
- //!
+ //!
 //! Complexity: Linear time.
- //!
+ //!
 //! Throws: Nothing.
 static std::size_t count(const const_node_ptr & node)
 { return tree_algorithms::count(node); }

 //! Requires: header is the header node of the tree.
- //!
+ //!
 //! Effects: Returns the number of nodes above the header.
- //!
+ //!
 //! Complexity: Linear time.
- //!
+ //!
 //! Throws: Nothing.
 static std::size_t size(const const_node_ptr & header)
 { return tree_algorithms::size(header); }

 //! Requires: p is a node from the tree except the header.
- //!
+ //!
 //! Effects: Returns the next node of the tree.
- //!
+ //!
 //! Complexity: Average constant time.
- //!
+ //!
 //! Throws: Nothing.
 static node_ptr next_node(const node_ptr & p)
 { return tree_algorithms::next_node(p); }

 //! Requires: p is a node from the tree except the leftmost node.
- //!
+ //!
 //! Effects: Returns the previous node of the tree.
- //!
+ //!
 //! Complexity: Average constant time.
- //!
+ //!
 //! Throws: Nothing.
 static node_ptr prev_node(const node_ptr & p)
 { return tree_algorithms::prev_node(p); }
@@ -364,9 +364,9 @@
 //! Requires: node must not be part of any tree.
 //!
 //! Effects: After the function unique(node) == true.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 //!
 //! Nodes: If node is inserted in a tree, this function corrupts the tree.
@@ -377,25 +377,25 @@
 //!
 //! Effects: Initializes the header to represent an empty tree.
 //! unique(header) == true.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 //!
 //! Nodes: If node is inserted in a tree, this function corrupts the tree.
 static void init_header(const node_ptr & header)
 {
 tree_algorithms::init_header(header);
- NodeTraits::set_color(header, NodeTraits::red());
+ NodeTraits::set_color(header, NodeTraits::red());
 }

 //! Requires: header must be the header of a tree, z a node
 //! of that tree and z != header.
 //!
 //! Effects: Erases node "z" from the tree with header "header".
- //!
+ //!
 //! Complexity: Amortized constant time.
- //!
+ //!
 //! Throws: Nothing.
 static node_ptr erase(const node_ptr & header, const node_ptr & z)
 {
@@ -415,18 +415,18 @@
 //! object taking a node_ptr and returning a new cloned node of it. "disposer" must
 //! take a node_ptr and shouldn't throw.
 //!
- //! Effects: First empties target tree calling
+ //! Effects: First empties target tree calling
 //! <tt>void disposer::operator()(const node_ptr &)</tt> for every node of the tree
 //! except the header.
- //!
+ //!
 //! Then, duplicates the entire tree pointed by "source_header" cloning each
- //! source node with <tt>node_ptr Cloner::operator()(const node_ptr &)</tt> to obtain
+ //! source node with <tt>node_ptr Cloner::operator()(const node_ptr &)</tt> to obtain
 //! the nodes of the target tree. If "cloner" throws, the cloned target nodes
 //! are disposed using <tt>void disposer(const node_ptr &)</tt>.
- //!
+ //!
 //! Complexity: Linear to the number of element of the source tree plus the.
 //! number of elements of tree target tree when calling this function.
- //!
+ //!
 //! Throws: If cloner functor throws. If this happens target nodes are disposed.
 template <class Cloner, class Disposer>
 static void clone
@@ -439,13 +439,13 @@
 //! Requires: "disposer" must be an object function
 //! taking a node_ptr parameter and shouldn't throw.
 //!
- //! Effects: Empties the target tree calling
+ //! Effects: Empties the target tree calling
 //! <tt>void disposer::operator()(const node_ptr &)</tt> for every node of the tree
 //! except the header.
- //!
+ //!
 //! Complexity: Linear to the number of element of the source tree plus the.
 //! number of elements of tree target tree when calling this function.
- //!
+ //!
 //! Throws: If cloner functor throws. If this happens target nodes are disposed.
 template<class Disposer>
 static void clear_and_dispose(const node_ptr & header, Disposer disposer)
@@ -461,7 +461,7 @@
 //! not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static node_ptr lower_bound
@@ -477,7 +477,7 @@
 //! than "key" according to "comp" or "header" if that element does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static node_ptr upper_bound
@@ -493,7 +493,7 @@
 //! "key" according to "comp" or "header" if that element does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static node_ptr find
@@ -511,7 +511,7 @@
 //! if they there are no equivalent elements.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static std::pair<node_ptr, node_ptr> equal_range
@@ -525,10 +525,10 @@
 //!
 //! Effects: Inserts new_node into the tree before the upper bound
 //! according to "comp".
- //!
+ //!
 //! Complexity: Average complexity for insert element is at
 //! most logarithmic.
- //!
+ //!
 //! Throws: If "comp" throws.
 template<class NodePtrCompare>
 static node_ptr insert_equal_upper_bound
@@ -546,10 +546,10 @@
 //!
 //! Effects: Inserts new_node into the tree before the lower bound
 //! according to "comp".
- //!
+ //!
 //! Complexity: Average complexity for insert element is at
 //! most logarithmic.
- //!
+ //!
 //! Throws: If "comp" throws.
 template<class NodePtrCompare>
 static node_ptr insert_equal_lower_bound
@@ -565,14 +565,14 @@
 //! ordering compatible with the strict weak ordering used to create the
 //! the tree. NodePtrCompare compares two node_ptrs. "hint" is node from
 //! the "header"'s tree.
- //!
+ //!
 //! Effects: Inserts new_node into the tree, using "hint" as a hint to
 //! where it will be inserted. If "hint" is the upper_bound
 //! the insertion takes constant time (two comparisons in the worst case).
 //!
 //! Complexity: Logarithmic in general, but it is amortized
 //! constant time if new_node is inserted immediately before "hint".
- //!
+ //!
 //! Throws: If "comp" throws.
 template<class NodePtrCompare>
 static node_ptr insert_equal
@@ -588,13 +588,13 @@
 //! "pos" must be an iterator pointing to the successor to "new_node"
 //! once inserted according to the order of already inserted nodes. This function does not
 //! check "pos" and this precondition must be guaranteed by the caller.
- //!
+ //!
 //! Effects: Inserts new_node into the tree before "pos".
 //!
 //! Complexity: Constant-time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: If "pos" is not the successor of the newly inserted "new_node"
 //! tree invariants might be broken.
 static node_ptr insert_before
@@ -608,13 +608,13 @@
 //! Requires: "header" must be the header node of a tree.
 //! "new_node" must be, according to the used ordering no less than the
 //! greatest inserted key.
- //!
+ //!
 //! Effects: Inserts new_node into the tree before "pos".
 //!
 //! Complexity: Constant-time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: If "new_node" is less than the greatest inserted key
 //! tree invariants are broken. This function is slightly faster than
 //! using "insert_before".
@@ -627,13 +627,13 @@
 //! Requires: "header" must be the header node of a tree.
 //! "new_node" must be, according to the used ordering, no greater than the
 //! lowest inserted key.
- //!
+ //!
 //! Effects: Inserts new_node into the tree before "pos".
 //!
 //! Complexity: Constant-time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: If "new_node" is greater than the lowest inserted key
 //! tree invariants are broken. This function is slightly faster than
 //! using "insert_before".
@@ -647,7 +647,7 @@
 //! KeyNodePtrCompare is a function object that induces a strict weak
 //! ordering compatible with the strict weak ordering used to create the
 //! the tree. NodePtrCompare compares KeyType with a node_ptr.
- //!
+ //!
 //! Effects: Checks if there is an equivalent node to "key" in the
 //! tree according to "comp" and obtains the needed information to realize
 //! a constant-time node insertion if there is no equivalent node.
@@ -658,11 +658,11 @@
 //! in the returned pair's boolean and fills "commit_data" that is meant to
 //! be used with the "insert_commit" function to achieve a constant-time
 //! insertion function.
- //!
+ //!
 //! Complexity: Average complexity is at most logarithmic.
 //!
 //! Throws: If "comp" throws.
- //!
+ //!
 //! Notes: This function is used to improve performance when constructing
 //! a node is expensive and the user does not want to have two equivalent nodes
 //! in the tree: if there is an equivalent value
@@ -688,12 +688,12 @@
 //! ordering compatible with the strict weak ordering used to create the
 //! the tree. NodePtrCompare compares KeyType with a node_ptr.
 //! "hint" is node from the "header"'s tree.
- //!
+ //!
 //! Effects: Checks if there is an equivalent node to "key" in the
 //! tree according to "comp" using "hint" as a hint to where it should be
 //! inserted and obtains the needed information to realize
- //! a constant-time node insertion if there is no equivalent node.
- //! If "hint" is the upper_bound the function has constant time
+ //! a constant-time node insertion if there is no equivalent node.
+ //! If "hint" is the upper_bound the function has constant time
 //! complexity (two comparisons in the worst case).
 //!
 //! Returns: If there is an equivalent value
@@ -702,12 +702,12 @@
 //! in the returned pair's boolean and fills "commit_data" that is meant to
 //! be used with the "insert_commit" function to achieve a constant-time
 //! insertion function.
- //!
+ //!
 //! Complexity: Average complexity is at most logarithmic, but it is
 //! amortized constant time if new_node should be inserted immediately before "hint".
 //!
 //! Throws: If "comp" throws.
- //!
+ //!
 //! Notes: This function is used to improve performance when constructing
 //! a node is expensive and the user does not want to have two equivalent nodes
 //! in the tree: if there is an equivalent value
@@ -732,16 +732,16 @@
 //! "commit_data" must have been obtained from a previous call to
 //! "insert_unique_check". No objects should have been inserted or erased
 //! from the set between the "insert_unique_check" that filled "commit_data"
- //! and the call to "insert_commit".
- //!
- //!
+ //! and the call to "insert_commit".
+ //!
+ //!
 //! Effects: Inserts new_node in the set using the information obtained
 //! from the "commit_data" that a previous "insert_check" filled.
 //!
 //! Complexity: Constant time.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Notes: This function has only sense if a "insert_unique_check" has been
 //! previously executed to fill "commit_data". No value should be inserted or
 //! erased between the "insert_check" and "insert_commit" calls.
@@ -757,7 +757,7 @@
 //! Effects: Returns a pointer to the header node of the tree.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 static node_ptr get_header(const node_ptr & n)
 { return tree_algorithms::get_header(n); }
@@ -766,17 +766,17 @@
 private:

 //! Requires: p is a node of a tree.
- //!
+ //!
 //! Effects: Returns true if p is the header of the tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 static bool is_header(const const_node_ptr & p)
 {
 return NodeTraits::get_color(p) == NodeTraits::red() &&
 tree_algorithms::is_header(p);
- //return NodeTraits::get_color(p) == NodeTraits::red() &&
+ //return NodeTraits::get_color(p) == NodeTraits::red() &&
 // NodeTraits::get_parent(NodeTraits::get_parent(p)) == p;
 }

@@ -797,7 +797,7 @@
 NodeTraits::set_color(w, NodeTraits::red());
 x = x_parent;
 x_parent = NodeTraits::get_parent(x_parent);
- }
+ }
 else {
 if(NodeTraits::get_right(w) == node_ptr() || NodeTraits::get_color(NodeTraits::get_right(w)) == NodeTraits::black()){
 NodeTraits::set_color(NodeTraits::get_left(w), NodeTraits::black());
@@ -902,8 +902,8 @@
 /// @endcond
};

-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Modified: branches/release/boost/intrusive/set.hpp
==============================================================================
--- branches/release/boost/intrusive/set.hpp (original)
+++ branches/release/boost/intrusive/set.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -23,9 +23,9 @@
namespace boost {
namespace intrusive {

-//! The class template set is an intrusive container, that mimics most of
+//! The class template set is an intrusive container, that mimics most of
//! the interface of std::set as described in the C++ standard.
-//!
+//!
//! The template parameter \c T is the type to be managed by the container.
//! The user can specify additional options and if no options are provided
//! default options are used.
@@ -86,30 +86,30 @@
 /// @endcond

 public:
- //! Effects: Constructs an empty set.
- //!
- //! Complexity: Constant.
- //!
+ //! Effects: Constructs an empty set.
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: If value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
- //! or the copy constructor of the value_compare object throws.
+ //! or the copy constructor of the value_compare object throws.
 set_impl( const value_compare &cmp = value_compare()
- , const value_traits &v_traits = value_traits())
+ , const value_traits &v_traits = value_traits())
 : tree_(cmp, v_traits)
 {}

- //! Requires: Dereferencing iterator must yield an lvalue of type value_type.
+ //! Requires: Dereferencing iterator must yield an lvalue of type value_type.
 //! cmp must be a comparison function that induces a strict weak ordering.
- //!
- //! Effects: Constructs an empty set and inserts elements from
+ //!
+ //! Effects: Constructs an empty set and inserts elements from
 //! [b, e).
- //!
- //! Complexity: Linear in N if [b, e) is already sorted using
+ //!
+ //! Complexity: Linear in N if [b, e) is already sorted using
 //! comp and otherwise N * log N, where N is std::distance(last, first).
- //!
+ //!
 //! Throws: If value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
- //! or the copy constructor/operator() of the value_compare object throws.
+ //! or the copy constructor/operator() of the value_compare object throws.
 template<class Iterator>
 set_impl( Iterator b, Iterator e
 , const value_compare &cmp = value_compare()
@@ -118,135 +118,135 @@
 {}

 //! Effects: to-do
- //!
- set_impl(BOOST_RV_REF(set_impl) x)
+ //!
+ set_impl(BOOST_RV_REF(set_impl) x)
 : tree_(::boost::move(x.tree_))
 {}

 //! Effects: to-do
- //!
- set_impl& operator=(BOOST_RV_REF(set_impl) x)
+ //!
+ set_impl& operator=(BOOST_RV_REF(set_impl) x)
 { tree_ = ::boost::move(x.tree_); return *this; }

- //! Effects: Detaches all elements from this. The objects in the set
+ //! Effects: Detaches all elements from this. The objects in the set
 //! are not deleted (i.e. no destructors are called).
- //!
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
- //!
+ //!
 //! Throws: Nothing.
- ~set_impl()
+ ~set_impl()
 {}

 //! Effects: Returns an iterator pointing to the beginning of the set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator begin()
 { return tree_.begin(); }

 //! Effects: Returns a const_iterator pointing to the beginning of the set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator begin() const
 { return tree_.begin(); }

 //! Effects: Returns a const_iterator pointing to the beginning of the set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator cbegin() const
 { return tree_.cbegin(); }

 //! Effects: Returns an iterator pointing to the end of the set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator end()
 { return tree_.end(); }

 //! Effects: Returns a const_iterator pointing to the end of the set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator end() const
 { return tree_.end(); }

 //! Effects: Returns a const_iterator pointing to the end of the set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator cend() const
 { return tree_.cend(); }

 //! Effects: Returns a reverse_iterator pointing to the beginning of the
 //! reversed set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 reverse_iterator rbegin()
 { return tree_.rbegin(); }

 //! Effects: Returns a const_reverse_iterator pointing to the beginning
 //! of the reversed set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator rbegin() const
 { return tree_.rbegin(); }

 //! Effects: Returns a const_reverse_iterator pointing to the beginning
 //! of the reversed set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator crbegin() const
 { return tree_.crbegin(); }

 //! Effects: Returns a reverse_iterator pointing to the end
 //! of the reversed set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 reverse_iterator rend()
 { return tree_.rend(); }

 //! Effects: Returns a const_reverse_iterator pointing to the end
 //! of the reversed set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator rend() const
 { return tree_.rend(); }

 //! Effects: Returns a const_reverse_iterator pointing to the end
 //! of the reversed set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator crend() const
 { return tree_.crend(); }

 //! Precondition: end_iterator must be a valid end iterator
 //! of set.
- //!
+ //!
 //! Effects: Returns a reference to the set associated to the end iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 static set_impl &container_from_end_iterator(iterator end_iterator)
 {
@@ -257,11 +257,11 @@

 //! Precondition: end_iterator must be a valid end const_iterator
 //! of set.
- //!
+ //!
 //! Effects: Returns a const reference to the set associated to the end iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 static const set_impl &container_from_end_iterator(const_iterator end_iterator)
 {
@@ -271,11 +271,11 @@
 }

 //! Precondition: it must be a valid iterator of set.
- //!
+ //!
 //! Effects: Returns a reference to the set associated to the iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Logarithmic.
 static set_impl &container_from_iterator(iterator it)
 {
@@ -285,11 +285,11 @@
 }

 //! Precondition: it must be a valid const_iterator of set.
- //!
+ //!
 //! Effects: Returns a const reference to the set associated to the iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Logarithmic.
 static const set_impl &container_from_iterator(const_iterator it)
 {
@@ -299,42 +299,42 @@
 }

 //! Effects: Returns the key_compare object used by the set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If key_compare copy-constructor throws.
 key_compare key_comp() const
 { return tree_.value_comp(); }

 //! Effects: Returns the value_compare object used by the set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If value_compare copy-constructor throws.
 value_compare value_comp() const
 { return tree_.value_comp(); }

 //! Effects: Returns true if the container is empty.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 bool empty() const
 { return tree_.empty(); }

 //! Effects: Returns the number of elements stored in the set.
- //!
+ //!
 //! Complexity: Linear to elements contained in *this if,
 //! constant-time size option is enabled. Constant-time otherwise.
- //!
+ //!
 //! Throws: Nothing.
 size_type size() const
 { return tree_.size(); }

 //! Effects: Swaps the contents of two sets.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If the swap() call for the comparison functor
 //! found using ADL throws. Strong guarantee.
 void swap(set_impl& other)
@@ -344,22 +344,22 @@
 //! Cloner should yield to nodes equivalent to the original nodes.
 //!
 //! Effects: Erases all the elements from *this
- //! calling Disposer::operator()(pointer), clones all the
+ //! calling Disposer::operator()(pointer), clones all the
 //! elements from src calling Cloner::operator()(const_reference )
 //! and inserts them on *this. Copies the predicate from the source container.
 //!
 //! If cloner throws, all cloned elements are unlinked and disposed
 //! calling Disposer::operator()(pointer).
- //!
+ //!
 //! Complexity: Linear to erased plus inserted elements.
- //!
+ //!
 //! Throws: If cloner throws or predicate copy assignment throws. Basic guarantee.
 template <class Cloner, class Disposer>
 void clone_from(const set_impl &src, Cloner cloner, Disposer disposer)
 { tree_.clone_from(src.tree_, cloner, disposer); }

 //! Requires: value must be an lvalue
- //!
+ //!
 //! Effects: Tries to inserts value into the set.
 //!
 //! Returns: If the value
@@ -367,39 +367,39 @@
 //! iterator to the new value and true. If there is an equivalent value
 //! returns a pair containing an iterator to the already present value
 //! and false.
- //!
+ //!
 //! Complexity: Average complexity for insert element is at
 //! most logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Strong guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 std::pair<iterator, bool> insert(reference value)
 { return tree_.insert_unique(value); }

 //! Requires: value must be an lvalue
- //!
- //! Effects: Tries to to insert x into the set, using "hint"
+ //!
+ //! Effects: Tries to to insert x into the set, using "hint"
 //! as a hint to where it will be inserted.
 //!
- //! Returns: An iterator that points to the position where the
+ //! Returns: An iterator that points to the position where the
 //! new element was inserted into the set.
- //!
+ //!
 //! Complexity: Logarithmic in general, but it's amortized
 //! constant time if t is inserted immediately before hint.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Strong guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 iterator insert(const_iterator hint, reference value)
 { return tree_.insert_unique(hint, value); }

- //! Requires: key_value_comp must be a comparison function that induces
+ //! Requires: key_value_comp must be a comparison function that induces
 //! the same strict weak ordering as value_compare. The difference is that
 //! key_value_comp compares an arbitrary key with the contained values.
- //!
+ //!
 //! Effects: Checks if a value can be inserted in the set, using
 //! a user provided key instead of the value itself.
 //!
@@ -408,16 +408,16 @@
 //! and false. If the value can be inserted returns true in the returned
 //! pair boolean and fills "commit_data" that is meant to be used with
 //! the "insert_commit" function.
- //!
+ //!
 //! Complexity: Average complexity is at most logarithmic.
 //!
 //! Throws: If the key_value_comp ordering function throws. Strong guarantee.
- //!
+ //!
 //! Notes: This function is used to improve performance when constructing
 //! a value_type is expensive: if there is an equivalent value
 //! the constructed object must be discarded. Many times, the part of the
 //! node that is used to impose the order is much cheaper to construct
- //! than the value_type and this function offers the possibility to use that
+ //! than the value_type and this function offers the possibility to use that
 //! part to check if the insertion will be successful.
 //!
 //! If the check is successful, the user can construct the value_type and use
@@ -431,12 +431,12 @@
 (const KeyType &key, KeyValueCompare key_value_comp, insert_commit_data &commit_data)
 { return tree_.insert_unique_check(key, key_value_comp, commit_data); }

- //! Requires: key_value_comp must be a comparison function that induces
+ //! Requires: key_value_comp must be a comparison function that induces
 //! the same strict weak ordering as value_compare. The difference is that
 //! key_value_comp compares an arbitrary key with the contained values.
- //!
+ //!
 //! Effects: Checks if a value can be inserted in the set, using
- //! a user provided key instead of the value itself, using "hint"
+ //! a user provided key instead of the value itself, using "hint"
 //! as a hint to where it will be inserted.
 //!
 //! Returns: If there is an equivalent value
@@ -444,23 +444,23 @@
 //! and false. If the value can be inserted returns true in the returned
 //! pair boolean and fills "commit_data" that is meant to be used with
 //! the "insert_commit" function.
- //!
+ //!
 //! Complexity: Logarithmic in general, but it's amortized
 //! constant time if t is inserted immediately before hint.
 //!
 //! Throws: If the key_value_comp ordering function throws. Strong guarantee.
- //!
+ //!
 //! Notes: This function is used to improve performance when constructing
 //! a value_type is expensive: if there is an equivalent value
 //! the constructed object must be discarded. Many times, the part of the
 //! constructing that is used to impose the order is much cheaper to construct
- //! than the value_type and this function offers the possibility to use that key
+ //! than the value_type and this function offers the possibility to use that key
 //! to check if the insertion will be successful.
 //!
 //! If the check is successful, the user can construct the value_type and use
 //! "insert_commit" to insert the object in constant-time. This can give a total
 //! constant-time complexity to the insertion: check(O(1)) + commit(O(1)).
- //!
+ //!
 //! "commit_data" remains valid for a subsequent "insert_commit" only if no more
 //! objects are inserted or erased from the set.
 template<class KeyType, class KeyValueCompare>
@@ -473,33 +473,33 @@
 //! must have been obtained from a previous call to "insert_check".
 //! No objects should have been inserted or erased from the set between
 //! the "insert_check" that filled "commit_data" and the call to "insert_commit".
- //!
+ //!
 //! Effects: Inserts the value in the set using the information obtained
 //! from the "commit_data" that a previous "insert_check" filled.
 //!
 //! Returns: An iterator to the newly inserted object.
- //!
+ //!
 //! Complexity: Constant time.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Notes: This function has only sense if a "insert_check" has been
 //! previously executed to fill "commit_data". No value should be inserted or
 //! erased between the "insert_check" and "insert_commit" calls.
 iterator insert_commit(reference value, const insert_commit_data &commit_data)
 { return tree_.insert_unique_commit(value, commit_data); }

- //! Requires: Dereferencing iterator must yield an lvalue
+ //! Requires: Dereferencing iterator must yield an lvalue
 //! of type value_type.
- //!
+ //!
 //! Effects: Inserts a range into the set.
- //!
+ //!
 //! Complexity: Insert range is in general O(N * log(N)), where N is the
 //! size of the range. However, it is linear in N if the range is already sorted
 //! by value_comp().
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Basic guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 template<class Iterator>
@@ -512,11 +512,11 @@
 //! inserted key according to the predicate.
 //!
 //! Effects: Inserts x into the tree before "pos".
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function does not check preconditions so if "pos" is not
 //! the successor of "value" or "value" is not unique tree ordering and uniqueness
 //! invariants will be broken respectively.
@@ -529,11 +529,11 @@
 //! any inserted key according to the predicate.
 //!
 //! Effects: Inserts x into the tree in the last position.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function does not check preconditions so if value is
 //! less than or equal to the greatest inserted key tree ordering invariant will be broken.
 //! This function is slightly more efficient than using "insert_before".
@@ -546,11 +546,11 @@
 //! than any inserted key according to the predicate.
 //!
 //! Effects: Inserts x into the tree in the first position.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function does not check preconditions so if value is
 //! greater than or equal to the the mimum inserted key tree ordering or uniqueness
 //! invariants will be broken.
@@ -560,41 +560,41 @@
 void push_front(reference value)
 { tree_.push_front(value); }

- //! Effects: Erases the element pointed to by pos.
- //!
+ //! Effects: Erases the element pointed to by pos.
+ //!
 //! Complexity: Average complexity is constant time.
- //!
+ //!
 //! Returns: An iterator to the element after the erased element.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 iterator erase(const_iterator i)
 { return tree_.erase(i); }

- //! Effects: Erases the range pointed to by b end e.
- //!
- //! Complexity: Average complexity for erase range is at most
+ //! Effects: Erases the range pointed to by b end e.
+ //!
+ //! Complexity: Average complexity for erase range is at most
 //! O(log(size() + N)), where N is the number of elements in the range.
- //!
+ //!
 //! Returns: An iterator to the element after the erased elements.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 iterator erase(const_iterator b, const_iterator e)
 { return tree_.erase(b, e); }

 //! Effects: Erases all the elements with the given value.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size()) + this->count(value)).
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 size_type erase(const_reference value)
@@ -602,13 +602,13 @@

 //! Effects: Erases all the elements that compare equal with
 //! the given key and the given comparison functor.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size() + this->count(key, comp)).
- //!
+ //!
 //! Throws: If the comp ordering function throws. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class KeyType, class KeyValueCompare>
@@ -621,16 +621,16 @@

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
 //!
- //! Effects: Erases the element pointed to by pos.
+ //! Effects: Erases the element pointed to by pos.
 //! Disposer::operator()(pointer) is called for the removed element.
- //!
- //! Complexity: Average complexity for erase element is constant time.
- //!
+ //!
+ //! Complexity: Average complexity for erase element is constant time.
+ //!
 //! Returns: An iterator to the element after the erased element.
- //!
+ //!
 //! Throws: Nothing.
- //!
- //! Note: Invalidates the iterators
+ //!
+ //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
 iterator erase_and_dispose(const_iterator i, Disposer disposer)
@@ -646,14 +646,14 @@
 //!
 //! Effects: Erases the range pointed to by b end e.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
- //! Complexity: Average complexity for erase range is at most
+ //!
+ //! Complexity: Average complexity for erase range is at most
 //! O(log(size() + N)), where N is the number of elements in the range.
- //!
+ //!
 //! Returns: An iterator to the element after the erased elements.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
@@ -664,13 +664,13 @@
 //!
 //! Effects: Erases all the elements with the given value.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
- //!
+ //!
 //! Complexity: O(log(size() + this->count(value)). Basic guarantee.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class Disposer>
@@ -684,11 +684,11 @@
 //! Disposer::operator()(pointer) is called for the removed elements.
 //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size() + this->count(key, comp)).
- //!
+ //!
 //! Throws: If comp ordering function throws. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class KeyType, class KeyValueCompare, class Disposer>
@@ -700,26 +700,26 @@
 { return tree_.erase_and_dispose(key, comp, disposer); }

 //! Effects: Erases all the elements of the container.
- //!
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 void clear()
 { return tree_.clear(); }

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
- //!
+ //!
 //! Effects: Erases all the elements of the container.
- //!
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class Disposer>
@@ -727,20 +727,20 @@
 { return tree_.clear_and_dispose(disposer); }

 //! Effects: Returns the number of contained elements with the given key
- //!
+ //!
 //! Complexity: Logarithmic to the number of elements contained plus lineal
 //! to number of objects with the given key.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 size_type count(const_reference value) const
 { return tree_.find(value) != end(); }

 //! Effects: Returns the number of contained elements with the same key
 //! compared with the given comparison functor.
- //!
+ //!
 //! Complexity: Logarithmic to the number of elements contained plus lineal
 //! to number of objects with the given key.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 template<class KeyType, class KeyValueCompare>
 size_type count(const KeyType& key, KeyValueCompare comp) const
@@ -748,9 +748,9 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is not less than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 iterator lower_bound(const_reference value)
 { return tree_.lower_bound(value); }
@@ -760,13 +760,13 @@
 //! that is used in the ordering functor.
 //!
 //! Effects: Returns an iterator to the first element whose
- //! key according to the comparison functor is not less than k or
+ //! key according to the comparison functor is not less than k or
 //! end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
- //!
+ //!
 //! Note: This function is used when constructing a value_type
 //! is expensive and the value_type can be compared with a cheaper
 //! key type. Usually this key is part of the value_type.
@@ -776,9 +776,9 @@

 //! Effects: Returns a const iterator to the first element whose
 //! key is not less than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 const_iterator lower_bound(const_reference value) const
 { return tree_.lower_bound(value); }
@@ -788,13 +788,13 @@
 //! that is used in the ordering functor.
 //!
 //! Effects: Returns a const_iterator to the first element whose
- //! key according to the comparison functor is not less than k or
+ //! key according to the comparison functor is not less than k or
 //! end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
- //!
+ //!
 //! Note: This function is used when constructing a value_type
 //! is expensive and the value_type can be compared with a cheaper
 //! key type. Usually this key is part of the value_type.
@@ -804,9 +804,9 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is greater than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 iterator upper_bound(const_reference value)
 { return tree_.upper_bound(value); }
@@ -816,11 +816,11 @@
 //! that is used in the ordering functor.
 //!
 //! Effects: Returns an iterator to the first element whose
- //! key according to the comparison functor is greater than key or
+ //! key according to the comparison functor is greater than key or
 //! end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -832,9 +832,9 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is greater than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 const_iterator upper_bound(const_reference value) const
 { return tree_.upper_bound(value); }
@@ -844,11 +844,11 @@
 //! that is used in the ordering functor.
 //!
 //! Effects: Returns a const_iterator to the first element whose
- //! key according to the comparison functor is greater than key or
+ //! key according to the comparison functor is greater than key or
 //! end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -858,11 +858,11 @@
 const_iterator upper_bound(const KeyType& key, KeyValueCompare comp) const
 { return tree_.upper_bound(key, comp); }

- //! Effects: Finds an iterator to the first element whose value is
+ //! Effects: Finds an iterator to the first element whose value is
 //! "value" or end() if that element does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 iterator find(const_reference value)
 { return tree_.find(value); }
@@ -871,12 +871,12 @@
 //! value_compare. Usually key is the part of the value_type
 //! that is used in the ordering functor.
 //!
- //! Effects: Finds an iterator to the first element whose key is
- //! "key" according to the comparison functor or end() if that element
+ //! Effects: Finds an iterator to the first element whose key is
+ //! "key" according to the comparison functor or end() if that element
 //! does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -886,11 +886,11 @@
 iterator find(const KeyType& key, KeyValueCompare comp)
 { return tree_.find(key, comp); }

- //! Effects: Finds a const_iterator to the first element whose value is
+ //! Effects: Finds a const_iterator to the first element whose value is
 //! "value" or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 const_iterator find(const_reference value) const
 { return tree_.find(value); }
@@ -899,12 +899,12 @@
 //! value_compare. Usually key is the part of the value_type
 //! that is used in the ordering functor.
 //!
- //! Effects: Finds a const_iterator to the first element whose key is
- //! "key" according to the comparison functor or end() if that element
+ //! Effects: Finds a const_iterator to the first element whose key is
+ //! "key" according to the comparison functor or end() if that element
 //! does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -917,9 +917,9 @@
 //! Effects: Finds a range containing all elements whose key is k or
 //! an empty range that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 std::pair<iterator,iterator> equal_range(const_reference value)
 { return tree_.equal_range(value); }
@@ -928,13 +928,13 @@
 //! value_compare. Usually key is the part of the value_type
 //! that is used in the ordering functor.
 //!
- //! Effects: Finds a range containing all elements whose key is k
- //! according to the comparison functor or an empty range
+ //! Effects: Finds a range containing all elements whose key is k
+ //! according to the comparison functor or an empty range
 //! that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -947,9 +947,9 @@
 //! Effects: Finds a range containing all elements whose key is k or
 //! an empty range that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 std::pair<const_iterator, const_iterator>
 equal_range(const_reference value) const
@@ -959,13 +959,13 @@
 //! value_compare. Usually key is the part of the value_type
 //! that is used in the ordering functor.
 //!
- //! Effects: Finds a range containing all elements whose key is k
- //! according to the comparison functor or an empty range
+ //! Effects: Finds a range containing all elements whose key is k
+ //! according to the comparison functor or an empty range
 //! that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -978,14 +978,14 @@

 //! Requires: value must be an lvalue and shall be in a set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid iterator i belonging to the set
 //! that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This static function is available only if the value traits
 //! is stateless.
 static iterator s_iterator_to(reference value)
@@ -993,14 +993,14 @@

 //! Requires: value must be an lvalue and shall be in a set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid const_iterator i belonging to the
 //! set that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This static function is available only if the value traits
 //! is stateless.
 static const_iterator s_iterator_to(const_reference value)
@@ -1008,48 +1008,48 @@

 //! Requires: value must be an lvalue and shall be in a set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid iterator i belonging to the set
 //! that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator iterator_to(reference value)
 { return tree_.iterator_to(value); }

 //! Requires: value must be an lvalue and shall be in a set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid const_iterator i belonging to the
 //! set that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator iterator_to(const_reference value) const
 { return tree_.iterator_to(value); }

 //! Requires: value shall not be in a set/multiset.
- //!
+ //!
 //! Effects: init_node puts the hook of a value in a well-known default
 //! state.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Note: This function puts the hook in the well-known default state
 //! used by auto_unlink and safe hooks.
 static void init_node(reference value)
 { tree_type::init_node(value); }

 //! Effects: Unlinks the leftmost node from the tree.
- //!
+ //!
 //! Complexity: Average complexity is constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Notes: This function breaks the tree and the tree can
 //! only be used for more unlink_leftmost_without_rebalance calls.
 //! This function is normally used to achieve a step by step
@@ -1059,14 +1059,14 @@

 //! Requires: replace_this must be a valid iterator of *this
 //! and with_this must not be inserted in any tree.
- //!
+ //!
 //! Effects: Replaces replace_this in its position in the
 //! tree with with_this. The tree does not need to be rebalanced.
- //!
- //! Complexity: Constant.
- //!
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function will break container ordering invariants if
 //! with_this is not equivalent to *replace_this according to the
 //! ordering rules. This function is faster than erasing and inserting
@@ -1188,7 +1188,7 @@
>::type
{
 typedef typename make_set
- <T,
+ <T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
@@ -1240,9 +1240,9 @@

#endif

-//! The class template multiset is an intrusive container, that mimics most of
+//! The class template multiset is an intrusive container, that mimics most of
//! the interface of std::multiset as described in the C++ standard.
-//!
+//!
//! The template parameter \c T is the type to be managed by the container.
//! The user can specify additional options and if no options are provided
//! default options are used.
@@ -1302,30 +1302,30 @@
 /// @endcond

 public:
- //! Effects: Constructs an empty multiset.
- //!
- //! Complexity: Constant.
- //!
+ //! Effects: Constructs an empty multiset.
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: If value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
- //! or the copy constructor/operator() of the value_compare object throws.
+ //! or the copy constructor/operator() of the value_compare object throws.
 multiset_impl( const value_compare &cmp = value_compare()
- , const value_traits &v_traits = value_traits())
+ , const value_traits &v_traits = value_traits())
 : tree_(cmp, v_traits)
 {}

- //! Requires: Dereferencing iterator must yield an lvalue of type value_type.
+ //! Requires: Dereferencing iterator must yield an lvalue of type value_type.
 //! cmp must be a comparison function that induces a strict weak ordering.
- //!
- //! Effects: Constructs an empty multiset and inserts elements from
+ //!
+ //! Effects: Constructs an empty multiset and inserts elements from
 //! [b, e).
- //!
+ //!
 //! Complexity: Linear in N if [b, e) is already sorted using
 //! comp and otherwise N * log N, where N is the distance between first and last
- //!
+ //!
 //! Throws: If value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
- //! or the copy constructor/operator() of the value_compare object throws.
+ //! or the copy constructor/operator() of the value_compare object throws.
 template<class Iterator>
 multiset_impl( Iterator b, Iterator e
 , const value_compare &cmp = value_compare()
@@ -1334,135 +1334,135 @@
 {}

 //! Effects: to-do
- //!
- multiset_impl(BOOST_RV_REF(multiset_impl) x)
+ //!
+ multiset_impl(BOOST_RV_REF(multiset_impl) x)
 : tree_(::boost::move(x.tree_))
 {}

 //! Effects: to-do
- //!
- multiset_impl& operator=(BOOST_RV_REF(multiset_impl) x)
+ //!
+ multiset_impl& operator=(BOOST_RV_REF(multiset_impl) x)
 { tree_ = ::boost::move(x.tree_); return *this; }

- //! Effects: Detaches all elements from this. The objects in the set
+ //! Effects: Detaches all elements from this. The objects in the set
 //! are not deleted (i.e. no destructors are called).
- //!
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
- //!
+ //!
 //! Throws: Nothing.
- ~multiset_impl()
+ ~multiset_impl()
 {}

 //! Effects: Returns an iterator pointing to the beginning of the multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator begin()
 { return tree_.begin(); }

 //! Effects: Returns a const_iterator pointing to the beginning of the multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator begin() const
 { return tree_.begin(); }

 //! Effects: Returns a const_iterator pointing to the beginning of the multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator cbegin() const
 { return tree_.cbegin(); }

 //! Effects: Returns an iterator pointing to the end of the multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator end()
 { return tree_.end(); }

 //! Effects: Returns a const_iterator pointing to the end of the multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator end() const
 { return tree_.end(); }

 //! Effects: Returns a const_iterator pointing to the end of the multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator cend() const
 { return tree_.cend(); }

 //! Effects: Returns a reverse_iterator pointing to the beginning of the
 //! reversed multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 reverse_iterator rbegin()
 { return tree_.rbegin(); }

 //! Effects: Returns a const_reverse_iterator pointing to the beginning
 //! of the reversed multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator rbegin() const
 { return tree_.rbegin(); }

 //! Effects: Returns a const_reverse_iterator pointing to the beginning
 //! of the reversed multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator crbegin() const
 { return tree_.crbegin(); }

 //! Effects: Returns a reverse_iterator pointing to the end
 //! of the reversed multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 reverse_iterator rend()
 { return tree_.rend(); }

 //! Effects: Returns a const_reverse_iterator pointing to the end
 //! of the reversed multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator rend() const
 { return tree_.rend(); }

 //! Effects: Returns a const_reverse_iterator pointing to the end
 //! of the reversed multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator crend() const
 { return tree_.crend(); }

 //! Precondition: end_iterator must be a valid end iterator
 //! of multiset.
- //!
+ //!
 //! Effects: Returns a const reference to the multiset associated to the end iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 static multiset_impl &container_from_end_iterator(iterator end_iterator)
 {
@@ -1473,11 +1473,11 @@

 //! Precondition: end_iterator must be a valid end const_iterator
 //! of multiset.
- //!
+ //!
 //! Effects: Returns a const reference to the multiset associated to the end iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 static const multiset_impl &container_from_end_iterator(const_iterator end_iterator)
 {
@@ -1487,11 +1487,11 @@
 }

 //! Precondition: it must be a valid iterator of multiset.
- //!
+ //!
 //! Effects: Returns a const reference to the multiset associated to the iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Logarithmic.
 static multiset_impl &container_from_iterator(iterator it)
 {
@@ -1501,11 +1501,11 @@
 }

 //! Precondition: it must be a valid const_iterator of multiset.
- //!
+ //!
 //! Effects: Returns a const reference to the multiset associated to the iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Logarithmic.
 static const multiset_impl &container_from_iterator(const_iterator it)
 {
@@ -1515,42 +1515,42 @@
 }

 //! Effects: Returns the key_compare object used by the multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If key_compare copy-constructor throws.
 key_compare key_comp() const
 { return tree_.value_comp(); }

 //! Effects: Returns the value_compare object used by the multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If value_compare copy-constructor throws.
 value_compare value_comp() const
 { return tree_.value_comp(); }

 //! Effects: Returns true if the container is empty.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 bool empty() const
 { return tree_.empty(); }

 //! Effects: Returns the number of elements stored in the multiset.
- //!
+ //!
 //! Complexity: Linear to elements contained in *this if,
 //! constant-time size option is enabled. Constant-time otherwise.
- //!
+ //!
 //! Throws: Nothing.
 size_type size() const
 { return tree_.size(); }

 //! Effects: Swaps the contents of two multisets.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If the swap() call for the comparison functor
 //! found using ADL throws. Strong guarantee.
 void swap(multiset_impl& other)
@@ -1560,69 +1560,69 @@
 //! Cloner should yield to nodes equivalent to the original nodes.
 //!
 //! Effects: Erases all the elements from *this
- //! calling Disposer::operator()(pointer), clones all the
+ //! calling Disposer::operator()(pointer), clones all the
 //! elements from src calling Cloner::operator()(const_reference )
 //! and inserts them on *this. Copies the predicate from the source container.
 //!
 //! If cloner throws, all cloned elements are unlinked and disposed
 //! calling Disposer::operator()(pointer).
- //!
+ //!
 //! Complexity: Linear to erased plus inserted elements.
- //!
+ //!
 //! Throws: If cloner throws or predicate copy assignment throws. Basic guarantee.
 template <class Cloner, class Disposer>
 void clone_from(const multiset_impl &src, Cloner cloner, Disposer disposer)
 { tree_.clone_from(src.tree_, cloner, disposer); }

 //! Requires: value must be an lvalue
- //!
+ //!
 //! Effects: Inserts value into the multiset.
- //!
+ //!
 //! Returns: An iterator that points to the position where the new
 //! element was inserted.
- //!
+ //!
 //! Complexity: Average complexity for insert element is at
 //! most logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Strong guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 iterator insert(reference value)
 { return tree_.insert_equal(value); }

 //! Requires: value must be an lvalue
- //!
+ //!
 //! Effects: Inserts x into the multiset, using pos as a hint to
 //! where it will be inserted.
- //!
+ //!
 //! Returns: An iterator that points to the position where the new
 //! element was inserted.
- //!
+ //!
 //! Complexity: Logarithmic in general, but it is amortized
 //! constant time if t is inserted immediately before hint.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Strong guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 iterator insert(const_iterator hint, reference value)
 { return tree_.insert_equal(hint, value); }

- //! Requires: Dereferencing iterator must yield an lvalue
+ //! Requires: Dereferencing iterator must yield an lvalue
 //! of type value_type.
- //!
+ //!
 //! Effects: Inserts a range into the multiset.
- //!
+ //!
 //! Returns: An iterator that points to the position where the new
 //! element was inserted.
- //!
+ //!
 //! Complexity: Insert range is in general O(N * log(N)), where N is the
 //! size of the range. However, it is linear in N if the range is already sorted
 //! by value_comp().
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Basic guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 template<class Iterator>
@@ -1634,11 +1634,11 @@
 //! once inserted according to the predicate
 //!
 //! Effects: Inserts x into the tree before "pos".
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function does not check preconditions so if "pos" is not
 //! the successor of "value" tree ordering invariant will be broken.
 //! This is a low-level function to be used only for performance reasons
@@ -1650,11 +1650,11 @@
 //! than the greatest inserted key
 //!
 //! Effects: Inserts x into the tree in the last position.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function does not check preconditions so if value is
 //! less than the greatest inserted key tree ordering invariant will be broken.
 //! This function is slightly more efficient than using "insert_before".
@@ -1667,11 +1667,11 @@
 //! than the minimum inserted key
 //!
 //! Effects: Inserts x into the tree in the first position.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function does not check preconditions so if value is
 //! greater than the minimum inserted key tree ordering invariant will be broken.
 //! This function is slightly more efficient than using "insert_before".
@@ -1680,41 +1680,41 @@
 void push_front(reference value)
 { tree_.push_front(value); }

- //! Effects: Erases the element pointed to by pos.
- //!
- //! Complexity: Average complexity is constant time.
- //!
+ //! Effects: Erases the element pointed to by pos.
+ //!
+ //! Complexity: Average complexity is constant time.
+ //!
 //! Returns: An iterator to the element after the erased element.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 iterator erase(const_iterator i)
 { return tree_.erase(i); }

- //! Effects: Erases the range pointed to by b end e.
+ //! Effects: Erases the range pointed to by b end e.
 //!
 //! Returns: An iterator to the element after the erased elements.
- //!
- //! Complexity: Average complexity for erase range is at most
+ //!
+ //! Complexity: Average complexity for erase range is at most
 //! O(log(size() + N)), where N is the number of elements in the range.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 iterator erase(const_iterator b, iterator e)
 { return tree_.erase(b, e); }

 //! Effects: Erases all the elements with the given value.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size() + this->count(value)).
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 size_type erase(const_reference value)
@@ -1722,13 +1722,13 @@

 //! Effects: Erases all the elements that compare equal with
 //! the given key and the given comparison functor.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size() + this->count(key, comp)).
- //!
+ //!
 //! Throws: If comp ordering function throws. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class KeyType, class KeyValueCompare>
@@ -1743,14 +1743,14 @@
 //!
 //! Returns: An iterator to the element after the erased element.
 //!
- //! Effects: Erases the element pointed to by pos.
+ //! Effects: Erases the element pointed to by pos.
 //! Disposer::operator()(pointer) is called for the removed element.
- //!
- //! Complexity: Average complexity for erase element is constant time.
- //!
+ //!
+ //! Complexity: Average complexity for erase element is constant time.
+ //!
 //! Throws: Nothing.
- //!
- //! Note: Invalidates the iterators
+ //!
+ //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
 iterator erase_and_dispose(const_iterator i, Disposer disposer)
@@ -1768,12 +1768,12 @@
 //!
 //! Effects: Erases the range pointed to by b end e.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
- //! Complexity: Average complexity for erase range is at most
+ //!
+ //! Complexity: Average complexity for erase range is at most
 //! O(log(size() + N)), where N is the number of elements in the range.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
@@ -1784,13 +1784,13 @@
 //!
 //! Effects: Erases all the elements with the given value.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size() + this->count(value)).
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class Disposer>
@@ -1804,11 +1804,11 @@
 //! Disposer::operator()(pointer) is called for the removed elements.
 //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size() + this->count(key, comp)).
- //!
+ //!
 //! Throws: If comp ordering function throws. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class KeyType, class KeyValueCompare, class Disposer>
@@ -1820,26 +1820,26 @@
 { return tree_.erase_and_dispose(key, comp, disposer); }

 //! Effects: Erases all the elements of the container.
- //!
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 void clear()
 { return tree_.clear(); }

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
- //!
+ //!
 //! Effects: Erases all the elements of the container.
- //!
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class Disposer>
@@ -1847,20 +1847,20 @@
 { return tree_.clear_and_dispose(disposer); }

 //! Effects: Returns the number of contained elements with the given key
- //!
+ //!
 //! Complexity: Logarithmic to the number of elements contained plus lineal
 //! to number of objects with the given key.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 size_type count(const_reference value) const
 { return tree_.count(value); }

 //! Effects: Returns the number of contained elements with the same key
 //! compared with the given comparison functor.
- //!
+ //!
 //! Complexity: Logarithmic to the number of elements contained plus lineal
 //! to number of objects with the given key.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 template<class KeyType, class KeyValueCompare>
 size_type count(const KeyType& key, KeyValueCompare comp) const
@@ -1868,9 +1868,9 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is not less than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 iterator lower_bound(const_reference value)
 { return tree_.lower_bound(value); }
@@ -1880,13 +1880,13 @@
 //! that is used in the ordering functor.
 //!
 //! Effects: Returns an iterator to the first element whose
- //! key according to the comparison functor is not less than k or
+ //! key according to the comparison functor is not less than k or
 //! end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
- //!
+ //!
 //! Note: This function is used when constructing a value_type
 //! is expensive and the value_type can be compared with a cheaper
 //! key type. Usually this key is part of the value_type.
@@ -1896,9 +1896,9 @@

 //! Effects: Returns a const iterator to the first element whose
 //! key is not less than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 const_iterator lower_bound(const_reference value) const
 { return tree_.lower_bound(value); }
@@ -1908,13 +1908,13 @@
 //! that is used in the ordering functor.
 //!
 //! Effects: Returns a const_iterator to the first element whose
- //! key according to the comparison functor is not less than k or
+ //! key according to the comparison functor is not less than k or
 //! end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
- //!
+ //!
 //! Note: This function is used when constructing a value_type
 //! is expensive and the value_type can be compared with a cheaper
 //! key type. Usually this key is part of the value_type.
@@ -1924,9 +1924,9 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is greater than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 iterator upper_bound(const_reference value)
 { return tree_.upper_bound(value); }
@@ -1936,11 +1936,11 @@
 //! that is used in the ordering functor.
 //!
 //! Effects: Returns an iterator to the first element whose
- //! key according to the comparison functor is greater than key or
+ //! key according to the comparison functor is greater than key or
 //! end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -1952,9 +1952,9 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is greater than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 const_iterator upper_bound(const_reference value) const
 { return tree_.upper_bound(value); }
@@ -1964,11 +1964,11 @@
 //! that is used in the ordering functor.
 //!
 //! Effects: Returns a const_iterator to the first element whose
- //! key according to the comparison functor is greater than key or
+ //! key according to the comparison functor is greater than key or
 //! end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -1978,11 +1978,11 @@
 const_iterator upper_bound(const KeyType& key, KeyValueCompare comp) const
 { return tree_.upper_bound(key, comp); }

- //! Effects: Finds an iterator to the first element whose value is
+ //! Effects: Finds an iterator to the first element whose value is
 //! "value" or end() if that element does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 iterator find(const_reference value)
 { return tree_.find(value); }
@@ -1991,12 +1991,12 @@
 //! value_compare. Usually key is the part of the value_type
 //! that is used in the ordering functor.
 //!
- //! Effects: Finds an iterator to the first element whose key is
- //! "key" according to the comparison functor or end() if that element
+ //! Effects: Finds an iterator to the first element whose key is
+ //! "key" according to the comparison functor or end() if that element
 //! does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -2006,11 +2006,11 @@
 iterator find(const KeyType& key, KeyValueCompare comp)
 { return tree_.find(key, comp); }

- //! Effects: Finds a const_iterator to the first element whose value is
+ //! Effects: Finds a const_iterator to the first element whose value is
 //! "value" or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 const_iterator find(const_reference value) const
 { return tree_.find(value); }
@@ -2019,12 +2019,12 @@
 //! value_compare. Usually key is the part of the value_type
 //! that is used in the ordering functor.
 //!
- //! Effects: Finds a const_iterator to the first element whose key is
- //! "key" according to the comparison functor or end() if that element
+ //! Effects: Finds a const_iterator to the first element whose key is
+ //! "key" according to the comparison functor or end() if that element
 //! does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -2037,9 +2037,9 @@
 //! Effects: Finds a range containing all elements whose key is k or
 //! an empty range that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 std::pair<iterator,iterator> equal_range(const_reference value)
 { return tree_.equal_range(value); }
@@ -2048,13 +2048,13 @@
 //! value_compare. Usually key is the part of the value_type
 //! that is used in the ordering functor.
 //!
- //! Effects: Finds a range containing all elements whose key is k
- //! according to the comparison functor or an empty range
+ //! Effects: Finds a range containing all elements whose key is k
+ //! according to the comparison functor or an empty range
 //! that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -2067,9 +2067,9 @@
 //! Effects: Finds a range containing all elements whose key is k or
 //! an empty range that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 std::pair<const_iterator, const_iterator>
 equal_range(const_reference value) const
@@ -2079,13 +2079,13 @@
 //! value_compare. Usually key is the part of the value_type
 //! that is used in the ordering functor.
 //!
- //! Effects: Finds a range containing all elements whose key is k
- //! according to the comparison functor or an empty range
+ //! Effects: Finds a range containing all elements whose key is k
+ //! according to the comparison functor or an empty range
 //! that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -2098,14 +2098,14 @@

 //! Requires: value must be an lvalue and shall be in a set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid iterator i belonging to the set
 //! that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This static function is available only if the value traits
 //! is stateless.
 static iterator s_iterator_to(reference value)
@@ -2113,14 +2113,14 @@

 //! Requires: value must be an lvalue and shall be in a set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid const_iterator i belonging to the
 //! set that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This static function is available only if the value traits
 //! is stateless.
 static const_iterator s_iterator_to(const_reference value)
@@ -2128,48 +2128,48 @@

 //! Requires: value must be an lvalue and shall be in a set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid iterator i belonging to the set
 //! that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator iterator_to(reference value)
 { return tree_.iterator_to(value); }

 //! Requires: value must be an lvalue and shall be in a set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid const_iterator i belonging to the
 //! set that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator iterator_to(const_reference value) const
 { return tree_.iterator_to(value); }

 //! Requires: value shall not be in a set/multiset.
- //!
+ //!
 //! Effects: init_node puts the hook of a value in a well-known default
 //! state.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Note: This function puts the hook in the well-known default state
 //! used by auto_unlink and safe hooks.
 static void init_node(reference value)
 { tree_type::init_node(value); }

 //! Effects: Unlinks the leftmost node from the tree.
- //!
+ //!
 //! Complexity: Average complexity is constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Notes: This function breaks the tree and the tree can
 //! only be used for more unlink_leftmost_without_rebalance calls.
 //! This function is normally used to achieve a step by step
@@ -2179,14 +2179,14 @@

 //! Requires: replace_this must be a valid iterator of *this
 //! and with_this must not be inserted in any tree.
- //!
+ //!
 //! Effects: Replaces replace_this in its position in the
 //! tree with with_this. The tree does not need to be rebalanced.
- //!
- //! Complexity: Constant.
- //!
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function will break container ordering invariants if
 //! with_this is not equivalent to *replace_this according to the
 //! ordering rules. This function is faster than erasing and inserting
@@ -2195,11 +2195,11 @@
 { tree_.replace_node(replace_this, with_this); }

 //! Effects: removes "value" from the container.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Logarithmic time.
- //!
+ //!
 //! Note: This static function is only usable with non-constant
 //! time size containers that have stateless comparison functors.
 //!
@@ -2323,14 +2323,14 @@
 #endif
>::type
{
- typedef typename make_multiset<T,
+ typedef typename make_multiset<T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
 Options...
 #endif
>::type Base;
-
+
 BOOST_MOVABLE_BUT_NOT_COPYABLE(multiset)

 public:
@@ -2376,8 +2376,8 @@

#endif

-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Modified: branches/release/boost/intrusive/set_hook.hpp
==============================================================================
--- branches/release/boost/intrusive/set_hook.hpp (original)
+++ branches/release/boost/intrusive/set_hook.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -44,7 +44,7 @@
{
 /// @cond
 typedef typename pack_options
- < hook_defaults,
+ < hook_defaults,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
@@ -63,16 +63,16 @@
 typedef implementation_defined type;
};

-//! Derive a class from set_base_hook in order to store objects in
-//! in a set/multiset. set_base_hook holds the data necessary to maintain
+//! Derive a class from set_base_hook in order to store objects in
+//! in a set/multiset. set_base_hook holds the data necessary to maintain
//! the set/multiset and provides an appropriate value_traits class for set/multiset.
-//!
+//!
//! The hook admits the following options: \c tag<>, \c void_pointer<>,
//! \c link_mode<> and \c optimize_size<>.
//!
-//! \c tag<> defines a tag to identify the node.
-//! The same tag value can be used in different classes, but if a class is
-//! derived from more than one \c list_base_hook, then each \c list_base_hook needs its
+//! \c tag<> defines a tag to identify the node.
+//! The same tag value can be used in different classes, but if a class is
+//! derived from more than one \c list_base_hook, then each \c list_base_hook needs its
//! unique tag.
//!
//! \c void_pointer<> is the pointer type that will be used internally in the hook
@@ -101,27 +101,27 @@
 public:
 //! Effects: If link_mode is \c auto_unlink or \c safe_link
 //! initializes the node to an unlinked state.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 set_base_hook();

 //! Effects: If link_mode is \c auto_unlink or \c safe_link
 //! initializes the node to an unlinked state. The argument is ignored.
- //!
- //! Throws: Nothing.
- //!
+ //!
+ //! Throws: Nothing.
+ //!
 //! Rationale: Providing a copy-constructor
- //! makes classes using the hook STL-compliant without forcing the
+ //! makes classes using the hook STL-compliant without forcing the
 //! user to do some additional work. \c swap can be used to emulate
 //! move-semantics.
 set_base_hook(const set_base_hook& );

 //! Effects: Empty function. The argument is ignored.
- //!
- //! Throws: Nothing.
- //!
- //! Rationale: Providing an assignment operator
- //! makes classes using the hook STL-compliant without forcing the
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Rationale: Providing an assignment operator
+ //! makes classes using the hook STL-compliant without forcing the
 //! user to do some additional work. \c swap can be used to emulate
 //! move-semantics.
 set_base_hook& operator=(const set_base_hook& );
@@ -130,37 +130,37 @@
 //! nothing (ie. no code is generated). If link_mode is \c safe_link and the
 //! object is stored in a set an assertion is raised. If link_mode is
 //! \c auto_unlink and \c is_linked() is true, the node is unlinked.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 ~set_base_hook();

- //! Effects: Swapping two nodes swaps the position of the elements
- //! related to those nodes in one or two containers. That is, if the node
- //! this is part of the element e1, the node x is part of the element e2
- //! and both elements are included in the containers s1 and s2, then after
- //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1
- //! at the position of e1. If one element is not in a container, then
- //! after the swap-operation the other element is not in a container.
- //! Iterators to e1 and e2 related to those nodes are invalidated.
+ //! Effects: Swapping two nodes swaps the position of the elements
+ //! related to those nodes in one or two containers. That is, if the node
+ //! this is part of the element e1, the node x is part of the element e2
+ //! and both elements are included in the containers s1 and s2, then after
+ //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1
+ //! at the position of e1. If one element is not in a container, then
+ //! after the swap-operation the other element is not in a container.
+ //! Iterators to e1 and e2 related to those nodes are invalidated.
 //!
- //! Complexity: Constant
+ //! Complexity: Constant
 //!
- //! Throws: Nothing.
+ //! Throws: Nothing.
 void swap_nodes(set_base_hook &other);

 //! Precondition: link_mode must be \c safe_link or \c auto_unlink.
 //!
 //! Returns: true, if the node belongs to a container, false
- //! otherwise. This function can be used to test whether \c set::iterator_to
- //! will return a valid iterator.
+ //! otherwise. This function can be used to test whether \c set::iterator_to
+ //! will return a valid iterator.
 //!
- //! Complexity: Constant
+ //! Complexity: Constant
 bool is_linked() const;

 //! Effects: Removes the node if it's inserted in a container.
 //! This function is only allowed if link_mode is \c auto_unlink.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 void unlink();
 #endif
};
@@ -176,7 +176,7 @@
{
 /// @cond
 typedef typename pack_options
- < hook_defaults,
+ < hook_defaults,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
@@ -198,7 +198,7 @@
//! Put a public data member set_member_hook in order to store objects of this class in
//! a set/multiset. set_member_hook holds the data necessary for maintaining the
//! set/multiset and provides an appropriate value_traits class for set/multiset.
-//!
+//!
//! The hook admits the following options: \c void_pointer<>,
//! \c link_mode<> and \c optimize_size<>.
//!
@@ -228,27 +228,27 @@
 public:
 //! Effects: If link_mode is \c auto_unlink or \c safe_link
 //! initializes the node to an unlinked state.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 set_member_hook();

 //! Effects: If link_mode is \c auto_unlink or \c safe_link
 //! initializes the node to an unlinked state. The argument is ignored.
- //!
- //! Throws: Nothing.
- //!
+ //!
+ //! Throws: Nothing.
+ //!
 //! Rationale: Providing a copy-constructor
- //! makes classes using the hook STL-compliant without forcing the
+ //! makes classes using the hook STL-compliant without forcing the
 //! user to do some additional work. \c swap can be used to emulate
 //! move-semantics.
 set_member_hook(const set_member_hook& );

 //! Effects: Empty function. The argument is ignored.
- //!
- //! Throws: Nothing.
- //!
- //! Rationale: Providing an assignment operator
- //! makes classes using the hook STL-compliant without forcing the
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Rationale: Providing an assignment operator
+ //! makes classes using the hook STL-compliant without forcing the
 //! user to do some additional work. \c swap can be used to emulate
 //! move-semantics.
 set_member_hook& operator=(const set_member_hook& );
@@ -257,43 +257,43 @@
 //! nothing (ie. no code is generated). If link_mode is \c safe_link and the
 //! object is stored in a set an assertion is raised. If link_mode is
 //! \c auto_unlink and \c is_linked() is true, the node is unlinked.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 ~set_member_hook();

- //! Effects: Swapping two nodes swaps the position of the elements
- //! related to those nodes in one or two containers. That is, if the node
- //! this is part of the element e1, the node x is part of the element e2
- //! and both elements are included in the containers s1 and s2, then after
- //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1
- //! at the position of e1. If one element is not in a container, then
- //! after the swap-operation the other element is not in a container.
- //! Iterators to e1 and e2 related to those nodes are invalidated.
+ //! Effects: Swapping two nodes swaps the position of the elements
+ //! related to those nodes in one or two containers. That is, if the node
+ //! this is part of the element e1, the node x is part of the element e2
+ //! and both elements are included in the containers s1 and s2, then after
+ //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1
+ //! at the position of e1. If one element is not in a container, then
+ //! after the swap-operation the other element is not in a container.
+ //! Iterators to e1 and e2 related to those nodes are invalidated.
 //!
- //! Complexity: Constant
+ //! Complexity: Constant
 //!
- //! Throws: Nothing.
+ //! Throws: Nothing.
 void swap_nodes(set_member_hook &other);

 //! Precondition: link_mode must be \c safe_link or \c auto_unlink.
 //!
 //! Returns: true, if the node belongs to a container, false
- //! otherwise. This function can be used to test whether \c set::iterator_to
- //! will return a valid iterator.
+ //! otherwise. This function can be used to test whether \c set::iterator_to
+ //! will return a valid iterator.
 //!
- //! Complexity: Constant
+ //! Complexity: Constant
 bool is_linked() const;

 //! Effects: Removes the node if it's inserted in a container.
 //! This function is only allowed if link_mode is \c auto_unlink.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 void unlink();
 #endif
};

-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Modified: branches/release/boost/intrusive/sg_set.hpp
==============================================================================
--- branches/release/boost/intrusive/sg_set.hpp (original)
+++ branches/release/boost/intrusive/sg_set.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -22,9 +22,9 @@
namespace boost {
namespace intrusive {

-//! The class template sg_set is an intrusive container, that mimics most of
+//! The class template sg_set is an intrusive container, that mimics most of
//! the interface of std::set as described in the C++ standard.
-//!
+//!
//! The template parameter \c T is the type to be managed by the container.
//! The user can specify additional options and if no options are provided
//! default options are used.
@@ -77,30 +77,30 @@
 /// @endcond

 public:
- //! Effects: Constructs an empty sg_set.
- //!
- //! Complexity: Constant.
- //!
+ //! Effects: Constructs an empty sg_set.
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: If value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
- //! or the copy constructor of the value_compare object throws.
+ //! or the copy constructor of the value_compare object throws.
 sg_set_impl( const value_compare &cmp = value_compare()
- , const value_traits &v_traits = value_traits())
+ , const value_traits &v_traits = value_traits())
 : tree_(cmp, v_traits)
 {}

- //! Requires: Dereferencing iterator must yield an lvalue of type value_type.
+ //! Requires: Dereferencing iterator must yield an lvalue of type value_type.
 //! cmp must be a comparison function that induces a strict weak ordering.
- //!
- //! Effects: Constructs an empty sg_set and inserts elements from
+ //!
+ //! Effects: Constructs an empty sg_set and inserts elements from
 //! [b, e).
- //!
- //! Complexity: Linear in N if [b, e) is already sorted using
+ //!
+ //! Complexity: Linear in N if [b, e) is already sorted using
 //! comp and otherwise N * log N, where N is std::distance(last, first).
- //!
+ //!
 //! Throws: If value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
- //! or the copy constructor/operator() of the value_compare object throws.
+ //! or the copy constructor/operator() of the value_compare object throws.
 template<class Iterator>
 sg_set_impl( Iterator b, Iterator e
 , const value_compare &cmp = value_compare()
@@ -109,135 +109,135 @@
 {}

 //! Effects: to-do
- //!
- sg_set_impl(BOOST_RV_REF(sg_set_impl) x)
+ //!
+ sg_set_impl(BOOST_RV_REF(sg_set_impl) x)
 : tree_(::boost::move(x.tree_))
 {}

 //! Effects: to-do
- //!
- sg_set_impl& operator=(BOOST_RV_REF(sg_set_impl) x)
+ //!
+ sg_set_impl& operator=(BOOST_RV_REF(sg_set_impl) x)
 { tree_ = ::boost::move(x.tree_); return *this; }

- //! Effects: Detaches all elements from this. The objects in the sg_set
+ //! Effects: Detaches all elements from this. The objects in the sg_set
 //! are not deleted (i.e. no destructors are called).
- //!
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
- //!
+ //!
 //! Throws: Nothing.
- ~sg_set_impl()
+ ~sg_set_impl()
 {}

 //! Effects: Returns an iterator pointing to the beginning of the sg_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator begin()
 { return tree_.begin(); }

 //! Effects: Returns a const_iterator pointing to the beginning of the sg_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator begin() const
 { return tree_.begin(); }

 //! Effects: Returns a const_iterator pointing to the beginning of the sg_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator cbegin() const
 { return tree_.cbegin(); }

 //! Effects: Returns an iterator pointing to the end of the sg_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator end()
 { return tree_.end(); }

 //! Effects: Returns a const_iterator pointing to the end of the sg_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator end() const
 { return tree_.end(); }

 //! Effects: Returns a const_iterator pointing to the end of the sg_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator cend() const
 { return tree_.cend(); }

 //! Effects: Returns a reverse_iterator pointing to the beginning of the
 //! reversed sg_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 reverse_iterator rbegin()
 { return tree_.rbegin(); }

 //! Effects: Returns a const_reverse_iterator pointing to the beginning
 //! of the reversed sg_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator rbegin() const
 { return tree_.rbegin(); }

 //! Effects: Returns a const_reverse_iterator pointing to the beginning
 //! of the reversed sg_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator crbegin() const
 { return tree_.crbegin(); }

 //! Effects: Returns a reverse_iterator pointing to the end
 //! of the reversed sg_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 reverse_iterator rend()
 { return tree_.rend(); }

 //! Effects: Returns a const_reverse_iterator pointing to the end
 //! of the reversed sg_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator rend() const
 { return tree_.rend(); }

 //! Effects: Returns a const_reverse_iterator pointing to the end
 //! of the reversed sg_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator crend() const
 { return tree_.crend(); }

 //! Precondition: end_iterator must be a valid end iterator
 //! of sg_set.
- //!
+ //!
 //! Effects: Returns a const reference to the sg_set associated to the end iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 static sg_set_impl &container_from_end_iterator(iterator end_iterator)
 {
@@ -248,11 +248,11 @@

 //! Precondition: end_iterator must be a valid end const_iterator
 //! of sg_set.
- //!
+ //!
 //! Effects: Returns a const reference to the sg_set associated to the end iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 static const sg_set_impl &container_from_end_iterator(const_iterator end_iterator)
 {
@@ -262,11 +262,11 @@
 }

 //! Precondition: it must be a valid iterator of set.
- //!
+ //!
 //! Effects: Returns a reference to the set associated to the iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Logarithmic.
 static sg_set_impl &container_from_iterator(iterator it)
 {
@@ -276,11 +276,11 @@
 }

 //! Precondition: it must be a valid const_iterator of set.
- //!
+ //!
 //! Effects: Returns a const reference to the set associated to the iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Logarithmic.
 static const sg_set_impl &container_from_iterator(const_iterator it)
 {
@@ -290,42 +290,42 @@
 }

 //! Effects: Returns the key_compare object used by the sg_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If key_compare copy-constructor throws.
 key_compare key_comp() const
 { return tree_.value_comp(); }

 //! Effects: Returns the value_compare object used by the sg_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If value_compare copy-constructor throws.
 value_compare value_comp() const
 { return tree_.value_comp(); }

 //! Effects: Returns true if the container is empty.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 bool empty() const
 { return tree_.empty(); }

 //! Effects: Returns the number of elements stored in the sg_set.
- //!
+ //!
 //! Complexity: Linear to elements contained in *this if,
 //! constant-time size option is enabled. Constant-time otherwise.
- //!
+ //!
 //! Throws: Nothing.
 size_type size() const
 { return tree_.size(); }

 //! Effects: Swaps the contents of two sets.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If the swap() call for the comparison functor
 //! found using ADL throws. Strong guarantee.
 void swap(sg_set_impl& other)
@@ -335,22 +335,22 @@
 //! Cloner should yield to nodes equivalent to the original nodes.
 //!
 //! Effects: Erases all the elements from *this
- //! calling Disposer::operator()(pointer), clones all the
+ //! calling Disposer::operator()(pointer), clones all the
 //! elements from src calling Cloner::operator()(const_reference )
 //! and inserts them on *this. Copies the predicate from the source container.
 //!
 //! If cloner throws, all cloned elements are unlinked and disposed
 //! calling Disposer::operator()(pointer).
- //!
+ //!
 //! Complexity: Linear to erased plus inserted elements.
- //!
+ //!
 //! Throws: If cloner throws or predicate copy assignment throws. Basic guarantee.
 template <class Cloner, class Disposer>
 void clone_from(const sg_set_impl &src, Cloner cloner, Disposer disposer)
 { tree_.clone_from(src.tree_, cloner, disposer); }

 //! Requires: value must be an lvalue
- //!
+ //!
 //! Effects: Tries to inserts value into the sg_set.
 //!
 //! Returns: If the value
@@ -358,39 +358,39 @@
 //! iterator to the new value and true. If there is an equivalent value
 //! returns a pair containing an iterator to the already present value
 //! and false.
- //!
+ //!
 //! Complexity: Average complexity for insert element is at
 //! most logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Strong guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 std::pair<iterator, bool> insert(reference value)
 { return tree_.insert_unique(value); }

 //! Requires: value must be an lvalue
- //!
- //! Effects: Tries to to insert x into the sg_set, using "hint"
+ //!
+ //! Effects: Tries to to insert x into the sg_set, using "hint"
 //! as a hint to where it will be inserted.
 //!
- //! Returns: An iterator that points to the position where the
+ //! Returns: An iterator that points to the position where the
 //! new element was inserted into the sg_set.
- //!
+ //!
 //! Complexity: Logarithmic in general, but it's amortized
 //! constant time if t is inserted immediately before hint.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Strong guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 iterator insert(const_iterator hint, reference value)
 { return tree_.insert_unique(hint, value); }

- //! Requires: key_value_comp must be a comparison function that induces
+ //! Requires: key_value_comp must be a comparison function that induces
 //! the same strict weak ordering as value_compare. The difference is that
 //! key_value_comp compares an arbitrary key with the contained values.
- //!
+ //!
 //! Effects: Checks if a value can be inserted in the sg_set, using
 //! a user provided key instead of the value itself.
 //!
@@ -399,16 +399,16 @@
 //! and false. If the value can be inserted returns true in the returned
 //! pair boolean and fills "commit_data" that is meant to be used with
 //! the "insert_commit" function.
- //!
+ //!
 //! Complexity: Average complexity is at most logarithmic.
 //!
 //! Throws: If the key_value_comp ordering function throws. Strong guarantee.
- //!
+ //!
 //! Notes: This function is used to improve performance when constructing
 //! a value_type is expensive: if there is an equivalent value
 //! the constructed object must be discarded. Many times, the part of the
 //! node that is used to impose the order is much cheaper to construct
- //! than the value_type and this function offers the possibility to use that
+ //! than the value_type and this function offers the possibility to use that
 //! part to check if the insertion will be successful.
 //!
 //! If the check is successful, the user can construct the value_type and use
@@ -422,12 +422,12 @@
 (const KeyType &key, KeyValueCompare key_value_comp, insert_commit_data &commit_data)
 { return tree_.insert_unique_check(key, key_value_comp, commit_data); }

- //! Requires: key_value_comp must be a comparison function that induces
+ //! Requires: key_value_comp must be a comparison function that induces
 //! the same strict weak ordering as value_compare. The difference is that
 //! key_value_comp compares an arbitrary key with the contained values.
- //!
+ //!
 //! Effects: Checks if a value can be inserted in the sg_set, using
- //! a user provided key instead of the value itself, using "hint"
+ //! a user provided key instead of the value itself, using "hint"
 //! as a hint to where it will be inserted.
 //!
 //! Returns: If there is an equivalent value
@@ -435,23 +435,23 @@
 //! and false. If the value can be inserted returns true in the returned
 //! pair boolean and fills "commit_data" that is meant to be used with
 //! the "insert_commit" function.
- //!
+ //!
 //! Complexity: Logarithmic in general, but it's amortized
 //! constant time if t is inserted immediately before hint.
 //!
 //! Throws: If the key_value_comp ordering function throws. Strong guarantee.
- //!
+ //!
 //! Notes: This function is used to improve performance when constructing
 //! a value_type is expensive: if there is an equivalent value
 //! the constructed object must be discarded. Many times, the part of the
 //! constructing that is used to impose the order is much cheaper to construct
- //! than the value_type and this function offers the possibility to use that key
+ //! than the value_type and this function offers the possibility to use that key
 //! to check if the insertion will be successful.
 //!
 //! If the check is successful, the user can construct the value_type and use
 //! "insert_commit" to insert the object in constant-time. This can give a total
 //! constant-time complexity to the insertion: check(O(1)) + commit(O(1)).
- //!
+ //!
 //! "commit_data" remains valid for a subsequent "insert_commit" only if no more
 //! objects are inserted or erased from the sg_set.
 template<class KeyType, class KeyValueCompare>
@@ -464,33 +464,33 @@
 //! must have been obtained from a previous call to "insert_check".
 //! No objects should have been inserted or erased from the sg_set between
 //! the "insert_check" that filled "commit_data" and the call to "insert_commit".
- //!
+ //!
 //! Effects: Inserts the value in the sg_set using the information obtained
 //! from the "commit_data" that a previous "insert_check" filled.
 //!
 //! Returns: An iterator to the newly inserted object.
- //!
+ //!
 //! Complexity: Constant time.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Notes: This function has only sense if a "insert_check" has been
 //! previously executed to fill "commit_data". No value should be inserted or
 //! erased between the "insert_check" and "insert_commit" calls.
 iterator insert_commit(reference value, const insert_commit_data &commit_data)
 { return tree_.insert_unique_commit(value, commit_data); }

- //! Requires: Dereferencing iterator must yield an lvalue
+ //! Requires: Dereferencing iterator must yield an lvalue
 //! of type value_type.
- //!
+ //!
 //! Effects: Inserts a range into the sg_set.
- //!
+ //!
 //! Complexity: Insert range is in general O(N * log(N)), where N is the
 //! size of the range. However, it is linear in N if the range is already sorted
 //! by value_comp().
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Basic guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 template<class Iterator>
@@ -503,11 +503,11 @@
 //! inserted key according to the predicate.
 //!
 //! Effects: Inserts x into the tree before "pos".
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function does not check preconditions so if "pos" is not
 //! the successor of "value" or "value" is not unique tree ordering and uniqueness
 //! invariants will be broken respectively.
@@ -520,11 +520,11 @@
 //! any inserted key according to the predicate.
 //!
 //! Effects: Inserts x into the tree in the last position.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function does not check preconditions so if value is
 //! less than or equal to the greatest inserted key tree ordering invariant will be broken.
 //! This function is slightly more efficient than using "insert_before".
@@ -537,11 +537,11 @@
 //! than any inserted key according to the predicate.
 //!
 //! Effects: Inserts x into the tree in the first position.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function does not check preconditions so if value is
 //! greater than or equal to the the mimum inserted key tree ordering or uniqueness
 //! invariants will be broken.
@@ -551,41 +551,41 @@
 void push_front(reference value)
 { tree_.push_front(value); }

- //! Effects: Erases the element pointed to by pos.
- //!
+ //! Effects: Erases the element pointed to by pos.
+ //!
 //! Complexity: Average complexity is constant time.
- //!
+ //!
 //! Returns: An iterator to the element after the erased element.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 iterator erase(const_iterator i)
 { return tree_.erase(i); }

- //! Effects: Erases the range pointed to by b end e.
- //!
- //! Complexity: Average complexity for erase range is at most
+ //! Effects: Erases the range pointed to by b end e.
+ //!
+ //! Complexity: Average complexity for erase range is at most
 //! O(log(size() + N)), where N is the number of elements in the range.
- //!
+ //!
 //! Returns: An iterator to the element after the erased elements.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 iterator erase(const_iterator b, const_iterator e)
 { return tree_.erase(b, e); }

 //! Effects: Erases all the elements with the given value.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size()) + this->count(value)).
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 size_type erase(const_reference value)
@@ -593,13 +593,13 @@

 //! Effects: Erases all the elements that compare equal with
 //! the given key and the given comparison functor.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size() + this->count(key, comp)).
- //!
+ //!
 //! Throws: If the comp ordering function throws. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class KeyType, class KeyValueCompare>
@@ -612,16 +612,16 @@

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
 //!
- //! Effects: Erases the element pointed to by pos.
+ //! Effects: Erases the element pointed to by pos.
 //! Disposer::operator()(pointer) is called for the removed element.
- //!
- //! Complexity: Average complexity for erase element is constant time.
- //!
+ //!
+ //! Complexity: Average complexity for erase element is constant time.
+ //!
 //! Returns: An iterator to the element after the erased element.
- //!
+ //!
 //! Throws: Nothing.
- //!
- //! Note: Invalidates the iterators
+ //!
+ //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
 iterator erase_and_dispose(const_iterator i, Disposer disposer)
@@ -637,14 +637,14 @@
 //!
 //! Effects: Erases the range pointed to by b end e.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
- //! Complexity: Average complexity for erase range is at most
+ //!
+ //! Complexity: Average complexity for erase range is at most
 //! O(log(size() + N)), where N is the number of elements in the range.
- //!
+ //!
 //! Returns: An iterator to the element after the erased elements.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
@@ -655,13 +655,13 @@
 //!
 //! Effects: Erases all the elements with the given value.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
- //!
+ //!
 //! Complexity: O(log(size() + this->count(value)). Basic guarantee.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class Disposer>
@@ -675,11 +675,11 @@
 //! Disposer::operator()(pointer) is called for the removed elements.
 //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size() + this->count(key, comp)).
- //!
+ //!
 //! Throws: If comp ordering function throws. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class KeyType, class KeyValueCompare, class Disposer>
@@ -691,26 +691,26 @@
 { return tree_.erase_and_dispose(key, comp, disposer); }

 //! Effects: Erases all the elements of the container.
- //!
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 void clear()
 { return tree_.clear(); }

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
- //!
+ //!
 //! Effects: Erases all the elements of the container.
- //!
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class Disposer>
@@ -718,20 +718,20 @@
 { return tree_.clear_and_dispose(disposer); }

 //! Effects: Returns the number of contained elements with the given key
- //!
+ //!
 //! Complexity: Logarithmic to the number of elements contained plus lineal
 //! to number of objects with the given key.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 size_type count(const_reference value) const
 { return tree_.find(value) != end(); }

 //! Effects: Returns the number of contained elements with the same key
 //! compared with the given comparison functor.
- //!
+ //!
 //! Complexity: Logarithmic to the number of elements contained plus lineal
 //! to number of objects with the given key.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 template<class KeyType, class KeyValueCompare>
 size_type count(const KeyType& key, KeyValueCompare comp) const
@@ -739,9 +739,9 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is not less than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 iterator lower_bound(const_reference value)
 { return tree_.lower_bound(value); }
@@ -751,13 +751,13 @@
 //! that is used in the ordering functor.
 //!
 //! Effects: Returns an iterator to the first element whose
- //! key according to the comparison functor is not less than k or
+ //! key according to the comparison functor is not less than k or
 //! end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
- //!
+ //!
 //! Note: This function is used when constructing a value_type
 //! is expensive and the value_type can be compared with a cheaper
 //! key type. Usually this key is part of the value_type.
@@ -767,9 +767,9 @@

 //! Effects: Returns a const iterator to the first element whose
 //! key is not less than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 const_iterator lower_bound(const_reference value) const
 { return tree_.lower_bound(value); }
@@ -779,13 +779,13 @@
 //! that is used in the ordering functor.
 //!
 //! Effects: Returns a const_iterator to the first element whose
- //! key according to the comparison functor is not less than k or
+ //! key according to the comparison functor is not less than k or
 //! end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
- //!
+ //!
 //! Note: This function is used when constructing a value_type
 //! is expensive and the value_type can be compared with a cheaper
 //! key type. Usually this key is part of the value_type.
@@ -795,9 +795,9 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is greater than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 iterator upper_bound(const_reference value)
 { return tree_.upper_bound(value); }
@@ -807,11 +807,11 @@
 //! that is used in the ordering functor.
 //!
 //! Effects: Returns an iterator to the first element whose
- //! key according to the comparison functor is greater than key or
+ //! key according to the comparison functor is greater than key or
 //! end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -823,9 +823,9 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is greater than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 const_iterator upper_bound(const_reference value) const
 { return tree_.upper_bound(value); }
@@ -835,11 +835,11 @@
 //! that is used in the ordering functor.
 //!
 //! Effects: Returns a const_iterator to the first element whose
- //! key according to the comparison functor is greater than key or
+ //! key according to the comparison functor is greater than key or
 //! end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -849,11 +849,11 @@
 const_iterator upper_bound(const KeyType& key, KeyValueCompare comp) const
 { return tree_.upper_bound(key, comp); }

- //! Effects: Finds an iterator to the first element whose value is
+ //! Effects: Finds an iterator to the first element whose value is
 //! "value" or end() if that element does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 iterator find(const_reference value)
 { return tree_.find(value); }
@@ -862,12 +862,12 @@
 //! value_compare. Usually key is the part of the value_type
 //! that is used in the ordering functor.
 //!
- //! Effects: Finds an iterator to the first element whose key is
- //! "key" according to the comparison functor or end() if that element
+ //! Effects: Finds an iterator to the first element whose key is
+ //! "key" according to the comparison functor or end() if that element
 //! does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -877,11 +877,11 @@
 iterator find(const KeyType& key, KeyValueCompare comp)
 { return tree_.find(key, comp); }

- //! Effects: Finds a const_iterator to the first element whose value is
+ //! Effects: Finds a const_iterator to the first element whose value is
 //! "value" or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 const_iterator find(const_reference value) const
 { return tree_.find(value); }
@@ -890,12 +890,12 @@
 //! value_compare. Usually key is the part of the value_type
 //! that is used in the ordering functor.
 //!
- //! Effects: Finds a const_iterator to the first element whose key is
- //! "key" according to the comparison functor or end() if that element
+ //! Effects: Finds a const_iterator to the first element whose key is
+ //! "key" according to the comparison functor or end() if that element
 //! does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -908,9 +908,9 @@
 //! Effects: Finds a range containing all elements whose key is k or
 //! an empty range that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 std::pair<iterator,iterator> equal_range(const_reference value)
 { return tree_.equal_range(value); }
@@ -919,13 +919,13 @@
 //! value_compare. Usually key is the part of the value_type
 //! that is used in the ordering functor.
 //!
- //! Effects: Finds a range containing all elements whose key is k
- //! according to the comparison functor or an empty range
+ //! Effects: Finds a range containing all elements whose key is k
+ //! according to the comparison functor or an empty range
 //! that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -938,9 +938,9 @@
 //! Effects: Finds a range containing all elements whose key is k or
 //! an empty range that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 std::pair<const_iterator, const_iterator>
 equal_range(const_reference value) const
@@ -950,13 +950,13 @@
 //! value_compare. Usually key is the part of the value_type
 //! that is used in the ordering functor.
 //!
- //! Effects: Finds a range containing all elements whose key is k
- //! according to the comparison functor or an empty range
+ //! Effects: Finds a range containing all elements whose key is k
+ //! according to the comparison functor or an empty range
 //! that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -969,14 +969,14 @@

 //! Requires: value must be an lvalue and shall be in a sg_set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid iterator i belonging to the sg_set
 //! that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This static function is available only if the value traits
 //! is stateless.
 static iterator s_iterator_to(reference value)
@@ -984,14 +984,14 @@

 //! Requires: value must be an lvalue and shall be in a sg_set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid const_iterator i belonging to the
 //! sg_set that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This static function is available only if the value traits
 //! is stateless.
 static const_iterator s_iterator_to(const_reference value)
@@ -999,48 +999,48 @@

 //! Requires: value must be an lvalue and shall be in a sg_set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid iterator i belonging to the sg_set
 //! that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator iterator_to(reference value)
 { return tree_.iterator_to(value); }

 //! Requires: value must be an lvalue and shall be in a sg_set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid const_iterator i belonging to the
 //! sg_set that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator iterator_to(const_reference value) const
 { return tree_.iterator_to(value); }

 //! Requires: value shall not be in a sg_set/sg_multiset.
- //!
+ //!
 //! Effects: init_node puts the hook of a value in a well-known default
 //! state.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Note: This function puts the hook in the well-known default state
 //! used by auto_unlink and safe hooks.
 static void init_node(reference value)
 { tree_type::init_node(value); }

 //! Effects: Unlinks the leftmost node from the tree.
- //!
+ //!
 //! Complexity: Average complexity is constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Notes: This function breaks the tree and the tree can
 //! only be used for more unlink_leftmost_without_rebalance calls.
 //! This function is normally used to achieve a step by step
@@ -1050,14 +1050,14 @@

 //! Requires: replace_this must be a valid iterator of *this
 //! and with_this must not be inserted in any tree.
- //!
+ //!
 //! Effects: Replaces replace_this in its position in the
 //! tree with with_this. The tree does not need to be rebalanced.
- //!
- //! Complexity: Constant.
- //!
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function will break container ordering invariants if
 //! with_this is not equivalent to *replace_this according to the
 //! ordering rules. This function is faster than erasing and inserting
@@ -1066,21 +1066,21 @@
 { tree_.replace_node(replace_this, with_this); }

 //! Effects: Rebalances the tree.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear.
 void rebalance()
 { tree_.rebalance(); }

 //! Requires: old_root is a node of a tree.
- //!
+ //!
 //! Effects: Rebalances the subtree rooted at old_root.
 //!
 //! Returns: The new root of the subtree.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the elements in the subtree.
 iterator rebalance_subtree(iterator root)
 { return tree_.rebalance_subtree(root); }
@@ -1088,18 +1088,18 @@
 //! Returns: The balance factor (alpha) used in this tree
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 float balance_factor() const
 { return tree_.balance_factor(); }

 //! Requires: new_alpha must be a value between 0.5 and 1.0
- //!
+ //!
 //! Effects: Establishes a new balance factor (alpha) and rebalances
 //! the tree if the new balance factor is stricter (less) than the old factor.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the elements in the subtree.
 void balance_factor(float new_alpha)
 { tree_.balance_factor(new_alpha); }
@@ -1190,7 +1190,7 @@
{
 /// @cond
 typedef sg_set_impl
- < typename make_sgtree_opt<T,
+ < typename make_sgtree_opt<T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
@@ -1210,7 +1210,7 @@
template<class T, class ...Options>
#endif
class sg_set
- : public make_sg_set<T,
+ : public make_sg_set<T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
@@ -1219,7 +1219,7 @@
>::type
{
 typedef typename make_sg_set
- <T,
+ <T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
@@ -1271,9 +1271,9 @@

#endif

-//! The class template sg_multiset is an intrusive container, that mimics most of
+//! The class template sg_multiset is an intrusive container, that mimics most of
//! the interface of std::sg_multiset as described in the C++ standard.
-//!
+//!
//! The template parameter \c T is the type to be managed by the container.
//! The user can specify additional options and if no options are provided
//! default options are used.
@@ -1325,30 +1325,30 @@
 /// @endcond

 public:
- //! Effects: Constructs an empty sg_multiset.
- //!
- //! Complexity: Constant.
- //!
+ //! Effects: Constructs an empty sg_multiset.
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: If value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
- //! or the copy constructor/operator() of the value_compare object throws.
+ //! or the copy constructor/operator() of the value_compare object throws.
 sg_multiset_impl( const value_compare &cmp = value_compare()
- , const value_traits &v_traits = value_traits())
+ , const value_traits &v_traits = value_traits())
 : tree_(cmp, v_traits)
 {}

- //! Requires: Dereferencing iterator must yield an lvalue of type value_type.
+ //! Requires: Dereferencing iterator must yield an lvalue of type value_type.
 //! cmp must be a comparison function that induces a strict weak ordering.
- //!
- //! Effects: Constructs an empty sg_multiset and inserts elements from
+ //!
+ //! Effects: Constructs an empty sg_multiset and inserts elements from
 //! [b, e).
- //!
+ //!
 //! Complexity: Linear in N if [b, e) is already sorted using
 //! comp and otherwise N * log N, where N is the distance between first and last
- //!
+ //!
 //! Throws: If value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
- //! or the copy constructor/operator() of the value_compare object throws.
+ //! or the copy constructor/operator() of the value_compare object throws.
 template<class Iterator>
 sg_multiset_impl( Iterator b, Iterator e
 , const value_compare &cmp = value_compare()
@@ -1357,135 +1357,135 @@
 {}

 //! Effects: to-do
- //!
- sg_multiset_impl(BOOST_RV_REF(sg_multiset_impl) x)
+ //!
+ sg_multiset_impl(BOOST_RV_REF(sg_multiset_impl) x)
 : tree_(::boost::move(x.tree_))
 {}

 //! Effects: to-do
- //!
- sg_multiset_impl& operator=(BOOST_RV_REF(sg_multiset_impl) x)
+ //!
+ sg_multiset_impl& operator=(BOOST_RV_REF(sg_multiset_impl) x)
 { tree_ = ::boost::move(x.tree_); return *this; }

- //! Effects: Detaches all elements from this. The objects in the sg_multiset
+ //! Effects: Detaches all elements from this. The objects in the sg_multiset
 //! are not deleted (i.e. no destructors are called).
- //!
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
- //!
+ //!
 //! Throws: Nothing.
- ~sg_multiset_impl()
+ ~sg_multiset_impl()
 {}

 //! Effects: Returns an iterator pointing to the beginning of the sg_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator begin()
 { return tree_.begin(); }

 //! Effects: Returns a const_iterator pointing to the beginning of the sg_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator begin() const
 { return tree_.begin(); }

 //! Effects: Returns a const_iterator pointing to the beginning of the sg_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator cbegin() const
 { return tree_.cbegin(); }

 //! Effects: Returns an iterator pointing to the end of the sg_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator end()
 { return tree_.end(); }

 //! Effects: Returns a const_iterator pointing to the end of the sg_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator end() const
 { return tree_.end(); }

 //! Effects: Returns a const_iterator pointing to the end of the sg_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator cend() const
 { return tree_.cend(); }

 //! Effects: Returns a reverse_iterator pointing to the beginning of the
 //! reversed sg_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 reverse_iterator rbegin()
 { return tree_.rbegin(); }

 //! Effects: Returns a const_reverse_iterator pointing to the beginning
 //! of the reversed sg_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator rbegin() const
 { return tree_.rbegin(); }

 //! Effects: Returns a const_reverse_iterator pointing to the beginning
 //! of the reversed sg_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator crbegin() const
 { return tree_.crbegin(); }

 //! Effects: Returns a reverse_iterator pointing to the end
 //! of the reversed sg_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 reverse_iterator rend()
 { return tree_.rend(); }

 //! Effects: Returns a const_reverse_iterator pointing to the end
 //! of the reversed sg_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator rend() const
 { return tree_.rend(); }

 //! Effects: Returns a const_reverse_iterator pointing to the end
 //! of the reversed sg_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator crend() const
 { return tree_.crend(); }

 //! Precondition: end_iterator must be a valid end iterator
 //! of sg_multiset.
- //!
+ //!
 //! Effects: Returns a const reference to the sg_multiset associated to the end iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 static sg_multiset_impl &container_from_end_iterator(iterator end_iterator)
 {
@@ -1496,11 +1496,11 @@

 //! Precondition: end_iterator must be a valid end const_iterator
 //! of sg_multiset.
- //!
+ //!
 //! Effects: Returns a const reference to the sg_multiset associated to the end iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 static const sg_multiset_impl &container_from_end_iterator(const_iterator end_iterator)
 {
@@ -1510,11 +1510,11 @@
 }

 //! Precondition: it must be a valid iterator of multiset.
- //!
+ //!
 //! Effects: Returns a const reference to the multiset associated to the iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 static sg_multiset_impl &container_from_iterator(iterator it)
 {
@@ -1524,11 +1524,11 @@
 }

 //! Precondition: it must be a valid const_iterator of multiset.
- //!
+ //!
 //! Effects: Returns a const reference to the multiset associated to the iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 static const sg_multiset_impl &container_from_iterator(const_iterator it)
 {
@@ -1538,42 +1538,42 @@
 }

 //! Effects: Returns the key_compare object used by the sg_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If key_compare copy-constructor throws.
 key_compare key_comp() const
 { return tree_.value_comp(); }

 //! Effects: Returns the value_compare object used by the sg_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If value_compare copy-constructor throws.
 value_compare value_comp() const
 { return tree_.value_comp(); }

 //! Effects: Returns true if the container is empty.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 bool empty() const
 { return tree_.empty(); }

 //! Effects: Returns the number of elements stored in the sg_multiset.
- //!
+ //!
 //! Complexity: Linear to elements contained in *this if,
 //! constant-time size option is enabled. Constant-time otherwise.
- //!
+ //!
 //! Throws: Nothing.
 size_type size() const
 { return tree_.size(); }

 //! Effects: Swaps the contents of two sg_multisets.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If the swap() call for the comparison functor
 //! found using ADL throws. Strong guarantee.
 void swap(sg_multiset_impl& other)
@@ -1583,69 +1583,69 @@
 //! Cloner should yield to nodes equivalent to the original nodes.
 //!
 //! Effects: Erases all the elements from *this
- //! calling Disposer::operator()(pointer), clones all the
+ //! calling Disposer::operator()(pointer), clones all the
 //! elements from src calling Cloner::operator()(const_reference )
 //! and inserts them on *this. Copies the predicate from the source container.
 //!
 //! If cloner throws, all cloned elements are unlinked and disposed
 //! calling Disposer::operator()(pointer).
- //!
+ //!
 //! Complexity: Linear to erased plus inserted elements.
- //!
+ //!
 //! Throws: If cloner throws or predicate copy assignment throws. Basic guarantee.
 template <class Cloner, class Disposer>
 void clone_from(const sg_multiset_impl &src, Cloner cloner, Disposer disposer)
 { tree_.clone_from(src.tree_, cloner, disposer); }

 //! Requires: value must be an lvalue
- //!
+ //!
 //! Effects: Inserts value into the sg_multiset.
- //!
+ //!
 //! Returns: An iterator that points to the position where the new
 //! element was inserted.
- //!
+ //!
 //! Complexity: Average complexity for insert element is at
 //! most logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Strong guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 iterator insert(reference value)
 { return tree_.insert_equal(value); }

 //! Requires: value must be an lvalue
- //!
+ //!
 //! Effects: Inserts x into the sg_multiset, using pos as a hint to
 //! where it will be inserted.
- //!
+ //!
 //! Returns: An iterator that points to the position where the new
 //! element was inserted.
- //!
+ //!
 //! Complexity: Logarithmic in general, but it is amortized
 //! constant time if t is inserted immediately before hint.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Strong guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 iterator insert(const_iterator hint, reference value)
 { return tree_.insert_equal(hint, value); }

- //! Requires: Dereferencing iterator must yield an lvalue
+ //! Requires: Dereferencing iterator must yield an lvalue
 //! of type value_type.
- //!
+ //!
 //! Effects: Inserts a range into the sg_multiset.
- //!
+ //!
 //! Returns: An iterator that points to the position where the new
 //! element was inserted.
- //!
+ //!
 //! Complexity: Insert range is in general O(N * log(N)), where N is the
 //! size of the range. However, it is linear in N if the range is already sorted
 //! by value_comp().
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Basic guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 template<class Iterator>
@@ -1657,11 +1657,11 @@
 //! once inserted according to the predicate
 //!
 //! Effects: Inserts x into the tree before "pos".
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function does not check preconditions so if "pos" is not
 //! the successor of "value" tree ordering invariant will be broken.
 //! This is a low-level function to be used only for performance reasons
@@ -1673,11 +1673,11 @@
 //! than the greatest inserted key
 //!
 //! Effects: Inserts x into the tree in the last position.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function does not check preconditions so if value is
 //! less than the greatest inserted key tree ordering invariant will be broken.
 //! This function is slightly more efficient than using "insert_before".
@@ -1690,11 +1690,11 @@
 //! than the minimum inserted key
 //!
 //! Effects: Inserts x into the tree in the first position.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function does not check preconditions so if value is
 //! greater than the minimum inserted key tree ordering invariant will be broken.
 //! This function is slightly more efficient than using "insert_before".
@@ -1703,41 +1703,41 @@
 void push_front(reference value)
 { tree_.push_front(value); }

- //! Effects: Erases the element pointed to by pos.
- //!
- //! Complexity: Average complexity is constant time.
- //!
+ //! Effects: Erases the element pointed to by pos.
+ //!
+ //! Complexity: Average complexity is constant time.
+ //!
 //! Returns: An iterator to the element after the erased element.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 iterator erase(const_iterator i)
 { return tree_.erase(i); }

- //! Effects: Erases the range pointed to by b end e.
+ //! Effects: Erases the range pointed to by b end e.
 //!
 //! Returns: An iterator to the element after the erased elements.
- //!
- //! Complexity: Average complexity for erase range is at most
+ //!
+ //! Complexity: Average complexity for erase range is at most
 //! O(log(size() + N)), where N is the number of elements in the range.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 iterator erase(const_iterator b, const_iterator e)
 { return tree_.erase(b, e); }

 //! Effects: Erases all the elements with the given value.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size() + this->count(value)).
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 size_type erase(const_reference value)
@@ -1745,13 +1745,13 @@

 //! Effects: Erases all the elements that compare equal with
 //! the given key and the given comparison functor.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size() + this->count(key, comp)).
- //!
+ //!
 //! Throws: If comp ordering function throws. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class KeyType, class KeyValueCompare>
@@ -1766,14 +1766,14 @@
 //!
 //! Returns: An iterator to the element after the erased element.
 //!
- //! Effects: Erases the element pointed to by pos.
+ //! Effects: Erases the element pointed to by pos.
 //! Disposer::operator()(pointer) is called for the removed element.
- //!
- //! Complexity: Average complexity for erase element is constant time.
- //!
+ //!
+ //! Complexity: Average complexity for erase element is constant time.
+ //!
 //! Throws: Nothing.
- //!
- //! Note: Invalidates the iterators
+ //!
+ //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
 iterator erase_and_dispose(const_iterator i, Disposer disposer)
@@ -1791,12 +1791,12 @@
 //!
 //! Effects: Erases the range pointed to by b end e.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
- //! Complexity: Average complexity for erase range is at most
+ //!
+ //! Complexity: Average complexity for erase range is at most
 //! O(log(size() + N)), where N is the number of elements in the range.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
@@ -1807,13 +1807,13 @@
 //!
 //! Effects: Erases all the elements with the given value.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size() + this->count(value)).
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class Disposer>
@@ -1827,11 +1827,11 @@
 //! Disposer::operator()(pointer) is called for the removed elements.
 //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size() + this->count(key, comp)).
- //!
+ //!
 //! Throws: If comp ordering function throws. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class KeyType, class KeyValueCompare, class Disposer>
@@ -1843,26 +1843,26 @@
 { return tree_.erase_and_dispose(key, comp, disposer); }

 //! Effects: Erases all the elements of the container.
- //!
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 void clear()
 { return tree_.clear(); }

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
- //!
+ //!
 //! Effects: Erases all the elements of the container.
- //!
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class Disposer>
@@ -1870,20 +1870,20 @@
 { return tree_.clear_and_dispose(disposer); }

 //! Effects: Returns the number of contained elements with the given key
- //!
+ //!
 //! Complexity: Logarithmic to the number of elements contained plus lineal
 //! to number of objects with the given key.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 size_type count(const_reference value) const
 { return tree_.count(value); }

 //! Effects: Returns the number of contained elements with the same key
 //! compared with the given comparison functor.
- //!
+ //!
 //! Complexity: Logarithmic to the number of elements contained plus lineal
 //! to number of objects with the given key.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 template<class KeyType, class KeyValueCompare>
 size_type count(const KeyType& key, KeyValueCompare comp) const
@@ -1891,9 +1891,9 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is not less than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 iterator lower_bound(const_reference value)
 { return tree_.lower_bound(value); }
@@ -1903,13 +1903,13 @@
 //! that is used in the ordering functor.
 //!
 //! Effects: Returns an iterator to the first element whose
- //! key according to the comparison functor is not less than k or
+ //! key according to the comparison functor is not less than k or
 //! end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
- //!
+ //!
 //! Note: This function is used when constructing a value_type
 //! is expensive and the value_type can be compared with a cheaper
 //! key type. Usually this key is part of the value_type.
@@ -1919,9 +1919,9 @@

 //! Effects: Returns a const iterator to the first element whose
 //! key is not less than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 const_iterator lower_bound(const_reference value) const
 { return tree_.lower_bound(value); }
@@ -1931,13 +1931,13 @@
 //! that is used in the ordering functor.
 //!
 //! Effects: Returns a const_iterator to the first element whose
- //! key according to the comparison functor is not less than k or
+ //! key according to the comparison functor is not less than k or
 //! end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
- //!
+ //!
 //! Note: This function is used when constructing a value_type
 //! is expensive and the value_type can be compared with a cheaper
 //! key type. Usually this key is part of the value_type.
@@ -1947,9 +1947,9 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is greater than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 iterator upper_bound(const_reference value)
 { return tree_.upper_bound(value); }
@@ -1959,11 +1959,11 @@
 //! that is used in the ordering functor.
 //!
 //! Effects: Returns an iterator to the first element whose
- //! key according to the comparison functor is greater than key or
+ //! key according to the comparison functor is greater than key or
 //! end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -1975,9 +1975,9 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is greater than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 const_iterator upper_bound(const_reference value) const
 { return tree_.upper_bound(value); }
@@ -1987,11 +1987,11 @@
 //! that is used in the ordering functor.
 //!
 //! Effects: Returns a const_iterator to the first element whose
- //! key according to the comparison functor is greater than key or
+ //! key according to the comparison functor is greater than key or
 //! end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -2001,11 +2001,11 @@
 const_iterator upper_bound(const KeyType& key, KeyValueCompare comp) const
 { return tree_.upper_bound(key, comp); }

- //! Effects: Finds an iterator to the first element whose value is
+ //! Effects: Finds an iterator to the first element whose value is
 //! "value" or end() if that element does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 iterator find(const_reference value)
 { return tree_.find(value); }
@@ -2014,12 +2014,12 @@
 //! value_compare. Usually key is the part of the value_type
 //! that is used in the ordering functor.
 //!
- //! Effects: Finds an iterator to the first element whose key is
- //! "key" according to the comparison functor or end() if that element
+ //! Effects: Finds an iterator to the first element whose key is
+ //! "key" according to the comparison functor or end() if that element
 //! does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -2029,11 +2029,11 @@
 iterator find(const KeyType& key, KeyValueCompare comp)
 { return tree_.find(key, comp); }

- //! Effects: Finds a const_iterator to the first element whose value is
+ //! Effects: Finds a const_iterator to the first element whose value is
 //! "value" or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 const_iterator find(const_reference value) const
 { return tree_.find(value); }
@@ -2042,12 +2042,12 @@
 //! value_compare. Usually key is the part of the value_type
 //! that is used in the ordering functor.
 //!
- //! Effects: Finds a const_iterator to the first element whose key is
- //! "key" according to the comparison functor or end() if that element
+ //! Effects: Finds a const_iterator to the first element whose key is
+ //! "key" according to the comparison functor or end() if that element
 //! does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -2060,9 +2060,9 @@
 //! Effects: Finds a range containing all elements whose key is k or
 //! an empty range that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 std::pair<iterator,iterator> equal_range(const_reference value)
 { return tree_.equal_range(value); }
@@ -2071,13 +2071,13 @@
 //! value_compare. Usually key is the part of the value_type
 //! that is used in the ordering functor.
 //!
- //! Effects: Finds a range containing all elements whose key is k
- //! according to the comparison functor or an empty range
+ //! Effects: Finds a range containing all elements whose key is k
+ //! according to the comparison functor or an empty range
 //! that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -2090,9 +2090,9 @@
 //! Effects: Finds a range containing all elements whose key is k or
 //! an empty range that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 std::pair<const_iterator, const_iterator>
 equal_range(const_reference value) const
@@ -2102,13 +2102,13 @@
 //! value_compare. Usually key is the part of the value_type
 //! that is used in the ordering functor.
 //!
- //! Effects: Finds a range containing all elements whose key is k
- //! according to the comparison functor or an empty range
+ //! Effects: Finds a range containing all elements whose key is k
+ //! according to the comparison functor or an empty range
 //! that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -2121,14 +2121,14 @@

 //! Requires: value must be an lvalue and shall be in a sg_multiset of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid iterator i belonging to the sg_multiset
 //! that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This static function is available only if the value traits
 //! is stateless.
 static iterator s_iterator_to(reference value)
@@ -2136,14 +2136,14 @@

 //! Requires: value must be an lvalue and shall be in a sg_multiset of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid const_iterator i belonging to the
 //! sg_multiset that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This static function is available only if the value traits
 //! is stateless.
 static const_iterator s_iterator_to(const_reference value)
@@ -2151,48 +2151,48 @@

 //! Requires: value must be an lvalue and shall be in a sg_multiset of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid iterator i belonging to the sg_multiset
 //! that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator iterator_to(reference value)
 { return tree_.iterator_to(value); }

 //! Requires: value must be an lvalue and shall be in a sg_multiset of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid const_iterator i belonging to the
 //! sg_multiset that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator iterator_to(const_reference value) const
 { return tree_.iterator_to(value); }

 //! Requires: value shall not be in a sg_multiset/sg_multiset.
- //!
+ //!
 //! Effects: init_node puts the hook of a value in a well-known default
 //! state.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Note: This function puts the hook in the well-known default state
 //! used by auto_unlink and safe hooks.
 static void init_node(reference value)
 { tree_type::init_node(value); }

 //! Effects: Unlinks the leftmost node from the tree.
- //!
+ //!
 //! Complexity: Average complexity is constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Notes: This function breaks the tree and the tree can
 //! only be used for more unlink_leftmost_without_rebalance calls.
 //! This function is normally used to achieve a step by step
@@ -2202,14 +2202,14 @@

 //! Requires: replace_this must be a valid iterator of *this
 //! and with_this must not be inserted in any tree.
- //!
+ //!
 //! Effects: Replaces replace_this in its position in the
 //! tree with with_this. The tree does not need to be rebalanced.
- //!
- //! Complexity: Constant.
- //!
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function will break container ordering invariants if
 //! with_this is not equivalent to *replace_this according to the
 //! ordering rules. This function is faster than erasing and inserting
@@ -2218,21 +2218,21 @@
 { tree_.replace_node(replace_this, with_this); }

 //! Effects: Rebalances the tree.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear.
 void rebalance()
 { tree_.rebalance(); }

 //! Requires: old_root is a node of a tree.
- //!
+ //!
 //! Effects: Rebalances the subtree rooted at old_root.
 //!
 //! Returns: The new root of the subtree.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the elements in the subtree.
 iterator rebalance_subtree(iterator root)
 { return tree_.rebalance_subtree(root); }
@@ -2240,18 +2240,18 @@
 //! Returns: The balance factor (alpha) used in this tree
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 float balance_factor() const
 { return tree_.balance_factor(); }

 //! Requires: new_alpha must be a value between 0.5 and 1.0
- //!
+ //!
 //! Effects: Establishes a new balance factor (alpha) and rebalances
 //! the tree if the new balance factor is stricter (less) than the old factor.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the elements in the subtree.
 void balance_factor(float new_alpha)
 { tree_.balance_factor(new_alpha); }
@@ -2342,7 +2342,7 @@
{
 /// @cond
 typedef sg_multiset_impl
- < typename make_sgtree_opt<T,
+ < typename make_sgtree_opt<T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
@@ -2362,7 +2362,7 @@
template<class T, class ...Options>
#endif
class sg_multiset
- : public make_sg_multiset<T,
+ : public make_sg_multiset<T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
@@ -2371,7 +2371,7 @@
>::type
{
 typedef typename make_sg_multiset
- <T,
+ <T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
@@ -2423,8 +2423,8 @@

#endif

-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Modified: branches/release/boost/intrusive/sgtree.hpp
==============================================================================
--- branches/release/boost/intrusive/sgtree.hpp (original)
+++ branches/release/boost/intrusive/sgtree.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -103,7 +103,7 @@
 alpha_by_max_size_t(float alpha)
 : alpha_(alpha)
 {}
-
+
 float operator()(std::size_t max_tree_size) const
 { return float(max_tree_size)*alpha_; }

@@ -125,7 +125,7 @@
 { return alpha_; }

 void set_alpha(float alpha)
- {
+ {
 alpha_ = alpha;
 inv_minus_logalpha_ = 1/(-detail::fast_log2(alpha));
 }
@@ -191,7 +191,7 @@

//! The class template sgtree is an intrusive scapegoat tree container, that
//! is used to construct intrusive sg_set and sg_multiset containers.
-//! The no-throw guarantee holds only, if the value_compare object
+//! The no-throw guarantee holds only, if the value_compare object
//! doesn't throw.
//!
//! The template parameter \c T is the type to be managed by the container.
@@ -260,7 +260,7 @@
 //noncopyable
 BOOST_MOVABLE_BUT_NOT_COPYABLE(sgtree_impl)

- enum { safemode_or_autounlink =
+ enum { safemode_or_autounlink =
 (int)real_value_traits::link_mode == (int)auto_unlink ||
 (int)real_value_traits::link_mode == (int)safe_link };

@@ -299,7 +299,7 @@

 void priv_alpha(float alpha)
 { return this->priv_alpha_traits().set_alpha(alpha); }
-
+
 const value_compare &priv_comp() const
 { return data_.node_plus_pred_.get(); }

@@ -363,18 +363,18 @@

 typedef typename node_algorithms::insert_commit_data insert_commit_data;

- //! Effects: Constructs an empty tree.
- //!
- //! Complexity: Constant.
- //!
+ //! Effects: Constructs an empty tree.
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: If value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
 //! or the copy constructorof the value_compare object throws. Basic guarantee.
 sgtree_impl( const value_compare &cmp = value_compare()
- , const value_traits &v_traits = value_traits())
+ , const value_traits &v_traits = value_traits())
 : data_(cmp, v_traits)
- {
- node_algorithms::init_header(this->priv_header_ptr());
+ {
+ node_algorithms::init_header(this->priv_header_ptr());
 this->priv_size_traits().set_size(size_type(0));
 }

@@ -386,7 +386,7 @@
 //!
 //! Complexity: Linear in N if [b, e) is already sorted using
 //! comp and otherwise N * log N, where N is the distance between first and last.
- //!
+ //!
 //! Throws: If value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
 //! or the copy constructor/operator() of the value_compare object throws. Basic guarantee.
@@ -405,58 +405,58 @@
 }

 //! Effects: to-do
- //!
+ //!
 sgtree_impl(BOOST_RV_REF(sgtree_impl) x)
 : data_(::boost::move(x.priv_comp()), ::boost::move(x.priv_value_traits()))
 {
- node_algorithms::init_header(this->priv_header_ptr());
+ node_algorithms::init_header(this->priv_header_ptr());
 this->priv_size_traits().set_size(size_type(0));
 this->swap(x);
 }

 //! Effects: to-do
- //!
- sgtree_impl& operator=(BOOST_RV_REF(sgtree_impl) x)
+ //!
+ sgtree_impl& operator=(BOOST_RV_REF(sgtree_impl) x)
 { this->swap(x); return *this; }

- //! Effects: Detaches all elements from this. The objects in the set
- //! are not deleted (i.e. no destructors are called), but the nodes according to
- //! the value_traits template parameter are reinitialized and thus can be reused.
- //!
- //! Complexity: Linear to elements contained in *this.
- //!
+ //! Effects: Detaches all elements from this. The objects in the set
+ //! are not deleted (i.e. no destructors are called), but the nodes according to
+ //! the value_traits template parameter are reinitialized and thus can be reused.
+ //!
+ //! Complexity: Linear to elements contained in *this.
+ //!
 //! Throws: Nothing.
- ~sgtree_impl()
+ ~sgtree_impl()
 {}

 //! Effects: Returns an iterator pointing to the beginning of the tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator begin()
 { return iterator (node_traits::get_left(this->priv_header_ptr()), this); }

 //! Effects: Returns a const_iterator pointing to the beginning of the tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator begin() const
 { return cbegin(); }

 //! Effects: Returns a const_iterator pointing to the beginning of the tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator cbegin() const
 { return const_iterator (node_traits::get_left(this->priv_header_ptr()), this); }

 //! Effects: Returns an iterator pointing to the end of the tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator end()
 { return iterator (this->priv_header_ptr(), this); }
@@ -464,138 +464,138 @@
 //! Effects: Returns a const_iterator pointing to the end of the tree.
 //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator end() const
 { return cend(); }

 //! Effects: Returns a const_iterator pointing to the end of the tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator cend() const
 { return const_iterator (uncast(this->priv_header_ptr()), this); }

 //! Effects: Returns a reverse_iterator pointing to the beginning of the
 //! reversed tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 reverse_iterator rbegin()
 { return reverse_iterator(end()); }

 //! Effects: Returns a const_reverse_iterator pointing to the beginning
 //! of the reversed tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator rbegin() const
 { return const_reverse_iterator(end()); }

 //! Effects: Returns a const_reverse_iterator pointing to the beginning
 //! of the reversed tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator crbegin() const
 { return const_reverse_iterator(end()); }

 //! Effects: Returns a reverse_iterator pointing to the end
 //! of the reversed tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 reverse_iterator rend()
 { return reverse_iterator(begin()); }

 //! Effects: Returns a const_reverse_iterator pointing to the end
 //! of the reversed tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator rend() const
 { return const_reverse_iterator(begin()); }

 //! Effects: Returns a const_reverse_iterator pointing to the end
 //! of the reversed tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator crend() const
 { return const_reverse_iterator(begin()); }

 //! Precondition: end_iterator must be a valid end iterator
 //! of sgtree.
- //!
+ //!
 //! Effects: Returns a const reference to the sgtree associated to the end iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 static sgtree_impl &container_from_end_iterator(iterator end_iterator)
 { return priv_container_from_end_iterator(end_iterator); }

 //! Precondition: end_iterator must be a valid end const_iterator
 //! of sgtree.
- //!
+ //!
 //! Effects: Returns a const reference to the sgtree associated to the end iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 static const sgtree_impl &container_from_end_iterator(const_iterator end_iterator)
 { return priv_container_from_end_iterator(end_iterator); }

 //! Precondition: it must be a valid iterator
 //! of rbtree.
- //!
+ //!
 //! Effects: Returns a const reference to the tree associated to the iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Logarithmic.
 static sgtree_impl &container_from_iterator(iterator it)
 { return priv_container_from_iterator(it); }

 //! Precondition: it must be a valid end const_iterator
 //! of rbtree.
- //!
+ //!
 //! Effects: Returns a const reference to the tree associated to the iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Logarithmic.
 static const sgtree_impl &container_from_iterator(const_iterator it)
 { return priv_container_from_iterator(it); }

 //! Effects: Returns the value_compare object used by the tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If value_compare copy-constructor throws.
 value_compare value_comp() const
 { return priv_comp(); }

 //! Effects: Returns true if the container is empty.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 bool empty() const
 { return node_algorithms::unique(this->priv_header_ptr()); }

 //! Effects: Returns the number of elements stored in the tree.
- //!
+ //!
 //! Complexity: Linear to elements contained in *this
 //! if constant-time size option is disabled. Constant time otherwise.
- //!
+ //!
 //! Throws: Nothing.
 size_type size() const
 {
@@ -607,9 +607,9 @@
 }

 //! Effects: Swaps the contents of two sgtrees.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If the comparison functor's swap call throws.
 void swap(sgtree_impl& other)
 {
@@ -628,14 +628,14 @@
 }

 //! Requires: value must be an lvalue
- //!
+ //!
 //! Effects: Inserts value into the tree before the upper bound.
- //!
+ //!
 //! Complexity: Average complexity for insert element is at
 //! most logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Strong guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 iterator insert_equal(reference value)
@@ -656,16 +656,16 @@

 //! Requires: value must be an lvalue, and "hint" must be
 //! a valid iterator.
- //!
+ //!
 //! Effects: Inserts x into the tree, using "hint" as a hint to
 //! where it will be inserted. If "hint" is the upper_bound
 //! the insertion takes constant time (two comparisons in the worst case)
- //!
+ //!
 //! Complexity: Logarithmic in general, but it is amortized
 //! constant time if t is inserted immediately before hint.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 iterator insert_equal(const_iterator hint, reference value)
@@ -684,18 +684,18 @@
 return iterator(p, this);
 }

- //! Requires: Dereferencing iterator must yield an lvalue
+ //! Requires: Dereferencing iterator must yield an lvalue
 //! of type value_type.
- //!
+ //!
 //! Effects: Inserts a each element of a range into the tree
 //! before the upper bound of the key of each element.
- //!
+ //!
 //! Complexity: Insert range is in general O(N * log(N)), where N is the
 //! size of the range. However, it is linear in N if the range is already sorted
 //! by value_comp().
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 template<class Iterator>
@@ -707,15 +707,15 @@
 }

 //! Requires: value must be an lvalue
- //!
+ //!
 //! Effects: Inserts value into the tree if the value
 //! is not already present.
- //!
+ //!
 //! Complexity: Average complexity for insert element is at
 //! most logarithmic.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 std::pair<iterator, bool> insert_unique(reference value)
@@ -729,16 +729,16 @@

 //! Requires: value must be an lvalue, and "hint" must be
 //! a valid iterator
- //!
+ //!
 //! Effects: Tries to insert x into the tree, using "hint" as a hint
 //! to where it will be inserted.
- //!
+ //!
 //! Complexity: Logarithmic in general, but it is amortized
 //! constant time (two comparisons in the worst case)
 //! if t is inserted immediately before hint.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 iterator insert_unique(const_iterator hint, reference value)
@@ -750,17 +750,17 @@
 return insert_unique_commit(value, commit_data);
 }

- //! Requires: Dereferencing iterator must yield an lvalue
+ //! Requires: Dereferencing iterator must yield an lvalue
 //! of type value_type.
- //!
+ //!
 //! Effects: Tries to insert each element of a range into the tree.
- //!
- //! Complexity: Insert range is in general O(N * log(N)), where N is the
- //! size of the range. However, it is linear in N if the range is already sorted
+ //!
+ //! Complexity: Insert range is in general O(N * log(N)), where N is the
+ //! size of the range. However, it is linear in N if the range is already sorted
 //! by value_comp().
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 template<class Iterator>
@@ -777,10 +777,10 @@
 }
 }

- //! Requires: key_value_comp must be a comparison function that induces
+ //! Requires: key_value_comp must be a comparison function that induces
 //! the same strict weak ordering as value_compare. The difference is that
 //! key_value_comp compares an arbitrary key with the contained values.
- //!
+ //!
 //! Effects: Checks if a value can be inserted in the container, using
 //! a user provided key instead of the value itself.
 //!
@@ -789,16 +789,16 @@
 //! and false. If the value can be inserted returns true in the returned
 //! pair boolean and fills "commit_data" that is meant to be used with
 //! the "insert_commit" function.
- //!
+ //!
 //! Complexity: Average complexity is at most logarithmic.
 //!
 //! Throws: If the key_value_comp ordering function throws. Strong guarantee.
- //!
+ //!
 //! Notes: This function is used to improve performance when constructing
 //! a value_type is expensive: if there is an equivalent value
 //! the constructed object must be discarded. Many times, the part of the
 //! node that is used to impose the order is much cheaper to construct
- //! than the value_type and this function offers the possibility to use that
+ //! than the value_type and this function offers the possibility to use that
 //! part to check if the insertion will be successful.
 //!
 //! If the check is successful, the user can construct the value_type and use
@@ -813,18 +813,18 @@
 {
 detail::key_nodeptr_comp<KeyValueCompare, sgtree_impl>
 comp(key_value_comp, this);
- std::pair<node_ptr, bool> ret =
+ std::pair<node_ptr, bool> ret =
 (node_algorithms::insert_unique_check
 (this->priv_header_ptr(), key, comp, commit_data));
 return std::pair<iterator, bool>(iterator(ret.first, this), ret.second);
 }

- //! Requires: key_value_comp must be a comparison function that induces
+ //! Requires: key_value_comp must be a comparison function that induces
 //! the same strict weak ordering as value_compare. The difference is that
 //! key_value_comp compares an arbitrary key with the contained values.
- //!
+ //!
 //! Effects: Checks if a value can be inserted in the container, using
- //! a user provided key instead of the value itself, using "hint"
+ //! a user provided key instead of the value itself, using "hint"
 //! as a hint to where it will be inserted.
 //!
 //! Returns: If there is an equivalent value
@@ -832,23 +832,23 @@
 //! and false. If the value can be inserted returns true in the returned
 //! pair boolean and fills "commit_data" that is meant to be used with
 //! the "insert_commit" function.
- //!
+ //!
 //! Complexity: Logarithmic in general, but it's amortized
 //! constant time if t is inserted immediately before hint.
 //!
 //! Throws: If the key_value_comp ordering function throws. Strong guarantee.
- //!
+ //!
 //! Notes: This function is used to improve performance when constructing
 //! a value_type is expensive: if there is an equivalent value
 //! the constructed object must be discarded. Many times, the part of the
 //! constructing that is used to impose the order is much cheaper to construct
- //! than the value_type and this function offers the possibility to use that key
+ //! than the value_type and this function offers the possibility to use that key
 //! to check if the insertion will be successful.
 //!
 //! If the check is successful, the user can construct the value_type and use
 //! "insert_commit" to insert the object in constant-time. This can give a total
 //! constant-time complexity to the insertion: check(O(1)) + commit(O(1)).
- //!
+ //!
 //! "commit_data" remains valid for a subsequent "insert_commit" only if no more
 //! objects are inserted or erased from the container.
 template<class KeyType, class KeyValueCompare>
@@ -858,7 +858,7 @@
 {
 detail::key_nodeptr_comp<KeyValueCompare, sgtree_impl>
 comp(key_value_comp, this);
- std::pair<node_ptr, bool> ret =
+ std::pair<node_ptr, bool> ret =
 (node_algorithms::insert_unique_check
 (this->priv_header_ptr(), hint.pointed_node(), key, comp, commit_data));
 return std::pair<iterator, bool>(iterator(ret.first, this), ret.second);
@@ -868,16 +868,16 @@
 //! must have been obtained from a previous call to "insert_check".
 //! No objects should have been inserted or erased from the container between
 //! the "insert_check" that filled "commit_data" and the call to "insert_commit".
- //!
+ //!
 //! Effects: Inserts the value in the avl_set using the information obtained
 //! from the "commit_data" that a previous "insert_check" filled.
 //!
 //! Returns: An iterator to the newly inserted object.
- //!
+ //!
 //! Complexity: Constant time.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Notes: This function has only sense if a "insert_check" has been
 //! previously executed to fill "commit_data". No value should be inserted or
 //! erased between the "insert_check" and "insert_commit" calls.
@@ -900,11 +900,11 @@
 //! once inserted according to the predicate
 //!
 //! Effects: Inserts x into the tree before "pos".
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function does not check preconditions so if "pos" is not
 //! the successor of "value" tree ordering invariant will be broken.
 //! This is a low-level function to be used only for performance reasons
@@ -927,11 +927,11 @@
 //! than the greatest inserted key
 //!
 //! Effects: Inserts x into the tree in the last position.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function does not check preconditions so if value is
 //! less than the greatest inserted key tree ordering invariant will be broken.
 //! This function is slightly more efficient than using "insert_before".
@@ -944,7 +944,7 @@
 BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
 std::size_t max_tree_size = (std::size_t)data_.max_tree_size_;
 node_algorithms::push_back
- ( this->priv_header_ptr(), to_insert
+ ( this->priv_header_ptr(), to_insert
 , (size_type)this->size(), this->get_h_alpha_func(), max_tree_size);
 this->priv_size_traits().increment();
 data_.max_tree_size_ = (size_type)max_tree_size;
@@ -954,11 +954,11 @@
 //! than the minimum inserted key
 //!
 //! Effects: Inserts x into the tree in the first position.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function does not check preconditions so if value is
 //! greater than the minimum inserted key tree ordering invariant will be broken.
 //! This function is slightly more efficient than using "insert_before".
@@ -977,12 +977,12 @@
 data_.max_tree_size_ = (size_type)max_tree_size;
 }

- //! Effects: Erases the element pointed to by pos.
- //!
- //! Complexity: Average complexity for erase element is constant time.
- //!
+ //! Effects: Erases the element pointed to by pos.
+ //!
+ //! Complexity: Average complexity for erase element is constant time.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 iterator erase(const_iterator i)
@@ -1003,26 +1003,26 @@
 return ret.unconst();
 }

- //! Effects: Erases the range pointed to by b end e.
- //!
- //! Complexity: Average complexity for erase range is at most
+ //! Effects: Erases the range pointed to by b end e.
+ //!
+ //! Complexity: Average complexity for erase range is at most
 //! O(log(size() + N)), where N is the number of elements in the range.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 iterator erase(const_iterator b, const_iterator e)
 { size_type n; return private_erase(b, e, n); }

 //! Effects: Erases all the elements with the given value.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size() + N).
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 size_type erase(const_reference value)
@@ -1032,15 +1032,15 @@
 //! according to the comparison functor "comp".
 //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size() + N).
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class KeyType, class KeyValueCompare>
- size_type erase(const KeyType& key, KeyValueCompare comp
+ size_type erase(const KeyType& key, KeyValueCompare comp
 /// @cond
 , typename detail::enable_if_c<!detail::is_convertible<KeyValueCompare, const_iterator>::value >::type * = 0
 /// @endcond
@@ -1054,14 +1054,14 @@

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
 //!
- //! Effects: Erases the element pointed to by pos.
+ //! Effects: Erases the element pointed to by pos.
 //! Disposer::operator()(pointer) is called for the removed element.
- //!
- //! Complexity: Average complexity for erase element is constant time.
- //!
+ //!
+ //! Complexity: Average complexity for erase element is constant time.
+ //!
 //! Throws: Nothing.
- //!
- //! Note: Invalidates the iterators
+ //!
+ //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
 iterator erase_and_dispose(const_iterator i, Disposer disposer)
@@ -1082,12 +1082,12 @@
 //!
 //! Effects: Erases the range pointed to by b end e.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
- //! Complexity: Average complexity for erase range is at most
+ //!
+ //! Complexity: Average complexity for erase range is at most
 //! O(log(size() + N)), where N is the number of elements in the range.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
@@ -1098,13 +1098,13 @@
 //!
 //! Effects: Erases all the elements with the given value.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size() + N).
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class Disposer>
@@ -1123,11 +1123,11 @@
 //! Disposer::operator()(pointer) is called for the removed elements.
 //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size() + N).
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class KeyType, class KeyValueCompare, class Disposer>
@@ -1143,13 +1143,13 @@
 return n;
 }

- //! Effects: Erases all of the elements.
- //!
+ //! Effects: Erases all of the elements.
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 void clear()
@@ -1167,9 +1167,9 @@
 //! each node to be erased.
 //! Complexity: Average complexity for is at most O(log(size() + N)),
 //! where N is the number of elements in the container.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. Calls N times to disposer functor.
 template<class Disposer>
@@ -1181,19 +1181,19 @@
 }

 //! Effects: Returns the number of contained elements with the given value
- //!
+ //!
 //! Complexity: Logarithmic to the number of elements contained plus lineal
 //! to number of objects with the given value.
- //!
+ //!
 //! Throws: Nothing.
 size_type count(const_reference value) const
 { return this->count(value, priv_comp()); }

 //! Effects: Returns the number of contained elements with the given key
- //!
+ //!
 //! Complexity: Logarithmic to the number of elements contained plus lineal
 //! to number of objects with the given key.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 size_type count(const KeyType &key, KeyValueCompare comp) const
@@ -1204,27 +1204,27 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is not less than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 iterator lower_bound(const_reference value)
 { return this->lower_bound(value, priv_comp()); }

 //! Effects: Returns an iterator to the first element whose
 //! key is not less than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator lower_bound(const_reference value) const
 { return this->lower_bound(value, priv_comp()); }

 //! Effects: Returns an iterator to the first element whose
 //! key is not less than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 iterator lower_bound(const KeyType &key, KeyValueCompare comp)
@@ -1237,9 +1237,9 @@

 //! Effects: Returns a const iterator to the first element whose
 //! key is not less than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 const_iterator lower_bound(const KeyType &key, KeyValueCompare comp) const
@@ -1252,9 +1252,9 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is greater than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 iterator upper_bound(const_reference value)
 { return this->upper_bound(value, priv_comp()); }
@@ -1264,7 +1264,7 @@
 //! does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 iterator upper_bound(const KeyType &key, KeyValueCompare comp)
@@ -1277,9 +1277,9 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is greater than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator upper_bound(const_reference value) const
 { return this->upper_bound(value, priv_comp()); }
@@ -1289,7 +1289,7 @@
 //! does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 const_iterator upper_bound(const KeyType &key, KeyValueCompare comp) const
@@ -1300,20 +1300,20 @@
 (this->priv_header_ptr(), key, key_node_comp), this);
 }

- //! Effects: Finds an iterator to the first element whose key is
+ //! Effects: Finds an iterator to the first element whose key is
 //! k or end() if that element does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 iterator find(const_reference value)
 { return this->find(value, priv_comp()); }

- //! Effects: Finds an iterator to the first element whose key is
+ //! Effects: Finds an iterator to the first element whose key is
 //! k or end() if that element does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 iterator find(const KeyType &key, KeyValueCompare comp)
@@ -1324,20 +1324,20 @@
 (node_algorithms::find(this->priv_header_ptr(), key, key_node_comp), this);
 }

- //! Effects: Finds a const_iterator to the first element whose key is
+ //! Effects: Finds a const_iterator to the first element whose key is
 //! k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator find(const_reference value) const
 { return this->find(value, priv_comp()); }

- //! Effects: Finds a const_iterator to the first element whose key is
+ //! Effects: Finds a const_iterator to the first element whose key is
 //! k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 const_iterator find(const KeyType &key, KeyValueCompare comp) const
@@ -1351,9 +1351,9 @@
 //! Effects: Finds a range containing all elements whose key is k or
 //! an empty range that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 std::pair<iterator,iterator> equal_range(const_reference value)
 { return this->equal_range(value, priv_comp()); }
@@ -1361,9 +1361,9 @@
 //! Effects: Finds a range containing all elements whose key is k or
 //! an empty range that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 std::pair<iterator,iterator> equal_range(const KeyType &key, KeyValueCompare comp)
@@ -1378,9 +1378,9 @@
 //! Effects: Finds a range containing all elements whose key is k or
 //! an empty range that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 std::pair<const_iterator, const_iterator>
 equal_range(const_reference value) const
@@ -1389,9 +1389,9 @@
 //! Effects: Finds a range containing all elements whose key is k or
 //! an empty range that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 std::pair<const_iterator, const_iterator>
@@ -1408,15 +1408,15 @@
 //! Cloner should yield to nodes equivalent to the original nodes.
 //!
 //! Effects: Erases all the elements from *this
- //! calling Disposer::operator()(pointer), clones all the
+ //! calling Disposer::operator()(pointer), clones all the
 //! elements from src calling Cloner::operator()(const_reference )
 //! and inserts them on *this. Copies the predicate from the source container.
 //!
 //! If cloner throws, all cloned elements are unlinked and disposed
 //! calling Disposer::operator()(pointer).
- //!
+ //!
 //! Complexity: Linear to erased plus inserted elements.
- //!
+ //!
 //! Throws: If cloner throws or predicate copy assignment throws. Basic guarantee.
 template <class Cloner, class Disposer>
 void clone_from(const sgtree_impl &src, Cloner cloner, Disposer disposer)
@@ -1437,11 +1437,11 @@
 }

 //! Effects: Unlinks the leftmost node from the tree.
- //!
+ //!
 //! Complexity: Average complexity is constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Notes: This function breaks the tree and the tree can
 //! only be used for more unlink_leftmost_without_rebalance calls.
 //! This function is normally used to achieve a step by step
@@ -1460,14 +1460,14 @@

 //! Requires: replace_this must be a valid iterator of *this
 //! and with_this must not be inserted in any tree.
- //!
+ //!
 //! Effects: Replaces replace_this in its position in the
 //! tree with with_this. The tree does not need to be rebalanced.
- //!
- //! Complexity: Constant.
- //!
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function will break container ordering invariants if
 //! with_this is not equivalent to *replace_this according to the
 //! ordering rules. This function is faster than erasing and inserting
@@ -1483,14 +1483,14 @@

 //! Requires: value must be an lvalue and shall be in a set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid iterator i belonging to the set
 //! that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This static function is available only if the value traits
 //! is stateless.
 static iterator s_iterator_to(reference value)
@@ -1501,17 +1501,17 @@

 //! Requires: value must be an lvalue and shall be in a set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid const_iterator i belonging to the
 //! set that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This static function is available only if the value traits
 //! is stateless.
- static const_iterator s_iterator_to(const_reference value)
+ static const_iterator s_iterator_to(const_reference value)
 {
 BOOST_STATIC_ASSERT((!stateful_value_traits));
 return const_iterator (value_traits::to_node_ptr(const_cast<reference> (value)), 0);
@@ -1519,58 +1519,58 @@

 //! Requires: value must be an lvalue and shall be in a set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid iterator i belonging to the set
 //! that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator iterator_to(reference value)
 { return iterator (value_traits::to_node_ptr(value), this); }

 //! Requires: value must be an lvalue and shall be in a set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid const_iterator i belonging to the
 //! set that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator iterator_to(const_reference value) const
 { return const_iterator (value_traits::to_node_ptr(const_cast<reference> (value)), this); }

 //! Requires: value shall not be in a tree.
- //!
+ //!
 //! Effects: init_node puts the hook of a value in a well-known default
 //! state.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Note: This function puts the hook in the well-known default state
 //! used by auto_unlink and safe hooks.
 static void init_node(reference value)
 { node_algorithms::init(value_traits::to_node_ptr(value)); }

 //! Effects: Rebalances the tree.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear.
 void rebalance()
 { node_algorithms::rebalance(this->priv_header_ptr()); }

 //! Requires: old_root is a node of a tree.
- //!
+ //!
 //! Effects: Rebalances the subtree rooted at old_root.
 //!
 //! Returns: The new root of the subtree.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the elements in the subtree.
 iterator rebalance_subtree(iterator root)
 { return iterator(node_algorithms::rebalance_subtree(root.pointed_node()), this); }
@@ -1578,18 +1578,18 @@
 //! Returns: The balance factor (alpha) used in this tree
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 float balance_factor() const
 { return this->priv_alpha(); }

 //! Requires: new_alpha must be a value between 0.5 and 1.0
- //!
+ //!
 //! Effects: Establishes a new balance factor (alpha) and rebalances
 //! the tree if the new balance factor is stricter (less) than the old factor.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the elements in the subtree.
 void balance_factor(float new_alpha)
 {
@@ -1609,12 +1609,12 @@
 }
/*
 //! Effects: removes x from a tree of the appropriate type. It has no effect,
- //! if x is not in such a tree.
- //!
+ //! if x is not in such a tree.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Note: This static function is only usable with the "safe mode"
 //! hook and non-constant time size lists. Otherwise, the user must use
 //! the non-static "erase(reference )" member. If the user calls
@@ -1624,7 +1624,7 @@
 static void remove_node(T& value)
 {
 //This function is only usable for safe mode hooks and non-constant
- //time lists.
+ //time lists.
 //BOOST_STATIC_ASSERT((!(safemode_or_autounlink && constant_time_size)));
 BOOST_STATIC_ASSERT((!constant_time_size));
 BOOST_STATIC_ASSERT((boost::is_convertible<T, value_type>::value));
@@ -1795,7 +1795,7 @@
struct make_sgtree_opt
{
 typedef typename pack_options
- < sg_set_defaults<T>,
+ < sg_set_defaults<T>,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
@@ -1826,7 +1826,7 @@
{
 /// @cond
 typedef sgtree_impl
- < typename make_sgtree_opt<T,
+ < typename make_sgtree_opt<T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
@@ -1845,7 +1845,7 @@
template<class T, class ...Options>
#endif
class sgtree
- : public make_sgtree<T,
+ : public make_sgtree<T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
@@ -1854,7 +1854,7 @@
>::type
{
 typedef typename make_sgtree
- <T,
+ <T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
@@ -1903,8 +1903,8 @@
#endif

-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Modified: branches/release/boost/intrusive/sgtree_algorithms.hpp
==============================================================================
--- branches/release/boost/intrusive/sgtree_algorithms.hpp (original)
+++ branches/release/boost/intrusive/sgtree_algorithms.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -45,15 +45,15 @@
//! Static functions:
//!
//! <tt>static node_ptr get_parent(const_node_ptr n);</tt>
-//!
+//!
//! <tt>static void set_parent(node_ptr n, node_ptr parent);</tt>
//!
//! <tt>static node_ptr get_left(const_node_ptr n);</tt>
-//!
+//!
//! <tt>static void set_left(node_ptr n, node_ptr left);</tt>
//!
//! <tt>static node_ptr get_right(const_node_ptr n);</tt>
-//!
+//!
//! <tt>static void set_right(node_ptr n, node_ptr right);</tt>
template<class NodeTraits>
class sgtree_algorithms
@@ -90,27 +90,27 @@

 //! Requires: header1 and header2 must be the header nodes
 //! of two trees.
- //!
- //! Effects: Swaps two trees. After the function header1 will contain
+ //!
+ //! Effects: Swaps two trees. After the function header1 will contain
 //! links to the second tree and header2 will have links to the first tree.
- //!
- //! Complexity: Constant.
- //!
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: Nothing.
 static void swap_tree(const node_ptr & header1, const node_ptr & header2)
 { return tree_algorithms::swap_tree(header1, header2); }

 //! Requires: node1 and node2 can't be header nodes
 //! of two trees.
- //!
+ //!
 //! Effects: Swaps two nodes. After the function node1 will be inserted
 //! in the position node2 before the function. node2 will be inserted in the
 //! position node1 had before the function.
- //!
- //! Complexity: Logarithmic.
- //!
+ //!
+ //! Complexity: Logarithmic.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function will break container ordering invariants if
 //! node1 and node2 are not equivalent according to the ordering rules.
 //!
@@ -119,22 +119,22 @@
 {
 if(node1 == node2)
 return;
-
+
 node_ptr header1(tree_algorithms::get_header(node1)), header2(tree_algorithms::get_header(node2));
 swap_nodes(node1, header1, node2, header2);
 }

 //! Requires: node1 and node2 can't be header nodes
 //! of two trees with header header1 and header2.
- //!
+ //!
 //! Effects: Swaps two nodes. After the function node1 will be inserted
 //! in the position node2 before the function. node2 will be inserted in the
 //! position node1 had before the function.
- //!
- //! Complexity: Constant.
- //!
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function will break container ordering invariants if
 //! node1 and node2 are not equivalent according to the ordering rules.
 //!
@@ -144,14 +144,14 @@

 //! Requires: node_to_be_replaced must be inserted in a tree
 //! and new_node must not be inserted in a tree.
- //!
+ //!
 //! Effects: Replaces node_to_be_replaced in its position in the
 //! tree with new_node. The tree does not need to be rebalanced
- //!
- //! Complexity: Logarithmic.
- //!
+ //!
+ //! Complexity: Logarithmic.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function will break container ordering invariants if
 //! new_node is not equivalent to node_to_be_replaced according to the
 //! ordering rules. This function is faster than erasing and inserting
@@ -167,14 +167,14 @@

 //! Requires: node_to_be_replaced must be inserted in a tree
 //! with header "header" and new_node must not be inserted in a tree.
- //!
+ //!
 //! Effects: Replaces node_to_be_replaced in its position in the
 //! tree with new_node. The tree does not need to be rebalanced
- //!
- //! Complexity: Constant.
- //!
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function will break container ordering invariants if
 //! new_node is not equivalent to node_to_be_replaced according to the
 //! ordering rules. This function is faster than erasing and inserting
@@ -185,11 +185,11 @@
 { tree_algorithms::replace_node(node_to_be_replaced, header, new_node); }

 //! Requires: node is a tree node but not the header.
- //!
+ //!
 //! Effects: Unlinks the node and rebalances the tree.
- //!
+ //!
 //! Complexity: Average complexity is constant time.
- //!
+ //!
 //! Throws: Nothing.
 static void unlink(const node_ptr & node)
 {
@@ -202,14 +202,14 @@
 }

 //! Requires: header is the header of a tree.
- //!
+ //!
 //! Effects: Unlinks the leftmost node from the tree, and
 //! updates the header link to the new leftmost node.
- //!
+ //!
 //! Complexity: Average complexity is constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Notes: This function breaks the tree and the tree can
 //! only be used for more unlink_leftmost_without_rebalance calls.
 //! This function is normally used to achieve a step by step
@@ -219,51 +219,51 @@

 //! Requires: node is a node of the tree or an node initialized
 //! by init(...).
- //!
+ //!
 //! Effects: Returns true if the node is initialized by init().
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: Nothing.
 static bool unique(const const_node_ptr & node)
 { return tree_algorithms::unique(node); }

 //! Requires: node is a node of the tree but it's not the header.
- //!
+ //!
 //! Effects: Returns the number of nodes of the subtree.
- //!
+ //!
 //! Complexity: Linear time.
- //!
+ //!
 //! Throws: Nothing.
 static std::size_t count(const const_node_ptr & node)
 { return tree_algorithms::count(node); }

 //! Requires: header is the header node of the tree.
- //!
+ //!
 //! Effects: Returns the number of nodes above the header.
- //!
+ //!
 //! Complexity: Linear time.
- //!
+ //!
 //! Throws: Nothing.
 static std::size_t size(const const_node_ptr & header)
 { return tree_algorithms::size(header); }

 //! Requires: p is a node from the tree except the header.
- //!
+ //!
 //! Effects: Returns the next node of the tree.
- //!
+ //!
 //! Complexity: Average constant time.
- //!
+ //!
 //! Throws: Nothing.
 static node_ptr next_node(const node_ptr & p)
 { return tree_algorithms::next_node(p); }

 //! Requires: p is a node from the tree except the leftmost node.
- //!
+ //!
 //! Effects: Returns the previous node of the tree.
- //!
+ //!
 //! Complexity: Average constant time.
- //!
+ //!
 //! Throws: Nothing.
 static node_ptr prev_node(const node_ptr & p)
 { return tree_algorithms::prev_node(p); }
@@ -271,9 +271,9 @@
 //! Requires: node must not be part of any tree.
 //!
 //! Effects: After the function unique(node) == true.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 //!
 //! Nodes: If node is inserted in a tree, this function corrupts the tree.
@@ -284,9 +284,9 @@
 //!
 //! Effects: Initializes the header to represent an empty tree.
 //! unique(header) == true.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 //!
 //! Nodes: If node is inserted in a tree, this function corrupts the tree.
@@ -297,9 +297,9 @@
 //! of that tree and z != header.
 //!
 //! Effects: Erases node "z" from the tree with header "header".
- //!
+ //!
 //! Complexity: Amortized constant time.
- //!
+ //!
 //! Throws: Nothing.
 template<class AlphaByMaxSize>
 static node_ptr erase(const node_ptr & header, const node_ptr & z, std::size_t tree_size, std::size_t &max_tree_size, AlphaByMaxSize alpha_by_maxsize)
@@ -307,7 +307,7 @@
 //typename tree_algorithms::data_for_rebalance info;
 tree_algorithms::erase(header, z);
 --tree_size;
- if (tree_size > 0 &&
+ if (tree_size > 0 &&
 tree_size < alpha_by_maxsize(max_tree_size)){
 tree_algorithms::rebalance(header);
 max_tree_size = tree_size;
@@ -319,18 +319,18 @@
 //! object taking a node_ptr and returning a new cloned node of it. "disposer" must
 //! take a node_ptr and shouldn't throw.
 //!
- //! Effects: First empties target tree calling
+ //! Effects: First empties target tree calling
 //! <tt>void disposer::operator()(const node_ptr &)</tt> for every node of the tree
 //! except the header.
- //!
+ //!
 //! Then, duplicates the entire tree pointed by "source_header" cloning each
- //! source node with <tt>node_ptr Cloner::operator()(const node_ptr &)</tt> to obtain
+ //! source node with <tt>node_ptr Cloner::operator()(const node_ptr &)</tt> to obtain
 //! the nodes of the target tree. If "cloner" throws, the cloned target nodes
 //! are disposed using <tt>void disposer(const node_ptr &)</tt>.
- //!
+ //!
 //! Complexity: Linear to the number of element of the source tree plus the.
 //! number of elements of tree target tree when calling this function.
- //!
+ //!
 //! Throws: If cloner functor throws. If this happens target nodes are disposed.
 template <class Cloner, class Disposer>
 static void clone
@@ -342,13 +342,13 @@
 //! Requires: "disposer" must be an object function
 //! taking a node_ptr parameter and shouldn't throw.
 //!
- //! Effects: Empties the target tree calling
+ //! Effects: Empties the target tree calling
 //! <tt>void disposer::operator()(const node_ptr &)</tt> for every node of the tree
 //! except the header.
- //!
+ //!
 //! Complexity: Linear to the number of element of the source tree plus the.
 //! number of elements of tree target tree when calling this function.
- //!
+ //!
 //! Throws: If cloner functor throws. If this happens target nodes are disposed.
 template<class Disposer>
 static void clear_and_dispose(const node_ptr & header, Disposer disposer)
@@ -364,7 +364,7 @@
 //! not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static node_ptr lower_bound
@@ -380,7 +380,7 @@
 //! than "key" according to "comp" or "header" if that element does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static node_ptr upper_bound
@@ -396,7 +396,7 @@
 //! "key" according to "comp" or "header" if that element does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static node_ptr find
@@ -414,7 +414,7 @@
 //! if they there are no equivalent elements.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static std::pair<node_ptr, node_ptr> equal_range
@@ -428,10 +428,10 @@
 //!
 //! Effects: Inserts new_node into the tree before the upper bound
 //! according to "comp".
- //!
+ //!
 //! Complexity: Average complexity for insert element is at
 //! most logarithmic.
- //!
+ //!
 //! Throws: If "comp" throws.
 template<class NodePtrCompare, class H_Alpha>
 static node_ptr insert_equal_upper_bound
@@ -451,10 +451,10 @@
 //!
 //! Effects: Inserts new_node into the tree before the lower bound
 //! according to "comp".
- //!
+ //!
 //! Complexity: Average complexity for insert element is at
 //! most logarithmic.
- //!
+ //!
 //! Throws: If "comp" throws.
 template<class NodePtrCompare, class H_Alpha>
 static node_ptr insert_equal_lower_bound
@@ -472,14 +472,14 @@
 //! ordering compatible with the strict weak ordering used to create the
 //! the tree. NodePtrCompare compares two node_ptrs. "hint" is node from
 //! the "header"'s tree.
- //!
+ //!
 //! Effects: Inserts new_node into the tree, using "hint" as a hint to
 //! where it will be inserted. If "hint" is the upper_bound
 //! the insertion takes constant time (two comparisons in the worst case).
 //!
 //! Complexity: Logarithmic in general, but it is amortized
 //! constant time if new_node is inserted immediately before "hint".
- //!
+ //!
 //! Throws: If "comp" throws.
 template<class NodePtrCompare, class H_Alpha>
 static node_ptr insert_equal
@@ -496,7 +496,7 @@
 //! KeyNodePtrCompare is a function object that induces a strict weak
 //! ordering compatible with the strict weak ordering used to create the
 //! the tree. NodePtrCompare compares KeyType with a node_ptr.
- //!
+ //!
 //! Effects: Checks if there is an equivalent node to "key" in the
 //! tree according to "comp" and obtains the needed information to realize
 //! a constant-time node insertion if there is no equivalent node.
@@ -507,11 +507,11 @@
 //! in the returned pair's boolean and fills "commit_data" that is meant to
 //! be used with the "insert_commit" function to achieve a constant-time
 //! insertion function.
- //!
+ //!
 //! Complexity: Average complexity is at most logarithmic.
 //!
 //! Throws: If "comp" throws.
- //!
+ //!
 //! Notes: This function is used to improve performance when constructing
 //! a node is expensive and the user does not want to have two equivalent nodes
 //! in the tree: if there is an equivalent value
@@ -532,7 +532,7 @@
 ,KeyNodePtrCompare comp, insert_commit_data &commit_data)
 {
 std::size_t depth;
- std::pair<node_ptr, bool> ret =
+ std::pair<node_ptr, bool> ret =
 tree_algorithms::insert_unique_check(header, key, comp, commit_data, &depth);
 commit_data.depth = depth;
 return ret;
@@ -544,13 +544,13 @@
 //! "pos" must be an iterator pointing to the successor to "new_node"
 //! once inserted according to the order of already inserted nodes. This function does not
 //! check "pos" and this precondition must be guaranteed by the caller.
- //!
+ //!
 //! Effects: Inserts new_node into the tree before "pos".
 //!
 //! Complexity: Constant-time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: If "pos" is not the successor of the newly inserted "new_node"
 //! tree invariants might be broken.
 template<class H_Alpha>
@@ -567,13 +567,13 @@
 //! Requires: "header" must be the header node of a tree.
 //! "new_node" must be, according to the used ordering no less than the
 //! greatest inserted key.
- //!
+ //!
 //! Effects: Inserts new_node into the tree before "pos".
 //!
 //! Complexity: Constant-time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: If "new_node" is less than the greatest inserted key
 //! tree invariants are broken. This function is slightly faster than
 //! using "insert_before".
@@ -589,13 +589,13 @@
 //! Requires: "header" must be the header node of a tree.
 //! "new_node" must be, according to the used ordering, no greater than the
 //! lowest inserted key.
- //!
+ //!
 //! Effects: Inserts new_node into the tree before "pos".
 //!
 //! Complexity: Constant-time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: If "new_node" is greater than the lowest inserted key
 //! tree invariants are broken. This function is slightly faster than
 //! using "insert_before".
@@ -613,12 +613,12 @@
 //! ordering compatible with the strict weak ordering used to create the
 //! the tree. NodePtrCompare compares KeyType with a node_ptr.
 //! "hint" is node from the "header"'s tree.
- //!
+ //!
 //! Effects: Checks if there is an equivalent node to "key" in the
 //! tree according to "comp" using "hint" as a hint to where it should be
 //! inserted and obtains the needed information to realize
- //! a constant-time node insertion if there is no equivalent node.
- //! If "hint" is the upper_bound the function has constant time
+ //! a constant-time node insertion if there is no equivalent node.
+ //! If "hint" is the upper_bound the function has constant time
 //! complexity (two comparisons in the worst case).
 //!
 //! Returns: If there is an equivalent value
@@ -627,12 +627,12 @@
 //! in the returned pair's boolean and fills "commit_data" that is meant to
 //! be used with the "insert_commit" function to achieve a constant-time
 //! insertion function.
- //!
+ //!
 //! Complexity: Average complexity is at most logarithmic, but it is
 //! amortized constant time if new_node should be inserted immediately before "hint".
 //!
 //! Throws: If "comp" throws.
- //!
+ //!
 //! Notes: This function is used to improve performance when constructing
 //! a node is expensive and the user does not want to have two equivalent nodes
 //! in the tree: if there is an equivalent value
@@ -653,7 +653,7 @@
 ,KeyNodePtrCompare comp, insert_commit_data &commit_data)
 {
 std::size_t depth;
- std::pair<node_ptr, bool> ret =
+ std::pair<node_ptr, bool> ret =
 tree_algorithms::insert_unique_check
 (header, hint, key, comp, commit_data, &depth);
 commit_data.depth = depth;
@@ -664,16 +664,16 @@
 //! "commit_data" must have been obtained from a previous call to
 //! "insert_unique_check". No objects should have been inserted or erased
 //! from the set between the "insert_unique_check" that filled "commit_data"
- //! and the call to "insert_commit".
- //!
- //!
+ //! and the call to "insert_commit".
+ //!
+ //!
 //! Effects: Inserts new_node in the set using the information obtained
 //! from the "commit_data" that a previous "insert_check" filled.
 //!
 //! Complexity: Constant time.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Notes: This function has only sense if a "insert_unique_check" has been
 //! previously executed to fill "commit_data". No value should be inserted or
 //! erased between the "insert_check" and "insert_commit" calls.
@@ -687,23 +687,23 @@
 }

 //! Requires: header must be the header of a tree.
- //!
+ //!
 //! Effects: Rebalances the tree.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear.
 static void rebalance(const node_ptr & header)
 { tree_algorithms::rebalance(header); }

 //! Requires: old_root is a node of a tree.
- //!
+ //!
 //! Effects: Rebalances the subtree rooted at old_root.
 //!
 //! Returns: The new root of the subtree.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear.
 static node_ptr rebalance_subtree(const node_ptr & old_root)
 { return tree_algorithms::rebalance_subtree(old_root); }
@@ -713,7 +713,7 @@
 //! Effects: Returns a pointer to the header node of the tree.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 static node_ptr get_header(const node_ptr & n)
 { return tree_algorithms::get_header(n); }
@@ -722,11 +722,11 @@
 private:

 //! Requires: p is a node of a tree.
- //!
+ //!
 //! Effects: Returns true if p is the header of the tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 static bool is_header(const const_node_ptr & p)
 { return tree_algorithms::is_header(p); }
@@ -774,8 +774,8 @@
 /// @endcond
};

-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Modified: branches/release/boost/intrusive/slist.hpp
==============================================================================
--- branches/release/boost/intrusive/slist.hpp (original)
+++ branches/release/boost/intrusive/slist.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -75,12 +75,12 @@

/// @endcond

-//! The class template slist is an intrusive container, that encapsulates
-//! a singly-linked list. You can use such a list to squeeze the last bit
-//! of performance from your application. Unfortunately, the little gains
-//! come with some huge drawbacks. A lot of member functions can't be
-//! implemented as efficiently as for standard containers. To overcome
-//! this limitation some other member functions with rather unusual semantics
+//! The class template slist is an intrusive container, that encapsulates
+//! a singly-linked list. You can use such a list to squeeze the last bit
+//! of performance from your application. Unfortunately, the little gains
+//! come with some huge drawbacks. A lot of member functions can't be
+//! implemented as efficiently as for standard containers. To overcome
+//! this limitation some other member functions with rather unusual semantics
//! have to be introduced.
//!
//! The template parameter \c T is the type to be managed by the container.
@@ -91,11 +91,11 @@
//! \c base_hook<>/member_hook<>/value_traits<>,
//! \c constant_time_size<>, \c size_type<>,
//! \c linear<> and \c cache_last<>.
-//!
-//! The iterators of slist are forward iterators. slist provides a static
-//! function called "previous" to compute the previous iterator of a given iterator.
-//! This function has linear complexity. To improve the usability esp. with
-//! the '*_after' functions, ++end() == begin() and previous(begin()) == end()
+//!
+//! The iterators of slist are forward iterators. slist provides a static
+//! function called "previous" to compute the previous iterator of a given iterator.
+//! This function has linear complexity. To improve the usability esp. with
+//! the '*_after' functions, ++end() == begin() and previous(begin()) == end()
//! are defined. An new special function "before_begin()" is defined, which returns
//! an iterator that points one less the beginning of the list: ++before_begin() == begin()
#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
@@ -151,7 +151,7 @@
 //noncopyable
 BOOST_MOVABLE_BUT_NOT_COPYABLE(slist_impl)

- enum { safemode_or_autounlink =
+ enum { safemode_or_autounlink =
 (int)real_value_traits::link_mode == (int)auto_unlink ||
 (int)real_value_traits::link_mode == (int)safe_link };

@@ -273,10 +273,10 @@
 { return this->get_real_value_traits(detail::bool_<external_value_traits>()); }

 public:
- //! Effects: constructs an empty list.
- //!
- //! Complexity: Constant
- //!
+ //! Effects: constructs an empty list.
+ //!
+ //! Complexity: Constant
+ //!
 //! Throws: If value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks).
 slist_impl(const value_traits &v_traits = value_traits())
@@ -284,11 +284,11 @@
 { this->set_default_constructed_state(); }

 //! Requires: Dereferencing iterator must yield an lvalue of type value_type.
- //!
+ //!
 //! Effects: Constructs a list equal to [first,last).
- //!
- //! Complexity: Linear in std::distance(b, e). No copy constructors are called.
- //!
+ //!
+ //! Complexity: Linear in std::distance(b, e). No copy constructors are called.
+ //!
 //! Throws: If value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks).
 template<class Iterator>
@@ -300,44 +300,44 @@
 }

 //! Effects: to-do
- //!
+ //!
 slist_impl(BOOST_RV_REF(slist_impl) x)
 : data_(::boost::move(x.priv_value_traits()))
 {
 this->priv_size_traits().set_size(size_type(0));
- node_algorithms::init_header(this->get_root_node());
+ node_algorithms::init_header(this->get_root_node());
 this->swap(x);
 }

 //! Effects: to-do
- //!
- slist_impl& operator=(BOOST_RV_REF(slist_impl) x)
+ //!
+ slist_impl& operator=(BOOST_RV_REF(slist_impl) x)
 { this->swap(x); return *this; }

 //! Effects: If it's a safe-mode
 //! or auto-unlink value, the destructor does nothing
- //! (ie. no code is generated). Otherwise it detaches all elements from this.
- //! In this case the objects in the list are not deleted (i.e. no destructors
+ //! (ie. no code is generated). Otherwise it detaches all elements from this.
+ //! In this case the objects in the list are not deleted (i.e. no destructors
 //! are called), but the hooks according to the value_traits template parameter
 //! are set to their default value.
- //!
- //! Complexity: Linear to the number of elements in the list, if
+ //!
+ //! Complexity: Linear to the number of elements in the list, if
 //! it's a safe-mode or auto-unlink value. Otherwise constant.
 ~slist_impl()
 {}

 //! Effects: Erases all the elements of the container.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the number of elements of the list.
 //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references) to the erased elements.
 void clear()
 {
 if(safemode_or_autounlink){
- this->clear_and_dispose(detail::null_disposer());
+ this->clear_and_dispose(detail::null_disposer());
 }
 else{
 this->set_default_constructed_state();
@@ -348,11 +348,11 @@
 //!
 //! Effects: Erases all the elements of the container
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the number of elements of the list.
- //!
+ //!
 //! Note: Invalidates the iterators to the erased elements.
 template <class Disposer>
 void clear_and_dispose(Disposer disposer)
@@ -369,16 +369,16 @@
 }

 //! Requires: value must be an lvalue.
- //!
+ //!
 //! Effects: Inserts the value in the front of the list.
 //! No copy constructors are called.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
- void push_front(reference value)
+ void push_front(reference value)
 {
 node_ptr to_insert = get_real_value_traits().to_node_ptr(value);
 if(safemode_or_autounlink)
@@ -388,22 +388,22 @@
 this->set_last_node(to_insert);
 }
 }
- node_algorithms::link_after(this->get_root_node(), to_insert);
+ node_algorithms::link_after(this->get_root_node(), to_insert);
 this->priv_size_traits().increment();
 }

 //! Requires: value must be an lvalue.
- //!
+ //!
 //! Effects: Inserts the value in the back of the list.
 //! No copy constructors are called.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! This function is only available is cache_last<> is true.
- void push_back(reference value)
+ void push_back(reference value)
 {
 BOOST_STATIC_ASSERT((cache_last));
 this->insert_after(const_iterator(this->get_last_node(), this), value);
@@ -411,24 +411,24 @@

 //! Effects: Erases the first element of the list.
 //! No destructors are called.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references) to the erased element.
- void pop_front()
+ void pop_front()
 { return this->pop_front_and_dispose(detail::null_disposer()); }

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
 //!
 //! Effects: Erases the first element of the list.
 //! Disposer::operator()(pointer) is called for the removed element.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Note: Invalidates the iterators to the erased element.
 template<class Disposer>
 void pop_front_and_dispose(Disposer disposer)
@@ -447,23 +447,23 @@
 }

 //! Effects: Returns a reference to the first element of the list.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 reference front()
 { return *this->get_real_value_traits().to_value_ptr(node_traits::get_next(this->get_root_node())); }

 //! Effects: Returns a const_reference to the first element of the list.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 const_reference front() const
 { return *this->get_real_value_traits().to_value_ptr(uncast(node_traits::get_next(this->get_root_node()))); }

 //! Effects: Returns a reference to the last element of the list.
- //!
+ //!
 //! Throws: Nothing.
 //!
 //! Complexity: Constant.
@@ -477,9 +477,9 @@
 }

 //! Effects: Returns a const_reference to the last element of the list.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 //!
 //! Note: Does not affect the validity of iterators and references.
@@ -491,165 +491,165 @@
 }

 //! Effects: Returns an iterator to the first element contained in the list.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- iterator begin()
+ iterator begin()
 { return iterator (node_traits::get_next(this->get_root_node()), this); }

 //! Effects: Returns a const_iterator to the first element contained in the list.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- const_iterator begin() const
+ const_iterator begin() const
 { return const_iterator (node_traits::get_next(this->get_root_node()), this); }

 //! Effects: Returns a const_iterator to the first element contained in the list.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- const_iterator cbegin() const
+ const_iterator cbegin() const
 { return const_iterator(node_traits::get_next(this->get_root_node()), this); }

 //! Effects: Returns an iterator to the end of the list.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- iterator end()
+ iterator end()
 { return iterator(this->get_end_node(), this); }

 //! Effects: Returns a const_iterator to the end of the list.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- const_iterator end() const
+ const_iterator end() const
 { return const_iterator(uncast(this->get_end_node()), this); }

 //! Effects: Returns a const_iterator to the end of the list.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- const_iterator cend() const
+ const_iterator cend() const
 { return this->end(); }

 //! Effects: Returns an iterator that points to a position
 //! before the first element. Equivalent to "end()"
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- iterator before_begin()
+ iterator before_begin()
 { return iterator(this->get_root_node(), this); }

 //! Effects: Returns an iterator that points to a position
 //! before the first element. Equivalent to "end()"
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- const_iterator before_begin() const
+ const_iterator before_begin() const
 { return const_iterator(uncast(this->get_root_node()), this); }

 //! Effects: Returns an iterator that points to a position
 //! before the first element. Equivalent to "end()"
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- const_iterator cbefore_begin() const
+ const_iterator cbefore_begin() const
 { return this->before_begin(); }

 //! Effects: Returns an iterator to the last element contained in the list.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Note: This function is present only if cached_last<> option is true.
- iterator last()
+ iterator last()
 { return iterator (this->get_last_node(), this); }

 //! Effects: Returns a const_iterator to the first element contained in the list.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Note: This function is present only if cached_last<> option is true.
- const_iterator last() const
+ const_iterator last() const
 { return const_iterator (this->get_last_node(), this); }

 //! Effects: Returns a const_iterator to the first element contained in the list.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Note: This function is present only if cached_last<> option is true.
- const_iterator clast() const
+ const_iterator clast() const
 { return const_iterator(this->get_last_node(), this); }

 //! Precondition: end_iterator must be a valid end iterator
 //! of slist.
- //!
+ //!
 //! Effects: Returns a const reference to the slist associated to the end iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 static slist_impl &container_from_end_iterator(iterator end_iterator)
 { return slist_impl::priv_container_from_end_iterator(end_iterator); }

 //! Precondition: end_iterator must be a valid end const_iterator
 //! of slist.
- //!
+ //!
 //! Effects: Returns a const reference to the slist associated to the end iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 static const slist_impl &container_from_end_iterator(const_iterator end_iterator)
 { return slist_impl::priv_container_from_end_iterator(end_iterator); }

 //! Effects: Returns the number of the elements contained in the list.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the number of elements contained in the list.
 //! if constant_time_size is false. Constant time otherwise.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 size_type size() const
 {
 if(constant_time_size)
 return this->priv_size_traits().get_size();
 else
- return node_algorithms::count(this->get_root_node()) - 1;
+ return node_algorithms::count(this->get_root_node()) - 1;
 }

 //! Effects: Returns true if the list contains no elements.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 bool empty() const
 { return node_algorithms::unique(this->get_root_node()); }

 //! Effects: Swaps the elements of x and *this.
- //!
+ //!
 //! Throws: Nothing.
- //!
- //! Complexity: Linear to the number of elements of both lists.
+ //!
+ //! Complexity: Linear to the number of elements of both lists.
 //! Constant-time if linear<> and/or cache_last<> options are used.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 void swap(slist_impl& other)
 {
@@ -669,11 +669,11 @@
 //! Effects: Moves backwards all the elements, so that the first
 //! element becomes the second, the second becomes the third...
 //! the last element becomes the first one.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the number of elements plus the number shifts.
- //!
+ //!
 //! Note: Iterators Does not affect the validity of iterators and references.
 void shift_backwards(size_type n = 1)
 { this->priv_shift_backwards(n, detail::bool_<linear>()); }
@@ -681,11 +681,11 @@
 //! Effects: Moves forward all the elements, so that the second
 //! element becomes the first, the third becomes the second...
 //! the first element becomes the last one.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the number of elements plus the number shifts.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 void shift_forward(size_type n = 1)
 { this->priv_shift_forward(n, detail::bool_<linear>()); }
@@ -694,15 +694,15 @@
 //! Cloner should yield to nodes equivalent to the original nodes.
 //!
 //! Effects: Erases all the elements from *this
- //! calling Disposer::operator()(pointer), clones all the
+ //! calling Disposer::operator()(pointer), clones all the
 //! elements from src calling Cloner::operator()(const_reference )
 //! and inserts them on *this.
 //!
 //! If cloner throws, all cloned elements are unlinked and disposed
 //! calling Disposer::operator()(pointer).
- //!
+ //!
 //! Complexity: Linear to erased plus inserted elements.
- //!
+ //!
 //! Throws: If cloner throws.
 template <class Cloner, class Disposer>
 void clone_from(const slist_impl &src, Cloner cloner, Disposer disposer)
@@ -725,11 +725,11 @@
 //! No copy constructor is called.
 //!
 //! Returns: An iterator to the inserted element.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 iterator insert_after(const_iterator prev_p, reference value)
 {
@@ -745,17 +745,17 @@
 return iterator (n, this);
 }

- //! Requires: Dereferencing iterator must yield
+ //! Requires: Dereferencing iterator must yield
 //! an lvalue of type value_type and prev_p must point to an element
 //! contained by the list or to the end node.
- //!
+ //!
 //! Effects: Inserts the [first, last)
 //! after the position prev_p.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the number of elements inserted.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 template<class Iterator>
 void insert_after(const_iterator prev_p, Iterator first, Iterator last)
@@ -769,44 +769,44 @@
 //!
 //! Effects: Inserts the value before the position pointed by p.
 //! No copy constructor is called.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the number of elements before p.
 //! Constant-time if cache_last<> is true and p == end().
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 iterator insert(const_iterator p, reference value)
 { return this->insert_after(this->previous(p), value); }

- //! Requires: Dereferencing iterator must yield
- //! an lvalue of type value_type and p must point to an element
+ //! Requires: Dereferencing iterator must yield
+ //! an lvalue of type value_type and p must point to an element
 //! contained by the list or to the end node.
- //!
+ //!
 //! Effects: Inserts the pointed by b and e
 //! before the position p. No copy constructors are called.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the number of elements inserted plus linear
 //! to the elements before b.
 //! Linear to the number of elements to insert if cache_last<> option is true and p == end().
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 template<class Iterator>
 void insert(const_iterator p, Iterator b, Iterator e)
 { return this->insert_after(this->previous(p), b, e); }

- //! Effects: Erases the element after the element pointed by prev of
+ //! Effects: Erases the element after the element pointed by prev of
 //! the list. No destructors are called.
 //!
 //! Returns: the first element remaining beyond the removed elements,
 //! or end() if no such element exists.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references) to the
 //! erased element.
 iterator erase_after(const_iterator prev)
@@ -817,12 +817,12 @@
 //!
 //! Returns: the first element remaining beyond the removed elements,
 //! or end() if no such element exists.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the number of erased elements if it's a safe-mode
 //! , auto-unlink value or constant-time size is activated. Constant time otherwise.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references) to the
 //! erased element.
 iterator erase_after(const_iterator before_first, const_iterator last)
@@ -849,12 +849,12 @@
 //!
 //! Returns: the first element remaining beyond the removed elements,
 //! or end() if no such element exists.
- //!
+ //!
 //! Throws: Nothing.
- //!
- //! Complexity: constant-time if link_mode is normal_link.
+ //!
+ //! Complexity: constant-time if link_mode is normal_link.
 //! Linear to the elements (last - before_first) otherwise.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references) to the
 //! erased element.
 iterator erase_after(const_iterator before_first, const_iterator last, difference_type n)
@@ -879,33 +879,33 @@
 }
 }

- //! Effects: Erases the element pointed by i of the list.
+ //! Effects: Erases the element pointed by i of the list.
 //! No destructors are called.
 //!
 //! Returns: the first element remaining beyond the removed element,
 //! or end() if no such element exists.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the elements before i.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references) to the
 //! erased element.
 iterator erase(const_iterator i)
 { return this->erase_after(this->previous(i)); }

 //! Requires: first and last must be valid iterator to elements in *this.
- //!
+ //!
 //! Effects: Erases the range pointed by b and e.
 //! No destructors are called.
 //!
 //! Returns: the first element remaining beyond the removed elements,
 //! or end() if no such element exists.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the elements before last.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references) to the
 //! erased elements.
 iterator erase(const_iterator first, const_iterator last)
@@ -917,12 +917,12 @@
 //!
 //! Returns: the first element remaining beyond the removed elements,
 //! or end() if no such element exists.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: linear to the elements before first if link_mode is normal_link
 //! and constant_time_size is activated. Linear to the elements before last otherwise.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references) to the
 //! erased element.
 iterator erase(const_iterator first, const_iterator last, difference_type n)
@@ -930,17 +930,17 @@

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
 //!
- //! Effects: Erases the element after the element pointed by prev of
+ //! Effects: Erases the element after the element pointed by prev of
 //! the list.
 //! Disposer::operator()(pointer) is called for the removed element.
 //!
 //! Returns: the first element remaining beyond the removed elements,
 //! or end() if no such element exists.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Note: Invalidates the iterators to the erased element.
 template<class Disposer>
 iterator erase_after_and_dispose(const_iterator prev, Disposer disposer)
@@ -992,11 +992,11 @@
 //!
 //! Returns: the first element remaining beyond the removed elements,
 //! or end() if no such element exists.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Lineal to the elements (last - before_first + 1).
- //!
+ //!
 //! Note: Invalidates the iterators to the erased element.
 template<class Disposer>
 iterator erase_after_and_dispose(const_iterator before_first, const_iterator last, Disposer disposer)
@@ -1020,17 +1020,17 @@

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
 //!
- //! Effects: Erases the element pointed by i of the list.
+ //! Effects: Erases the element pointed by i of the list.
 //! No destructors are called.
 //! Disposer::operator()(pointer) is called for the removed element.
 //!
 //! Returns: the first element remaining beyond the removed element,
 //! or end() if no such element exists.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the elements before i.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references) to the
 //! erased element.
 template<class Disposer>
@@ -1045,38 +1045,38 @@

 //! Requires: first and last must be valid iterator to elements in *this.
 //! Disposer::operator()(pointer) shouldn't throw.
- //!
+ //!
 //! Effects: Erases the range pointed by b and e.
 //! No destructors are called.
 //! Disposer::operator()(pointer) is called for the removed elements.
 //!
 //! Returns: the first element remaining beyond the removed elements,
 //! or end() if no such element exists.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the number of erased elements plus linear
 //! to the elements before first.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references) to the
 //! erased elements.
 template<class Disposer>
 iterator erase_and_dispose(const_iterator first, const_iterator last, Disposer disposer)
 { return this->erase_after_and_dispose(this->previous(first), last, disposer); }

- //! Requires: Dereferencing iterator must yield
+ //! Requires: Dereferencing iterator must yield
 //! an lvalue of type value_type.
- //!
+ //!
 //! Effects: Clears the list and inserts the range pointed by b and e.
 //! No destructors or copy constructors are called.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the number of elements inserted plus
 //! linear to the elements contained in the list if it's a safe-mode
 //! or auto-unlink value.
 //! Linear to the number of elements inserted in the list otherwise.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements.
 template<class Iterator>
@@ -1088,18 +1088,18 @@

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
 //!
- //! Requires: Dereferencing iterator must yield
+ //! Requires: Dereferencing iterator must yield
 //! an lvalue of type value_type.
- //!
+ //!
 //! Effects: Clears the list and inserts the range pointed by b and e.
 //! No destructors or copy constructors are called.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the number of elements inserted plus
 //! linear to the elements contained in the list.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements.
 template<class Iterator, class Disposer>
@@ -1111,18 +1111,18 @@

 //! Requires: prev must point to an element contained by this list or
 //! to the before_begin() element
- //!
+ //!
 //! Effects: Transfers all the elements of list x to this list, after the
 //! the element pointed by prev. No destructors or copy constructors are called.
- //!
+ //!
 //! Returns: Nothing.
- //!
+ //!
 //! Throws: Nothing.
 //!
 //! Complexity: In general, linear to the elements contained in x.
- //! Constant-time if cache_last<> option is true and also constant-time if
+ //! Constant-time if cache_last<> option is true and also constant-time if
 //! linear<> option is true "this" is empty and "last" is not used.
- //!
+ //!
 //! Note: Iterators of values obtained from list x now point to elements of this
 //! list. Iterators of this list and all the references are not invalidated.
 //!
@@ -1159,14 +1159,14 @@
 //! Requires: prev must point to an element contained by this list or
 //! to the before_begin() element. prev_ele must point to an element contained in list
 //! x or must be x.before_begin().
- //!
- //! Effects: Transfers the element after prev_ele, from list x to this list,
+ //!
+ //! Effects: Transfers the element after prev_ele, from list x to this list,
 //! after the element pointed by prev. No destructors or copy constructors are called.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Note: Iterators of values obtained from list x now point to elements of this
 //! list. Iterators of this list and all the references are not invalidated.
 void splice_after(const_iterator prev_pos, slist_impl &x, const_iterator prev_ele)
@@ -1177,17 +1177,17 @@

 //! Requires: prev_pos must be a dereferenceable iterator in *this or be
 //! before_begin(), and before_first and before_last belong to x and
- //! ++before_first != x.end() && before_last != x.end().
- //!
+ //! ++before_first != x.end() && before_last != x.end().
+ //!
 //! Effects: Transfers the range (before_first, before_last] from list x to this
 //! list, after the element pointed by prev_pos.
 //! No destructors or copy constructors are called.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the number of elements transferred
 //! if constant_time_size is true. Constant-time otherwise.
- //!
+ //!
 //! Note: Iterators of values obtained from list x now point to elements of this
 //! list. Iterators of this list and all the references are not invalidated.
 void splice_after(const_iterator prev_pos, slist_impl &x, const_iterator before_first, const_iterator before_last)
@@ -1203,14 +1203,14 @@
 //! before_begin(), and before_first and before_last belong to x and
 //! ++before_first != x.end() && before_last != x.end() and
 //! n == std::distance(before_first, before_last).
- //!
+ //!
 //! Effects: Transfers the range (before_first, before_last] from list x to this
 //! list, after the element pointed by p. No destructors or copy constructors are called.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Note: Iterators of values obtained from list x now point to elements of this
 //! list. Iterators of this list and all the references are not invalidated.
 void splice_after(const_iterator prev_pos, slist_impl &x, const_iterator before_first, const_iterator before_last, difference_type n)
@@ -1227,19 +1227,19 @@
 }

 //! Requires: it is an iterator to an element in *this.
- //!
+ //!
 //! Effects: Transfers all the elements of list x to this list, before the
 //! the element pointed by it. No destructors or copy constructors are called.
- //!
+ //!
 //! Returns: Nothing.
- //!
+ //!
 //! Throws: Nothing.
 //!
 //! Complexity: Linear to the elements contained in x plus linear to
 //! the elements before it.
 //! Linear to the elements before it if cache_last<> option is true.
 //! Constant-time if cache_last<> option is true and it == end().
- //!
+ //!
 //! Note: Iterators of values obtained from list x now point to elements of this
 //! list. Iterators of this list and all the references are not invalidated.
 //!
@@ -1253,66 +1253,66 @@
 //! Requires: it p must be a valid iterator of *this.
 //! elem must point to an element contained in list
 //! x.
- //!
- //! Effects: Transfers the element elem, from list x to this list,
+ //!
+ //! Effects: Transfers the element elem, from list x to this list,
 //! before the element pointed by pos. No destructors or copy constructors are called.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the elements before pos and before elem.
 //! Linear to the elements before elem if cache_last<> option is true and pos == end().
- //!
+ //!
 //! Note: Iterators of values obtained from list x now point to elements of this
 //! list. Iterators of this list and all the references are not invalidated.
 void splice(const_iterator pos, slist_impl &x, const_iterator elem)
 { return this->splice_after(this->previous(pos), x, x.previous(elem)); }

 //! Requires: pos must be a dereferenceable iterator in *this
- //! and first and last belong to x and first and last a valid range on x.
- //!
+ //! and first and last belong to x and first and last a valid range on x.
+ //!
 //! Effects: Transfers the range [first, last) from list x to this
 //! list, before the element pointed by pos.
 //! No destructors or copy constructors are called.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the sum of elements before pos, first, and last
 //! plus linear to the number of elements transferred if constant_time_size is true.
 //! Linear to the sum of elements before first, and last
 //! plus linear to the number of elements transferred if constant_time_size is true
 //! if cache_last<> is true and pos == end()
- //!
+ //!
 //! Note: Iterators of values obtained from list x now point to elements of this
 //! list. Iterators of this list and all the references are not invalidated.
 void splice(const_iterator pos, slist_impl &x, const_iterator first, const_iterator last)
 { return this->splice_after(this->previous(pos), x, x.previous(first), x.previous(last)); }

 //! Requires: pos must be a dereferenceable iterator in *this
- //! and first and last belong to x and first and last a valid range on x.
+ //! and first and last belong to x and first and last a valid range on x.
 //! n == std::distance(first, last).
- //!
+ //!
 //! Effects: Transfers the range [first, last) from list x to this
 //! list, before the element pointed by pos.
 //! No destructors or copy constructors are called.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the sum of elements before pos, first, and last.
 //! Linear to the sum of elements before first and last
 //! if cache_last<> is true and pos == end().
- //!
+ //!
 //! Note: Iterators of values obtained from list x now point to elements of this
 //! list. Iterators of this list and all the references are not invalidated.
 void splice(const_iterator pos, slist_impl &x, const_iterator first, const_iterator last, difference_type n)
 { return this->splice_after(this->previous(pos), x, x.previous(first), x.previous(last), n); }

- //! Effects: This function sorts the list *this according to std::less<value_type>.
+ //! Effects: This function sorts the list *this according to std::less<value_type>.
 //! The sort is stable, that is, the relative order of equivalent elements is preserved.
- //!
+ //!
 //! Throws: If value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
 //! or the predicate throws. Basic guarantee.
- //!
+ //!
 //! Complexity: The number of comparisons is approximately N log N, where N
 //! is the list's size.
 //!
@@ -1368,44 +1368,44 @@

 //! Requires: p must be a comparison function that induces a strict weak
 //! ordering and both *this and x must be sorted according to that ordering
- //! The lists x and *this must be distinct.
- //!
+ //! The lists x and *this must be distinct.
+ //!
 //! Effects: This function removes all of x's elements and inserts them
- //! in order into *this. The merge is stable; that is, if an element from *this is
- //! equivalent to one from x, then the element from *this will precede the one from x.
- //!
+ //! in order into *this. The merge is stable; that is, if an element from *this is
+ //! equivalent to one from x, then the element from *this will precede the one from x.
+ //!
 //! Throws: If value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
 //! or std::less<value_type> throws. Basic guarantee.
- //!
+ //!
 //! Complexity: This function is linear time: it performs at most
 //! size() + x.size() - 1 comparisons.
- //!
+ //!
 //! Note: Iterators and references are not invalidated.
 void sort()
 { this->sort(std::less<value_type>()); }

 //! Requires: p must be a comparison function that induces a strict weak
 //! ordering and both *this and x must be sorted according to that ordering
- //! The lists x and *this must be distinct.
- //!
+ //! The lists x and *this must be distinct.
+ //!
 //! Effects: This function removes all of x's elements and inserts them
- //! in order into *this. The merge is stable; that is, if an element from *this is
- //! equivalent to one from x, then the element from *this will precede the one from x.
- //!
+ //! in order into *this. The merge is stable; that is, if an element from *this is
+ //! equivalent to one from x, then the element from *this will precede the one from x.
+ //!
 //! Returns: Nothing.
- //!
+ //!
 //! Throws: If the predicate throws. Basic guarantee.
- //!
+ //!
 //! Complexity: This function is linear time: it performs at most
 //! size() + x.size() - 1 comparisons.
- //!
+ //!
 //! Note: Iterators and references are not invalidated.
- //!
+ //!
 //! Additional note: If optional "last" argument is passed, it is assigned
 //! to an iterator to the last transferred value or end() is x is empty.
 template<class Predicate>
- void merge(slist_impl& x, Predicate p, const_iterator *last = 0)
+ void merge(slist_impl& x, Predicate p, const_iterator *last = 0)
 {
 const_iterator e(this->cend()), ex(x.cend()), bb(this->cbefore_begin()),
 bb_next;
@@ -1432,25 +1432,25 @@
 }

 //! Effects: This function removes all of x's elements and inserts them
- //! in order into *this according to std::less<value_type>. The merge is stable;
- //! that is, if an element from *this is equivalent to one from x, then the element
- //! from *this will precede the one from x.
- //!
+ //! in order into *this according to std::less<value_type>. The merge is stable;
+ //! that is, if an element from *this is equivalent to one from x, then the element
+ //! from *this will precede the one from x.
+ //!
 //! Throws: if std::less<value_type> throws. Basic guarantee.
- //!
+ //!
 //! Complexity: This function is linear time: it performs at most
 //! size() + x.size() - 1 comparisons.
- //!
+ //!
 //! Note: Iterators and references are not invalidated
 void merge(slist_impl& x)
 { this->merge(x, std::less<value_type>()); }

- //! Effects: Reverses the order of elements in the list.
- //!
+ //! Effects: Reverses the order of elements in the list.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: This function is linear to the contained elements.
- //!
+ //!
 //! Note: Iterators and references are not invalidated
 void reverse()
 {
@@ -1462,13 +1462,13 @@

 //! Effects: Removes all the elements that compare equal to value.
 //! No destructors are called.
- //!
+ //!
 //! Throws: If std::equal_to<value_type> throws. Basic guarantee.
- //!
+ //!
 //! Complexity: Linear time. It performs exactly size() comparisons for equality.
- //!
+ //!
 //! Note: The relative order of elements that are not removed is unchanged,
- //! and iterators to elements that are not removed remain valid. This function is
+ //! and iterators to elements that are not removed remain valid. This function is
 //! linear time: it performs exactly size() comparisons for equality.
 void remove(const_reference value)
 { this->remove_if(detail::equal_to_value<const_reference>(value)); }
@@ -1479,9 +1479,9 @@
 //! Disposer::operator()(pointer) is called for every removed element.
 //!
 //! Throws: If std::equal_to<value_type> throws. Basic guarantee.
- //!
+ //!
 //! Complexity: Linear time. It performs exactly size() comparisons for equality.
- //!
+ //!
 //! Note: The relative order of elements that are not removed is unchanged,
 //! and iterators to elements that are not removed remain valid.
 template<class Disposer>
@@ -1490,11 +1490,11 @@

 //! Effects: Removes all the elements for which a specified
 //! predicate is satisfied. No destructors are called.
- //!
+ //!
 //! Throws: If pred throws. Basic guarantee.
- //!
+ //!
 //! Complexity: Linear time. It performs exactly size() calls to the predicate.
- //!
+ //!
 //! Note: The relative order of elements that are not removed is unchanged,
 //! and iterators to elements that are not removed remain valid.
 template<class Pred>
@@ -1508,7 +1508,7 @@
 //! Disposer::operator()(pointer) is called for every removed element.
 //!
 //! Throws: If pred throws. Basic guarantee.
- //!
+ //!
 //! Complexity: Linear time. It performs exactly size() comparisons for equality.
 //!
 //! Note: The relative order of elements that are not removed is unchanged,
@@ -1517,7 +1517,7 @@
 void remove_and_dispose_if(Pred pred, Disposer disposer)
 {
 const_iterator bcur(this->before_begin()), cur(this->begin()), e(this->end());
-
+
 while(cur != e){
 if (pred(*cur)){
 cur = this->erase_after_and_dispose(bcur, disposer);
@@ -1532,26 +1532,26 @@
 }
 }

- //! Effects: Removes adjacent duplicate elements or adjacent
+ //! Effects: Removes adjacent duplicate elements or adjacent
 //! elements that are equal from the list. No destructors are called.
- //!
+ //!
 //! Throws: If std::equal_to<value_type> throws. Basic guarantee.
- //!
+ //!
 //! Complexity: Linear time (size()-1) comparisons calls to pred()).
- //!
+ //!
 //! Note: The relative order of elements that are not removed is unchanged,
 //! and iterators to elements that are not removed remain valid.
 void unique()
 { this->unique_and_dispose(std::equal_to<value_type>(), detail::null_disposer()); }

- //! Effects: Removes adjacent duplicate elements or adjacent
+ //! Effects: Removes adjacent duplicate elements or adjacent
 //! elements that satisfy some binary predicate from the list.
 //! No destructors are called.
- //!
+ //!
 //! Throws: If the predicate throws. Basic guarantee.
- //!
+ //!
 //! Complexity: Linear time (size()-1) comparisons equality comparisons.
- //!
+ //!
 //! Note: The relative order of elements that are not removed is unchanged,
 //! and iterators to elements that are not removed remain valid.
 template<class BinaryPredicate>
@@ -1560,14 +1560,14 @@

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
 //!
- //! Effects: Removes adjacent duplicate elements or adjacent
+ //! Effects: Removes adjacent duplicate elements or adjacent
 //! elements that satisfy some binary predicate from the list.
 //! Disposer::operator()(pointer) is called for every removed element.
- //!
+ //!
 //! Throws: If std::equal_to<value_type> throws. Basic guarantee.
- //!
+ //!
 //! Complexity: Linear time (size()-1) comparisons equality comparisons.
- //!
+ //!
 //! Note: The relative order of elements that are not removed is unchanged,
 //! and iterators to elements that are not removed remain valid.
 template<class Disposer>
@@ -1576,14 +1576,14 @@

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
 //!
- //! Effects: Removes adjacent duplicate elements or adjacent
+ //! Effects: Removes adjacent duplicate elements or adjacent
 //! elements that satisfy some binary predicate from the list.
 //! Disposer::operator()(pointer) is called for every removed element.
- //!
+ //!
 //! Throws: If the predicate throws. Basic guarantee.
- //!
+ //!
 //! Complexity: Linear time (size()-1) comparisons equality comparisons.
- //!
+ //!
 //! Note: The relative order of elements that are not removed is unchanged,
 //! and iterators to elements that are not removed remain valid.
 template<class BinaryPredicate, class Disposer>
@@ -1610,17 +1610,17 @@
 }

 //! Requires: value must be a reference to a value inserted in a list.
- //!
+ //!
 //! Effects: This function returns a const_iterator pointing to the element
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Note: Iterators and references are not invalidated.
 //! This static function is available only if the value traits
 //! is stateless.
- static iterator s_iterator_to(reference value)
+ static iterator s_iterator_to(reference value)
 {
 BOOST_STATIC_ASSERT((!stateful_value_traits));
 //BOOST_INTRUSIVE_INVARIANT_ASSERT (!node_algorithms::inited(value_traits::to_node_ptr(value)));
@@ -1628,17 +1628,17 @@
 }

 //! Requires: value must be a const reference to a value inserted in a list.
- //!
+ //!
 //! Effects: This function returns an iterator pointing to the element.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Note: Iterators and references are not invalidated.
 //! This static function is available only if the value traits
 //! is stateless.
- static const_iterator s_iterator_to(const_reference value)
+ static const_iterator s_iterator_to(const_reference value)
 {
 BOOST_STATIC_ASSERT((!stateful_value_traits));
 //BOOST_INTRUSIVE_INVARIANT_ASSERT (!node_algorithms::inited(value_traits::to_node_ptr(const_cast<reference> (value))));
@@ -1646,28 +1646,28 @@
 }

 //! Requires: value must be a reference to a value inserted in a list.
- //!
+ //!
 //! Effects: This function returns a const_iterator pointing to the element
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Note: Iterators and references are not invalidated.
- iterator iterator_to(reference value)
+ iterator iterator_to(reference value)
 {
 //BOOST_INTRUSIVE_INVARIANT_ASSERT (!node_algorithms::inited(value_traits::to_node_ptr(value)));
 return iterator (value_traits::to_node_ptr(value), this);
 }

 //! Requires: value must be a const reference to a value inserted in a list.
- //!
+ //!
 //! Effects: This function returns an iterator pointing to the element.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Note: Iterators and references are not invalidated.
 const_iterator iterator_to(const_reference value) const
 {
@@ -1675,35 +1675,35 @@
 return const_iterator (value_traits::to_node_ptr(const_cast<reference> (value)), this);
 }

- //! Returns: The iterator to the element before i in the list.
- //! Returns the end-iterator, if either i is the begin-iterator or the
- //! list is empty.
- //!
+ //! Returns: The iterator to the element before i in the list.
+ //! Returns the end-iterator, if either i is the begin-iterator or the
+ //! list is empty.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the number of elements before i.
 //! Constant if cache_last<> is true and i == end().
 iterator previous(iterator i)
 { return this->previous(this->cbefore_begin(), i); }

- //! Returns: The const_iterator to the element before i in the list.
- //! Returns the end-const_iterator, if either i is the begin-const_iterator or
- //! the list is empty.
- //!
+ //! Returns: The const_iterator to the element before i in the list.
+ //! Returns the end-const_iterator, if either i is the begin-const_iterator or
+ //! the list is empty.
+ //!
 //! Throws: Nothing.
- //!
- //! Complexity: Linear to the number of elements before i.
+ //!
+ //! Complexity: Linear to the number of elements before i.
 //! Constant if cache_last<> is true and i == end().
 const_iterator previous(const_iterator i) const
 { return this->previous(this->cbefore_begin(), i); }

 //! Returns: The iterator to the element before i in the list,
 //! starting the search on element after prev_from.
- //! Returns the end-iterator, if either i is the begin-iterator or the
- //! list is empty.
- //!
+ //! Returns the end-iterator, if either i is the begin-iterator or the
+ //! list is empty.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the number of elements before i.
 //! Constant if cache_last<> is true and i == end().
 iterator previous(const_iterator prev_from, iterator i)
@@ -1711,12 +1711,12 @@

 //! Returns: The const_iterator to the element before i in the list,
 //! starting the search on element after prev_from.
- //! Returns the end-const_iterator, if either i is the begin-const_iterator or
- //! the list is empty.
- //!
+ //! Returns the end-const_iterator, if either i is the begin-const_iterator or
+ //! the list is empty.
+ //!
 //! Throws: Nothing.
- //!
- //! Complexity: Linear to the number of elements before i.
+ //!
+ //! Complexity: Linear to the number of elements before i.
 //! Constant if cache_last<> is true and i == end().
 const_iterator previous(const_iterator prev_from, const_iterator i) const
 {
@@ -1730,17 +1730,17 @@

 //! Requires: prev_pos must be a dereferenceable iterator in *this or be
 //! before_begin(), and before_first and before_last belong to x and
- //! ++before_first != x.end() && before_last != x.end().
- //!
+ //! ++before_first != x.end() && before_last != x.end().
+ //!
 //! Effects: Transfers the range (before_first, before_last] to this
 //! list, after the element pointed by prev_pos.
 //! No destructors or copy constructors are called.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the number of elements transferred
 //! if constant_time_size is true. Constant-time otherwise.
- //!
+ //!
 //! Note: Iterators of values obtained from list x now point to elements of this
 //! list. Iterators of this list and all the references are not invalidated.
 void incorporate_after(const_iterator prev_from, const node_ptr & first, const node_ptr & before_last)
@@ -1756,14 +1756,14 @@
 //! before_begin(), and before_first and before_last belong to x and
 //! ++before_first != x.end() && before_last != x.end() and
 //! n == std::distance(first, before_last) + 1.
- //!
+ //!
 //! Effects: Transfers the range (before_first, before_last] from list x to this
 //! list, after the element pointed by p. No destructors or copy constructors are called.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Note: Iterators of values obtained from list x now point to elements of this
 //! list. Iterators of this list and all the references are not invalidated.
 void incorporate_after(const_iterator prev_pos, const node_ptr & first, const node_ptr & before_last, difference_type n)
@@ -1837,7 +1837,7 @@

 void priv_shift_forward(size_type n, detail::bool_<false>)
 {
- node_ptr last = node_algorithms::move_backwards(this->get_root_node(), (std::size_t)n);
+ node_ptr last = node_algorithms::move_backwards(this->get_root_node(), (std::size_t)n);
 if(cache_last && last){
 this->set_last_node(last);
 }
@@ -1860,7 +1860,7 @@
 {
 bool other_was_empty = false;
 if(this_impl->empty()){
- //Check if both are empty or
+ //Check if both are empty or
 if(other_impl->empty())
 return;
 //If this is empty swap pointers
@@ -2043,7 +2043,7 @@
{
 /// @cond
 typedef typename pack_options
- < slist_defaults<T>,
+ < slist_defaults<T>,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4, O5
 #else
@@ -2075,7 +2075,7 @@
template<class T, class ...Options>
#endif
class slist
- : public make_slist<T,
+ : public make_slist<T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4, O5
 #else
@@ -2084,7 +2084,7 @@
>::type
{
 typedef typename make_slist
- <T,
+ <T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4, O5
 #else
@@ -2126,8 +2126,8 @@

#endif

-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Modified: branches/release/boost/intrusive/slist_hook.hpp
==============================================================================
--- branches/release/boost/intrusive/slist_hook.hpp (original)
+++ branches/release/boost/intrusive/slist_hook.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -46,7 +46,7 @@
{
 /// @cond
 typedef typename pack_options
- < hook_defaults,
+ < hook_defaults,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3
 #else
@@ -64,16 +64,16 @@
 typedef implementation_defined type;
};

-//! Derive a class from slist_base_hook in order to store objects in
-//! in an list. slist_base_hook holds the data necessary to maintain the
+//! Derive a class from slist_base_hook in order to store objects in
+//! in an list. slist_base_hook holds the data necessary to maintain the
//! list and provides an appropriate value_traits class for list.
-//!
+//!
//! The hook admits the following options: \c tag<>, \c void_pointer<> and
//! \c link_mode<>.
//!
-//! \c tag<> defines a tag to identify the node.
-//! The same tag value can be used in different classes, but if a class is
-//! derived from more than one \c list_base_hook, then each \c list_base_hook needs its
+//! \c tag<> defines a tag to identify the node.
+//! The same tag value can be used in different classes, but if a class is
+//! derived from more than one \c list_base_hook, then each \c list_base_hook needs its
//! unique tag.
//!
//! \c link_mode<> will specify the linking mode of the hook (\c normal_link,
@@ -99,27 +99,27 @@
 public:
 //! Effects: If link_mode is \c auto_unlink or \c safe_link
 //! initializes the node to an unlinked state.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 slist_base_hook();

 //! Effects: If link_mode is \c auto_unlink or \c safe_link
 //! initializes the node to an unlinked state. The argument is ignored.
- //!
- //! Throws: Nothing.
- //!
+ //!
+ //! Throws: Nothing.
+ //!
 //! Rationale: Providing a copy-constructor
- //! makes classes using the hook STL-compliant without forcing the
+ //! makes classes using the hook STL-compliant without forcing the
 //! user to do some additional work. \c swap can be used to emulate
 //! move-semantics.
 slist_base_hook(const slist_base_hook& );

 //! Effects: Empty function. The argument is ignored.
- //!
- //! Throws: Nothing.
- //!
- //! Rationale: Providing an assignment operator
- //! makes classes using the hook STL-compliant without forcing the
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Rationale: Providing an assignment operator
+ //! makes classes using the hook STL-compliant without forcing the
 //! user to do some additional work. \c swap can be used to emulate
 //! move-semantics.
 slist_base_hook& operator=(const slist_base_hook& );
@@ -128,37 +128,37 @@
 //! nothing (ie. no code is generated). If link_mode is \c safe_link and the
 //! object is stored in an slist an assertion is raised. If link_mode is
 //! \c auto_unlink and \c is_linked() is true, the node is unlinked.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 ~slist_base_hook();

- //! Effects: Swapping two nodes swaps the position of the elements
- //! related to those nodes in one or two containers. That is, if the node
- //! this is part of the element e1, the node x is part of the element e2
- //! and both elements are included in the containers s1 and s2, then after
- //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1
- //! at the position of e1. If one element is not in a container, then
- //! after the swap-operation the other element is not in a container.
- //! Iterators to e1 and e2 related to those nodes are invalidated.
+ //! Effects: Swapping two nodes swaps the position of the elements
+ //! related to those nodes in one or two containers. That is, if the node
+ //! this is part of the element e1, the node x is part of the element e2
+ //! and both elements are included in the containers s1 and s2, then after
+ //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1
+ //! at the position of e1. If one element is not in a container, then
+ //! after the swap-operation the other element is not in a container.
+ //! Iterators to e1 and e2 related to those nodes are invalidated.
 //!
- //! Complexity: Constant
+ //! Complexity: Constant
 //!
- //! Throws: Nothing.
+ //! Throws: Nothing.
 void swap_nodes(slist_base_hook &other);

 //! Precondition: link_mode must be \c safe_link or \c auto_unlink.
 //!
 //! Returns: true, if the node belongs to a container, false
- //! otherwise. This function can be used to test whether \c slist::iterator_to
- //! will return a valid iterator.
+ //! otherwise. This function can be used to test whether \c slist::iterator_to
+ //! will return a valid iterator.
 //!
- //! Complexity: Constant
+ //! Complexity: Constant
 bool is_linked() const;

 //! Effects: Removes the node if it's inserted in a container.
 //! This function is only allowed if link_mode is \c auto_unlink.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 void unlink();
 #endif
};
@@ -174,7 +174,7 @@
{
 /// @cond
 typedef typename pack_options
- < hook_defaults,
+ < hook_defaults,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3
 #else
@@ -193,12 +193,12 @@
};

//! Put a public data member slist_member_hook in order to store objects of this class in
-//! an list. slist_member_hook holds the data necessary for maintaining the list and
+//! an list. slist_member_hook holds the data necessary for maintaining the list and
//! provides an appropriate value_traits class for list.
-//!
+//!
//! The hook admits the following options: \c void_pointer<> and
//! \c link_mode<>.
-//!
+//!
//! \c link_mode<> will specify the linking mode of the hook (\c normal_link,
//! \c auto_unlink or \c safe_link).
//!
@@ -222,27 +222,27 @@
 public:
 //! Effects: If link_mode is \c auto_unlink or \c safe_link
 //! initializes the node to an unlinked state.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 slist_member_hook();

 //! Effects: If link_mode is \c auto_unlink or \c safe_link
 //! initializes the node to an unlinked state. The argument is ignored.
- //!
- //! Throws: Nothing.
- //!
+ //!
+ //! Throws: Nothing.
+ //!
 //! Rationale: Providing a copy-constructor
- //! makes classes using the hook STL-compliant without forcing the
+ //! makes classes using the hook STL-compliant without forcing the
 //! user to do some additional work. \c swap can be used to emulate
 //! move-semantics.
 slist_member_hook(const slist_member_hook& );

 //! Effects: Empty function. The argument is ignored.
- //!
- //! Throws: Nothing.
- //!
- //! Rationale: Providing an assignment operator
- //! makes classes using the hook STL-compliant without forcing the
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Rationale: Providing an assignment operator
+ //! makes classes using the hook STL-compliant without forcing the
 //! user to do some additional work. \c swap can be used to emulate
 //! move-semantics.
 slist_member_hook& operator=(const slist_member_hook& );
@@ -251,43 +251,43 @@
 //! nothing (ie. no code is generated). If link_mode is \c safe_link and the
 //! object is stored in an slist an assertion is raised. If link_mode is
 //! \c auto_unlink and \c is_linked() is true, the node is unlinked.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 ~slist_member_hook();

- //! Effects: Swapping two nodes swaps the position of the elements
- //! related to those nodes in one or two containers. That is, if the node
- //! this is part of the element e1, the node x is part of the element e2
- //! and both elements are included in the containers s1 and s2, then after
- //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1
- //! at the position of e1. If one element is not in a container, then
- //! after the swap-operation the other element is not in a container.
- //! Iterators to e1 and e2 related to those nodes are invalidated.
+ //! Effects: Swapping two nodes swaps the position of the elements
+ //! related to those nodes in one or two containers. That is, if the node
+ //! this is part of the element e1, the node x is part of the element e2
+ //! and both elements are included in the containers s1 and s2, then after
+ //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1
+ //! at the position of e1. If one element is not in a container, then
+ //! after the swap-operation the other element is not in a container.
+ //! Iterators to e1 and e2 related to those nodes are invalidated.
 //!
- //! Complexity: Constant
+ //! Complexity: Constant
 //!
- //! Throws: Nothing.
+ //! Throws: Nothing.
 void swap_nodes(slist_member_hook &other);

 //! Precondition: link_mode must be \c safe_link or \c auto_unlink.
 //!
 //! Returns: true, if the node belongs to a container, false
- //! otherwise. This function can be used to test whether \c slist::iterator_to
- //! will return a valid iterator.
+ //! otherwise. This function can be used to test whether \c slist::iterator_to
+ //! will return a valid iterator.
 //!
- //! Complexity: Constant
+ //! Complexity: Constant
 bool is_linked() const;

 //! Effects: Removes the node if it's inserted in a container.
 //! This function is only allowed if link_mode is \c auto_unlink.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 void unlink();
 #endif
};

-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Modified: branches/release/boost/intrusive/splay_set.hpp
==============================================================================
--- branches/release/boost/intrusive/splay_set.hpp (original)
+++ branches/release/boost/intrusive/splay_set.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -22,9 +22,9 @@
namespace boost {
namespace intrusive {

-//! The class template splay_set is an intrusive container, that mimics most of
+//! The class template splay_set is an intrusive container, that mimics most of
//! the interface of std::set as described in the C++ standard.
-//!
+//!
//! The template parameter \c T is the type to be managed by the container.
//! The user can specify additional options and if no options are provided
//! default options are used.
@@ -79,30 +79,30 @@
 /// @endcond

 public:
- //! Effects: Constructs an empty splay_set.
- //!
- //! Complexity: Constant.
- //!
+ //! Effects: Constructs an empty splay_set.
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: If value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
- //! or the copy constructor of the value_compare object throws.
+ //! or the copy constructor of the value_compare object throws.
 splay_set_impl( const value_compare &cmp = value_compare()
- , const value_traits &v_traits = value_traits())
+ , const value_traits &v_traits = value_traits())
 : tree_(cmp, v_traits)
 {}

- //! Requires: Dereferencing iterator must yield an lvalue of type value_type.
+ //! Requires: Dereferencing iterator must yield an lvalue of type value_type.
 //! cmp must be a comparison function that induces a strict weak ordering.
- //!
- //! Effects: Constructs an empty splay_set and inserts elements from
+ //!
+ //! Effects: Constructs an empty splay_set and inserts elements from
 //! [b, e).
- //!
- //! Complexity: Linear in N if [b, e) is already sorted using
+ //!
+ //! Complexity: Linear in N if [b, e) is already sorted using
 //! comp and otherwise amortized N * log N, where N is std::distance(last, first).
- //!
+ //!
 //! Throws: If value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
- //! or the copy constructor/operator() of the value_compare object throws.
+ //! or the copy constructor/operator() of the value_compare object throws.
 template<class Iterator>
 splay_set_impl( Iterator b, Iterator e
 , const value_compare &cmp = value_compare()
@@ -111,135 +111,135 @@
 {}

 //! Effects: to-do
- //!
- splay_set_impl(BOOST_RV_REF(splay_set_impl) x)
+ //!
+ splay_set_impl(BOOST_RV_REF(splay_set_impl) x)
 : tree_(::boost::move(x.tree_))
 {}

 //! Effects: to-do
- //!
- splay_set_impl& operator=(BOOST_RV_REF(splay_set_impl) x)
+ //!
+ splay_set_impl& operator=(BOOST_RV_REF(splay_set_impl) x)
 { tree_ = ::boost::move(x.tree_); return *this; }

- //! Effects: Detaches all elements from this. The objects in the splay_set
+ //! Effects: Detaches all elements from this. The objects in the splay_set
 //! are not deleted (i.e. no destructors are called).
- //!
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
- //!
+ //!
 //! Throws: Nothing.
- ~splay_set_impl()
+ ~splay_set_impl()
 {}

 //! Effects: Returns an iterator pointing to the beginning of the splay_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator begin()
 { return tree_.begin(); }

 //! Effects: Returns a const_iterator pointing to the beginning of the splay_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator begin() const
 { return tree_.begin(); }

 //! Effects: Returns a const_iterator pointing to the beginning of the splay_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator cbegin() const
 { return tree_.cbegin(); }

 //! Effects: Returns an iterator pointing to the end of the splay_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator end()
 { return tree_.end(); }

 //! Effects: Returns a const_iterator pointing to the end of the splay_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator end() const
 { return tree_.end(); }

 //! Effects: Returns a const_iterator pointing to the end of the splay_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator cend() const
 { return tree_.cend(); }

 //! Effects: Returns a reverse_iterator pointing to the beginning of the
 //! reversed splay_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 reverse_iterator rbegin()
 { return tree_.rbegin(); }

 //! Effects: Returns a const_reverse_iterator pointing to the beginning
 //! of the reversed splay_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator rbegin() const
 { return tree_.rbegin(); }

 //! Effects: Returns a const_reverse_iterator pointing to the beginning
 //! of the reversed splay_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator crbegin() const
 { return tree_.crbegin(); }

 //! Effects: Returns a reverse_iterator pointing to the end
 //! of the reversed splay_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 reverse_iterator rend()
 { return tree_.rend(); }

 //! Effects: Returns a const_reverse_iterator pointing to the end
 //! of the reversed splay_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator rend() const
 { return tree_.rend(); }

 //! Effects: Returns a const_reverse_iterator pointing to the end
 //! of the reversed splay_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator crend() const
 { return tree_.crend(); }

 //! Precondition: end_iterator must be a valid end iterator
 //! of splay_set.
- //!
+ //!
 //! Effects: Returns a const reference to the splay_set associated to the end iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 static splay_set_impl &container_from_end_iterator(iterator end_iterator)
 {
@@ -250,11 +250,11 @@

 //! Precondition: end_iterator must be a valid end const_iterator
 //! of splay_set.
- //!
+ //!
 //! Effects: Returns a const reference to the splay_set associated to the end iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 static const splay_set_impl &container_from_end_iterator(const_iterator end_iterator)
 {
@@ -264,11 +264,11 @@
 }

 //! Precondition: it must be a valid iterator of set.
- //!
+ //!
 //! Effects: Returns a reference to the set associated to the iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 static splay_set_impl &container_from_iterator(iterator it)
 {
@@ -278,11 +278,11 @@
 }

 //! Precondition: it must be a valid const_iterator of set.
- //!
+ //!
 //! Effects: Returns a const reference to the set associated to the iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Logarithmic.
 static const splay_set_impl &container_from_iterator(const_iterator it)
 {
@@ -292,42 +292,42 @@
 }

 //! Effects: Returns the key_compare object used by the splay_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If key_compare copy-constructor throws.
 key_compare key_comp() const
 { return tree_.value_comp(); }

 //! Effects: Returns the value_compare object used by the splay_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If value_compare copy-constructor throws.
 value_compare value_comp() const
 { return tree_.value_comp(); }

 //! Effects: Returns true if the container is empty.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 bool empty() const
 { return tree_.empty(); }

 //! Effects: Returns the number of elements stored in the splay_set.
- //!
+ //!
 //! Complexity: Linear to elements contained in *this if,
 //! constant-time size option is enabled. Constant-time otherwise.
- //!
+ //!
 //! Throws: Nothing.
 size_type size() const
 { return tree_.size(); }

 //! Effects: Swaps the contents of two splay_sets.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If the swap() call for the comparison functor
 //! found using ADL throws. Strong guarantee.
 void swap(splay_set_impl& other)
@@ -337,22 +337,22 @@
 //! Cloner should yield to nodes equivalent to the original nodes.
 //!
 //! Effects: Erases all the elements from *this
- //! calling Disposer::operator()(pointer), clones all the
+ //! calling Disposer::operator()(pointer), clones all the
 //! elements from src calling Cloner::operator()(const_reference )
 //! and inserts them on *this. Copies the predicate from the source container.
 //!
 //! If cloner throws, all cloned elements are unlinked and disposed
 //! calling Disposer::operator()(pointer).
- //!
+ //!
 //! Complexity: Linear to erased plus inserted elements.
- //!
+ //!
 //! Throws: If cloner throws or predicate copy assignment throws. Basic guarantee.
 template <class Cloner, class Disposer>
 void clone_from(const splay_set_impl &src, Cloner cloner, Disposer disposer)
 { tree_.clone_from(src.tree_, cloner, disposer); }

 //! Requires: value must be an lvalue
- //!
+ //!
 //! Effects: Tries to inserts value into the splay_set.
 //!
 //! Returns: If the value
@@ -360,38 +360,38 @@
 //! iterator to the new value and true. If there is an equivalent value
 //! returns a pair containing an iterator to the already present value
 //! and false.
- //!
+ //!
 //! Complexity: Amortized logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Strong guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 std::pair<iterator, bool> insert(reference value)
 { return tree_.insert_unique(value); }

 //! Requires: value must be an lvalue
- //!
- //! Effects: Tries to to insert x into the splay_set, using "hint"
+ //!
+ //! Effects: Tries to to insert x into the splay_set, using "hint"
 //! as a hint to where it will be inserted.
 //!
- //! Returns: An iterator that points to the position where the
+ //! Returns: An iterator that points to the position where the
 //! new element was inserted into the splay_set.
- //!
+ //!
 //! Complexity: Amortized logarithmic in general, but it's amortized
 //! constant time if t is inserted immediately before hint.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Strong guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 iterator insert(const_iterator hint, reference value)
 { return tree_.insert_unique(hint, value); }

- //! Requires: key_value_comp must be a comparison function that induces
+ //! Requires: key_value_comp must be a comparison function that induces
 //! the same strict weak ordering as value_compare. The difference is that
 //! key_value_comp compares an arbitrary key with the contained values.
- //!
+ //!
 //! Effects: Checks if a value can be inserted in the splay_set, using
 //! a user provided key instead of the value itself.
 //!
@@ -400,16 +400,16 @@
 //! and false. If the value can be inserted returns true in the returned
 //! pair boolean and fills "commit_data" that is meant to be used with
 //! the "insert_commit" function.
- //!
+ //!
 //! Complexity: Amortized logarithmic.
 //!
 //! Throws: If the key_value_comp ordering function throws. Strong guarantee.
- //!
+ //!
 //! Notes: This function is used to improve performance when constructing
 //! a value_type is expensive: if there is an equivalent value
 //! the constructed object must be discarded. Many times, the part of the
 //! node that is used to impose the order is much cheaper to construct
- //! than the value_type and this function offers the possibility to use that
+ //! than the value_type and this function offers the possibility to use that
 //! part to check if the insertion will be successful.
 //!
 //! If the check is successful, the user can construct the value_type and use
@@ -423,12 +423,12 @@
 (const KeyType &key, KeyValueCompare key_value_comp, insert_commit_data &commit_data)
 { return tree_.insert_unique_check(key, key_value_comp, commit_data); }

- //! Requires: key_value_comp must be a comparison function that induces
+ //! Requires: key_value_comp must be a comparison function that induces
 //! the same strict weak ordering as value_compare. The difference is that
 //! key_value_comp compares an arbitrary key with the contained values.
- //!
+ //!
 //! Effects: Checks if a value can be inserted in the splay_set, using
- //! a user provided key instead of the value itself, using "hint"
+ //! a user provided key instead of the value itself, using "hint"
 //! as a hint to where it will be inserted.
 //!
 //! Returns: If there is an equivalent value
@@ -436,23 +436,23 @@
 //! and false. If the value can be inserted returns true in the returned
 //! pair boolean and fills "commit_data" that is meant to be used with
 //! the "insert_commit" function.
- //!
+ //!
 //! Complexity: Amortized logarithmic in general, but it's amortized
 //! constant time if t is inserted immediately before hint.
 //!
 //! Throws: If the key_value_comp ordering function throws. Strong guarantee.
- //!
+ //!
 //! Notes: This function is used to improve performance when constructing
 //! a value_type is expensive: if there is an equivalent value
 //! the constructed object must be discarded. Many times, the part of the
 //! constructing that is used to impose the order is much cheaper to construct
- //! than the value_type and this function offers the possibility to use that key
+ //! than the value_type and this function offers the possibility to use that key
 //! to check if the insertion will be successful.
 //!
 //! If the check is successful, the user can construct the value_type and use
 //! "insert_commit" to insert the object in constant-time. This can give a total
 //! constant-time complexity to the insertion: check(O(1)) + commit(O(1)).
- //!
+ //!
 //! "commit_data" remains valid for a subsequent "insert_commit" only if no more
 //! objects are inserted or erased from the splay_set.
 template<class KeyType, class KeyValueCompare>
@@ -465,74 +465,74 @@
 //! must have been obtained from a previous call to "insert_check".
 //! No objects should have been inserted or erased from the splay_set between
 //! the "insert_check" that filled "commit_data" and the call to "insert_commit".
- //!
+ //!
 //! Effects: Inserts the value in the splay_set using the information obtained
 //! from the "commit_data" that a previous "insert_check" filled.
 //!
 //! Returns: An iterator to the newly inserted object.
- //!
+ //!
 //! Complexity: Constant time.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Notes: This function has only sense if a "insert_check" has been
 //! previously executed to fill "commit_data". No value should be inserted or
 //! erased between the "insert_check" and "insert_commit" calls.
 iterator insert_commit(reference value, const insert_commit_data &commit_data)
 { return tree_.insert_unique_commit(value, commit_data); }

- //! Requires: Dereferencing iterator must yield an lvalue
+ //! Requires: Dereferencing iterator must yield an lvalue
 //! of type value_type.
- //!
+ //!
 //! Effects: Inserts a range into the splay_set.
- //!
+ //!
 //! Complexity: Insert range is amortized O(N * log(N)), where N is the
 //! size of the range. However, it is linear in N if the range is already sorted
 //! by value_comp().
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Basic guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 template<class Iterator>
 void insert(Iterator b, Iterator e)
 { tree_.insert_unique(b, e); }

- //! Effects: Erases the element pointed to by pos.
- //!
+ //! Effects: Erases the element pointed to by pos.
+ //!
 //! Complexity: Average complexity is constant time.
- //!
+ //!
 //! Returns: An iterator to the element after the erased element.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 iterator erase(const_iterator i)
 { return tree_.erase(i); }

- //! Effects: Erases the range pointed to by b end e.
- //!
+ //! Effects: Erases the range pointed to by b end e.
+ //!
 //! Complexity: Average complexity for erase range is amortized
 //! O(log(size() + N)), where N is the number of elements in the range.
- //!
+ //!
 //! Returns: An iterator to the element after the erased elements.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 iterator erase(const_iterator b, const_iterator e)
 { return tree_.erase(b, e); }

 //! Effects: Erases all the elements with the given value.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: Amortized O(log(size()) + this->count(value)).
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 size_type erase(const_reference value)
@@ -540,13 +540,13 @@

 //! Effects: Erases all the elements that compare equal with
 //! the given key and the given comparison functor.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: Amortized O(log(size() + this->count(key, comp)).
- //!
+ //!
 //! Throws: If the comp ordering function throws. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class KeyType, class KeyValueCompare>
@@ -559,16 +559,16 @@

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
 //!
- //! Effects: Erases the element pointed to by pos.
+ //! Effects: Erases the element pointed to by pos.
 //! Disposer::operator()(pointer) is called for the removed element.
- //!
- //! Complexity: Average complexity for erase element is constant time.
- //!
+ //!
+ //! Complexity: Average complexity for erase element is constant time.
+ //!
 //! Returns: An iterator to the element after the erased element.
- //!
+ //!
 //! Throws: Nothing.
- //!
- //! Note: Invalidates the iterators
+ //!
+ //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
 iterator erase_and_dispose(const_iterator i, Disposer disposer)
@@ -584,14 +584,14 @@
 //!
 //! Effects: Erases the range pointed to by b end e.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
- //! Complexity: Average complexity for erase range is at most
+ //!
+ //! Complexity: Average complexity for erase range is at most
 //! O(log(size() + N)), where N is the number of elements in the range.
- //!
+ //!
 //! Returns: An iterator to the element after the erased elements.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
@@ -602,13 +602,13 @@
 //!
 //! Effects: Erases all the elements with the given value.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
- //!
+ //!
 //! Complexity: Amortized O(log(size() + this->count(value)). Basic guarantee.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class Disposer>
@@ -622,11 +622,11 @@
 //! Disposer::operator()(pointer) is called for the removed elements.
 //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: Amortized O(log(size() + this->count(key, comp)).
- //!
+ //!
 //! Throws: If comp ordering function throws. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class KeyType, class KeyValueCompare, class Disposer>
@@ -638,26 +638,26 @@
 { return tree_.erase_and_dispose(key, comp, disposer); }

 //! Effects: Erases all the elements of the container.
- //!
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 void clear()
 { return tree_.clear(); }

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
- //!
+ //!
 //! Effects: Erases all the elements of the container.
- //!
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class Disposer>
@@ -665,40 +665,40 @@
 { return tree_.clear_and_dispose(disposer); }

 //! Effects: Returns the number of contained elements with the given key
- //!
+ //!
 //! Complexity: Amortized logarithmic to the number of elements contained plus lineal
 //! to number of objects with the given key.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 size_type count(const_reference value)
 { return tree_.find(value) != end(); }

 //! Effects: Returns the number of contained elements with the same key
 //! compared with the given comparison functor.
- //!
+ //!
 //! Complexity: Amortized logarithmic to the number of elements contained plus lineal
 //! to number of objects with the given key.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 template<class KeyType, class KeyValueCompare>
 size_type count(const KeyType& key, KeyValueCompare comp)
 { return tree_.find(key, comp) != end(); }

 //! Effects: Returns the number of contained elements with the given key
- //!
+ //!
 //! Complexity: Logarithmic to the number of elements contained plus lineal
 //! to number of objects with the given key.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 size_type count_dont_splay(const_reference value)const
 { return tree_.find_dont_splay(value) != end(); }

 //! Effects: Returns the number of contained elements with the same key
 //! compared with the given comparison functor.
- //!
+ //!
 //! Complexity: Logarithmic to the number of elements contained plus lineal
 //! to number of objects with the given key.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 template<class KeyType, class KeyValueCompare>
 size_type count_dont_splay(const KeyType& key, KeyValueCompare comp)const
@@ -706,9 +706,9 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is not less than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Amortized logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 iterator lower_bound(const_reference value)
 { return tree_.lower_bound(value); }
@@ -718,13 +718,13 @@
 //! that is used in the ordering functor.
 //!
 //! Effects: Returns an iterator to the first element whose
- //! key according to the comparison functor is not less than k or
+ //! key according to the comparison functor is not less than k or
 //! end() if that element does not exist.
- //!
+ //!
 //! Complexity: Amortized logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
- //!
+ //!
 //! Note: This function is used when constructing a value_type
 //! is expensive and the value_type can be compared with a cheaper
 //! key type. Usually this key is part of the value_type.
@@ -734,9 +734,9 @@

 //! Effects: Returns a const iterator to the first element whose
 //! key is not less than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 const_iterator lower_bound_dont_splay(const_reference value) const
 { return tree_.lower_bound_dont_splay(value); }
@@ -746,13 +746,13 @@
 //! that is used in the ordering functor.
 //!
 //! Effects: Returns a const_iterator to the first element whose
- //! key according to the comparison functor is not less than k or
+ //! key according to the comparison functor is not less than k or
 //! end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
- //!
+ //!
 //! Note: This function is used when constructing a value_type
 //! is expensive and the value_type can be compared with a cheaper
 //! key type. Usually this key is part of the value_type.
@@ -762,9 +762,9 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is greater than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Amortized logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 iterator upper_bound(const_reference value)
 { return tree_.upper_bound(value); }
@@ -774,11 +774,11 @@
 //! that is used in the ordering functor.
 //!
 //! Effects: Returns an iterator to the first element whose
- //! key according to the comparison functor is greater than key or
+ //! key according to the comparison functor is greater than key or
 //! end() if that element does not exist.
- //!
+ //!
 //! Complexity: Amortized logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -790,9 +790,9 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is greater than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 const_iterator upper_bound_dont_splay(const_reference value) const
 { return tree_.upper_bound_dont_splay(value); }
@@ -802,11 +802,11 @@
 //! that is used in the ordering functor.
 //!
 //! Effects: Returns a const_iterator to the first element whose
- //! key according to the comparison functor is greater than key or
+ //! key according to the comparison functor is greater than key or
 //! end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -816,11 +816,11 @@
 const_iterator upper_bound_dont_splay(const KeyType& key, KeyValueCompare comp) const
 { return tree_.upper_bound_dont_splay(key, comp); }

- //! Effects: Finds an iterator to the first element whose value is
+ //! Effects: Finds an iterator to the first element whose value is
 //! "value" or end() if that element does not exist.
 //!
 //! Complexity: Amortized logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 iterator find(const_reference value)
 { return tree_.find(value); }
@@ -829,12 +829,12 @@
 //! value_compare. Usually key is the part of the value_type
 //! that is used in the ordering functor.
 //!
- //! Effects: Finds an iterator to the first element whose key is
- //! "key" according to the comparison functor or end() if that element
+ //! Effects: Finds an iterator to the first element whose key is
+ //! "key" according to the comparison functor or end() if that element
 //! does not exist.
 //!
 //! Complexity: Amortized logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -844,11 +844,11 @@
 iterator find(const KeyType& key, KeyValueCompare comp)
 { return tree_.find(key, comp); }

- //! Effects: Finds a const_iterator to the first element whose value is
+ //! Effects: Finds a const_iterator to the first element whose value is
 //! "value" or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 const_iterator find_dont_splay(const_reference value) const
 { return tree_.find_dont_splay(value); }
@@ -857,12 +857,12 @@
 //! value_compare. Usually key is the part of the value_type
 //! that is used in the ordering functor.
 //!
- //! Effects: Finds a const_iterator to the first element whose key is
- //! "key" according to the comparison functor or end() if that element
+ //! Effects: Finds a const_iterator to the first element whose key is
+ //! "key" according to the comparison functor or end() if that element
 //! does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -875,9 +875,9 @@
 //! Effects: Finds a range containing all elements whose key is k or
 //! an empty range that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Amortized logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 std::pair<iterator,iterator> equal_range(const_reference value)
 { return tree_.equal_range(value); }
@@ -886,13 +886,13 @@
 //! value_compare. Usually key is the part of the value_type
 //! that is used in the ordering functor.
 //!
- //! Effects: Finds a range containing all elements whose key is k
- //! according to the comparison functor or an empty range
+ //! Effects: Finds a range containing all elements whose key is k
+ //! according to the comparison functor or an empty range
 //! that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Amortized logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -905,9 +905,9 @@
 //! Effects: Finds a range containing all elements whose key is k or
 //! an empty range that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 std::pair<const_iterator, const_iterator>
 equal_range_dont_splay(const_reference value) const
@@ -917,13 +917,13 @@
 //! value_compare. Usually key is the part of the value_type
 //! that is used in the ordering functor.
 //!
- //! Effects: Finds a range containing all elements whose key is k
- //! according to the comparison functor or an empty range
+ //! Effects: Finds a range containing all elements whose key is k
+ //! according to the comparison functor or an empty range
 //! that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -936,14 +936,14 @@

 //! Requires: value must be an lvalue and shall be in a splay_set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid iterator i belonging to the splay_set
 //! that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This static function is available only if the value traits
 //! is stateless.
 static iterator s_iterator_to(reference value)
@@ -951,14 +951,14 @@

 //! Requires: value must be an lvalue and shall be in a splay_set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid const_iterator i belonging to the
 //! splay_set that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This static function is available only if the value traits
 //! is stateless.
 static const_iterator s_iterator_to(const_reference value)
@@ -966,48 +966,48 @@

 //! Requires: value must be an lvalue and shall be in a splay_set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid iterator i belonging to the splay_set
 //! that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator iterator_to(reference value)
 { return tree_.iterator_to(value); }

 //! Requires: value must be an lvalue and shall be in a splay_set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid const_iterator i belonging to the
 //! splay_set that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator iterator_to(const_reference value) const
 { return tree_.iterator_to(value); }

 //! Requires: value shall not be in a splay_set/multisplay_set.
- //!
+ //!
 //! Effects: init_node puts the hook of a value in a well-known default
 //! state.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Note: This function puts the hook in the well-known default state
 //! used by auto_unlink and safe hooks.
 static void init_node(reference value)
 { tree_type::init_node(value); }

 //! Effects: Unlinks the leftmost node from the tree.
- //!
+ //!
 //! Complexity: Average complexity is constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Notes: This function breaks the tree and the tree can
 //! only be used for more unlink_leftmost_without_rebalance calls.
 //! This function is normally used to achieve a step by step
@@ -1017,14 +1017,14 @@

 //! Requires: replace_this must be a valid iterator of *this
 //! and with_this must not be inserted in any tree.
- //!
+ //!
 //! Effects: Replaces replace_this in its position in the
 //! tree with with_this. The tree does not need to be rebalanced.
- //!
- //! Complexity: Constant.
- //!
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function will break container ordering invariants if
 //! with_this is not equivalent to *replace_this according to the
 //! ordering rules. This function is faster than erasing and inserting
@@ -1033,12 +1033,12 @@
 { tree_.replace_node(replace_this, with_this); }

 //! Requires: i must be a valid iterator of *this.
- //!
+ //!
 //! Effects: Rearranges the splay set so that the element pointed by i
 //! is placed as the root of the tree, improving future searches of this value.
- //!
+ //!
 //! Complexity: Amortized logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 void splay_up(iterator i)
 { tree_.splay_up(i); }
@@ -1047,9 +1047,9 @@
 //! with a key equivalent to value the element is placed as the root of the
 //! tree. If the element is not present returns the last node compared with the key.
 //! If the tree is empty, end() is returned.
- //!
+ //!
 //! Complexity: Amortized logarithmic.
- //!
+ //!
 //! Returns: An iterator to the new root of the tree, end() if the tree is empty.
 //!
 //! Throws: If the comparison functor throws.
@@ -1060,9 +1060,9 @@
 //! Effects: Rearranges the splay set so that if *this stores an element
 //! with a key equivalent to value the element is placed as the root of the
 //! tree.
- //!
+ //!
 //! Complexity: Amortized logarithmic.
- //!
+ //!
 //! Returns: An iterator to the new root of the tree, end() if the tree is empty.
 //!
 //! Throws: If the predicate throws.
@@ -1070,21 +1070,21 @@
 { return tree_.splay_down(value); }

 //! Effects: Rebalances the tree.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear.
 void rebalance()
 { tree_.rebalance(); }

 //! Requires: old_root is a node of a tree.
- //!
+ //!
 //! Effects: Rebalances the subtree rooted at old_root.
 //!
 //! Returns: The new root of the subtree.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the elements in the subtree.
 iterator rebalance_subtree(iterator root)
 { return tree_.rebalance_subtree(root); }
@@ -1175,7 +1175,7 @@
{
 /// @cond
 typedef splay_set_impl
- < typename make_splaytree_opt<T,
+ < typename make_splaytree_opt<T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
@@ -1194,7 +1194,7 @@
template<class T, class ...Options>
#endif
class splay_set
- : public make_splay_set<T,
+ : public make_splay_set<T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
@@ -1203,7 +1203,7 @@
>::type
{
 typedef typename make_splay_set
- <T,
+ <T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
@@ -1255,9 +1255,9 @@

#endif

-//! The class template splay_multiset is an intrusive container, that mimics most of
+//! The class template splay_multiset is an intrusive container, that mimics most of
//! the interface of std::multiset as described in the C++ standard.
-//!
+//!
//! The template parameter \c T is the type to be managed by the container.
//! The user can specify additional options and if no options are provided
//! default options are used.
@@ -1311,30 +1311,30 @@
 /// @endcond

 public:
- //! Effects: Constructs an empty splay_multiset.
- //!
- //! Complexity: Constant.
- //!
+ //! Effects: Constructs an empty splay_multiset.
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: If value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
- //! or the copy constructor/operator() of the value_compare object throws.
+ //! or the copy constructor/operator() of the value_compare object throws.
 splay_multiset_impl( const value_compare &cmp = value_compare()
- , const value_traits &v_traits = value_traits())
+ , const value_traits &v_traits = value_traits())
 : tree_(cmp, v_traits)
 {}

- //! Requires: Dereferencing iterator must yield an lvalue of type value_type.
+ //! Requires: Dereferencing iterator must yield an lvalue of type value_type.
 //! cmp must be a comparison function that induces a strict weak ordering.
- //!
- //! Effects: Constructs an empty splay_multiset and inserts elements from
+ //!
+ //! Effects: Constructs an empty splay_multiset and inserts elements from
 //! [b, e).
- //!
+ //!
 //! Complexity: Linear in N if [b, e) is already sorted using
 //! comp and otherwise amortized N * log N, where N is the distance between first and last.
- //!
+ //!
 //! Throws: If value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
- //! or the copy constructor/operator() of the value_compare object throws.
+ //! or the copy constructor/operator() of the value_compare object throws.
 template<class Iterator>
 splay_multiset_impl( Iterator b, Iterator e
 , const value_compare &cmp = value_compare()
@@ -1343,135 +1343,135 @@
 {}

 //! Effects: to-do
- //!
- splay_multiset_impl(BOOST_RV_REF(splay_multiset_impl) x)
+ //!
+ splay_multiset_impl(BOOST_RV_REF(splay_multiset_impl) x)
 : tree_(::boost::move(x.tree_))
 {}

 //! Effects: to-do
- //!
- splay_multiset_impl& operator=(BOOST_RV_REF(splay_multiset_impl) x)
+ //!
+ splay_multiset_impl& operator=(BOOST_RV_REF(splay_multiset_impl) x)
 { tree_ = ::boost::move(x.tree_); return *this; }

- //! Effects: Detaches all elements from this. The objects in the set
+ //! Effects: Detaches all elements from this. The objects in the set
 //! are not deleted (i.e. no destructors are called).
- //!
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
- //!
+ //!
 //! Throws: Nothing.
- ~splay_multiset_impl()
+ ~splay_multiset_impl()
 {}

 //! Effects: Returns an iterator pointing to the beginning of the splay_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator begin()
 { return tree_.begin(); }

 //! Effects: Returns a const_iterator pointing to the beginning of the splay_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator begin() const
 { return tree_.begin(); }

 //! Effects: Returns a const_iterator pointing to the beginning of the splay_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator cbegin() const
 { return tree_.cbegin(); }

 //! Effects: Returns an iterator pointing to the end of the splay_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator end()
 { return tree_.end(); }

 //! Effects: Returns a const_iterator pointing to the end of the splay_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator end() const
 { return tree_.end(); }

 //! Effects: Returns a const_iterator pointing to the end of the splay_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator cend() const
 { return tree_.cend(); }

 //! Effects: Returns a reverse_iterator pointing to the beginning of the
 //! reversed splay_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 reverse_iterator rbegin()
 { return tree_.rbegin(); }

 //! Effects: Returns a const_reverse_iterator pointing to the beginning
 //! of the reversed splay_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator rbegin() const
 { return tree_.rbegin(); }

 //! Effects: Returns a const_reverse_iterator pointing to the beginning
 //! of the reversed splay_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator crbegin() const
 { return tree_.crbegin(); }

 //! Effects: Returns a reverse_iterator pointing to the end
 //! of the reversed splay_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 reverse_iterator rend()
 { return tree_.rend(); }

 //! Effects: Returns a const_reverse_iterator pointing to the end
 //! of the reversed splay_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator rend() const
 { return tree_.rend(); }

 //! Effects: Returns a const_reverse_iterator pointing to the end
 //! of the reversed splay_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator crend() const
 { return tree_.crend(); }

 //! Precondition: end_iterator must be a valid end iterator
 //! of splay_multiset.
- //!
+ //!
 //! Effects: Returns a const reference to the splay_multiset associated to the end iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 static splay_multiset_impl &container_from_end_iterator(iterator end_iterator)
 {
@@ -1482,11 +1482,11 @@

 //! Precondition: end_iterator must be a valid end const_iterator
 //! of splay_multiset.
- //!
+ //!
 //! Effects: Returns a const reference to the splay_multiset associated to the end iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 static const splay_multiset_impl &container_from_end_iterator(const_iterator end_iterator)
 {
@@ -1496,11 +1496,11 @@
 }

 //! Precondition: it must be a valid iterator of multiset.
- //!
+ //!
 //! Effects: Returns a const reference to the multiset associated to the iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Logarithmic.
 static splay_multiset_impl &container_from_iterator(iterator it)
 {
@@ -1510,11 +1510,11 @@
 }

 //! Precondition: it must be a valid const_iterator of multiset.
- //!
+ //!
 //! Effects: Returns a const reference to the multiset associated to the iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 static const splay_multiset_impl &container_from_iterator(const_iterator it)
 {
@@ -1524,42 +1524,42 @@
 }

 //! Effects: Returns the key_compare object used by the splay_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If key_compare copy-constructor throws.
 key_compare key_comp() const
 { return tree_.value_comp(); }

 //! Effects: Returns the value_compare object used by the splay_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If value_compare copy-constructor throws.
 value_compare value_comp() const
 { return tree_.value_comp(); }

 //! Effects: Returns true if the container is empty.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 bool empty() const
 { return tree_.empty(); }

 //! Effects: Returns the number of elements stored in the splay_multiset.
- //!
+ //!
 //! Complexity: Linear to elements contained in *this if,
 //! constant-time size option is enabled. Constant-time otherwise.
- //!
+ //!
 //! Throws: Nothing.
 size_type size() const
 { return tree_.size(); }

 //! Effects: Swaps the contents of two splay_multisets.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If the swap() call for the comparison functor
 //! found using ADL throws. Strong guarantee.
 void swap(splay_multiset_impl& other)
@@ -1569,109 +1569,109 @@
 //! Cloner should yield to nodes equivalent to the original nodes.
 //!
 //! Effects: Erases all the elements from *this
- //! calling Disposer::operator()(pointer), clones all the
+ //! calling Disposer::operator()(pointer), clones all the
 //! elements from src calling Cloner::operator()(const_reference )
 //! and inserts them on *this. Copies the predicate from the source container.
 //!
 //! If cloner throws, all cloned elements are unlinked and disposed
 //! calling Disposer::operator()(pointer).
- //!
+ //!
 //! Complexity: Linear to erased plus inserted elements.
- //!
+ //!
 //! Throws: If cloner throws or predicate copy assignment throws. Basic guarantee.
 template <class Cloner, class Disposer>
 void clone_from(const splay_multiset_impl &src, Cloner cloner, Disposer disposer)
 { tree_.clone_from(src.tree_, cloner, disposer); }

 //! Requires: value must be an lvalue
- //!
+ //!
 //! Effects: Inserts value into the splay_multiset.
- //!
+ //!
 //! Returns: An iterator that points to the position where the new
 //! element was inserted.
- //!
+ //!
 //! Complexity: Amortized logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Strong guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 iterator insert(reference value)
 { return tree_.insert_equal(this->end(), value); }

 //! Requires: value must be an lvalue
- //!
+ //!
 //! Effects: Inserts x into the splay_multiset, using pos as a hint to
 //! where it will be inserted.
- //!
+ //!
 //! Returns: An iterator that points to the position where the new
 //! element was inserted.
- //!
+ //!
 //! Complexity: Amortized logarithmic in general, but it is amortized
 //! constant time if t is inserted immediately before hint.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Strong guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 iterator insert(const_iterator hint, reference value)
 { return tree_.insert_equal(hint, value); }

- //! Requires: Dereferencing iterator must yield an lvalue
+ //! Requires: Dereferencing iterator must yield an lvalue
 //! of type value_type.
- //!
+ //!
 //! Effects: Inserts a range into the splay_multiset.
- //!
+ //!
 //! Returns: An iterator that points to the position where the new
 //! element was inserted.
- //!
+ //!
 //! Complexity: Insert range is amortized O(N * log(N)), where N is the
 //! size of the range. However, it is linear in N if the range is already sorted
 //! by value_comp().
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Basic guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 template<class Iterator>
 void insert(Iterator b, Iterator e)
 { tree_.insert_equal(b, e); }

- //! Effects: Erases the element pointed to by pos.
- //!
- //! Complexity: Average complexity is constant time.
- //!
+ //! Effects: Erases the element pointed to by pos.
+ //!
+ //! Complexity: Average complexity is constant time.
+ //!
 //! Returns: An iterator to the element after the erased element.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 iterator erase(const_iterator i)
 { return tree_.erase(i); }

- //! Effects: Erases the range pointed to by b end e.
+ //! Effects: Erases the range pointed to by b end e.
 //!
 //! Returns: An iterator to the element after the erased elements.
- //!
+ //!
 //! Complexity: Average complexity for erase range is amortized
 //! O(log(size() + N)), where N is the number of elements in the range.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 iterator erase(const_iterator b, const_iterator e)
 { return tree_.erase(b, e); }

 //! Effects: Erases all the elements with the given value.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: Amortized O(log(size() + this->count(value)).
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 size_type erase(const_reference value)
@@ -1679,13 +1679,13 @@

 //! Effects: Erases all the elements that compare equal with
 //! the given key and the given comparison functor.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: Amortized O(log(size() + this->count(key, comp)).
- //!
+ //!
 //! Throws: If comp ordering function throws. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class KeyType, class KeyValueCompare>
@@ -1700,14 +1700,14 @@
 //!
 //! Returns: An iterator to the element after the erased element.
 //!
- //! Effects: Erases the element pointed to by pos.
+ //! Effects: Erases the element pointed to by pos.
 //! Disposer::operator()(pointer) is called for the removed element.
- //!
- //! Complexity: Average complexity for erase element is constant time.
- //!
+ //!
+ //! Complexity: Average complexity for erase element is constant time.
+ //!
 //! Throws: Nothing.
- //!
- //! Note: Invalidates the iterators
+ //!
+ //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
 iterator erase_and_dispose(const_iterator i, Disposer disposer)
@@ -1725,12 +1725,12 @@
 //!
 //! Effects: Erases the range pointed to by b end e.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
+ //!
 //! Complexity: Average complexity for erase range is amortized
 //! O(log(size() + N)), where N is the number of elements in the range.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
@@ -1741,13 +1741,13 @@
 //!
 //! Effects: Erases all the elements with the given value.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: Amortized O(log(size() + this->count(value)).
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class Disposer>
@@ -1761,11 +1761,11 @@
 //! Disposer::operator()(pointer) is called for the removed elements.
 //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: Amortized O(log(size() + this->count(key, comp)).
- //!
+ //!
 //! Throws: If comp ordering function throws. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class KeyType, class KeyValueCompare, class Disposer>
@@ -1777,26 +1777,26 @@
 { return tree_.erase_and_dispose(key, comp, disposer); }

 //! Effects: Erases all the elements of the container.
- //!
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 void clear()
 { return tree_.clear(); }

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
- //!
+ //!
 //! Effects: Erases all the elements of the container.
- //!
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class Disposer>
@@ -1804,40 +1804,40 @@
 { return tree_.clear_and_dispose(disposer); }

 //! Effects: Returns the number of contained elements with the given key
- //!
+ //!
 //! Complexity: Amortized logarithmic to the number of elements contained plus lineal
 //! to number of objects with the given key.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 size_type count(const_reference value)
 { return tree_.count(value); }

 //! Effects: Returns the number of contained elements with the same key
 //! compared with the given comparison functor.
- //!
+ //!
 //! Complexity: Amortized logarithmic to the number of elements contained plus lineal
 //! to number of objects with the given key.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 template<class KeyType, class KeyValueCompare>
 size_type count(const KeyType& key, KeyValueCompare comp)
 { return tree_.count(key, comp); }

 //! Effects: Returns the number of contained elements with the given key
- //!
+ //!
 //! Complexity: Logarithmic to the number of elements contained plus lineal
 //! to number of objects with the given key.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 size_type count_dont_splay(const_reference value) const
 { return tree_.count_dont_splay(value); }

 //! Effects: Returns the number of contained elements with the same key
 //! compared with the given comparison functor.
- //!
+ //!
 //! Complexity: Logarithmic to the number of elements contained plus lineal
 //! to number of objects with the given key.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 template<class KeyType, class KeyValueCompare>
 size_type count_dont_splay(const KeyType& key, KeyValueCompare comp) const
@@ -1845,9 +1845,9 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is not less than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Amortized logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 iterator lower_bound(const_reference value)
 { return tree_.lower_bound(value); }
@@ -1857,13 +1857,13 @@
 //! that is used in the ordering functor.
 //!
 //! Effects: Returns an iterator to the first element whose
- //! key according to the comparison functor is not less than k or
+ //! key according to the comparison functor is not less than k or
 //! end() if that element does not exist.
- //!
+ //!
 //! Complexity: Amortized logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
- //!
+ //!
 //! Note: This function is used when constructing a value_type
 //! is expensive and the value_type can be compared with a cheaper
 //! key type. Usually this key is part of the value_type.
@@ -1873,9 +1873,9 @@

 //! Effects: Returns a const iterator to the first element whose
 //! key is not less than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 const_iterator lower_bound_dont_splay(const_reference value) const
 { return tree_.lower_bound_dont_splay(value); }
@@ -1885,13 +1885,13 @@
 //! that is used in the ordering functor.
 //!
 //! Effects: Returns a const_iterator to the first element whose
- //! key according to the comparison functor is not less than k or
+ //! key according to the comparison functor is not less than k or
 //! end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
- //!
+ //!
 //! Note: This function is used when constructing a value_type
 //! is expensive and the value_type can be compared with a cheaper
 //! key type. Usually this key is part of the value_type.
@@ -1901,9 +1901,9 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is greater than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Amortized logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 iterator upper_bound(const_reference value)
 { return tree_.upper_bound(value); }
@@ -1913,11 +1913,11 @@
 //! that is used in the ordering functor.
 //!
 //! Effects: Returns an iterator to the first element whose
- //! key according to the comparison functor is greater than key or
+ //! key according to the comparison functor is greater than key or
 //! end() if that element does not exist.
- //!
+ //!
 //! Complexity: Amortized logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -1929,9 +1929,9 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is greater than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 const_iterator upper_bound_dont_splay(const_reference value) const
 { return tree_.upper_bound_dont_splay(value); }
@@ -1941,11 +1941,11 @@
 //! that is used in the ordering functor.
 //!
 //! Effects: Returns a const_iterator to the first element whose
- //! key according to the comparison functor is greater than key or
+ //! key according to the comparison functor is greater than key or
 //! end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -1955,11 +1955,11 @@
 const_iterator upper_bound_dont_splay(const KeyType& key, KeyValueCompare comp) const
 { return tree_.upper_bound_dont_splay(key, comp); }

- //! Effects: Finds an iterator to the first element whose value is
+ //! Effects: Finds an iterator to the first element whose value is
 //! "value" or end() if that element does not exist.
 //!
 //! Complexity: Amortized logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 iterator find(const_reference value)
 { return tree_.find(value); }
@@ -1968,12 +1968,12 @@
 //! value_compare. Usually key is the part of the value_type
 //! that is used in the ordering functor.
 //!
- //! Effects: Finds an iterator to the first element whose key is
- //! "key" according to the comparison functor or end() if that element
+ //! Effects: Finds an iterator to the first element whose key is
+ //! "key" according to the comparison functor or end() if that element
 //! does not exist.
 //!
 //! Complexity: Amortized logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -1983,11 +1983,11 @@
 iterator find(const KeyType& key, KeyValueCompare comp)
 { return tree_.find(key, comp); }

- //! Effects: Finds a const_iterator to the first element whose value is
+ //! Effects: Finds a const_iterator to the first element whose value is
 //! "value" or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 const_iterator find_dont_splay(const_reference value) const
 { return tree_.find_dont_splay(value); }
@@ -1996,12 +1996,12 @@
 //! value_compare. Usually key is the part of the value_type
 //! that is used in the ordering functor.
 //!
- //! Effects: Finds a const_iterator to the first element whose key is
- //! "key" according to the comparison functor or end() if that element
+ //! Effects: Finds a const_iterator to the first element whose key is
+ //! "key" according to the comparison functor or end() if that element
 //! does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -2014,9 +2014,9 @@
 //! Effects: Finds a range containing all elements whose key is k or
 //! an empty range that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Amortized logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 std::pair<iterator,iterator> equal_range(const_reference value)
 { return tree_.equal_range(value); }
@@ -2025,13 +2025,13 @@
 //! value_compare. Usually key is the part of the value_type
 //! that is used in the ordering functor.
 //!
- //! Effects: Finds a range containing all elements whose key is k
- //! according to the comparison functor or an empty range
+ //! Effects: Finds a range containing all elements whose key is k
+ //! according to the comparison functor or an empty range
 //! that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Amortized logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -2044,9 +2044,9 @@
 //! Effects: Finds a range containing all elements whose key is k or
 //! an empty range that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 std::pair<const_iterator, const_iterator>
 equal_range_dont_splay(const_reference value) const
@@ -2056,13 +2056,13 @@
 //! value_compare. Usually key is the part of the value_type
 //! that is used in the ordering functor.
 //!
- //! Effects: Finds a range containing all elements whose key is k
- //! according to the comparison functor or an empty range
+ //! Effects: Finds a range containing all elements whose key is k
+ //! according to the comparison functor or an empty range
 //! that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -2075,14 +2075,14 @@

 //! Requires: value must be an lvalue and shall be in a set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid iterator i belonging to the set
 //! that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This static function is available only if the value traits
 //! is stateless.
 static iterator s_iterator_to(reference value)
@@ -2090,14 +2090,14 @@

 //! Requires: value must be an lvalue and shall be in a set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid const_iterator i belonging to the
 //! set that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This static function is available only if the value traits
 //! is stateless.
 static const_iterator s_iterator_to(const_reference value)
@@ -2105,48 +2105,48 @@

 //! Requires: value must be an lvalue and shall be in a set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid iterator i belonging to the set
 //! that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator iterator_to(reference value)
 { return tree_.iterator_to(value); }

 //! Requires: value must be an lvalue and shall be in a set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid const_iterator i belonging to the
 //! set that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator iterator_to(const_reference value) const
 { return tree_.iterator_to(value); }

 //! Requires: value shall not be in a set/splay_multiset.
- //!
+ //!
 //! Effects: init_node puts the hook of a value in a well-known default
 //! state.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Note: This function puts the hook in the well-known default state
 //! used by auto_unlink and safe hooks.
 static void init_node(reference value)
 { tree_type::init_node(value); }

 //! Effects: Unlinks the leftmost node from the tree.
- //!
+ //!
 //! Complexity: Average complexity is constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Notes: This function breaks the tree and the tree can
 //! only be used for more unlink_leftmost_without_rebalance calls.
 //! This function is normally used to achieve a step by step
@@ -2156,14 +2156,14 @@

 //! Requires: replace_this must be a valid iterator of *this
 //! and with_this must not be inserted in any tree.
- //!
+ //!
 //! Effects: Replaces replace_this in its position in the
 //! tree with with_this. The tree does not need to be rebalanced.
- //!
- //! Complexity: Constant.
- //!
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function will break container ordering invariants if
 //! with_this is not equivalent to *replace_this according to the
 //! ordering rules. This function is faster than erasing and inserting
@@ -2172,12 +2172,12 @@
 { tree_.replace_node(replace_this, with_this); }

 //! Requires: i must be a valid iterator of *this.
- //!
+ //!
 //! Effects: Rearranges the splay set so that the element pointed by i
 //! is placed as the root of the tree, improving future searches of this value.
- //!
+ //!
 //! Complexity: Amortized logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 void splay_up(iterator i)
 { tree_.splay_up(i); }
@@ -2186,9 +2186,9 @@
 //! with a key equivalent to value the element is placed as the root of the
 //! tree. If the element is not present returns the last node compared with the key.
 //! If the tree is empty, end() is returned.
- //!
+ //!
 //! Complexity: Amortized logarithmic.
- //!
+ //!
 //! Returns: An iterator to the new root of the tree, end() if the tree is empty.
 //!
 //! Throws: If the comparison functor throws.
@@ -2199,9 +2199,9 @@
 //! Effects: Rearranges the splay set so that if *this stores an element
 //! with a key equivalent to value the element is placed as the root of the
 //! tree.
- //!
+ //!
 //! Complexity: Amortized logarithmic.
- //!
+ //!
 //! Returns: An iterator to the new root of the tree, end() if the tree is empty.
 //!
 //! Throws: If the predicate throws.
@@ -2209,21 +2209,21 @@
 { return tree_.splay_down(value); }

 //! Effects: Rebalances the tree.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear.
 void rebalance()
 { tree_.rebalance(); }

 //! Requires: old_root is a node of a tree.
- //!
+ //!
 //! Effects: Rebalances the subtree rooted at old_root.
 //!
 //! Returns: The new root of the subtree.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the elements in the subtree.
 iterator rebalance_subtree(iterator root)
 { return tree_.rebalance_subtree(root); }
@@ -2314,7 +2314,7 @@
{
 /// @cond
 typedef splay_multiset_impl
- < typename make_splaytree_opt<T,
+ < typename make_splaytree_opt<T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
@@ -2334,7 +2334,7 @@
template<class T, class ...Options>
#endif
class splay_multiset
- : public make_splay_multiset<T,
+ : public make_splay_multiset<T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
@@ -2343,7 +2343,7 @@
>::type
{
 typedef typename make_splay_multiset
- <T,
+ <T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
@@ -2395,8 +2395,8 @@

#endif

-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Modified: branches/release/boost/intrusive/splay_set_hook.hpp
==============================================================================
--- branches/release/boost/intrusive/splay_set_hook.hpp (original)
+++ branches/release/boost/intrusive/splay_set_hook.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -43,7 +43,7 @@
{
 /// @cond
 typedef typename pack_options
- < hook_defaults,
+ < hook_defaults,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3
 #else
@@ -61,16 +61,16 @@
 typedef implementation_defined type;
};

-//! Derive a class from splay_set_base_hook in order to store objects in
-//! in a splay_set/splay_multiset. splay_set_base_hook holds the data necessary to maintain
+//! Derive a class from splay_set_base_hook in order to store objects in
+//! in a splay_set/splay_multiset. splay_set_base_hook holds the data necessary to maintain
//! the splay_set/splay_multiset and provides an appropriate value_traits class for splay_set/splay_multiset.
-//!
+//!
//! The hook admits the following options: \c tag<>, \c void_pointer<>,
//! \c link_mode<> and \c optimize_size<>.
//!
-//! \c tag<> defines a tag to identify the node.
-//! The same tag value can be used in different classes, but if a class is
-//! derived from more than one \c list_base_hook, then each \c list_base_hook needs its
+//! \c tag<> defines a tag to identify the node.
+//! The same tag value can be used in different classes, but if a class is
+//! derived from more than one \c list_base_hook, then each \c list_base_hook needs its
//! unique tag.
//!
//! \c void_pointer<> is the pointer type that will be used internally in the hook
@@ -96,27 +96,27 @@
 public:
 //! Effects: If link_mode is \c auto_unlink or \c safe_link
 //! initializes the node to an unlinked state.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 splay_set_base_hook();

 //! Effects: If link_mode is \c auto_unlink or \c safe_link
 //! initializes the node to an unlinked state. The argument is ignored.
- //!
- //! Throws: Nothing.
- //!
+ //!
+ //! Throws: Nothing.
+ //!
 //! Rationale: Providing a copy-constructor
- //! makes classes using the hook STL-compliant without forcing the
+ //! makes classes using the hook STL-compliant without forcing the
 //! user to do some additional work. \c swap can be used to emulate
 //! move-semantics.
 splay_set_base_hook(const splay_set_base_hook& );

 //! Effects: Empty function. The argument is ignored.
- //!
- //! Throws: Nothing.
- //!
- //! Rationale: Providing an assignment operator
- //! makes classes using the hook STL-compliant without forcing the
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Rationale: Providing an assignment operator
+ //! makes classes using the hook STL-compliant without forcing the
 //! user to do some additional work. \c swap can be used to emulate
 //! move-semantics.
 splay_set_base_hook& operator=(const splay_set_base_hook& );
@@ -125,37 +125,37 @@
 //! nothing (ie. no code is generated). If link_mode is \c safe_link and the
 //! object is stored in a set an assertion is raised. If link_mode is
 //! \c auto_unlink and \c is_linked() is true, the node is unlinked.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 ~splay_set_base_hook();

- //! Effects: Swapping two nodes swaps the position of the elements
- //! related to those nodes in one or two containers. That is, if the node
- //! this is part of the element e1, the node x is part of the element e2
- //! and both elements are included in the containers s1 and s2, then after
- //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1
- //! at the position of e1. If one element is not in a container, then
- //! after the swap-operation the other element is not in a container.
- //! Iterators to e1 and e2 related to those nodes are invalidated.
+ //! Effects: Swapping two nodes swaps the position of the elements
+ //! related to those nodes in one or two containers. That is, if the node
+ //! this is part of the element e1, the node x is part of the element e2
+ //! and both elements are included in the containers s1 and s2, then after
+ //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1
+ //! at the position of e1. If one element is not in a container, then
+ //! after the swap-operation the other element is not in a container.
+ //! Iterators to e1 and e2 related to those nodes are invalidated.
 //!
- //! Complexity: Constant
+ //! Complexity: Constant
 //!
- //! Throws: Nothing.
+ //! Throws: Nothing.
 void swap_nodes(splay_set_base_hook &other);

 //! Precondition: link_mode must be \c safe_link or \c auto_unlink.
 //!
 //! Returns: true, if the node belongs to a container, false
- //! otherwise. This function can be used to test whether \c set::iterator_to
- //! will return a valid iterator.
+ //! otherwise. This function can be used to test whether \c set::iterator_to
+ //! will return a valid iterator.
 //!
- //! Complexity: Constant
+ //! Complexity: Constant
 bool is_linked() const;

 //! Effects: Removes the node if it's inserted in a container.
 //! This function is only allowed if link_mode is \c auto_unlink.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 void unlink();
 #endif
};
@@ -171,7 +171,7 @@
{
 /// @cond
 typedef typename pack_options
- < hook_defaults,
+ < hook_defaults,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3
 #else
@@ -193,7 +193,7 @@
//! class in a splay_set/splay_multiset. splay_set_member_hook holds the data
//! necessary for maintaining the splay_set/splay_multiset and provides an appropriate
//! value_traits class for splay_set/splay_multiset.
-//!
+//!
//! The hook admits the following options: \c void_pointer<>,
//! \c link_mode<> and \c optimize_size<>.
//!
@@ -220,27 +220,27 @@
 public:
 //! Effects: If link_mode is \c auto_unlink or \c safe_link
 //! initializes the node to an unlinked state.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 splay_set_member_hook();

 //! Effects: If link_mode is \c auto_unlink or \c safe_link
 //! initializes the node to an unlinked state. The argument is ignored.
- //!
- //! Throws: Nothing.
- //!
+ //!
+ //! Throws: Nothing.
+ //!
 //! Rationale: Providing a copy-constructor
- //! makes classes using the hook STL-compliant without forcing the
+ //! makes classes using the hook STL-compliant without forcing the
 //! user to do some additional work. \c swap can be used to emulate
 //! move-semantics.
 splay_set_member_hook(const splay_set_member_hook& );

 //! Effects: Empty function. The argument is ignored.
- //!
- //! Throws: Nothing.
- //!
- //! Rationale: Providing an assignment operator
- //! makes classes using the hook STL-compliant without forcing the
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Rationale: Providing an assignment operator
+ //! makes classes using the hook STL-compliant without forcing the
 //! user to do some additional work. \c swap can be used to emulate
 //! move-semantics.
 splay_set_member_hook& operator=(const splay_set_member_hook& );
@@ -249,43 +249,43 @@
 //! nothing (ie. no code is generated). If link_mode is \c safe_link and the
 //! object is stored in a set an assertion is raised. If link_mode is
 //! \c auto_unlink and \c is_linked() is true, the node is unlinked.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 ~splay_set_member_hook();

- //! Effects: Swapping two nodes swaps the position of the elements
- //! related to those nodes in one or two containers. That is, if the node
- //! this is part of the element e1, the node x is part of the element e2
- //! and both elements are included in the containers s1 and s2, then after
- //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1
- //! at the position of e1. If one element is not in a container, then
- //! after the swap-operation the other element is not in a container.
- //! Iterators to e1 and e2 related to those nodes are invalidated.
+ //! Effects: Swapping two nodes swaps the position of the elements
+ //! related to those nodes in one or two containers. That is, if the node
+ //! this is part of the element e1, the node x is part of the element e2
+ //! and both elements are included in the containers s1 and s2, then after
+ //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1
+ //! at the position of e1. If one element is not in a container, then
+ //! after the swap-operation the other element is not in a container.
+ //! Iterators to e1 and e2 related to those nodes are invalidated.
 //!
- //! Complexity: Constant
+ //! Complexity: Constant
 //!
- //! Throws: Nothing.
+ //! Throws: Nothing.
 void swap_nodes(splay_set_member_hook &other);

 //! Precondition: link_mode must be \c safe_link or \c auto_unlink.
 //!
 //! Returns: true, if the node belongs to a container, false
- //! otherwise. This function can be used to test whether \c set::iterator_to
- //! will return a valid iterator.
+ //! otherwise. This function can be used to test whether \c set::iterator_to
+ //! will return a valid iterator.
 //!
- //! Complexity: Constant
+ //! Complexity: Constant
 bool is_linked() const;

 //! Effects: Removes the node if it's inserted in a container.
 //! This function is only allowed if link_mode is \c auto_unlink.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 void unlink();
 #endif
};

-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Modified: branches/release/boost/intrusive/splaytree.hpp
==============================================================================
--- branches/release/boost/intrusive/splaytree.hpp (original)
+++ branches/release/boost/intrusive/splaytree.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -63,8 +63,8 @@
/// @endcond

//! The class template splaytree is an intrusive splay tree container that
-//! is used to construct intrusive splay_set and splay_multiset containers. The no-throw
-//! guarantee holds only, if the value_compare object
+//! is used to construct intrusive splay_set and splay_multiset containers. The no-throw
+//! guarantee holds only, if the value_compare object
//! doesn't throw.
//!
//! The template parameter \c T is the type to be managed by the container.
@@ -129,7 +129,7 @@
 //noncopyable
 BOOST_MOVABLE_BUT_NOT_COPYABLE(splaytree_impl)

- enum { safemode_or_autounlink =
+ enum { safemode_or_autounlink =
 (int)real_value_traits::link_mode == (int)auto_unlink ||
 (int)real_value_traits::link_mode == (int)safe_link };

@@ -155,7 +155,7 @@
 {}
 node_plus_pred_t node_plus_pred_;
 } data_;
-
+
 const value_compare &priv_comp() const
 { return data_.node_plus_pred_.get(); }

@@ -207,18 +207,18 @@

 typedef typename node_algorithms::insert_commit_data insert_commit_data;

- //! Effects: Constructs an empty tree.
- //!
+ //! Effects: Constructs an empty tree.
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
 //! or the copy constructorof the value_compare object throws. Basic guarantee.
 splaytree_impl( const value_compare &cmp = value_compare()
- , const value_traits &v_traits = value_traits())
+ , const value_traits &v_traits = value_traits())
 : data_(cmp, v_traits)
- {
- node_algorithms::init_header(this->priv_header_ptr());
+ {
+ node_algorithms::init_header(this->priv_header_ptr());
 this->priv_size_traits().set_size(size_type(0));
 }

@@ -230,7 +230,7 @@
 //!
 //! Complexity: Linear in N if [b, e) is already sorted using
 //! comp and otherwise amortized N * log N, where N is the distance between first and last.
- //!
+ //!
 //! Throws: If value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
 //! or the copy constructor/operator() of the value_compare object throws. Basic guarantee.
@@ -249,59 +249,59 @@
 }

 //! Effects: to-do
- //!
+ //!
 splaytree_impl(BOOST_RV_REF(splaytree_impl) x)
 : data_(::boost::move(x.priv_comp()), ::boost::move(x.priv_value_traits()))
 {
- node_algorithms::init_header(this->priv_header_ptr());
+ node_algorithms::init_header(this->priv_header_ptr());
 this->priv_size_traits().set_size(size_type(0));
 this->swap(x);
 }

 //! Effects: to-do
- //!
- splaytree_impl& operator=(BOOST_RV_REF(splaytree_impl) x)
+ //!
+ splaytree_impl& operator=(BOOST_RV_REF(splaytree_impl) x)
 { this->swap(x); return *this; }

- //! Effects: Detaches all elements from this. The objects in the set
- //! are not deleted (i.e. no destructors are called), but the nodes according to
- //! the value_traits template parameter are reinitialized and thus can be reused.
- //!
+ //! Effects: Detaches all elements from this. The objects in the set
+ //! are not deleted (i.e. no destructors are called), but the nodes according to
+ //! the value_traits template parameter are reinitialized and thus can be reused.
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
- //!
+ //!
 //! Throws: Nothing.
- ~splaytree_impl()
+ ~splaytree_impl()
 {}

 //! Effects: Returns an iterator pointing to the beginning of the tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator begin()
 { return iterator(node_algorithms::begin_node(this->priv_header_ptr()), this); }

 //! Effects: Returns a const_iterator pointing to the beginning of the tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator begin() const
 { return cbegin(); }

 //! Effects: Returns a const_iterator pointing to the beginning of the tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator cbegin() const
 { return const_iterator(node_algorithms::begin_node(this->priv_header_ptr()), this); }

 //! Effects: Returns an iterator pointing to the end of the tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator end()
 { return iterator (this->priv_header_ptr(), this); }
@@ -309,138 +309,138 @@
 //! Effects: Returns a const_iterator pointing to the end of the tree.
 //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator end() const
 { return cend(); }

 //! Effects: Returns a const_iterator pointing to the end of the tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator cend() const
 { return const_iterator (uncast(this->priv_header_ptr()), this); }

 //! Effects: Returns a reverse_iterator pointing to the beginning of the
 //! reversed tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 reverse_iterator rbegin()
 { return reverse_iterator(end()); }

 //! Effects: Returns a const_reverse_iterator pointing to the beginning
 //! of the reversed tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator rbegin() const
 { return const_reverse_iterator(end()); }

 //! Effects: Returns a const_reverse_iterator pointing to the beginning
 //! of the reversed tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator crbegin() const
 { return const_reverse_iterator(end()); }

 //! Effects: Returns a reverse_iterator pointing to the end
 //! of the reversed tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 reverse_iterator rend()
 { return reverse_iterator(begin()); }

 //! Effects: Returns a const_reverse_iterator pointing to the end
 //! of the reversed tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator rend() const
 { return const_reverse_iterator(begin()); }

 //! Effects: Returns a const_reverse_iterator pointing to the end
 //! of the reversed tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator crend() const
 { return const_reverse_iterator(begin()); }

 //! Precondition: end_iterator must be a valid end iterator
 //! of splaytree.
- //!
+ //!
 //! Effects: Returns a const reference to the splaytree associated to the end iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 static splaytree_impl &container_from_end_iterator(iterator end_iterator)
 { return priv_container_from_end_iterator(end_iterator); }

 //! Precondition: end_iterator must be a valid end const_iterator
 //! of splaytree.
- //!
+ //!
 //! Effects: Returns a const reference to the splaytree associated to the end iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 static const splaytree_impl &container_from_end_iterator(const_iterator end_iterator)
 { return priv_container_from_end_iterator(end_iterator); }

 //! Precondition: it must be a valid iterator
 //! of rbtree.
- //!
+ //!
 //! Effects: Returns a const reference to the tree associated to the iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Logarithmic.
 static splaytree_impl &container_from_iterator(iterator it)
 { return priv_container_from_iterator(it); }

 //! Precondition: it must be a valid end const_iterator
 //! of rbtree.
- //!
+ //!
 //! Effects: Returns a const reference to the tree associated to the iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Logarithmic.
 static const splaytree_impl &container_from_iterator(const_iterator it)
 { return priv_container_from_iterator(it); }

 //! Effects: Returns the value_compare object used by the tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If value_compare copy-constructor throws.
 value_compare value_comp() const
 { return priv_comp(); }

 //! Effects: Returns true if the container is empty.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 bool empty() const
 { return this->cbegin() == this->cend(); }

 //! Effects: Returns the number of elements stored in the tree.
- //!
+ //!
 //! Complexity: Linear to elements contained in *this
 //! if constant-time size option is disabled. Constant time otherwise.
- //!
+ //!
 //! Throws: Nothing.
 size_type size() const
 {
@@ -453,9 +453,9 @@
 }

 //! Effects: Swaps the contents of two splaytrees.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If the comparison functor's swap call throws.
 void swap(splaytree_impl& other)
 {
@@ -472,14 +472,14 @@
 }

 //! Requires: value must be an lvalue
- //!
+ //!
 //! Effects: Inserts value into the tree before the lower bound.
- //!
+ //!
 //! Complexity: Average complexity for insert element is amortized
 //! logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Strong guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 iterator insert_equal(reference value)
@@ -497,16 +497,16 @@

 //! Requires: value must be an lvalue, and "hint" must be
 //! a valid iterator.
- //!
+ //!
 //! Effects: Inserts x into the tree, using "hint" as a hint to
 //! where it will be inserted. If "hint" is the upper_bound
 //! the insertion takes constant time (two comparisons in the worst case)
- //!
+ //!
 //! Complexity: Amortized logarithmic in general, but it is amortized
 //! constant time if t is inserted immediately before hint.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Strong guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 iterator insert_equal(const_iterator hint, reference value)
@@ -522,18 +522,18 @@
 return ret;
 }

- //! Requires: Dereferencing iterator must yield an lvalue
+ //! Requires: Dereferencing iterator must yield an lvalue
 //! of type value_type.
- //!
+ //!
 //! Effects: Inserts a each element of a range into the tree
 //! before the upper bound of the key of each element.
- //!
+ //!
 //! Complexity: Insert range is in general amortized O(N * log(N)), where N is the
 //! size of the range. However, it is linear in N if the range is already sorted
 //! by value_comp().
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 template<class Iterator>
@@ -547,14 +547,14 @@
 }

 //! Requires: value must be an lvalue
- //!
+ //!
 //! Effects: Inserts value into the tree if the value
 //! is not already present.
- //!
+ //!
 //! Complexity: Amortized logarithmic.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 std::pair<iterator, bool> insert_unique(reference value)
@@ -568,16 +568,16 @@

 //! Requires: value must be an lvalue, and "hint" must be
 //! a valid iterator
- //!
+ //!
 //! Effects: Tries to insert x into the tree, using "hint" as a hint
 //! to where it will be inserted.
- //!
+ //!
 //! Complexity: Amortized logarithmic in general, but it is amortized
 //! constant time (two comparisons in the worst case)
 //! if t is inserted immediately before hint.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 iterator insert_unique(const_iterator hint, reference value)
@@ -589,17 +589,17 @@
 return insert_unique_commit(value, commit_data);
 }

- //! Requires: Dereferencing iterator must yield an lvalue
+ //! Requires: Dereferencing iterator must yield an lvalue
 //! of type value_type.
- //!
+ //!
 //! Effects: Tries to insert each element of a range into the tree.
- //!
- //! Complexity: Insert range is in general amortized O(N * log(N)), where N is the
- //! size of the range. However, it is linear in N if the range is already sorted
+ //!
+ //! Complexity: Insert range is in general amortized O(N * log(N)), where N is the
+ //! size of the range. However, it is linear in N if the range is already sorted
 //! by value_comp().
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 template<class Iterator>
@@ -609,10 +609,10 @@
 this->insert_unique(*b);
 }

- //! Requires: key_value_comp must be a comparison function that induces
+ //! Requires: key_value_comp must be a comparison function that induces
 //! the same strict weak ordering as value_compare. The difference is that
 //! key_value_comp compares an arbitrary key with the contained values.
- //!
+ //!
 //! Effects: Checks if a value can be inserted in the container, using
 //! a user provided key instead of the value itself.
 //!
@@ -621,16 +621,16 @@
 //! and false. If the value can be inserted returns true in the returned
 //! pair boolean and fills "commit_data" that is meant to be used with
 //! the "insert_commit" function.
- //!
+ //!
 //! Complexity: Average complexity is at most logarithmic.
 //!
 //! Throws: If the key_value_comp ordering function throws. Strong guarantee.
- //!
+ //!
 //! Notes: This function is used to improve performance when constructing
 //! a value_type is expensive: if there is an equivalent value
 //! the constructed object must be discarded. Many times, the part of the
 //! node that is used to impose the order is much cheaper to construct
- //! than the value_type and this function offers the possibility to use that
+ //! than the value_type and this function offers the possibility to use that
 //! part to check if the insertion will be successful.
 //!
 //! If the check is successful, the user can construct the value_type and use
@@ -645,18 +645,18 @@
 {
 detail::key_nodeptr_comp<KeyValueCompare, splaytree_impl>
 comp(key_value_comp, this);
- std::pair<node_ptr, bool> ret =
+ std::pair<node_ptr, bool> ret =
 (node_algorithms::insert_unique_check
 (this->priv_header_ptr(), key, comp, commit_data));
 return std::pair<iterator, bool>(iterator(ret.first, this), ret.second);
 }

- //! Requires: key_value_comp must be a comparison function that induces
+ //! Requires: key_value_comp must be a comparison function that induces
 //! the same strict weak ordering as value_compare. The difference is that
 //! key_value_comp compares an arbitrary key with the contained values.
- //!
+ //!
 //! Effects: Checks if a value can be inserted in the container, using
- //! a user provided key instead of the value itself, using "hint"
+ //! a user provided key instead of the value itself, using "hint"
 //! as a hint to where it will be inserted.
 //!
 //! Returns: If there is an equivalent value
@@ -664,23 +664,23 @@
 //! and false. If the value can be inserted returns true in the returned
 //! pair boolean and fills "commit_data" that is meant to be used with
 //! the "insert_commit" function.
- //!
+ //!
 //! Complexity: Logarithmic in general, but it's amortized
 //! constant time if t is inserted immediately before hint.
 //!
 //! Throws: If the key_value_comp ordering function throws. Strong guarantee.
- //!
+ //!
 //! Notes: This function is used to improve performance when constructing
 //! a value_type is expensive: if there is an equivalent value
 //! the constructed object must be discarded. Many times, the part of the
 //! constructing that is used to impose the order is much cheaper to construct
- //! than the value_type and this function offers the possibility to use that key
+ //! than the value_type and this function offers the possibility to use that key
 //! to check if the insertion will be successful.
 //!
 //! If the check is successful, the user can construct the value_type and use
 //! "insert_commit" to insert the object in constant-time. This can give a total
 //! constant-time complexity to the insertion: check(O(1)) + commit(O(1)).
- //!
+ //!
 //! "commit_data" remains valid for a subsequent "insert_commit" only if no more
 //! objects are inserted or erased from the container.
 template<class KeyType, class KeyValueCompare>
@@ -690,7 +690,7 @@
 {
 detail::key_nodeptr_comp<KeyValueCompare, splaytree_impl>
 comp(key_value_comp, this);
- std::pair<node_ptr, bool> ret =
+ std::pair<node_ptr, bool> ret =
 node_algorithms::insert_unique_check
 (this->priv_header_ptr(), hint.pointed_node(), key, comp, commit_data);
 return std::pair<iterator, bool>(iterator(ret.first, this), ret.second);
@@ -700,16 +700,16 @@
 //! must have been obtained from a previous call to "insert_check".
 //! No objects should have been inserted or erased from the container between
 //! the "insert_check" that filled "commit_data" and the call to "insert_commit".
- //!
+ //!
 //! Effects: Inserts the value in the avl_set using the information obtained
 //! from the "commit_data" that a previous "insert_check" filled.
 //!
 //! Returns: An iterator to the newly inserted object.
- //!
+ //!
 //! Complexity: Constant time.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Notes: This function has only sense if a "insert_check" has been
 //! previously executed to fill "commit_data". No value should be inserted or
 //! erased between the "insert_check" and "insert_commit" calls.
@@ -724,12 +724,12 @@
 return iterator(to_insert, this);
 }

- //! Effects: Erases the element pointed to by pos.
- //!
- //! Complexity: Average complexity for erase element is constant time.
- //!
+ //! Effects: Erases the element pointed to by pos.
+ //!
+ //! Complexity: Average complexity for erase element is constant time.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 iterator erase(const_iterator i)
@@ -746,26 +746,26 @@
 return ret.unconst();
 }

- //! Effects: Erases the range pointed to by b end e.
- //!
+ //! Effects: Erases the range pointed to by b end e.
+ //!
 //! Complexity: Average complexity for erase range is amortized
 //! O(log(size() + N)), where N is the number of elements in the range.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 iterator erase(const_iterator b, const_iterator e)
 { size_type n; return private_erase(b, e, n); }

 //! Effects: Erases all the elements with the given value.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: Amortized O(log(size() + N).
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 size_type erase(const_reference value)
@@ -775,11 +775,11 @@
 //! according to the comparison functor "comp".
 //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: Amortized O(log(size() + N).
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class KeyType, class KeyValueCompare>
@@ -797,14 +797,14 @@

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
 //!
- //! Effects: Erases the element pointed to by pos.
+ //! Effects: Erases the element pointed to by pos.
 //! Disposer::operator()(pointer) is called for the removed element.
- //!
- //! Complexity: Average complexity for erase element is constant time.
- //!
+ //!
+ //! Complexity: Average complexity for erase element is constant time.
+ //!
 //! Throws: Nothing.
- //!
- //! Note: Invalidates the iterators
+ //!
+ //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
 iterator erase_and_dispose(const_iterator i, Disposer disposer)
@@ -825,12 +825,12 @@
 //!
 //! Effects: Erases the range pointed to by b end e.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
+ //!
 //! Complexity: Average complexity for erase range is amortized
 //! O(log(size() + N)), where N is the number of elements in the range.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
@@ -841,13 +841,13 @@
 //!
 //! Effects: Erases all the elements with the given value.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: Amortized O(log(size() + N).
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class Disposer>
@@ -866,11 +866,11 @@
 //! Disposer::operator()(pointer) is called for the removed elements.
 //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: Amortized O(log(size() + N).
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class KeyType, class KeyValueCompare, class Disposer>
@@ -886,13 +886,13 @@
 return n;
 }

- //! Effects: Erases all of the elements.
- //!
+ //! Effects: Erases all of the elements.
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 void clear()
@@ -910,9 +910,9 @@
 //! each node to be erased.
 //! Complexity: Amortized O(log(size() + N)),
 //! where N is the number of elements in the container.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. Calls N times to disposer functor.
 template<class Disposer>
@@ -924,19 +924,19 @@
 }

 //! Effects: Returns the number of contained elements with the given value
- //!
+ //!
 //! Complexity: Amortized logarithmic to the number of elements contained plus lineal
 //! to number of objects with the given value.
- //!
+ //!
 //! Throws: Nothing.
 size_type count(const_reference value)
 { return this->count(value, priv_comp()); }

 //! Effects: Returns the number of contained elements with the given key
- //!
+ //!
 //! Complexity: Amortized logarithmic to the number of elements contained plus lineal
 //! to number of objects with the given key.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 size_type count(const KeyType &key, KeyValueCompare comp)
@@ -946,19 +946,19 @@
 }

 //! Effects: Returns the number of contained elements with the given value
- //!
+ //!
 //! Complexity: Amortized logarithmic to the number of elements contained plus lineal
 //! to number of objects with the given value.
- //!
+ //!
 //! Throws: Nothing.
 size_type count_dont_splay(const_reference value) const
 { return this->count_dont_splay(value, priv_comp()); }

 //! Effects: Returns the number of contained elements with the given key
- //!
+ //!
 //! Complexity: Amortized logarithmic to the number of elements contained plus lineal
 //! to number of objects with the given key.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 size_type count_dont_splay(const KeyType &key, KeyValueCompare comp) const
@@ -969,27 +969,27 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is not less than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Amortized logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 iterator lower_bound(const_reference value)
 { return this->lower_bound(value, priv_comp()); }

 //! Effects: Returns an iterator to the first element whose
 //! key is not less than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator lower_bound_dont_splay(const_reference value) const
 { return this->lower_bound_dont_splay(value, priv_comp()); }

 //! Effects: Returns an iterator to the first element whose
 //! key is not less than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 iterator lower_bound(const KeyType &key, KeyValueCompare comp)
@@ -1002,9 +1002,9 @@

 //! Effects: Returns a const iterator to the first element whose
 //! key is not less than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 const_iterator lower_bound_dont_splay(const KeyType &key, KeyValueCompare comp) const
@@ -1017,9 +1017,9 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is greater than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Amortized logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 iterator upper_bound(const_reference value)
 { return this->upper_bound(value, priv_comp()); }
@@ -1029,7 +1029,7 @@
 //! does not exist.
 //!
 //! Complexity: Amortized logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 iterator upper_bound(const KeyType &key, KeyValueCompare comp)
@@ -1042,9 +1042,9 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is greater than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator upper_bound_dont_splay(const_reference value) const
 { return this->upper_bound_dont_splay(value, priv_comp()); }
@@ -1054,7 +1054,7 @@
 //! does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 const_iterator upper_bound_dont_splay(const KeyType &key, KeyValueCompare comp) const
@@ -1065,20 +1065,20 @@
 (this->priv_header_ptr(), key, key_node_comp, false), this);
 }

- //! Effects: Finds an iterator to the first element whose key is
+ //! Effects: Finds an iterator to the first element whose key is
 //! k or end() if that element does not exist.
 //!
 //! Complexity: Amortized logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 iterator find(const_reference value)
 { return this->find(value, priv_comp()); }

- //! Effects: Finds an iterator to the first element whose key is
+ //! Effects: Finds an iterator to the first element whose key is
 //! k or end() if that element does not exist.
 //!
 //! Complexity: Amortized logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 iterator find(const KeyType &key, KeyValueCompare comp)
@@ -1089,20 +1089,20 @@
 (node_algorithms::find(this->priv_header_ptr(), key, key_node_comp), this);
 }

- //! Effects: Finds a const_iterator to the first element whose key is
+ //! Effects: Finds a const_iterator to the first element whose key is
 //! k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator find_dont_splay(const_reference value) const
 { return this->find_dont_splay(value, priv_comp()); }

- //! Effects: Finds a const_iterator to the first element whose key is
+ //! Effects: Finds a const_iterator to the first element whose key is
 //! k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 const_iterator find_dont_splay(const KeyType &key, KeyValueCompare comp) const
@@ -1116,9 +1116,9 @@
 //! Effects: Finds a range containing all elements whose key is k or
 //! an empty range that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Amortized logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 std::pair<iterator,iterator> equal_range(const_reference value)
 { return this->equal_range(value, priv_comp()); }
@@ -1126,9 +1126,9 @@
 //! Effects: Finds a range containing all elements whose key is k or
 //! an empty range that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Amortized logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 std::pair<iterator,iterator> equal_range(const KeyType &key, KeyValueCompare comp)
@@ -1143,9 +1143,9 @@
 //! Effects: Finds a range containing all elements whose key is k or
 //! an empty range that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 std::pair<const_iterator, const_iterator>
 equal_range_dont_splay(const_reference value) const
@@ -1154,9 +1154,9 @@
 //! Effects: Finds a range containing all elements whose key is k or
 //! an empty range that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 std::pair<const_iterator, const_iterator>
@@ -1173,15 +1173,15 @@
 //! Cloner should yield to nodes equivalent to the original nodes.
 //!
 //! Effects: Erases all the elements from *this
- //! calling Disposer::operator()(pointer), clones all the
+ //! calling Disposer::operator()(pointer), clones all the
 //! elements from src calling Cloner::operator()(const_reference )
 //! and inserts them on *this. Copies the predicate from the source container.
 //!
 //! If cloner throws, all cloned elements are unlinked and disposed
 //! calling Disposer::operator()(pointer).
- //!
+ //!
 //! Complexity: Linear to erased plus inserted elements.
- //!
+ //!
 //! Throws: If cloner throws or predicate copy assignment throws. Basic guarantee.
 template <class Cloner, class Disposer>
 void clone_from(const splaytree_impl &src, Cloner cloner, Disposer disposer)
@@ -1202,11 +1202,11 @@
 }

 //! Effects: Unlinks the leftmost node from the tree.
- //!
+ //!
 //! Complexity: Average complexity is constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Notes: This function breaks the tree and the tree can
 //! only be used for more unlink_leftmost_without_rebalance calls.
 //! This function is normally used to achieve a step by step
@@ -1224,12 +1224,12 @@
 }

 //! Requires: i must be a valid iterator of *this.
- //!
+ //!
 //! Effects: Rearranges the splay set so that the element pointed by i
 //! is placed as the root of the tree, improving future searches of this value.
- //!
+ //!
 //! Complexity: Amortized logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 void splay_up(iterator i)
 { return node_algorithms::splay_up(i.pointed_node(), this->priv_header_ptr()); }
@@ -1238,7 +1238,7 @@
 //! with a key equivalent to value the element is placed as the root of the
 //! tree. If the element is not present returns the last node compared with the key.
 //! If the tree is empty, end() is returned.
- //!
+ //!
 //! Complexity: Amortized logarithmic.
 //!
 //! Returns: An iterator to the new root of the tree, end() if the tree is empty.
@@ -1256,9 +1256,9 @@
 //! Effects: Rearranges the splay set so that if *this stores an element
 //! with a key equivalent to value the element is placed as the root of the
 //! tree.
- //!
+ //!
 //! Complexity: Amortized logarithmic.
- //!
+ //!
 //! Returns: An iterator to the new root of the tree, end() if the tree is empty.
 //!
 //! Throws: If the predicate throws.
@@ -1267,14 +1267,14 @@

 //! Requires: replace_this must be a valid iterator of *this
 //! and with_this must not be inserted in any tree.
- //!
+ //!
 //! Effects: Replaces replace_this in its position in the
 //! tree with with_this. The tree does not need to be rebalanced.
- //!
- //! Complexity: Constant.
- //!
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function will break container ordering invariants if
 //! with_this is not equivalent to *replace_this according to the
 //! ordering rules. This function is faster than erasing and inserting
@@ -1290,14 +1290,14 @@

 //! Requires: value must be an lvalue and shall be in a set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid iterator i belonging to the set
 //! that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This static function is available only if the value traits
 //! is stateless.
 static iterator s_iterator_to(reference value)
@@ -1308,17 +1308,17 @@

 //! Requires: value must be an lvalue and shall be in a set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid const_iterator i belonging to the
 //! set that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This static function is available only if the value traits
 //! is stateless.
- static const_iterator s_iterator_to(const_reference value)
+ static const_iterator s_iterator_to(const_reference value)
 {
 BOOST_STATIC_ASSERT((!stateful_value_traits));
 return const_iterator (value_traits::to_node_ptr(const_cast<reference> (value)), 0);
@@ -1326,70 +1326,70 @@

 //! Requires: value must be an lvalue and shall be in a set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid iterator i belonging to the set
 //! that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator iterator_to(reference value)
 { return iterator (value_traits::to_node_ptr(value), this); }

 //! Requires: value must be an lvalue and shall be in a set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid const_iterator i belonging to the
 //! set that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator iterator_to(const_reference value) const
 { return const_iterator (value_traits::to_node_ptr(const_cast<reference> (value)), this); }

 //! Requires: value shall not be in a tree.
- //!
+ //!
 //! Effects: init_node puts the hook of a value in a well-known default
 //! state.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Note: This function puts the hook in the well-known default state
 //! used by auto_unlink and safe hooks.
 static void init_node(reference value)
 { node_algorithms::init(value_traits::to_node_ptr(value)); }

 //! Effects: Rebalances the tree.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear.
 void rebalance()
 { node_algorithms::rebalance(this->priv_header_ptr()); }

 //! Requires: old_root is a node of a tree.
- //!
+ //!
 //! Effects: Rebalances the subtree rooted at old_root.
 //!
 //! Returns: The new root of the subtree.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the elements in the subtree.
 iterator rebalance_subtree(iterator root)
 { return iterator(node_algorithms::rebalance_subtree(root.pointed_node()), this); }

/*
 //! Effects: removes x from a tree of the appropriate type. It has no effect,
- //! if x is not in such a tree.
- //!
+ //! if x is not in such a tree.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Note: This static function is only usable with the "safe mode"
 //! hook and non-constant time size lists. Otherwise, the user must use
 //! the non-static "erase(reference )" member. If the user calls
@@ -1399,7 +1399,7 @@
 static void remove_node(T& value)
 {
 //This function is only usable for safe mode hooks and non-constant
- //time lists.
+ //time lists.
 //BOOST_STATIC_ASSERT((!(safemode_or_autounlink && constant_time_size)));
 BOOST_STATIC_ASSERT((!constant_time_size));
 BOOST_STATIC_ASSERT((boost::is_convertible<T, value_type>::value));
@@ -1571,7 +1571,7 @@
struct make_splaytree_opt
{
 typedef typename pack_options
- < splay_set_defaults<T>,
+ < splay_set_defaults<T>,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
@@ -1602,7 +1602,7 @@
{
 /// @cond
 typedef splaytree_impl
- < typename make_splaytree_opt<T,
+ < typename make_splaytree_opt<T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
@@ -1621,7 +1621,7 @@
template<class T, class ...Options>
#endif
class splaytree
- : public make_splaytree<T,
+ : public make_splaytree<T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
@@ -1630,7 +1630,7 @@
>::type
{
 typedef typename make_splaytree
- <T,
+ <T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
@@ -1678,8 +1678,8 @@
#endif

-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Modified: branches/release/boost/intrusive/splaytree_algorithms.hpp
==============================================================================
--- branches/release/boost/intrusive/splaytree_algorithms.hpp (original)
+++ branches/release/boost/intrusive/splaytree_algorithms.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -16,7 +16,7 @@
// Here is the header of the file used as base code:
//
// splay_tree.h -- implementation of a STL complatible splay tree.
-//
+//
// Copyright (c) 2004 Ralf Mattethat
//
// Permission to copy, use, modify, sell and distribute this software
@@ -24,22 +24,22 @@
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
-// Please send questions, comments, complaints, performance data, etc to
+// Please send questions, comments, complaints, performance data, etc to
// ralf.mattethat_at_[hidden]
//
// Requirements for element type
// * must be copy-constructible
// * destructor must not throw exception
//
-// Methods marked with note A only throws an exception if the evaluation of the
-// predicate throws an exception. If an exception is thrown the call has no
+// Methods marked with note A only throws an exception if the evaluation of the
+// predicate throws an exception. If an exception is thrown the call has no
// effect on the containers state
//
// Methods marked with note B only throws an exception if the coppy constructor
-// or assignment operator of the predicate throws an exception. If an exception
+// or assignment operator of the predicate throws an exception. If an exception
// is thrown the call has no effect on the containers state
//
-// iterators are only invalidated, if the element pointed to by the iterator
+// iterators are only invalidated, if the element pointed to by the iterator
// is deleted. The same goes for element references
//

@@ -95,8 +95,8 @@

//! A splay tree is an implementation of a binary search tree. The tree is
//! self balancing using the splay algorithm as described in
-//!
-//! "Self-Adjusting Binary Search Trees
+//!
+//! "Self-Adjusting Binary Search Trees
//! by Daniel Dominic Sleator and Robert Endre Tarjan
//! AT&T Bell Laboratories, Murray Hill, NJ
//! Journal of the ACM, Vol 32, no 3, July 1985, pp 652-686
@@ -116,15 +116,15 @@
//! Static functions:
//!
//! <tt>static node_ptr get_parent(const_node_ptr n);</tt>
-//!
+//!
//! <tt>static void set_parent(node_ptr n, node_ptr parent);</tt>
//!
//! <tt>static node_ptr get_left(const_node_ptr n);</tt>
-//!
+//!
//! <tt>static void set_left(node_ptr n, node_ptr left);</tt>
//!
//! <tt>static node_ptr get_right(const_node_ptr n);</tt>
-//!
+//!
//! <tt>static void set_right(node_ptr n, node_ptr right);</tt>
template<class NodeTraits>
class splaytree_algorithms
@@ -159,11 +159,11 @@

 //! Requires: node is a node of the tree or an node initialized
 //! by init(...).
- //!
+ //!
 //! Effects: Returns true if the node is initialized by init().
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: Nothing.
 static bool unique(const const_node_ptr & node)
 { return tree_algorithms::unique(node); }
@@ -173,15 +173,15 @@

 //! Requires: node1 and node2 can't be header nodes
 //! of two trees.
- //!
+ //!
 //! Effects: Swaps two nodes. After the function node1 will be inserted
 //! in the position node2 before the function. node2 will be inserted in the
 //! position node1 had before the function.
- //!
- //! Complexity: Logarithmic.
- //!
+ //!
+ //! Complexity: Logarithmic.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function will break container ordering invariants if
 //! node1 and node2 are not equivalent according to the ordering rules.
 //!
@@ -190,22 +190,22 @@
 {
 if(node1 == node2)
 return;
-
+
 node_ptr header1(tree_algorithms::get_header(node1)), header2(tree_algorithms::get_header(node2));
 swap_nodes(node1, header1, node2, header2);
 }

 //! Requires: node1 and node2 can't be header nodes
 //! of two trees with header header1 and header2.
- //!
+ //!
 //! Effects: Swaps two nodes. After the function node1 will be inserted
 //! in the position node2 before the function. node2 will be inserted in the
 //! position node1 had before the function.
- //!
- //! Complexity: Constant.
- //!
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function will break container ordering invariants if
 //! node1 and node2 are not equivalent according to the ordering rules.
 //!
@@ -215,14 +215,14 @@

 //! Requires: node_to_be_replaced must be inserted in a tree
 //! and new_node must not be inserted in a tree.
- //!
+ //!
 //! Effects: Replaces node_to_be_replaced in its position in the
 //! tree with new_node. The tree does not need to be rebalanced
- //!
- //! Complexity: Logarithmic.
- //!
+ //!
+ //! Complexity: Logarithmic.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function will break container ordering invariants if
 //! new_node is not equivalent to node_to_be_replaced according to the
 //! ordering rules. This function is faster than erasing and inserting
@@ -238,14 +238,14 @@

 //! Requires: node_to_be_replaced must be inserted in a tree
 //! with header "header" and new_node must not be inserted in a tree.
- //!
+ //!
 //! Effects: Replaces node_to_be_replaced in its position in the
 //! tree with new_node. The tree does not need to be rebalanced
- //!
- //! Complexity: Constant.
- //!
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function will break container ordering invariants if
 //! new_node is not equivalent to node_to_be_replaced according to the
 //! ordering rules. This function is faster than erasing and inserting
@@ -256,21 +256,21 @@
 { tree_algorithms::replace_node(node_to_be_replaced, header, new_node); }

 //! Requires: p is a node from the tree except the header.
- //!
+ //!
 //! Effects: Returns the next node of the tree.
- //!
+ //!
 //! Complexity: Average constant time.
- //!
+ //!
 //! Throws: Nothing.
 static node_ptr next_node(const node_ptr & p)
 { return tree_algorithms::next_node(p); }

 //! Requires: p is a node from the tree except the leftmost node.
- //!
+ //!
 //! Effects: Returns the previous node of the tree.
- //!
+ //!
 //! Complexity: Average constant time.
- //!
+ //!
 //! Throws: Nothing.
 static node_ptr prev_node(const node_ptr & p)
 { return tree_algorithms::prev_node(p); }
@@ -278,9 +278,9 @@
 //! Requires: node must not be part of any tree.
 //!
 //! Effects: After the function unique(node) == true.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 //!
 //! Nodes: If node is inserted in a tree, this function corrupts the tree.
@@ -291,9 +291,9 @@
 //!
 //! Effects: Initializes the header to represent an empty tree.
 //! unique(header) == true.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 //!
 //! Nodes: If node is inserted in a tree, this function corrupts the tree.
@@ -303,46 +303,46 @@
 //! Requires: "disposer" must be an object function
 //! taking a node_ptr parameter and shouldn't throw.
 //!
- //! Effects: Empties the target tree calling
+ //! Effects: Empties the target tree calling
 //! <tt>void disposer::operator()(const node_ptr &)</tt> for every node of the tree
 //! except the header.
- //!
+ //!
 //! Complexity: Linear to the number of element of the source tree plus the.
 //! number of elements of tree target tree when calling this function.
- //!
+ //!
 //! Throws: If cloner functor throws. If this happens target nodes are disposed.
 template<class Disposer>
 static void clear_and_dispose(const node_ptr & header, Disposer disposer)
 { tree_algorithms::clear_and_dispose(header, disposer); }

 //! Requires: node is a node of the tree but it's not the header.
- //!
+ //!
 //! Effects: Returns the number of nodes of the subtree.
- //!
+ //!
 //! Complexity: Linear time.
- //!
+ //!
 //! Throws: Nothing.
 static std::size_t count(const const_node_ptr & node)
 { return tree_algorithms::count(node); }

 //! Requires: header is the header node of the tree.
- //!
+ //!
 //! Effects: Returns the number of nodes above the header.
- //!
+ //!
 //! Complexity: Linear time.
- //!
+ //!
 //! Throws: Nothing.
 static std::size_t size(const const_node_ptr & header)
 { return tree_algorithms::size(header); }

 //! Requires: header1 and header2 must be the header nodes
 //! of two trees.
- //!
- //! Effects: Swaps two trees. After the function header1 will contain
+ //!
+ //! Effects: Swaps two trees. After the function header1 will contain
 //! links to the second tree and header2 will have links to the first tree.
- //!
- //! Complexity: Constant.
- //!
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: Nothing.
 static void swap_tree(const node_ptr & header1, const node_ptr & header2)
 { return tree_algorithms::swap_tree(header1, header2); }
@@ -351,16 +351,16 @@
 //! "commit_data" must have been obtained from a previous call to
 //! "insert_unique_check". No objects should have been inserted or erased
 //! from the set between the "insert_unique_check" that filled "commit_data"
- //! and the call to "insert_commit".
- //!
- //!
+ //! and the call to "insert_commit".
+ //!
+ //!
 //! Effects: Inserts new_node in the set using the information obtained
 //! from the "commit_data" that a previous "insert_check" filled.
 //!
 //! Complexity: Constant time.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Notes: This function has only sense if a "insert_unique_check" has been
 //! previously executed to fill "commit_data". No value should be inserted or
 //! erased between the "insert_check" and "insert_commit" calls.
@@ -372,7 +372,7 @@
 //! KeyNodePtrCompare is a function object that induces a strict weak
 //! ordering compatible with the strict weak ordering used to create the
 //! the tree. NodePtrCompare compares KeyType with a node_ptr.
- //!
+ //!
 //! Effects: Checks if there is an equivalent node to "key" in the
 //! tree according to "comp" and obtains the needed information to realize
 //! a constant-time node insertion if there is no equivalent node.
@@ -383,11 +383,11 @@
 //! in the returned pair's boolean and fills "commit_data" that is meant to
 //! be used with the "insert_commit" function to achieve a constant-time
 //! insertion function.
- //!
+ //!
 //! Complexity: Average complexity is at most logarithmic.
 //!
 //! Throws: If "comp" throws.
- //!
+ //!
 //! Notes: This function is used to improve performance when constructing
 //! a node is expensive and the user does not want to have two equivalent nodes
 //! in the tree: if there is an equivalent value
@@ -432,7 +432,7 @@
 //! "key" according to "comp" or "header" if that element does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static node_ptr find
@@ -457,7 +457,7 @@
 //! if they there are no equivalent elements.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static std::pair<node_ptr, node_ptr> equal_range
@@ -483,7 +483,7 @@
 //! not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static node_ptr lower_bound
@@ -506,7 +506,7 @@
 //! than "key" according to "comp" or "header" if that element does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static node_ptr upper_bound
@@ -525,14 +525,14 @@
 //! ordering compatible with the strict weak ordering used to create the
 //! the tree. NodePtrCompare compares two node_ptrs. "hint" is node from
 //! the "header"'s tree.
- //!
+ //!
 //! Effects: Inserts new_node into the tree, using "hint" as a hint to
 //! where it will be inserted. If "hint" is the upper_bound
 //! the insertion takes constant time (two comparisons in the worst case).
 //!
 //! Complexity: Logarithmic in general, but it is amortized
 //! constant time if new_node is inserted immediately before "hint".
- //!
+ //!
 //! Throws: If "comp" throws.
 template<class NodePtrCompare>
 static node_ptr insert_equal
@@ -548,13 +548,13 @@
 //! "pos" must be an iterator pointing to the successor to "new_node"
 //! once inserted according to the order of already inserted nodes. This function does not
 //! check "pos" and this precondition must be guaranteed by the caller.
- //!
+ //!
 //! Effects: Inserts new_node into the tree before "pos".
 //!
 //! Complexity: Constant-time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: If "pos" is not the successor of the newly inserted "new_node"
 //! tree invariants might be broken.
 static node_ptr insert_before
@@ -568,13 +568,13 @@
 //! Requires: "header" must be the header node of a tree.
 //! "new_node" must be, according to the used ordering no less than the
 //! greatest inserted key.
- //!
+ //!
 //! Effects: Inserts new_node into the tree before "pos".
 //!
 //! Complexity: Constant-time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: If "new_node" is less than the greatest inserted key
 //! tree invariants are broken. This function is slightly faster than
 //! using "insert_before".
@@ -587,13 +587,13 @@
 //! Requires: "header" must be the header node of a tree.
 //! "new_node" must be, according to the used ordering, no greater than the
 //! lowest inserted key.
- //!
+ //!
 //! Effects: Inserts new_node into the tree before "pos".
 //!
 //! Complexity: Constant-time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: If "new_node" is greater than the lowest inserted key
 //! tree invariants are broken. This function is slightly faster than
 //! using "insert_before".
@@ -610,10 +610,10 @@
 //!
 //! Effects: Inserts new_node into the tree before the upper bound
 //! according to "comp".
- //!
+ //!
 //! Complexity: Average complexity for insert element is at
 //! most logarithmic.
- //!
+ //!
 //! Throws: If "comp" throws.
 template<class NodePtrCompare>
 static node_ptr insert_equal_upper_bound
@@ -630,10 +630,10 @@
 //!
 //! Effects: Inserts new_node into the tree before the lower bound
 //! according to "comp".
- //!
+ //!
 //! Complexity: Average complexity for insert element is at
 //! most logarithmic.
- //!
+ //!
 //! Throws: If "comp" throws.
 template<class NodePtrCompare>
 static node_ptr insert_equal_lower_bound
@@ -647,18 +647,18 @@
 //! object taking a node_ptr and returning a new cloned node of it. "disposer" must
 //! take a node_ptr and shouldn't throw.
 //!
- //! Effects: First empties target tree calling
+ //! Effects: First empties target tree calling
 //! <tt>void disposer::operator()(const node_ptr &)</tt> for every node of the tree
 //! except the header.
- //!
+ //!
 //! Then, duplicates the entire tree pointed by "source_header" cloning each
- //! source node with <tt>node_ptr Cloner::operator()(const node_ptr &)</tt> to obtain
+ //! source node with <tt>node_ptr Cloner::operator()(const node_ptr &)</tt> to obtain
 //! the nodes of the target tree. If "cloner" throws, the cloned target nodes
 //! are disposed using <tt>void disposer(const node_ptr &)</tt>.
- //!
+ //!
 //! Complexity: Linear to the number of element of the source tree plus the.
 //! number of elements of tree target tree when calling this function.
- //!
+ //!
 //! Throws: If cloner functor throws. If this happens target nodes are disposed.
 template <class Cloner, class Disposer>
 static void clone
@@ -723,13 +723,13 @@
 node_ptr t(header);

 if( n == t ) return;
-
+
 for( ;; ){
 node_ptr p(NodeTraits::get_parent(n));
 node_ptr g(NodeTraits::get_parent(p));

 if( p == t ) break;
-
+
 if( g == t ){
 // zig
 rotate(n);
@@ -841,23 +841,23 @@
 }

 //! Requires: header must be the header of a tree.
- //!
+ //!
 //! Effects: Rebalances the tree.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear.
 static void rebalance(const node_ptr & header)
 { tree_algorithms::rebalance(header); }

 //! Requires: old_root is a node of a tree.
- //!
+ //!
 //! Effects: Rebalances the subtree rooted at old_root.
 //!
 //! Returns: The new root of the subtree.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear.
 static node_ptr rebalance_subtree(const node_ptr & old_root)
 { return tree_algorithms::rebalance_subtree(old_root); }
@@ -868,7 +868,7 @@
 //! Effects: Returns a pointer to the header node of the tree.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 static node_ptr get_header(const node_ptr & n)
 { return tree_algorithms::get_header(n); }
@@ -926,10 +926,10 @@
 {
 node_ptr p = NodeTraits::get_parent(n);
 node_ptr g = NodeTraits::get_parent(p);
- //Test if g is header before breaking tree
+ //Test if g is header before breaking tree
 //invariants that would make is_header invalid
 bool g_is_header = is_header(g);
-
+
 if(NodeTraits::get_left(p) == n){
 NodeTraits::set_left(p, NodeTraits::get_right(n));
 if(NodeTraits::get_left(p) != node_ptr())
@@ -965,8 +965,8 @@
 /// @endcond
};

-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Modified: branches/release/boost/intrusive/treap.hpp
==============================================================================
--- branches/release/boost/intrusive/treap.hpp (original)
+++ branches/release/boost/intrusive/treap.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -66,7 +66,7 @@
/// @endcond

//! The class template treap is an intrusive treap container that
-//! is used to construct intrusive set and multiset containers. The no-throw
+//! is used to construct intrusive set and multiset containers. The no-throw
//! guarantee holds only, if the value_compare object and priority_compare object
//! don't throw.
//!
@@ -133,7 +133,7 @@
 //noncopyable
 BOOST_MOVABLE_BUT_NOT_COPYABLE(treap_impl)

- enum { safemode_or_autounlink =
+ enum { safemode_or_autounlink =
 (int)real_value_traits::link_mode == (int)auto_unlink ||
 (int)real_value_traits::link_mode == (int)safe_link };

@@ -167,7 +167,7 @@
 {}
 node_plus_pred_t node_plus_pred_;
 } data_;
-
+
 const value_compare &priv_comp() const
 { return data_.node_plus_pred_.get(); }

@@ -225,19 +225,19 @@

 typedef typename node_algorithms::insert_commit_data insert_commit_data;

- //! Effects: Constructs an empty treap.
- //!
- //! Complexity: Constant.
- //!
+ //! Effects: Constructs an empty treap.
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: If value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
 //! or the copy constructor of the value_compare/priority_compare objects throw. Basic guarantee.
 treap_impl( const value_compare &cmp = value_compare()
 , const priority_compare &pcmp = priority_compare()
- , const value_traits &v_traits = value_traits())
+ , const value_traits &v_traits = value_traits())
 : data_(cmp, pcmp, v_traits)
- {
- node_algorithms::init_header(this->priv_header_ptr());
+ {
+ node_algorithms::init_header(this->priv_header_ptr());
 this->priv_size_traits().set_size(size_type(0));
 }

@@ -249,10 +249,10 @@
 //!
 //! Complexity: Linear in N if [b, e) is already sorted using
 //! comp and otherwise N * log N, where N is the distance between first and last.
- //!
+ //!
 //! Throws: If value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
- //! or the copy constructor/operator() of the value_compare/priority_compare objects
+ //! or the copy constructor/operator() of the value_compare/priority_compare objects
 //! throw. Basic guarantee.
 template<class Iterator>
 treap_impl( bool unique, Iterator b, Iterator e
@@ -270,61 +270,61 @@
 }

 //! Effects: to-do
- //!
+ //!
 treap_impl(BOOST_RV_REF(treap_impl) x)
 : data_( ::boost::move(x.priv_comp())
 , ::boost::move(x.priv_pcomp())
 , ::boost::move(x.priv_value_traits()))
 {
- node_algorithms::init_header(this->priv_header_ptr());
+ node_algorithms::init_header(this->priv_header_ptr());
 this->priv_size_traits().set_size(size_type(0));
 this->swap(x);
 }

 //! Effects: to-do
- //!
- treap_impl& operator=(BOOST_RV_REF(treap_impl) x)
+ //!
+ treap_impl& operator=(BOOST_RV_REF(treap_impl) x)
 { this->swap(x); return *this; }

- //! Effects: Detaches all elements from this. The objects in the set
- //! are not deleted (i.e. no destructors are called), but the nodes according to
- //! the value_traits template parameter are reinitialized and thus can be reused.
- //!
+ //! Effects: Detaches all elements from this. The objects in the set
+ //! are not deleted (i.e. no destructors are called), but the nodes according to
+ //! the value_traits template parameter are reinitialized and thus can be reused.
+ //!
 //! Complexity: Linear to elements contained in *this
 //! if constant-time size option is disabled. Constant time otherwise.
- //!
+ //!
 //! Throws: Nothing.
- ~treap_impl()
+ ~treap_impl()
 {}

 //! Effects: Returns an iterator pointing to the beginning of the treap.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator begin()
 { return iterator (node_traits::get_left(this->priv_header_ptr()), this); }

 //! Effects: Returns a const_iterator pointing to the beginning of the treap.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator begin() const
 { return this->cbegin(); }

 //! Effects: Returns a const_iterator pointing to the beginning of the treap.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator cbegin() const
 { return const_iterator (node_traits::get_left(this->priv_header_ptr()), this); }

 //! Effects: Returns an iterator pointing to the end of the treap.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator end()
 { return iterator (this->priv_header_ptr(), this); }
@@ -332,198 +332,198 @@
 //! Effects: Returns a const_iterator pointing to the end of the treap.
 //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator end() const
 { return this->cend(); }

 //! Effects: Returns a const_iterator pointing to the end of the treap.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator cend() const
 { return const_iterator (uncast(this->priv_header_ptr()), this); }

 //! Effects: Returns an iterator pointing to the highest priority object of the treap.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator top()
 { return this->empty() ? this->end() : iterator (node_traits::get_parent(this->priv_header_ptr()), this); }

 //! Effects: Returns a const_iterator pointing to the highest priority object of the treap..
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator top() const
 { return this->ctop(); }

 //! Effects: Returns a const_iterator pointing to the highest priority object of the treap..
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator ctop() const
 { return this->empty() ? this->cend() : const_iterator (node_traits::get_parent(this->priv_header_ptr()), this); }

 //! Effects: Returns a reverse_iterator pointing to the beginning of the
 //! reversed treap.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 reverse_iterator rbegin()
 { return reverse_iterator(this->end()); }

 //! Effects: Returns a const_reverse_iterator pointing to the beginning
 //! of the reversed treap.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator rbegin() const
 { return const_reverse_iterator(this->end()); }

 //! Effects: Returns a const_reverse_iterator pointing to the beginning
 //! of the reversed treap.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator crbegin() const
 { return const_reverse_iterator(this->end()); }

 //! Effects: Returns a reverse_iterator pointing to the end
 //! of the reversed treap.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 reverse_iterator rend()
 { return reverse_iterator(this->begin()); }

 //! Effects: Returns a const_reverse_iterator pointing to the end
 //! of the reversed treap.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator rend() const
 { return const_reverse_iterator(this->begin()); }

 //! Effects: Returns a const_reverse_iterator pointing to the end
 //! of the reversed treap.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator crend() const
 { return const_reverse_iterator(this->begin()); }

 //! Effects: Returns a reverse_iterator pointing to the highest priority object of the
 //! reversed treap.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 reverse_iterator rtop()
 { return reverse_iterator(this->top()); }

 //! Effects: Returns a const_reverse_iterator pointing to the highest priority objec
 //! of the reversed treap.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator rtop() const
 { return const_reverse_iterator(this->top()); }

 //! Effects: Returns a const_reverse_iterator pointing to the highest priority object
 //! of the reversed treap.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator crtop() const
 { return const_reverse_iterator(this->top()); }

 //! Precondition: end_iterator must be a valid end iterator
 //! of treap.
- //!
+ //!
 //! Effects: Returns a const reference to the treap associated to the end iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 static treap_impl &container_from_end_iterator(iterator end_iterator)
 { return priv_container_from_end_iterator(end_iterator); }

 //! Precondition: end_iterator must be a valid end const_iterator
 //! of treap.
- //!
+ //!
 //! Effects: Returns a const reference to the treap associated to the iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 static const treap_impl &container_from_end_iterator(const_iterator end_iterator)
 { return priv_container_from_end_iterator(end_iterator); }

 //! Precondition: it must be a valid iterator
 //! of treap.
- //!
+ //!
 //! Effects: Returns a const reference to the treap associated to the iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Logarithmic.
 static treap_impl &container_from_iterator(iterator it)
 { return priv_container_from_iterator(it); }

 //! Precondition: it must be a valid end const_iterator
 //! of treap.
- //!
+ //!
 //! Effects: Returns a const reference to the treap associated to the end iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Logarithmic.
 static const treap_impl &container_from_iterator(const_iterator it)
 { return priv_container_from_iterator(it); }

 //! Effects: Returns the value_compare object used by the treap.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If value_compare copy-constructor throws.
 value_compare value_comp() const
 { return this->priv_comp(); }

 //! Effects: Returns the priority_compare object used by the treap.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If priority_compare copy-constructor throws.
 priority_compare priority_comp() const
 { return this->priv_pcomp(); }

 //! Effects: Returns true if the container is empty.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 bool empty() const
 { return node_algorithms::unique(this->priv_header_ptr()); }

 //! Effects: Returns the number of elements stored in the treap.
- //!
+ //!
 //! Complexity: Linear to elements contained in *this
 //! if constant-time size option is disabled. Constant time otherwise.
- //!
+ //!
 //! Throws: Nothing.
 size_type size() const
 {
@@ -535,9 +535,9 @@
 }

 //! Effects: Swaps the contents of two treaps.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If the comparison functor's swap call throws.
 void swap(treap_impl& other)
 {
@@ -555,14 +555,14 @@
 }

 //! Requires: value must be an lvalue
- //!
+ //!
 //! Effects: Inserts value into the treap before the upper bound.
- //!
+ //!
 //! Complexity: Average complexity for insert element is at
 //! most logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare or priority_compare functions throw. Strong guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 iterator insert_equal(reference value)
@@ -582,16 +582,16 @@

 //! Requires: value must be an lvalue, and "hint" must be
 //! a valid iterator.
- //!
+ //!
 //! Effects: Inserts x into the treap, using "hint" as a hint to
 //! where it will be inserted. If "hint" is the upper_bound
 //! the insertion takes constant time (two comparisons in the worst case)
- //!
+ //!
 //! Complexity: Logarithmic in general, but it is amortized
 //! constant time if t is inserted immediately before hint.
- //!
+ //!
 //! Throws: If the internal value_compare or priority_compare functions throw. Strong guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 iterator insert_equal(const_iterator hint, reference value)
@@ -609,19 +609,19 @@
 return ret;
 }

- //! Requires: Dereferencing iterator must yield an lvalue
+ //! Requires: Dereferencing iterator must yield an lvalue
 //! of type value_type.
- //!
+ //!
 //! Effects: Inserts a each element of a range into the treap
 //! before the upper bound of the key of each element.
- //!
+ //!
 //! Complexity: Insert range is in general O(N * log(N)), where N is the
 //! size of the range. However, it is linear in N if the range is already sorted
 //! by value_comp().
- //!
+ //!
 //! Throws: If the internal value_compare or priority_compare functions throw.
 //! Strong guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 template<class Iterator>
@@ -633,16 +633,16 @@
 }

 //! Requires: value must be an lvalue
- //!
+ //!
 //! Effects: Inserts value into the treap if the value
 //! is not already present.
- //!
+ //!
 //! Complexity: Average complexity for insert element is at
 //! most logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare or priority_compare functions throw.
 //! Strong guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 std::pair<iterator, bool> insert_unique(reference value)
@@ -656,17 +656,17 @@

 //! Requires: value must be an lvalue, and "hint" must be
 //! a valid iterator
- //!
+ //!
 //! Effects: Tries to insert x into the treap, using "hint" as a hint
 //! to where it will be inserted.
- //!
+ //!
 //! Complexity: Logarithmic in general, but it is amortized
 //! constant time (two comparisons in the worst case)
 //! if t is inserted immediately before hint.
- //!
+ //!
 //! Throws: If the internal value_compare or priority_compare functions throw.
 //! Strong guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 iterator insert_unique(const_iterator hint, reference value)
@@ -678,18 +678,18 @@
 return insert_unique_commit(value, commit_data);
 }

- //! Requires: Dereferencing iterator must yield an lvalue
+ //! Requires: Dereferencing iterator must yield an lvalue
 //! of type value_type.
- //!
+ //!
 //! Effects: Tries to insert each element of a range into the treap.
- //!
- //! Complexity: Insert range is in general O(N * log(N)), where N is the
- //! size of the range. However, it is linear in N if the range is already sorted
+ //!
+ //! Complexity: Insert range is in general O(N * log(N)), where N is the
+ //! size of the range. However, it is linear in N if the range is already sorted
 //! by value_comp().
- //!
+ //!
 //! Throws: If the internal value_compare or priority_compare functions throw.
 //! Strong guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 template<class Iterator>
@@ -706,12 +706,12 @@
 }
 }

- //! Requires: key_value_comp must be a comparison function that induces
+ //! Requires: key_value_comp must be a comparison function that induces
 //! the same strict weak ordering as value_compare.
- //! key_value_pcomp must be a comparison function that induces
+ //! key_value_pcomp must be a comparison function that induces
 //! the same strict weak ordering as priority_compare. The difference is that
 //! key_value_pcomp and key_value_comp compare an arbitrary key with the contained values.
- //!
+ //!
 //! Effects: Checks if a value can be inserted in the container, using
 //! a user provided key instead of the value itself.
 //!
@@ -720,17 +720,17 @@
 //! and false. If the value can be inserted returns true in the returned
 //! pair boolean and fills "commit_data" that is meant to be used with
 //! the "insert_commit" function.
- //!
+ //!
 //! Complexity: Average complexity is at most logarithmic.
 //!
 //! Throws: If the key_value_comp or key_value_pcomp
 //! ordering functions throw. Strong guarantee.
- //!
+ //!
 //! Notes: This function is used to improve performance when constructing
 //! a value_type is expensive: if there is an equivalent value
 //! the constructed object must be discarded. Many times, the part of the
 //! node that is used to impose the order is much cheaper to construct
- //! than the value_type and this function offers the possibility to use that
+ //! than the value_type and this function offers the possibility to use that
 //! part to check if the insertion will be successful.
 //!
 //! If the check is successful, the user can construct the value_type and use
@@ -748,20 +748,20 @@
 comp(key_value_comp, this);
 detail::key_nodeptr_comp<KeyValuePrioCompare, treap_impl>
 pcomp(key_value_pcomp, this);
- std::pair<node_ptr, bool> ret =
+ std::pair<node_ptr, bool> ret =
 (node_algorithms::insert_unique_check
 (this->priv_header_ptr(), key, comp, pcomp, commit_data));
 return std::pair<iterator, bool>(iterator(ret.first, this), ret.second);
 }

- //! Requires: key_value_comp must be a comparison function that induces
+ //! Requires: key_value_comp must be a comparison function that induces
 //! the same strict weak ordering as value_compare.
- //! key_value_pcomp must be a comparison function that induces
+ //! key_value_pcomp must be a comparison function that induces
 //! the same strict weak ordering as priority_compare. The difference is that
 //! key_value_pcomp and key_value_comp compare an arbitrary key with the contained values.
- //!
+ //!
 //! Effects: Checks if a value can be inserted in the container, using
- //! a user provided key instead of the value itself, using "hint"
+ //! a user provided key instead of the value itself, using "hint"
 //! as a hint to where it will be inserted.
 //!
 //! Returns: If there is an equivalent value
@@ -769,24 +769,24 @@
 //! and false. If the value can be inserted returns true in the returned
 //! pair boolean and fills "commit_data" that is meant to be used with
 //! the "insert_commit" function.
- //!
+ //!
 //! Complexity: Logarithmic in general, but it's amortized
 //! constant time if t is inserted immediately before hint.
 //!
 //! Throws: If the key_value_comp or key_value_pcomp
 //! ordering functions throw. Strong guarantee.
- //!
+ //!
 //! Notes: This function is used to improve performance when constructing
 //! a value_type is expensive: if there is an equivalent value
 //! the constructed object must be discarded. Many times, the part of the
 //! constructing that is used to impose the order is much cheaper to construct
- //! than the value_type and this function offers the possibility to use that key
+ //! than the value_type and this function offers the possibility to use that key
 //! to check if the insertion will be successful.
 //!
 //! If the check is successful, the user can construct the value_type and use
 //! "insert_commit" to insert the object in constant-time. This can give a total
 //! constant-time complexity to the insertion: check(O(1)) + commit(O(1)).
- //!
+ //!
 //! "commit_data" remains valid for a subsequent "insert_commit" only if no more
 //! objects are inserted or erased from the container.
 template<class KeyType, class KeyValueCompare, class KeyValuePrioCompare>
@@ -800,7 +800,7 @@
 comp(key_value_comp, this);
 detail::key_nodeptr_comp<KeyValuePrioCompare, treap_impl>
 pcomp(key_value_pcomp, this);
- std::pair<node_ptr, bool> ret =
+ std::pair<node_ptr, bool> ret =
 (node_algorithms::insert_unique_check
 (this->priv_header_ptr(), hint.pointed_node(), key, comp, pcomp, commit_data));
 return std::pair<iterator, bool>(iterator(ret.first, this), ret.second);
@@ -810,16 +810,16 @@
 //! must have been obtained from a previous call to "insert_check".
 //! No objects should have been inserted or erased from the container between
 //! the "insert_check" that filled "commit_data" and the call to "insert_commit".
- //!
+ //!
 //! Effects: Inserts the value in the avl_set using the information obtained
 //! from the "commit_data" that a previous "insert_check" filled.
 //!
 //! Returns: An iterator to the newly inserted object.
- //!
+ //!
 //! Complexity: Constant time.
 //!
 //! Throws: Nothing
- //!
+ //!
 //! Notes: This function has only sense if a "insert_check" has been
 //! previously executed to fill "commit_data". No value should be inserted or
 //! erased between the "insert_check" and "insert_commit" calls.
@@ -838,11 +838,11 @@
 //! once inserted according to the predicate
 //!
 //! Effects: Inserts x into the treap before "pos".
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: If the internal priority_compare function throws. Strong guarantee.
- //!
+ //!
 //! Note: This function does not check preconditions so if "pos" is not
 //! the successor of "value" treap ordering invariant will be broken.
 //! This is a low-level function to be used only for performance reasons
@@ -864,11 +864,11 @@
 //! than the greatest inserted key
 //!
 //! Effects: Inserts x into the treap in the last position.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: If the internal priority_compare function throws. Strong guarantee.
- //!
+ //!
 //! Note: This function does not check preconditions so if value is
 //! less than the greatest inserted key treap ordering invariant will be broken.
 //! This function is slightly more efficient than using "insert_before".
@@ -889,11 +889,11 @@
 //! than the minimum inserted key
 //!
 //! Effects: Inserts x into the treap in the first position.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: If the internal priority_compare function throws. Strong guarantee.
- //!
+ //!
 //! Note: This function does not check preconditions so if value is
 //! greater than the minimum inserted key treap ordering invariant will be broken.
 //! This function is slightly more efficient than using "insert_before".
@@ -910,12 +910,12 @@
 this->priv_size_traits().increment();
 }

- //! Effects: Erases the element pointed to by pos.
- //!
- //! Complexity: Average complexity for erase element is constant time.
- //!
+ //! Effects: Erases the element pointed to by pos.
+ //!
+ //! Complexity: Average complexity for erase element is constant time.
+ //!
 //! Throws: if the internal priority_compare function throws. Strong guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 iterator erase(const_iterator i)
@@ -934,26 +934,26 @@
 return ret.unconst();
 }

- //! Effects: Erases the range pointed to by b end e.
- //!
- //! Complexity: Average complexity for erase range is at most
+ //! Effects: Erases the range pointed to by b end e.
+ //!
+ //! Complexity: Average complexity for erase range is at most
 //! O(log(size() + N)), where N is the number of elements in the range.
- //!
+ //!
 //! Throws: if the internal priority_compare function throws. Strong guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 iterator erase(const_iterator b, const_iterator e)
 { size_type n; return private_erase(b, e, n); }

 //! Effects: Erases all the elements with the given value.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size() + N).
- //!
+ //!
 //! Throws: if the internal priority_compare function throws. Strong guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 size_type erase(const_reference value)
@@ -963,12 +963,12 @@
 //! according to the comparison functor "comp".
 //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size() + N).
- //!
+ //!
 //! Throws: if the internal priority_compare function throws.
 //! Equivalent guarantee to while(beg != end) erase(beg++);
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class KeyType, class KeyValueCompare>
@@ -986,14 +986,14 @@

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
 //!
- //! Effects: Erases the element pointed to by pos.
+ //! Effects: Erases the element pointed to by pos.
 //! Disposer::operator()(pointer) is called for the removed element.
- //!
- //! Complexity: Average complexity for erase element is constant time.
- //!
+ //!
+ //! Complexity: Average complexity for erase element is constant time.
+ //!
 //! Throws: if the internal priority_compare function throws. Strong guarantee.
- //!
- //! Note: Invalidates the iterators
+ //!
+ //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
 iterator erase_and_dispose(const_iterator i, Disposer disposer)
@@ -1014,12 +1014,12 @@
 //!
 //! Effects: Erases the range pointed to by b end e.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
- //! Complexity: Average complexity for erase range is at most
+ //!
+ //! Complexity: Average complexity for erase range is at most
 //! O(log(size() + N)), where N is the number of elements in the range.
- //!
+ //!
 //! Throws: if the internal priority_compare function throws. Strong guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
@@ -1030,14 +1030,14 @@
 //!
 //! Effects: Erases all the elements with the given value.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size() + N).
- //!
+ //!
 //! Throws: if the priority_compare function throws then weak guarantee and heap invariants are broken.
 //! The safest thing would be to clear or destroy the container.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class Disposer>
@@ -1056,12 +1056,12 @@
 //! Disposer::operator()(pointer) is called for the removed elements.
 //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size() + N).
- //!
+ //!
 //! Throws: if the priority_compare function throws then weak guarantee and heap invariants are broken.
 //! The safest thing would be to clear or destroy the container.
- //!
+ //!
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class KeyType, class KeyValueCompare, class Disposer>
@@ -1077,13 +1077,13 @@
 return n;
 }

- //! Effects: Erases all of the elements.
- //!
+ //! Effects: Erases all of the elements.
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 void clear()
@@ -1101,9 +1101,9 @@
 //! each node to be erased.
 //! Complexity: Average complexity for is at most O(log(size() + N)),
 //! where N is the number of elements in the container.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. Calls N times to disposer functor.
 template<class Disposer>
@@ -1116,19 +1116,19 @@
 }

 //! Effects: Returns the number of contained elements with the given value
- //!
+ //!
 //! Complexity: Logarithmic to the number of elements contained plus lineal
 //! to number of objects with the given value.
- //!
+ //!
 //! Throws: Nothing.
 size_type count(const_reference value) const
 { return this->count(value, priv_comp()); }

 //! Effects: Returns the number of contained elements with the given key
- //!
+ //!
 //! Complexity: Logarithmic to the number of elements contained plus lineal
 //! to number of objects with the given key.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 size_type count(const KeyType &key, KeyValueCompare comp) const
@@ -1139,27 +1139,27 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is not less than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 iterator lower_bound(const_reference value)
 { return this->lower_bound(value, priv_comp()); }

 //! Effects: Returns an iterator to the first element whose
 //! key is not less than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator lower_bound(const_reference value) const
 { return this->lower_bound(value, priv_comp()); }

 //! Effects: Returns an iterator to the first element whose
 //! key is not less than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 iterator lower_bound(const KeyType &key, KeyValueCompare comp)
@@ -1172,9 +1172,9 @@

 //! Effects: Returns a const iterator to the first element whose
 //! key is not less than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 const_iterator lower_bound(const KeyType &key, KeyValueCompare comp) const
@@ -1187,9 +1187,9 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is greater than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 iterator upper_bound(const_reference value)
 { return this->upper_bound(value, priv_comp()); }
@@ -1199,7 +1199,7 @@
 //! does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 iterator upper_bound(const KeyType &key, KeyValueCompare comp)
@@ -1212,9 +1212,9 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is greater than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator upper_bound(const_reference value) const
 { return this->upper_bound(value, priv_comp()); }
@@ -1224,7 +1224,7 @@
 //! does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 const_iterator upper_bound(const KeyType &key, KeyValueCompare comp) const
@@ -1235,20 +1235,20 @@
 (this->priv_header_ptr(), key, key_node_comp), this);
 }

- //! Effects: Finds an iterator to the first element whose key is
+ //! Effects: Finds an iterator to the first element whose key is
 //! k or end() if that element does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 iterator find(const_reference value)
 { return this->find(value, priv_comp()); }

- //! Effects: Finds an iterator to the first element whose key is
+ //! Effects: Finds an iterator to the first element whose key is
 //! k or end() if that element does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 iterator find(const KeyType &key, KeyValueCompare comp)
@@ -1259,20 +1259,20 @@
 (node_algorithms::find(this->priv_header_ptr(), key, key_node_comp), this);
 }

- //! Effects: Finds a const_iterator to the first element whose key is
+ //! Effects: Finds a const_iterator to the first element whose key is
 //! k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator find(const_reference value) const
 { return this->find(value, priv_comp()); }

- //! Effects: Finds a const_iterator to the first element whose key is
+ //! Effects: Finds a const_iterator to the first element whose key is
 //! k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 const_iterator find(const KeyType &key, KeyValueCompare comp) const
@@ -1286,9 +1286,9 @@
 //! Effects: Finds a range containing all elements whose key is k or
 //! an empty range that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 std::pair<iterator,iterator> equal_range(const_reference value)
 { return this->equal_range(value, priv_comp()); }
@@ -1296,9 +1296,9 @@
 //! Effects: Finds a range containing all elements whose key is k or
 //! an empty range that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 std::pair<iterator,iterator> equal_range(const KeyType &key, KeyValueCompare comp)
@@ -1313,9 +1313,9 @@
 //! Effects: Finds a range containing all elements whose key is k or
 //! an empty range that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 std::pair<const_iterator, const_iterator>
 equal_range(const_reference value) const
@@ -1324,9 +1324,9 @@
 //! Effects: Finds a range containing all elements whose key is k or
 //! an empty range that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 template<class KeyType, class KeyValueCompare>
 std::pair<const_iterator, const_iterator>
@@ -1343,15 +1343,15 @@
 //! Cloner should yield to nodes equivalent to the original nodes.
 //!
 //! Effects: Erases all the elements from *this
- //! calling Disposer::operator()(pointer), clones all the
+ //! calling Disposer::operator()(pointer), clones all the
 //! elements from src calling Cloner::operator()(const_reference )
 //! and inserts them on *this. Copies the predicate from the source container.
 //!
 //! If cloner throws, all cloned elements are unlinked and disposed
 //! calling Disposer::operator()(pointer).
- //!
+ //!
 //! Complexity: Linear to erased plus inserted elements.
- //!
+ //!
 //! Throws: If cloner throws or predicate copy assignment throws. Basic guarantee.
 template <class Cloner, class Disposer>
 void clone_from(const treap_impl &src, Cloner cloner, Disposer disposer)
@@ -1372,11 +1372,11 @@
 }

 //! Effects: Unlinks the leftmost node from the treap.
- //!
+ //!
 //! Complexity: Average complexity is constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Notes: This function breaks the treap and the treap can
 //! only be used for more unlink_leftmost_without_rebalance calls.
 //! This function is normally used to achieve a step by step
@@ -1395,14 +1395,14 @@

 //! Requires: replace_this must be a valid iterator of *this
 //! and with_this must not be inserted in any treap.
- //!
+ //!
 //! Effects: Replaces replace_this in its position in the
 //! treap with with_this. The treap does not need to be rebalanced.
- //!
- //! Complexity: Constant.
- //!
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function will break container ordering invariants if
 //! with_this is not equivalent to *replace_this according to the
 //! ordering and priority rules. This function is faster than erasing and inserting
@@ -1418,14 +1418,14 @@

 //! Requires: value must be an lvalue and shall be in a set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid iterator i belonging to the set
 //! that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This static function is available only if the value traits
 //! is stateless.
 static iterator s_iterator_to(reference value)
@@ -1436,17 +1436,17 @@

 //! Requires: value must be an lvalue and shall be in a set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid const_iterator i belonging to the
 //! set that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This static function is available only if the value traits
 //! is stateless.
- static const_iterator s_iterator_to(const_reference value)
+ static const_iterator s_iterator_to(const_reference value)
 {
 BOOST_STATIC_ASSERT((!stateful_value_traits));
 return const_iterator (value_traits::to_node_ptr(const_cast<reference> (value)), 0);
@@ -1454,37 +1454,37 @@

 //! Requires: value must be an lvalue and shall be in a set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid iterator i belonging to the set
 //! that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator iterator_to(reference value)
 { return iterator (value_traits::to_node_ptr(value), this); }

 //! Requires: value must be an lvalue and shall be in a set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid const_iterator i belonging to the
 //! set that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator iterator_to(const_reference value) const
 { return const_iterator (value_traits::to_node_ptr(const_cast<reference> (value)), this); }

 //! Requires: value shall not be in a treap.
- //!
+ //!
 //! Effects: init_node puts the hook of a value in a well-known default
 //! state.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Note: This function puts the hook in the well-known default state
 //! used by auto_unlink and safe hooks.
 static void init_node(reference value)
@@ -1658,7 +1658,7 @@
struct make_treap_opt
{
 typedef typename pack_options
- < treap_set_defaults<T>,
+ < treap_set_defaults<T>,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
@@ -1690,7 +1690,7 @@
{
 /// @cond
 typedef treap_impl
- < typename make_treap_opt<T,
+ < typename make_treap_opt<T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
@@ -1710,7 +1710,7 @@
template<class T, class ...Options>
#endif
class treap
- : public make_trie<T,
+ : public make_trie<T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
@@ -1719,7 +1719,7 @@
>::type
{
 typedef typename make_trie
- <T,
+ <T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
@@ -1776,8 +1776,8 @@
#endif

-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Modified: branches/release/boost/intrusive/treap_algorithms.hpp
==============================================================================
--- branches/release/boost/intrusive/treap_algorithms.hpp (original)
+++ branches/release/boost/intrusive/treap_algorithms.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -28,15 +28,15 @@
namespace boost {
namespace intrusive {

-//! treap_algorithms provides basic algorithms to manipulate
+//! treap_algorithms provides basic algorithms to manipulate
//! nodes forming a treap.
-//!
+//!
//! (1) the header node is maintained with links not only to the root
//! but also to the leftmost node of the tree, to enable constant time
//! begin(), and to the rightmost node of the tree, to enable linear time
//! performance when used with the generic set algorithms (set_union,
//! etc.);
-//!
+//!
//! (2) when a node being deleted has two children its successor node is
//! relinked into its place, rather than copied, so that the only
//! pointers invalidated are those referring to the deleted node.
@@ -56,15 +56,15 @@
//! Static functions:
//!
//! <tt>static node_ptr get_parent(const_node_ptr n);</tt>
-//!
+//!
//! <tt>static void set_parent(node_ptr n, node_ptr parent);</tt>
//!
//! <tt>static node_ptr get_left(const_node_ptr n);</tt>
-//!
+//!
//! <tt>static void set_left(node_ptr n, node_ptr left);</tt>
//!
//! <tt>static node_ptr get_right(const_node_ptr n);</tt>
-//!
+//!
//! <tt>static void set_right(node_ptr n, node_ptr right);</tt>
template<class NodeTraits>
class treap_algorithms
@@ -92,7 +92,7 @@
 tree_algorithms::erase(header_, z_);
 }
 }
-
+
 void release()
 { remove_it_ = false; }

@@ -117,7 +117,7 @@
 rotate_up_n(header_, p_, n_);
 }
 }
-
+
 void release()
 { remove_it_ = false; }

@@ -170,27 +170,27 @@

 //! Requires: header1 and header2 must be the header nodes
 //! of two trees.
- //!
- //! Effects: Swaps two trees. After the function header1 will contain
+ //!
+ //! Effects: Swaps two trees. After the function header1 will contain
 //! links to the second tree and header2 will have links to the first tree.
- //!
- //! Complexity: Constant.
- //!
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: Nothing.
 static void swap_tree(const node_ptr & header1, const node_ptr & header2)
 { return tree_algorithms::swap_tree(header1, header2); }

 //! Requires: node1 and node2 can't be header nodes
 //! of two trees.
- //!
+ //!
 //! Effects: Swaps two nodes. After the function node1 will be inserted
 //! in the position node2 before the function. node2 will be inserted in the
 //! position node1 had before the function.
- //!
- //! Complexity: Logarithmic.
- //!
+ //!
+ //! Complexity: Logarithmic.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function will break container ordering invariants if
 //! node1 and node2 are not equivalent according to the ordering rules.
 //!
@@ -199,22 +199,22 @@
 {
 if(node1 == node2)
 return;
-
+
 node_ptr header1(tree_algorithms::get_header(node1)), header2(tree_algorithms::get_header(node2));
 swap_nodes(node1, header1, node2, header2);
 }

 //! Requires: node1 and node2 can't be header nodes
 //! of two trees with header header1 and header2.
- //!
+ //!
 //! Effects: Swaps two nodes. After the function node1 will be inserted
 //! in the position node2 before the function. node2 will be inserted in the
 //! position node1 had before the function.
- //!
- //! Complexity: Constant.
- //!
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function will break container ordering invariants if
 //! node1 and node2 are not equivalent according to the ordering rules.
 //!
@@ -224,14 +224,14 @@

 //! Requires: node_to_be_replaced must be inserted in a tree
 //! and new_node must not be inserted in a tree.
- //!
+ //!
 //! Effects: Replaces node_to_be_replaced in its position in the
 //! tree with new_node. The tree does not need to be rebalanced
- //!
- //! Complexity: Logarithmic.
- //!
+ //!
+ //! Complexity: Logarithmic.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function will break container ordering invariants if
 //! new_node is not equivalent to node_to_be_replaced according to the
 //! ordering rules. This function is faster than erasing and inserting
@@ -247,14 +247,14 @@

 //! Requires: node_to_be_replaced must be inserted in a tree
 //! with header "header" and new_node must not be inserted in a tree.
- //!
+ //!
 //! Effects: Replaces node_to_be_replaced in its position in the
 //! tree with new_node. The tree does not need to be rebalanced
- //!
- //! Complexity: Constant.
- //!
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function will break container ordering invariants if
 //! new_node is not equivalent to node_to_be_replaced according to the
 //! ordering rules. This function is faster than erasing and inserting
@@ -265,11 +265,11 @@
 { tree_algorithms::replace_node(node_to_be_replaced, header, new_node); }

 //! Requires: node is a tree node but not the header.
- //!
+ //!
 //! Effects: Unlinks the node and rebalances the tree.
- //!
+ //!
 //! Complexity: Average complexity is constant time.
- //!
+ //!
 //! Throws: If "pcomp" throws, strong guarantee
 template<class NodePtrPriorityCompare>
 static void unlink(const node_ptr & node, NodePtrPriorityCompare pcomp)
@@ -283,14 +283,14 @@
 }

 //! Requires: header is the header of a tree.
- //!
+ //!
 //! Effects: Unlinks the leftmost node from the tree, and
 //! updates the header link to the new leftmost node.
- //!
+ //!
 //! Complexity: Average complexity is constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Notes: This function breaks the tree and the tree can
 //! only be used for more unlink_leftmost_without_rebalance calls.
 //! This function is normally used to achieve a step by step
@@ -300,51 +300,51 @@

 //! Requires: node is a node of the tree or an node initialized
 //! by init(...).
- //!
+ //!
 //! Effects: Returns true if the node is initialized by init().
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: Nothing.
 static bool unique(const const_node_ptr & node)
 { return tree_algorithms::unique(node); }

 //! Requires: node is a node of the tree but it's not the header.
- //!
+ //!
 //! Effects: Returns the number of nodes of the subtree.
- //!
+ //!
 //! Complexity: Linear time.
- //!
+ //!
 //! Throws: Nothing.
 static std::size_t count(const const_node_ptr & node)
 { return tree_algorithms::count(node); }

 //! Requires: header is the header node of the tree.
- //!
+ //!
 //! Effects: Returns the number of nodes above the header.
- //!
+ //!
 //! Complexity: Linear time.
- //!
+ //!
 //! Throws: Nothing.
 static std::size_t size(const const_node_ptr & header)
 { return tree_algorithms::size(header); }

 //! Requires: p is a node from the tree except the header.
- //!
+ //!
 //! Effects: Returns the next node of the tree.
- //!
+ //!
 //! Complexity: Average constant time.
- //!
+ //!
 //! Throws: Nothing.
 static node_ptr next_node(const node_ptr & p)
 { return tree_algorithms::next_node(p); }

 //! Requires: p is a node from the tree except the leftmost node.
- //!
+ //!
 //! Effects: Returns the previous node of the tree.
- //!
+ //!
 //! Complexity: Average constant time.
- //!
+ //!
 //! Throws: Nothing.
 static node_ptr prev_node(const node_ptr & p)
 { return tree_algorithms::prev_node(p); }
@@ -352,9 +352,9 @@
 //! Requires: node must not be part of any tree.
 //!
 //! Effects: After the function unique(node) == true.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 //!
 //! Nodes: If node is inserted in a tree, this function corrupts the tree.
@@ -365,9 +365,9 @@
 //!
 //! Effects: Initializes the header to represent an empty tree.
 //! unique(header) == true.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 //!
 //! Nodes: If node is inserted in a tree, this function corrupts the tree.
@@ -380,9 +380,9 @@
 //! of that tree and z != header.
 //!
 //! Effects: Erases node "z" from the tree with header "header".
- //!
+ //!
 //! Complexity: Amortized constant time.
- //!
+ //!
 //! Throws: If "pcomp" throws, strong guarantee.
 template<class NodePtrPriorityCompare>
 static node_ptr erase(const node_ptr & header, const node_ptr & z, NodePtrPriorityCompare pcomp)
@@ -397,18 +397,18 @@
 //! object taking a node_ptr and returning a new cloned node of it. "disposer" must
 //! take a node_ptr and shouldn't throw.
 //!
- //! Effects: First empties target tree calling
+ //! Effects: First empties target tree calling
 //! <tt>void disposer::operator()(const node_ptr &)</tt> for every node of the tree
 //! except the header.
- //!
+ //!
 //! Then, duplicates the entire tree pointed by "source_header" cloning each
- //! source node with <tt>node_ptr Cloner::operator()(const node_ptr &)</tt> to obtain
+ //! source node with <tt>node_ptr Cloner::operator()(const node_ptr &)</tt> to obtain
 //! the nodes of the target tree. If "cloner" throws, the cloned target nodes
 //! are disposed using <tt>void disposer(const node_ptr &)</tt>.
- //!
+ //!
 //! Complexity: Linear to the number of element of the source tree plus the.
 //! number of elements of tree target tree when calling this function.
- //!
+ //!
 //! Throws: If cloner functor throws. If this happens target nodes are disposed.
 template <class Cloner, class Disposer>
 static void clone
@@ -420,13 +420,13 @@
 //! Requires: "disposer" must be an object function
 //! taking a node_ptr parameter and shouldn't throw.
 //!
- //! Effects: Empties the target tree calling
+ //! Effects: Empties the target tree calling
 //! <tt>void disposer::operator()(const node_ptr &)</tt> for every node of the tree
 //! except the header.
- //!
+ //!
 //! Complexity: Linear to the number of element of the source tree plus the.
 //! number of elements of tree target tree when calling this function.
- //!
+ //!
 //! Throws: If cloner functor throws. If this happens target nodes are disposed.
 template<class Disposer>
 static void clear_and_dispose(const node_ptr & header, Disposer disposer)
@@ -442,7 +442,7 @@
 //! not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static node_ptr lower_bound
@@ -458,7 +458,7 @@
 //! than "key" according to "comp" or "header" if that element does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static node_ptr upper_bound
@@ -474,7 +474,7 @@
 //! "key" according to "comp" or "header" if that element does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static node_ptr find
@@ -492,7 +492,7 @@
 //! if they there are no equivalent elements.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If "comp" throws.
 template<class KeyType, class KeyNodePtrCompare>
 static std::pair<node_ptr, node_ptr> equal_range
@@ -509,10 +509,10 @@
 //!
 //! Effects: Inserts new_node into the tree before the upper bound
 //! according to "comp" and rotates the tree according to "pcomp".
- //!
+ //!
 //! Complexity: Average complexity for insert element is at
 //! most logarithmic.
- //!
+ //!
 //! Throws: If "comp" throw or "pcomp" throw.
 template<class NodePtrCompare, class NodePtrPriorityCompare>
 static node_ptr insert_equal_upper_bound
@@ -534,10 +534,10 @@
 //!
 //! Effects: Inserts new_node into the tree before the upper bound
 //! according to "comp" and rotates the tree according to "pcomp".
- //!
+ //!
 //! Complexity: Average complexity for insert element is at
 //! most logarithmic.
- //!
+ //!
 //! Throws: If "comp" throws.
 template<class NodePtrCompare, class NodePtrPriorityCompare>
 static node_ptr insert_equal_lower_bound
@@ -557,7 +557,7 @@
 //! NodePtrPriorityCompare is a priority function object that induces a strict weak
 //! ordering compatible with the one used to create the
 //! the tree. NodePtrPriorityCompare compares two node_ptrs.
- //!
+ //!
 //! Effects: Inserts new_node into the tree, using "hint" as a hint to
 //! where it will be inserted. If "hint" is the upper_bound
 //! the insertion takes constant time (two comparisons in the worst case).
@@ -565,7 +565,7 @@
 //!
 //! Complexity: Logarithmic in general, but it is amortized
 //! constant time if new_node is inserted immediately before "hint".
- //!
+ //!
 //! Throws: If "comp" throw or "pcomp" throw.
 template<class NodePtrCompare, class NodePtrPriorityCompare>
 static node_ptr insert_equal
@@ -585,14 +585,14 @@
 //! NodePtrPriorityCompare is a priority function object that induces a strict weak
 //! ordering compatible with the one used to create the
 //! the tree. NodePtrPriorityCompare compares two node_ptrs.
- //!
+ //!
 //! Effects: Inserts new_node into the tree before "pos"
 //! and rotates the tree according to "pcomp".
 //!
 //! Complexity: Constant-time.
- //!
+ //!
 //! Throws: If "pcomp" throws, strong guarantee.
- //!
+ //!
 //! Note: If "pos" is not the successor of the newly inserted "new_node"
 //! tree invariants might be broken.
 template<class NodePtrPriorityCompare>
@@ -611,14 +611,14 @@
 //! NodePtrPriorityCompare is a priority function object that induces a strict weak
 //! ordering compatible with the one used to create the
 //! the tree. NodePtrPriorityCompare compares two node_ptrs.
- //!
+ //!
 //! Effects: Inserts x into the tree in the last position
 //! and rotates the tree according to "pcomp".
 //!
 //! Complexity: Constant-time.
- //!
+ //!
 //! Throws: If "pcomp" throws, strong guarantee.
- //!
+ //!
 //! Note: If "new_node" is less than the greatest inserted key
 //! tree invariants are broken. This function is slightly faster than
 //! using "insert_before".
@@ -636,14 +636,14 @@
 //! NodePtrPriorityCompare is a priority function object that induces a strict weak
 //! ordering compatible with the one used to create the
 //! the tree. NodePtrPriorityCompare compares two node_ptrs.
- //!
+ //!
 //! Effects: Inserts x into the tree in the first position
 //! and rotates the tree according to "pcomp".
 //!
 //! Complexity: Constant-time.
- //!
+ //!
 //! Throws: If "pcomp" throws, strong guarantee.
- //!
+ //!
 //! Note: If "new_node" is greater than the lowest inserted key
 //! tree invariants are broken. This function is slightly faster than
 //! using "insert_before".
@@ -659,7 +659,7 @@
 //! KeyNodePtrCompare is a function object that induces a strict weak
 //! ordering compatible with the strict weak ordering used to create the
 //! the tree. NodePtrCompare compares KeyType with a node_ptr.
- //!
+ //!
 //! Effects: Checks if there is an equivalent node to "key" in the
 //! tree according to "comp" and obtains the needed information to realize
 //! a constant-time node insertion if there is no equivalent node.
@@ -670,11 +670,11 @@
 //! in the returned pair's boolean and fills "commit_data" that is meant to
 //! be used with the "insert_commit" function to achieve a constant-time
 //! insertion function.
- //!
+ //!
 //! Complexity: Average complexity is at most logarithmic.
 //!
 //! Throws: If "comp" throws.
- //!
+ //!
 //! Notes: This function is used to improve performance when constructing
 //! a node is expensive and the user does not want to have two equivalent nodes
 //! in the tree: if there is an equivalent value
@@ -707,12 +707,12 @@
 //! ordering compatible with the strict weak ordering used to create the
 //! the tree. NodePtrCompare compares KeyType with a node_ptr.
 //! "hint" is node from the "header"'s tree.
- //!
+ //!
 //! Effects: Checks if there is an equivalent node to "key" in the
 //! tree according to "comp" using "hint" as a hint to where it should be
 //! inserted and obtains the needed information to realize
- //! a constant-time node insertion if there is no equivalent node.
- //! If "hint" is the upper_bound the function has constant time
+ //! a constant-time node insertion if there is no equivalent node.
+ //! If "hint" is the upper_bound the function has constant time
 //! complexity (two comparisons in the worst case).
 //!
 //! Returns: If there is an equivalent value
@@ -721,12 +721,12 @@
 //! in the returned pair's boolean and fills "commit_data" that is meant to
 //! be used with the "insert_commit" function to achieve a constant-time
 //! insertion function.
- //!
+ //!
 //! Complexity: Average complexity is at most logarithmic, but it is
 //! amortized constant time if new_node should be inserted immediately before "hint".
 //!
 //! Throws: If "comp" throws.
- //!
+ //!
 //! Notes: This function is used to improve performance when constructing
 //! a node is expensive and the user does not want to have two equivalent nodes
 //! in the tree: if there is an equivalent value
@@ -757,16 +757,16 @@
 //! "commit_data" must have been obtained from a previous call to
 //! "insert_unique_check". No objects should have been inserted or erased
 //! from the set between the "insert_unique_check" that filled "commit_data"
- //! and the call to "insert_commit".
- //!
- //!
+ //! and the call to "insert_commit".
+ //!
+ //!
 //! Effects: Inserts new_node in the set using the information obtained
 //! from the "commit_data" that a previous "insert_check" filled.
 //!
 //! Complexity: Constant time.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Notes: This function has only sense if a "insert_unique_check" has been
 //! previously executed to fill "commit_data". No value should be inserted or
 //! erased between the "insert_check" and "insert_commit" calls.
@@ -782,7 +782,7 @@
 //! Effects: Returns a pointer to the header node of the tree.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: Nothing.
 static node_ptr get_header(const node_ptr & n)
 { return tree_algorithms::get_header(n); }
@@ -791,11 +791,11 @@
 private:

 //! Requires: p is a node of a tree.
- //!
+ //!
 //! Effects: Returns true if p is the header of the tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 static bool is_header(const const_node_ptr & p)
 {
@@ -887,8 +887,8 @@
 /// @endcond
};

-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Modified: branches/release/boost/intrusive/treap_set.hpp
==============================================================================
--- branches/release/boost/intrusive/treap_set.hpp (original)
+++ branches/release/boost/intrusive/treap_set.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -22,9 +22,9 @@
namespace boost {
namespace intrusive {

-//! The class template treap_set is an intrusive container, that mimics most of
+//! The class template treap_set is an intrusive container, that mimics most of
//! the interface of std::set as described in the C++ standard.
-//!
+//!
//! The template parameter \c T is the type to be managed by the container.
//! The user can specify additional options and if no options are provided
//! default options are used.
@@ -80,31 +80,31 @@
 /// @endcond

 public:
- //! Effects: Constructs an empty treap_set.
- //!
- //! Complexity: Constant.
- //!
+ //! Effects: Constructs an empty treap_set.
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: If value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
- //! or the copy constructor of the value_compare object throws.
+ //! or the copy constructor of the value_compare object throws.
 treap_set_impl( const value_compare &cmp = value_compare()
 , const priority_compare &pcmp = priority_compare()
- , const value_traits &v_traits = value_traits())
+ , const value_traits &v_traits = value_traits())
 : tree_(cmp, pcmp, v_traits)
 {}

- //! Requires: Dereferencing iterator must yield an lvalue of type value_type.
+ //! Requires: Dereferencing iterator must yield an lvalue of type value_type.
 //! cmp must be a comparison function that induces a strict weak ordering.
- //!
- //! Effects: Constructs an empty treap_set and inserts elements from
+ //!
+ //! Effects: Constructs an empty treap_set and inserts elements from
 //! [b, e).
- //!
- //! Complexity: Linear in N if [b, e) is already sorted using
+ //!
+ //! Complexity: Linear in N if [b, e) is already sorted using
 //! comp and otherwise N * log N, where N is std::distance(last, first).
- //!
+ //!
 //! Throws: If value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
- //! or the copy constructor/operator() of the value_compare object throws.
+ //! or the copy constructor/operator() of the value_compare object throws.
 template<class Iterator>
 treap_set_impl( Iterator b, Iterator e
 , const value_compare &cmp = value_compare()
@@ -114,186 +114,186 @@
 {}

 //! Effects: to-do
- //!
- treap_set_impl(BOOST_RV_REF(treap_set_impl) x)
+ //!
+ treap_set_impl(BOOST_RV_REF(treap_set_impl) x)
 : tree_(::boost::move(x.tree_))
 {}

 //! Effects: to-do
- //!
- treap_set_impl& operator=(BOOST_RV_REF(treap_set_impl) x)
+ //!
+ treap_set_impl& operator=(BOOST_RV_REF(treap_set_impl) x)
 { tree_ = ::boost::move(x.tree_); return *this; }

- //! Effects: Detaches all elements from this. The objects in the treap_set
+ //! Effects: Detaches all elements from this. The objects in the treap_set
 //! are not deleted (i.e. no destructors are called).
- //!
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
- //!
+ //!
 //! Throws: Nothing.
- ~treap_set_impl()
+ ~treap_set_impl()
 {}

 //! Effects: Returns an iterator pointing to the beginning of the treap_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator begin()
 { return tree_.begin(); }

 //! Effects: Returns a const_iterator pointing to the beginning of the treap_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator begin() const
 { return tree_.begin(); }

 //! Effects: Returns a const_iterator pointing to the beginning of the treap_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator cbegin() const
 { return tree_.cbegin(); }

 //! Effects: Returns an iterator pointing to the end of the treap_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator end()
 { return tree_.end(); }

 //! Effects: Returns a const_iterator pointing to the end of the treap_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator end() const
 { return tree_.end(); }

 //! Effects: Returns an iterator pointing to the highest priority object of the tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator top()
 { return tree_.top(); }

 //! Effects: Returns a const_iterator pointing to the highest priority object of the tree..
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator top() const
 { return this->ctop(); }

 //! Effects: Returns a const_iterator pointing to the highest priority object of the tree..
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator ctop() const
 { return tree_.ctop(); }

 //! Effects: Returns a const_iterator pointing to the end of the treap_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator cend() const
 { return tree_.cend(); }

 //! Effects: Returns a reverse_iterator pointing to the beginning of the
 //! reversed treap_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 reverse_iterator rbegin()
 { return tree_.rbegin(); }

 //! Effects: Returns a const_reverse_iterator pointing to the beginning
 //! of the reversed treap_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator rbegin() const
 { return tree_.rbegin(); }

 //! Effects: Returns a const_reverse_iterator pointing to the beginning
 //! of the reversed treap_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator crbegin() const
 { return tree_.crbegin(); }

 //! Effects: Returns a reverse_iterator pointing to the end
 //! of the reversed treap_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 reverse_iterator rend()
 { return tree_.rend(); }

 //! Effects: Returns a const_reverse_iterator pointing to the end
 //! of the reversed treap_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator rend() const
 { return tree_.rend(); }

 //! Effects: Returns a const_reverse_iterator pointing to the end
 //! of the reversed treap_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator crend() const
 { return tree_.crend(); }

 //! Effects: Returns a reverse_iterator pointing to the highest priority object of the
 //! reversed tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 reverse_iterator rtop()
 { return tree_.rtop(); }

 //! Effects: Returns a const_reverse_iterator pointing to the highest priority objec
 //! of the reversed tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator rtop() const
 { return tree_.crtop(); }

 //! Effects: Returns a const_reverse_iterator pointing to the highest priority object
 //! of the reversed tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator crtop() const
 { return tree_.crtop(); }

 //! Precondition: end_iterator must be a valid end iterator
 //! of treap_set.
- //!
+ //!
 //! Effects: Returns a const reference to the treap_set associated to the end iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 static treap_set_impl &container_from_end_iterator(iterator end_iterator)
 {
@@ -304,11 +304,11 @@

 //! Precondition: end_iterator must be a valid end const_iterator
 //! of treap_set.
- //!
+ //!
 //! Effects: Returns a const reference to the treap_set associated to the end iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 static const treap_set_impl &container_from_end_iterator(const_iterator end_iterator)
 {
@@ -318,11 +318,11 @@
 }

 //! Precondition: it must be a valid iterator of set.
- //!
+ //!
 //! Effects: Returns a reference to the set associated to the iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Logarithmic.
 static treap_set_impl &container_from_iterator(iterator it)
 {
@@ -332,11 +332,11 @@
 }

 //! Precondition: it must be a valid const_iterator of set.
- //!
+ //!
 //! Effects: Returns a const reference to the set associated to the iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Logarithmic.
 static const treap_set_impl &container_from_iterator(const_iterator it)
 {
@@ -346,50 +346,50 @@
 }

 //! Effects: Returns the key_compare object used by the treap_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If key_compare copy-constructor throws.
 key_compare key_comp() const
 { return tree_.value_comp(); }

 //! Effects: Returns the value_compare object used by the treap_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If value_compare copy-constructor throws.
 value_compare value_comp() const
 { return tree_.value_comp(); }

 //! Effects: Returns the priority_compare object used by the treap_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If priority_compare copy-constructor throws.
 priority_compare priority_comp() const
 { return tree_.priority_comp(); }

 //! Effects: Returns true if the container is empty.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 bool empty() const
 { return tree_.empty(); }

 //! Effects: Returns the number of elements stored in the treap_set.
- //!
+ //!
 //! Complexity: Linear to elements contained in *this if,
 //! constant-time size option is enabled. Constant-time otherwise.
- //!
+ //!
 //! Throws: Nothing.
 size_type size() const
 { return tree_.size(); }

 //! Effects: Swaps the contents of two sets.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If the swap() call for the comparison functor
 //! found using ADL throws. Strong guarantee.
 void swap(treap_set_impl& other)
@@ -399,22 +399,22 @@
 //! Cloner should yield to nodes equivalent to the original nodes.
 //!
 //! Effects: Erases all the elements from *this
- //! calling Disposer::operator()(pointer), clones all the
+ //! calling Disposer::operator()(pointer), clones all the
 //! elements from src calling Cloner::operator()(const_reference )
 //! and inserts them on *this. Copies the predicate from the source container.
 //!
 //! If cloner throws, all cloned elements are unlinked and disposed
 //! calling Disposer::operator()(pointer).
- //!
+ //!
 //! Complexity: Linear to erased plus inserted elements.
- //!
+ //!
 //! Throws: If cloner throws or predicate copy assignment throws. Basic guarantee.
 template <class Cloner, class Disposer>
 void clone_from(const treap_set_impl &src, Cloner cloner, Disposer disposer)
 { tree_.clone_from(src.tree_, cloner, disposer); }

 //! Requires: value must be an lvalue
- //!
+ //!
 //! Effects: Tries to inserts value into the treap_set.
 //!
 //! Returns: If the value
@@ -422,43 +422,43 @@
 //! iterator to the new value and true. If there is an equivalent value
 //! returns a pair containing an iterator to the already present value
 //! and false.
- //!
+ //!
 //! Complexity: Average complexity for insert element is at
 //! most logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare or priority_compare ordering function throw.
 //! Strong guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 std::pair<iterator, bool> insert(reference value)
 { return tree_.insert_unique(value); }

 //! Requires: value must be an lvalue
- //!
- //! Effects: Tries to to insert x into the treap_set, using "hint"
+ //!
+ //! Effects: Tries to to insert x into the treap_set, using "hint"
 //! as a hint to where it will be inserted.
 //!
- //! Returns: An iterator that points to the position where the
+ //! Returns: An iterator that points to the position where the
 //! new element was inserted into the treap_set.
- //!
+ //!
 //! Complexity: Logarithmic in general, but it's amortized
 //! constant time if t is inserted immediately before hint.
- //!
+ //!
 //! Throws: If the internal value_compare or priority_compare ordering
 //! functions throw. Strong guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 iterator insert(const_iterator hint, reference value)
 { return tree_.insert_unique(hint, value); }

- //! Requires: key_value_comp must be a comparison function that induces
+ //! Requires: key_value_comp must be a comparison function that induces
 //! the same strict weak ordering as value_compare.
- //! key_value_pcomp must be a comparison function that induces
+ //! key_value_pcomp must be a comparison function that induces
 //! the same strict weak ordering as priority_compare. The difference is that
 //! key_value_pcomp and key_value_comp compare an arbitrary key with the contained values.
- //!
+ //!
 //! Effects: Checks if a value can be inserted in the treap_set, using
 //! a user provided key instead of the value itself.
 //!
@@ -467,17 +467,17 @@
 //! and false. If the value can be inserted returns true in the returned
 //! pair boolean and fills "commit_data" that is meant to be used with
 //! the "insert_commit" function.
- //!
+ //!
 //! Complexity: Average complexity is at most logarithmic.
 //!
 //! Throws: If key_value_comp or key_value_pcomp ordering function throw.
 //! Strong guarantee.
- //!
+ //!
 //! Notes: This function is used to improve performance when constructing
 //! a value_type is expensive: if there is an equivalent value
 //! the constructed object must be discarded. Many times, the part of the
 //! node that is used to impose the order is much cheaper to construct
- //! than the value_type and this function offers the possibility to use that
+ //! than the value_type and this function offers the possibility to use that
 //! part to check if the insertion will be successful.
 //!
 //! If the check is successful, the user can construct the value_type and use
@@ -492,14 +492,14 @@
 , insert_commit_data &commit_data)
 { return tree_.insert_unique_check(key, key_value_comp, key_value_pcomp, commit_data); }

- //! Requires: key_value_comp must be a comparison function that induces
+ //! Requires: key_value_comp must be a comparison function that induces
 //! the same strict weak ordering as value_compare.
- //! key_value_pcomp must be a comparison function that induces
+ //! key_value_pcomp must be a comparison function that induces
 //! the same strict weak ordering as priority_compare. The difference is that
 //! key_value_pcomp and key_value_comp compare an arbitrary key with the contained values.
- //!
+ //!
 //! Effects: Checks if a value can be inserted in the treap_set, using
- //! a user provided key instead of the value itself, using "hint"
+ //! a user provided key instead of the value itself, using "hint"
 //! as a hint to where it will be inserted.
 //!
 //! Returns: If there is an equivalent value
@@ -507,24 +507,24 @@
 //! and false. If the value can be inserted returns true in the returned
 //! pair boolean and fills "commit_data" that is meant to be used with
 //! the "insert_commit" function.
- //!
+ //!
 //! Complexity: Logarithmic in general, but it's amortized
 //! constant time if t is inserted immediately before hint.
 //!
 //! Throws: If key_value_comp or key_value_pcomp ordering function throw.
 //! Strong guarantee.
- //!
+ //!
 //! Notes: This function is used to improve performance when constructing
 //! a value_type is expensive: if there is an equivalent value
 //! the constructed object must be discarded. Many times, the part of the
 //! constructing that is used to impose the order is much cheaper to construct
- //! than the value_type and this function offers the possibility to use that key
+ //! than the value_type and this function offers the possibility to use that key
 //! to check if the insertion will be successful.
 //!
 //! If the check is successful, the user can construct the value_type and use
 //! "insert_commit" to insert the object in constant-time. This can give a total
 //! constant-time complexity to the insertion: check(O(1)) + commit(O(1)).
- //!
+ //!
 //! "commit_data" remains valid for a subsequent "insert_commit" only if no more
 //! objects are inserted or erased from the treap_set.
 template<class KeyType, class KeyValueCompare, class KeyValuePriorityCompare>
@@ -538,34 +538,34 @@
 //! must have been obtained from a previous call to "insert_check".
 //! No objects should have been inserted or erased from the treap_set between
 //! the "insert_check" that filled "commit_data" and the call to "insert_commit".
- //!
+ //!
 //! Effects: Inserts the value in the treap_set using the information obtained
 //! from the "commit_data" that a previous "insert_check" filled.
 //!
 //! Returns: An iterator to the newly inserted object.
- //!
+ //!
 //! Complexity: Constant time.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Notes: This function has only sense if a "insert_check" has been
 //! previously executed to fill "commit_data". No value should be inserted or
 //! erased between the "insert_check" and "insert_commit" calls.
 iterator insert_commit(reference value, const insert_commit_data &commit_data)
 { return tree_.insert_unique_commit(value, commit_data); }

- //! Requires: Dereferencing iterator must yield an lvalue
+ //! Requires: Dereferencing iterator must yield an lvalue
 //! of type value_type.
- //!
+ //!
 //! Effects: Inserts a range into the treap_set.
- //!
+ //!
 //! Complexity: Insert range is in general O(N * log(N)), where N is the
 //! size of the range. However, it is linear in N if the range is already sorted
 //! by value_comp().
- //!
+ //!
 //! Throws: If the internal value_compare or priority_compare ordering function
 //! throw. Basic guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 template<class Iterator>
@@ -578,11 +578,11 @@
 //! inserted key according to the predicate.
 //!
 //! Effects: Inserts x into the treap before "pos".
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: If the internal priority_compare function throws. Strong guarantee.
- //!
+ //!
 //! Note: This function does not check preconditions so if "pos" is not
 //! the successor of "value" treap ordering invariant will be broken.
 //! This is a low-level function to be used only for performance reasons
@@ -594,11 +594,11 @@
 //! any inserted key according to the predicate.
 //!
 //! Effects: Inserts x into the treap in the last position.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: If the internal priority_compare function throws. Strong guarantee.
- //!
+ //!
 //! Note: This function does not check preconditions so if value is
 //! less than the greatest inserted key treap ordering invariant will be broken.
 //! This function is slightly more efficient than using "insert_before".
@@ -611,11 +611,11 @@
 //! than any inserted key according to the predicate.
 //!
 //! Effects: Inserts x into the treap in the first position.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: If the internal priority_compare function throws. Strong guarantee.
- //!
+ //!
 //! Note: This function does not check preconditions so if value is
 //! greater than the minimum inserted key treap ordering invariant will be broken.
 //! This function is slightly more efficient than using "insert_before".
@@ -624,42 +624,42 @@
 void push_front(reference value)
 { tree_.push_front(value); }

- //! Effects: Erases the element pointed to by pos.
- //!
+ //! Effects: Erases the element pointed to by pos.
+ //!
 //! Complexity: Average complexity is constant time.
- //!
+ //!
 //! Returns: An iterator to the element after the erased element.
 //!
 //! Throws: If the internal priority_compare function throws. Strong guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 iterator erase(const_iterator i)
 { return tree_.erase(i); }

- //! Effects: Erases the range pointed to by b end e.
- //!
- //! Complexity: Average complexity for erase range is at most
+ //! Effects: Erases the range pointed to by b end e.
+ //!
+ //! Complexity: Average complexity for erase range is at most
 //! O(log(size() + N)), where N is the number of elements in the range.
- //!
+ //!
 //! Returns: An iterator to the element after the erased elements.
- //!
+ //!
 //! Throws: If the internal priority_compare function throws. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 iterator erase(const_iterator b, const_iterator e)
 { return tree_.erase(b, e); }

 //! Effects: Erases all the elements with the given value.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size()) + this->count(value)).
- //!
+ //!
 //! Throws: If internal value_compare or priority_compare
 //! ordering functions throw. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 size_type erase(const_reference value)
@@ -667,14 +667,14 @@

 //! Effects: Erases all the elements that compare equal with
 //! the given key and the given comparison functor.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size() + this->count(key, comp)).
- //!
+ //!
 //! Throws: If comp or internal priority_compare
 //! ordering functions throw. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class KeyType, class KeyValueCompare>
@@ -687,16 +687,16 @@

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
 //!
- //! Effects: Erases the element pointed to by pos.
+ //! Effects: Erases the element pointed to by pos.
 //! Disposer::operator()(pointer) is called for the removed element.
- //!
- //! Complexity: Average complexity for erase element is constant time.
- //!
+ //!
+ //! Complexity: Average complexity for erase element is constant time.
+ //!
 //! Returns: An iterator to the element after the erased element.
- //!
+ //!
 //! Throws: If the internal priority_compare function throws. Strong guarantee.
- //!
- //! Note: Invalidates the iterators
+ //!
+ //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
 iterator erase_and_dispose(const_iterator i, Disposer disposer)
@@ -712,14 +712,14 @@
 //!
 //! Effects: Erases the range pointed to by b end e.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
- //! Complexity: Average complexity for erase range is at most
+ //!
+ //! Complexity: Average complexity for erase range is at most
 //! O(log(size() + N)), where N is the number of elements in the range.
- //!
+ //!
 //! Returns: An iterator to the element after the erased elements.
- //!
+ //!
 //! Throws: If the internal priority_compare function throws. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
@@ -730,13 +730,13 @@
 //!
 //! Effects: Erases all the elements with the given value.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
- //!
+ //!
 //! Complexity: O(log(size() + this->count(value)). Basic guarantee.
- //!
+ //!
 //! Throws: If the internal priority_compare function throws. Strong guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class Disposer>
@@ -750,12 +750,12 @@
 //! Disposer::operator()(pointer) is called for the removed elements.
 //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size() + this->count(key, comp)).
- //!
+ //!
 //! Throws: If comp or internal priority_compare ordering functions throw.
 //! Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class KeyType, class KeyValueCompare, class Disposer>
@@ -767,26 +767,26 @@
 { return tree_.erase_and_dispose(key, comp, disposer); }

 //! Effects: Erases all the elements of the container.
- //!
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 void clear()
 { return tree_.clear(); }

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
- //!
+ //!
 //! Effects: Erases all the elements of the container.
- //!
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class Disposer>
@@ -794,20 +794,20 @@
 { return tree_.clear_and_dispose(disposer); }

 //! Effects: Returns the number of contained elements with the given key
- //!
+ //!
 //! Complexity: Logarithmic to the number of elements contained plus lineal
 //! to number of objects with the given key.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 size_type count(const_reference value) const
 { return tree_.find(value) != end(); }

 //! Effects: Returns the number of contained elements with the same key
 //! compared with the given comparison functor.
- //!
+ //!
 //! Complexity: Logarithmic to the number of elements contained plus lineal
 //! to number of objects with the given key.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 template<class KeyType, class KeyValueCompare>
 size_type count(const KeyType& key, KeyValueCompare comp) const
@@ -815,9 +815,9 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is not less than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 iterator lower_bound(const_reference value)
 { return tree_.lower_bound(value); }
@@ -827,13 +827,13 @@
 //! that is used in the ordering functor.
 //!
 //! Effects: Returns an iterator to the first element whose
- //! key according to the comparison functor is not less than k or
+ //! key according to the comparison functor is not less than k or
 //! end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
- //!
+ //!
 //! Note: This function is used when constructing a value_type
 //! is expensive and the value_type can be compared with a cheaper
 //! key type. Usually this key is part of the value_type.
@@ -843,9 +843,9 @@

 //! Effects: Returns a const iterator to the first element whose
 //! key is not less than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 const_iterator lower_bound(const_reference value) const
 { return tree_.lower_bound(value); }
@@ -855,13 +855,13 @@
 //! that is used in the ordering functor.
 //!
 //! Effects: Returns a const_iterator to the first element whose
- //! key according to the comparison functor is not less than k or
+ //! key according to the comparison functor is not less than k or
 //! end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
- //!
+ //!
 //! Note: This function is used when constructing a value_type
 //! is expensive and the value_type can be compared with a cheaper
 //! key type. Usually this key is part of the value_type.
@@ -871,9 +871,9 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is greater than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 iterator upper_bound(const_reference value)
 { return tree_.upper_bound(value); }
@@ -883,11 +883,11 @@
 //! that is used in the ordering functor.
 //!
 //! Effects: Returns an iterator to the first element whose
- //! key according to the comparison functor is greater than key or
+ //! key according to the comparison functor is greater than key or
 //! end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -899,9 +899,9 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is greater than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 const_iterator upper_bound(const_reference value) const
 { return tree_.upper_bound(value); }
@@ -911,11 +911,11 @@
 //! that is used in the ordering functor.
 //!
 //! Effects: Returns a const_iterator to the first element whose
- //! key according to the comparison functor is greater than key or
+ //! key according to the comparison functor is greater than key or
 //! end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -925,11 +925,11 @@
 const_iterator upper_bound(const KeyType& key, KeyValueCompare comp) const
 { return tree_.upper_bound(key, comp); }

- //! Effects: Finds an iterator to the first element whose value is
+ //! Effects: Finds an iterator to the first element whose value is
 //! "value" or end() if that element does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 iterator find(const_reference value)
 { return tree_.find(value); }
@@ -938,12 +938,12 @@
 //! value_compare. Usually key is the part of the value_type
 //! that is used in the ordering functor.
 //!
- //! Effects: Finds an iterator to the first element whose key is
- //! "key" according to the comparison functor or end() if that element
+ //! Effects: Finds an iterator to the first element whose key is
+ //! "key" according to the comparison functor or end() if that element
 //! does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -953,11 +953,11 @@
 iterator find(const KeyType& key, KeyValueCompare comp)
 { return tree_.find(key, comp); }

- //! Effects: Finds a const_iterator to the first element whose value is
+ //! Effects: Finds a const_iterator to the first element whose value is
 //! "value" or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 const_iterator find(const_reference value) const
 { return tree_.find(value); }
@@ -966,12 +966,12 @@
 //! value_compare. Usually key is the part of the value_type
 //! that is used in the ordering functor.
 //!
- //! Effects: Finds a const_iterator to the first element whose key is
- //! "key" according to the comparison functor or end() if that element
+ //! Effects: Finds a const_iterator to the first element whose key is
+ //! "key" according to the comparison functor or end() if that element
 //! does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -984,9 +984,9 @@
 //! Effects: Finds a range containing all elements whose key is k or
 //! an empty range that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 std::pair<iterator,iterator> equal_range(const_reference value)
 { return tree_.equal_range(value); }
@@ -995,13 +995,13 @@
 //! value_compare. Usually key is the part of the value_type
 //! that is used in the ordering functor.
 //!
- //! Effects: Finds a range containing all elements whose key is k
- //! according to the comparison functor or an empty range
+ //! Effects: Finds a range containing all elements whose key is k
+ //! according to the comparison functor or an empty range
 //! that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -1014,9 +1014,9 @@
 //! Effects: Finds a range containing all elements whose key is k or
 //! an empty range that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 std::pair<const_iterator, const_iterator>
 equal_range(const_reference value) const
@@ -1026,13 +1026,13 @@
 //! value_compare. Usually key is the part of the value_type
 //! that is used in the ordering functor.
 //!
- //! Effects: Finds a range containing all elements whose key is k
- //! according to the comparison functor or an empty range
+ //! Effects: Finds a range containing all elements whose key is k
+ //! according to the comparison functor or an empty range
 //! that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -1045,14 +1045,14 @@

 //! Requires: value must be an lvalue and shall be in a treap_set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid iterator i belonging to the treap_set
 //! that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This static function is available only if the value traits
 //! is stateless.
 static iterator s_iterator_to(reference value)
@@ -1060,14 +1060,14 @@

 //! Requires: value must be an lvalue and shall be in a treap_set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid const_iterator i belonging to the
 //! treap_set that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This static function is available only if the value traits
 //! is stateless.
 static const_iterator s_iterator_to(const_reference value)
@@ -1075,48 +1075,48 @@

 //! Requires: value must be an lvalue and shall be in a treap_set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid iterator i belonging to the treap_set
 //! that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator iterator_to(reference value)
 { return tree_.iterator_to(value); }

 //! Requires: value must be an lvalue and shall be in a treap_set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid const_iterator i belonging to the
 //! treap_set that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator iterator_to(const_reference value) const
 { return tree_.iterator_to(value); }

 //! Requires: value shall not be in a treap_set/treap_multiset.
- //!
+ //!
 //! Effects: init_node puts the hook of a value in a well-known default
 //! state.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Note: This function puts the hook in the well-known default state
 //! used by auto_unlink and safe hooks.
 static void init_node(reference value)
 { tree_type::init_node(value); }

 //! Effects: Unlinks the leftmost node from the tree.
- //!
+ //!
 //! Complexity: Average complexity is constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Notes: This function breaks the tree and the tree can
 //! only be used for more unlink_leftmost_without_rebalance calls.
 //! This function is normally used to achieve a step by step
@@ -1126,14 +1126,14 @@

 //! Requires: replace_this must be a valid iterator of *this
 //! and with_this must not be inserted in any tree.
- //!
+ //!
 //! Effects: Replaces replace_this in its position in the
 //! tree with with_this. The tree does not need to be rebalanced.
- //!
- //! Complexity: Constant.
- //!
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function will break container ordering invariants if
 //! with_this is not equivalent to *replace_this according to the
 //! ordering rules. This function is faster than erasing and inserting
@@ -1142,21 +1142,21 @@
 { tree_.replace_node(replace_this, with_this); }

 //! Effects: Rebalances the tree.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear.
 void rebalance()
 { tree_.rebalance(); }

 //! Requires: old_root is a node of a tree.
- //!
+ //!
 //! Effects: Rebalances the subtree rooted at old_root.
 //!
 //! Returns: The new root of the subtree.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the elements in the subtree.
 iterator rebalance_subtree(iterator root)
 { return tree_.rebalance_subtree(root); }
@@ -1164,18 +1164,18 @@
 //! Returns: The balance factor (alpha) used in this tree
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 float balance_factor() const
 { return tree_.balance_factor(); }

 //! Requires: new_alpha must be a value between 0.5 and 1.0
- //!
+ //!
 //! Effects: Establishes a new balance factor (alpha) and rebalances
 //! the tree if the new balance factor is stricter (less) than the old factor.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the elements in the subtree.
 void balance_factor(float new_alpha)
 { tree_.balance_factor(new_alpha); }
@@ -1266,7 +1266,7 @@
{
 /// @cond
 typedef treap_set_impl
- < typename make_treap_opt<T,
+ < typename make_treap_opt<T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
@@ -1286,7 +1286,7 @@
template<class T, class ...Options>
#endif
class treap_set
- : public make_treap_set<T,
+ : public make_treap_set<T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
@@ -1295,7 +1295,7 @@
>::type
{
 typedef typename make_treap_set
- <T,
+ <T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
@@ -1350,9 +1350,9 @@

#endif

-//! The class template treap_multiset is an intrusive container, that mimics most of
+//! The class template treap_multiset is an intrusive container, that mimics most of
//! the interface of std::treap_multiset as described in the C++ standard.
-//!
+//!
//! The template parameter \c T is the type to be managed by the container.
//! The user can specify additional options and if no options are provided
//! default options are used.
@@ -1406,31 +1406,31 @@
 /// @endcond

 public:
- //! Effects: Constructs an empty treap_multiset.
- //!
- //! Complexity: Constant.
- //!
+ //! Effects: Constructs an empty treap_multiset.
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: If value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
- //! or the copy constructor of the value_compare/priority_compare objects throw.
+ //! or the copy constructor of the value_compare/priority_compare objects throw.
 treap_multiset_impl( const value_compare &cmp = value_compare()
 , const priority_compare &pcmp = priority_compare()
- , const value_traits &v_traits = value_traits())
+ , const value_traits &v_traits = value_traits())
 : tree_(cmp, pcmp, v_traits)
 {}

- //! Requires: Dereferencing iterator must yield an lvalue of type value_type.
+ //! Requires: Dereferencing iterator must yield an lvalue of type value_type.
 //! cmp must be a comparison function that induces a strict weak ordering.
- //!
- //! Effects: Constructs an empty treap_multiset and inserts elements from
+ //!
+ //! Effects: Constructs an empty treap_multiset and inserts elements from
 //! [b, e).
- //!
+ //!
 //! Complexity: Linear in N if [b, e) is already sorted using
 //! comp and otherwise N * log N, where N is the distance between first and last
- //!
+ //!
 //! Throws: If value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
- //! or the copy constructor/operator() of the value_compare/priority_compare objects throw.
+ //! or the copy constructor/operator() of the value_compare/priority_compare objects throw.
 template<class Iterator>
 treap_multiset_impl( Iterator b, Iterator e
 , const value_compare &cmp = value_compare()
@@ -1440,186 +1440,186 @@
 {}

 //! Effects: to-do
- //!
- treap_multiset_impl(BOOST_RV_REF(treap_multiset_impl) x)
+ //!
+ treap_multiset_impl(BOOST_RV_REF(treap_multiset_impl) x)
 : tree_(::boost::move(x.tree_))
 {}

 //! Effects: to-do
- //!
- treap_multiset_impl& operator=(BOOST_RV_REF(treap_multiset_impl) x)
+ //!
+ treap_multiset_impl& operator=(BOOST_RV_REF(treap_multiset_impl) x)
 { tree_ = ::boost::move(x.tree_); return *this; }

- //! Effects: Detaches all elements from this. The objects in the treap_multiset
+ //! Effects: Detaches all elements from this. The objects in the treap_multiset
 //! are not deleted (i.e. no destructors are called).
- //!
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
- //!
+ //!
 //! Throws: Nothing.
- ~treap_multiset_impl()
+ ~treap_multiset_impl()
 {}

 //! Effects: Returns an iterator pointing to the beginning of the treap_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator begin()
 { return tree_.begin(); }

 //! Effects: Returns a const_iterator pointing to the beginning of the treap_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator begin() const
 { return tree_.begin(); }

 //! Effects: Returns a const_iterator pointing to the beginning of the treap_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator cbegin() const
 { return tree_.cbegin(); }

 //! Effects: Returns an iterator pointing to the end of the treap_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator end()
 { return tree_.end(); }

 //! Effects: Returns a const_iterator pointing to the end of the treap_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator end() const
 { return tree_.end(); }

 //! Effects: Returns a const_iterator pointing to the end of the treap_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator cend() const
 { return tree_.cend(); }

 //! Effects: Returns an iterator pointing to the highest priority object of the tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator top()
 { return tree_.top(); }

 //! Effects: Returns a const_iterator pointing to the highest priority object of the tree..
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator top() const
 { return this->ctop(); }

 //! Effects: Returns a const_iterator pointing to the highest priority object of the tree..
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator ctop() const
 { return tree_.ctop(); }

 //! Effects: Returns a reverse_iterator pointing to the beginning of the
 //! reversed treap_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 reverse_iterator rbegin()
 { return tree_.rbegin(); }

 //! Effects: Returns a const_reverse_iterator pointing to the beginning
 //! of the reversed treap_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator rbegin() const
 { return tree_.rbegin(); }

 //! Effects: Returns a const_reverse_iterator pointing to the beginning
 //! of the reversed treap_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator crbegin() const
 { return tree_.crbegin(); }

 //! Effects: Returns a reverse_iterator pointing to the end
 //! of the reversed treap_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 reverse_iterator rend()
 { return tree_.rend(); }

 //! Effects: Returns a const_reverse_iterator pointing to the end
 //! of the reversed treap_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator rend() const
 { return tree_.rend(); }

 //! Effects: Returns a const_reverse_iterator pointing to the end
 //! of the reversed treap_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator crend() const
 { return tree_.crend(); }

 //! Effects: Returns a reverse_iterator pointing to the highest priority object of the
 //! reversed tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 reverse_iterator rtop()
 { return tree_.rtop(); }

 //! Effects: Returns a const_reverse_iterator pointing to the highest priority objec
 //! of the reversed tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator rtop() const
 { return tree_.crtop(); }

 //! Effects: Returns a const_reverse_iterator pointing to the highest priority object
 //! of the reversed tree.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_reverse_iterator crtop() const
 { return tree_.crtop(); }

 //! Precondition: end_iterator must be a valid end iterator
 //! of treap_multiset.
- //!
+ //!
 //! Effects: Returns a const reference to the treap_multiset associated to the end iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 static treap_multiset_impl &container_from_end_iterator(iterator end_iterator)
 {
@@ -1630,11 +1630,11 @@

 //! Precondition: end_iterator must be a valid end const_iterator
 //! of treap_multiset.
- //!
+ //!
 //! Effects: Returns a const reference to the treap_multiset associated to the end iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 static const treap_multiset_impl &container_from_end_iterator(const_iterator end_iterator)
 {
@@ -1644,11 +1644,11 @@
 }

 //! Precondition: it must be a valid iterator of multiset.
- //!
+ //!
 //! Effects: Returns a const reference to the multiset associated to the iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 static treap_multiset_impl &container_from_iterator(iterator it)
 {
@@ -1658,11 +1658,11 @@
 }

 //! Precondition: it must be a valid const_iterator of multiset.
- //!
+ //!
 //! Effects: Returns a const reference to the multiset associated to the iterator
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 static const treap_multiset_impl &container_from_iterator(const_iterator it)
 {
@@ -1672,50 +1672,50 @@
 }

 //! Effects: Returns the key_compare object used by the treap_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If key_compare copy-constructor throws.
 key_compare key_comp() const
 { return tree_.value_comp(); }

 //! Effects: Returns the value_compare object used by the treap_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If value_compare copy-constructor throws.
 value_compare value_comp() const
 { return tree_.value_comp(); }

 //! Effects: Returns the priority_compare object used by the treap_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If priority_compare copy-constructor throws.
 priority_compare priority_comp() const
 { return tree_.priority_comp(); }

 //! Effects: Returns true if the container is empty.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 bool empty() const
 { return tree_.empty(); }

 //! Effects: Returns the number of elements stored in the treap_multiset.
- //!
+ //!
 //! Complexity: Linear to elements contained in *this if,
 //! constant-time size option is enabled. Constant-time otherwise.
- //!
+ //!
 //! Throws: Nothing.
 size_type size() const
 { return tree_.size(); }

 //! Effects: Swaps the contents of two treap_multisets.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If the swap() call for the comparison functor
 //! found using ADL throws. Strong guarantee.
 void swap(treap_multiset_impl& other)
@@ -1725,72 +1725,72 @@
 //! Cloner should yield to nodes equivalent to the original nodes.
 //!
 //! Effects: Erases all the elements from *this
- //! calling Disposer::operator()(pointer), clones all the
+ //! calling Disposer::operator()(pointer), clones all the
 //! elements from src calling Cloner::operator()(const_reference )
 //! and inserts them on *this. Copies the predicate from the source container.
 //!
 //! If cloner throws, all cloned elements are unlinked and disposed
 //! calling Disposer::operator()(pointer).
- //!
+ //!
 //! Complexity: Linear to erased plus inserted elements.
- //!
+ //!
 //! Throws: If cloner throws or predicate copy assignment throws. Basic guarantee.
 template <class Cloner, class Disposer>
 void clone_from(const treap_multiset_impl &src, Cloner cloner, Disposer disposer)
 { tree_.clone_from(src.tree_, cloner, disposer); }

 //! Requires: value must be an lvalue
- //!
+ //!
 //! Effects: Inserts value into the treap_multiset.
- //!
+ //!
 //! Returns: An iterator that points to the position where the new
 //! element was inserted.
- //!
+ //!
 //! Complexity: Average complexity for insert element is at
 //! most logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare or priority_compare ordering
 //! function throws. Strong guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 iterator insert(reference value)
 { return tree_.insert_equal(value); }

 //! Requires: value must be an lvalue
- //!
+ //!
 //! Effects: Inserts x into the treap_multiset, using pos as a hint to
 //! where it will be inserted.
- //!
+ //!
 //! Returns: An iterator that points to the position where the new
 //! element was inserted.
- //!
+ //!
 //! Complexity: Logarithmic in general, but it is amortized
 //! constant time if t is inserted immediately before hint.
- //!
+ //!
 //! Throws: If internal value_compare or priority_compare ordering functions throw.
 //! Strong guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 iterator insert(const_iterator hint, reference value)
 { return tree_.insert_equal(hint, value); }

- //! Requires: Dereferencing iterator must yield an lvalue
+ //! Requires: Dereferencing iterator must yield an lvalue
 //! of type value_type.
- //!
+ //!
 //! Effects: Inserts a range into the treap_multiset.
- //!
+ //!
 //! Returns: An iterator that points to the position where the new
 //! element was inserted.
- //!
+ //!
 //! Complexity: Insert range is in general O(N * log(N)), where N is the
 //! size of the range. However, it is linear in N if the range is already sorted
 //! by value_comp().
- //!
+ //!
 //! Throws: If internal value_compare or priority_compare ordering functions throw.
 //! Basic guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 template<class Iterator>
@@ -1802,11 +1802,11 @@
 //! once inserted according to the predicate
 //!
 //! Effects: Inserts x into the treap before "pos".
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: If the internal priority_compare function throws. Strong guarantee.
- //!
+ //!
 //! Note: This function does not check preconditions so if "pos" is not
 //! the successor of "value" treap ordering invariant will be broken.
 //! This is a low-level function to be used only for performance reasons
@@ -1818,11 +1818,11 @@
 //! than the greatest inserted key.
 //!
 //! Effects: Inserts x into the treap in the last position.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: If the internal priority_compare function throws. Strong guarantee.
- //!
+ //!
 //! Note: This function does not check preconditions so if value is
 //! less than the greatest inserted key treap ordering invariant will be broken.
 //! This function is slightly more efficient than using "insert_before".
@@ -1835,11 +1835,11 @@
 //! than the minimum inserted key
 //!
 //! Effects: Inserts x into the treap in the first position.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Throws: If the internal priority_compare function throws. Strong guarantee.
- //!
+ //!
 //! Note: This function does not check preconditions so if value is
 //! greater than the minimum inserted key treap ordering invariant will be broken.
 //! This function is slightly more efficient than using "insert_before".
@@ -1848,42 +1848,42 @@
 void push_front(reference value)
 { tree_.push_front(value); }

- //! Effects: Erases the element pointed to by pos.
- //!
- //! Complexity: Average complexity is constant time.
- //!
+ //! Effects: Erases the element pointed to by pos.
+ //!
+ //! Complexity: Average complexity is constant time.
+ //!
 //! Returns: An iterator to the element after the erased element.
 //!
 //! Throws: If the internal priority_compare function throws. Strong guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 iterator erase(const_iterator i)
 { return tree_.erase(i); }

- //! Effects: Erases the range pointed to by b end e.
+ //! Effects: Erases the range pointed to by b end e.
 //!
 //! Returns: An iterator to the element after the erased elements.
- //!
- //! Complexity: Average complexity for erase range is at most
+ //!
+ //! Complexity: Average complexity for erase range is at most
 //! O(log(size() + N)), where N is the number of elements in the range.
- //!
+ //!
 //! Throws: If the internal priority_compare function throws. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 iterator erase(const_iterator b, const_iterator e)
 { return tree_.erase(b, e); }

 //! Effects: Erases all the elements with the given value.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size() + this->count(value)).
- //!
+ //!
 //! Throws: If the internal value_compare or priority_compare ordering
 //! functiona throw. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 size_type erase(const_reference value)
@@ -1891,13 +1891,13 @@

 //! Effects: Erases all the elements that compare equal with
 //! the given key and the given comparison functor.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size() + this->count(key, comp)).
- //!
+ //!
 //! Throws: If comp or internal priority_compare ordering functions throw. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class KeyType, class KeyValueCompare>
@@ -1912,14 +1912,14 @@
 //!
 //! Returns: An iterator to the element after the erased element.
 //!
- //! Effects: Erases the element pointed to by pos.
+ //! Effects: Erases the element pointed to by pos.
 //! Disposer::operator()(pointer) is called for the removed element.
- //!
- //! Complexity: Average complexity for erase element is constant time.
- //!
+ //!
+ //! Complexity: Average complexity for erase element is constant time.
+ //!
 //! Throws: If the internal priority_compare function throws. Strong guarantee.
- //!
- //! Note: Invalidates the iterators
+ //!
+ //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
 iterator erase_and_dispose(const_iterator i, Disposer disposer)
@@ -1937,12 +1937,12 @@
 //!
 //! Effects: Erases the range pointed to by b end e.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
- //! Complexity: Average complexity for erase range is at most
+ //!
+ //! Complexity: Average complexity for erase range is at most
 //! O(log(size() + N)), where N is the number of elements in the range.
- //!
+ //!
 //! Throws: If the internal priority_compare function throws. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
@@ -1953,13 +1953,13 @@
 //!
 //! Effects: Erases all the elements with the given value.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size() + this->count(value)).
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class Disposer>
@@ -1973,11 +1973,11 @@
 //! Disposer::operator()(pointer) is called for the removed elements.
 //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: O(log(size() + this->count(key, comp)).
- //!
+ //!
 //! Throws: If comp or internal priority_compare ordering functions throw. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class KeyType, class KeyValueCompare, class Disposer>
@@ -1989,26 +1989,26 @@
 { return tree_.erase_and_dispose(key, comp, disposer); }

 //! Effects: Erases all the elements of the container.
- //!
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 void clear()
 { return tree_.clear(); }

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
- //!
+ //!
 //! Effects: Erases all the elements of the container.
- //!
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class Disposer>
@@ -2016,20 +2016,20 @@
 { return tree_.clear_and_dispose(disposer); }

 //! Effects: Returns the number of contained elements with the given key
- //!
+ //!
 //! Complexity: Logarithmic to the number of elements contained plus lineal
 //! to number of objects with the given key.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 size_type count(const_reference value) const
 { return tree_.count(value); }

 //! Effects: Returns the number of contained elements with the same key
 //! compared with the given comparison functor.
- //!
+ //!
 //! Complexity: Logarithmic to the number of elements contained plus lineal
 //! to number of objects with the given key.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 template<class KeyType, class KeyValueCompare>
 size_type count(const KeyType& key, KeyValueCompare comp) const
@@ -2037,9 +2037,9 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is not less than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 iterator lower_bound(const_reference value)
 { return tree_.lower_bound(value); }
@@ -2049,13 +2049,13 @@
 //! that is used in the ordering functor.
 //!
 //! Effects: Returns an iterator to the first element whose
- //! key according to the comparison functor is not less than k or
+ //! key according to the comparison functor is not less than k or
 //! end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
- //!
+ //!
 //! Note: This function is used when constructing a value_type
 //! is expensive and the value_type can be compared with a cheaper
 //! key type. Usually this key is part of the value_type.
@@ -2065,9 +2065,9 @@

 //! Effects: Returns a const iterator to the first element whose
 //! key is not less than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 const_iterator lower_bound(const_reference value) const
 { return tree_.lower_bound(value); }
@@ -2077,13 +2077,13 @@
 //! that is used in the ordering functor.
 //!
 //! Effects: Returns a const_iterator to the first element whose
- //! key according to the comparison functor is not less than k or
+ //! key according to the comparison functor is not less than k or
 //! end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
- //!
+ //!
 //! Note: This function is used when constructing a value_type
 //! is expensive and the value_type can be compared with a cheaper
 //! key type. Usually this key is part of the value_type.
@@ -2093,9 +2093,9 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is greater than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 iterator upper_bound(const_reference value)
 { return tree_.upper_bound(value); }
@@ -2105,11 +2105,11 @@
 //! that is used in the ordering functor.
 //!
 //! Effects: Returns an iterator to the first element whose
- //! key according to the comparison functor is greater than key or
+ //! key according to the comparison functor is greater than key or
 //! end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -2121,9 +2121,9 @@

 //! Effects: Returns an iterator to the first element whose
 //! key is greater than k or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 const_iterator upper_bound(const_reference value) const
 { return tree_.upper_bound(value); }
@@ -2133,11 +2133,11 @@
 //! that is used in the ordering functor.
 //!
 //! Effects: Returns a const_iterator to the first element whose
- //! key according to the comparison functor is greater than key or
+ //! key according to the comparison functor is greater than key or
 //! end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -2147,11 +2147,11 @@
 const_iterator upper_bound(const KeyType& key, KeyValueCompare comp) const
 { return tree_.upper_bound(key, comp); }

- //! Effects: Finds an iterator to the first element whose value is
+ //! Effects: Finds an iterator to the first element whose value is
 //! "value" or end() if that element does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 iterator find(const_reference value)
 { return tree_.find(value); }
@@ -2160,12 +2160,12 @@
 //! value_compare. Usually key is the part of the value_type
 //! that is used in the ordering functor.
 //!
- //! Effects: Finds an iterator to the first element whose key is
- //! "key" according to the comparison functor or end() if that element
+ //! Effects: Finds an iterator to the first element whose key is
+ //! "key" according to the comparison functor or end() if that element
 //! does not exist.
 //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -2175,11 +2175,11 @@
 iterator find(const KeyType& key, KeyValueCompare comp)
 { return tree_.find(key, comp); }

- //! Effects: Finds a const_iterator to the first element whose value is
+ //! Effects: Finds a const_iterator to the first element whose value is
 //! "value" or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 const_iterator find(const_reference value) const
 { return tree_.find(value); }
@@ -2188,12 +2188,12 @@
 //! value_compare. Usually key is the part of the value_type
 //! that is used in the ordering functor.
 //!
- //! Effects: Finds a const_iterator to the first element whose key is
- //! "key" according to the comparison functor or end() if that element
+ //! Effects: Finds a const_iterator to the first element whose key is
+ //! "key" according to the comparison functor or end() if that element
 //! does not exist.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -2206,9 +2206,9 @@
 //! Effects: Finds a range containing all elements whose key is k or
 //! an empty range that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 std::pair<iterator,iterator> equal_range(const_reference value)
 { return tree_.equal_range(value); }
@@ -2217,13 +2217,13 @@
 //! value_compare. Usually key is the part of the value_type
 //! that is used in the ordering functor.
 //!
- //! Effects: Finds a range containing all elements whose key is k
- //! according to the comparison functor or an empty range
+ //! Effects: Finds a range containing all elements whose key is k
+ //! according to the comparison functor or an empty range
 //! that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -2236,9 +2236,9 @@
 //! Effects: Finds a range containing all elements whose key is k or
 //! an empty range that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If the internal value_compare ordering function throws.
 std::pair<const_iterator, const_iterator>
 equal_range(const_reference value) const
@@ -2248,13 +2248,13 @@
 //! value_compare. Usually key is the part of the value_type
 //! that is used in the ordering functor.
 //!
- //! Effects: Finds a range containing all elements whose key is k
- //! according to the comparison functor or an empty range
+ //! Effects: Finds a range containing all elements whose key is k
+ //! according to the comparison functor or an empty range
 //! that indicates the position where those elements would be
 //! if they there is no elements with key k.
- //!
+ //!
 //! Complexity: Logarithmic.
- //!
+ //!
 //! Throws: If comp ordering function throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -2267,14 +2267,14 @@

 //! Requires: value must be an lvalue and shall be in a treap_multiset of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid iterator i belonging to the treap_multiset
 //! that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This static function is available only if the value traits
 //! is stateless.
 static iterator s_iterator_to(reference value)
@@ -2282,14 +2282,14 @@

 //! Requires: value must be an lvalue and shall be in a treap_multiset of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid const_iterator i belonging to the
 //! treap_multiset that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This static function is available only if the value traits
 //! is stateless.
 static const_iterator s_iterator_to(const_reference value)
@@ -2297,48 +2297,48 @@

 //! Requires: value must be an lvalue and shall be in a treap_multiset of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid iterator i belonging to the treap_multiset
 //! that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator iterator_to(reference value)
 { return tree_.iterator_to(value); }

 //! Requires: value must be an lvalue and shall be in a treap_multiset of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid const_iterator i belonging to the
 //! treap_multiset that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator iterator_to(const_reference value) const
 { return tree_.iterator_to(value); }

 //! Requires: value shall not be in a treap_multiset/treap_multiset.
- //!
+ //!
 //! Effects: init_node puts the hook of a value in a well-known default
 //! state.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant time.
- //!
+ //!
 //! Note: This function puts the hook in the well-known default state
 //! used by auto_unlink and safe hooks.
 static void init_node(reference value)
 { tree_type::init_node(value); }

 //! Effects: Unlinks the leftmost node from the tree.
- //!
+ //!
 //! Complexity: Average complexity is constant time.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Notes: This function breaks the tree and the tree can
 //! only be used for more unlink_leftmost_without_rebalance calls.
 //! This function is normally used to achieve a step by step
@@ -2348,14 +2348,14 @@

 //! Requires: replace_this must be a valid iterator of *this
 //! and with_this must not be inserted in any tree.
- //!
+ //!
 //! Effects: Replaces replace_this in its position in the
 //! tree with with_this. The tree does not need to be rebalanced.
- //!
- //! Complexity: Constant.
- //!
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This function will break container ordering invariants if
 //! with_this is not equivalent to *replace_this according to the
 //! ordering rules. This function is faster than erasing and inserting
@@ -2364,21 +2364,21 @@
 { tree_.replace_node(replace_this, with_this); }

 //! Effects: Rebalances the tree.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear.
 void rebalance()
 { tree_.rebalance(); }

 //! Requires: old_root is a node of a tree.
- //!
+ //!
 //! Effects: Rebalances the subtree rooted at old_root.
 //!
 //! Returns: The new root of the subtree.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the elements in the subtree.
 iterator rebalance_subtree(iterator root)
 { return tree_.rebalance_subtree(root); }
@@ -2386,18 +2386,18 @@
 //! Returns: The balance factor (alpha) used in this tree
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Constant.
 float balance_factor() const
 { return tree_.balance_factor(); }

 //! Requires: new_alpha must be a value between 0.5 and 1.0
- //!
+ //!
 //! Effects: Establishes a new balance factor (alpha) and rebalances
 //! the tree if the new balance factor is stricter (less) than the old factor.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Complexity: Linear to the elements in the subtree.
 void balance_factor(float new_alpha)
 { tree_.balance_factor(new_alpha); }
@@ -2488,7 +2488,7 @@
{
 /// @cond
 typedef treap_multiset_impl
- < typename make_treap_opt<T,
+ < typename make_treap_opt<T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
@@ -2508,7 +2508,7 @@
template<class T, class ...Options>
#endif
class treap_multiset
- : public make_treap_multiset<T,
+ : public make_treap_multiset<T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
@@ -2517,7 +2517,7 @@
>::type
{
 typedef typename make_treap_multiset
- <T,
+ <T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
@@ -2573,8 +2573,8 @@

#endif

-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Modified: branches/release/boost/intrusive/trivial_value_traits.hpp
==============================================================================
--- branches/release/boost/intrusive/trivial_value_traits.hpp (original)
+++ branches/release/boost/intrusive/trivial_value_traits.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -40,7 +40,7 @@
static const const_pointer &to_value_ptr(const const_node_ptr &n) { return n; }
};

-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#endif //BOOST_INTRUSIVE_TRIVIAL_VALUE_TRAITS_HPP

Modified: branches/release/boost/intrusive/unordered_set.hpp
==============================================================================
--- branches/release/boost/intrusive/unordered_set.hpp (original)
+++ branches/release/boost/intrusive/unordered_set.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -23,7 +23,7 @@
namespace boost {
namespace intrusive {

-//! The class template unordered_set is an intrusive container, that mimics most of
+//! The class template unordered_set is an intrusive container, that mimics most of
//! the interface of std::tr1::unordered_set as described in the C++ TR1.
//!
//! unordered_set is a semi-intrusive container: each object to be stored in the
@@ -113,73 +113,73 @@
 //!
 //! Effects: Constructs an empty unordered_set_impl, storing a reference
 //! to the bucket array and copies of the hasher and equal functors.
- //!
- //! Complexity: Constant.
- //!
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: If value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
- //! or the copy constructor or invocation of Hash or Equal throws.
+ //! or the copy constructor or invocation of Hash or Equal throws.
 //!
 //! Notes: buckets array must be disposed only after
- //! *this is disposed.
+ //! *this is disposed.
 unordered_set_impl( const bucket_traits &b_traits
 , const hasher & hash_func = hasher()
 , const key_equal &equal_func = key_equal()
- , const value_traits &v_traits = value_traits())
+ , const value_traits &v_traits = value_traits())
 : table_(b_traits, hash_func, equal_func, v_traits)
 {}

 //! Requires: buckets must not be being used by any other resource
 //! and Dereferencing iterator must yield an lvalue of type value_type.
- //!
- //! Effects: Constructs an empty unordered_set and inserts elements from
+ //!
+ //! Effects: Constructs an empty unordered_set and inserts elements from
 //! [b, e).
- //!
+ //!
 //! Complexity: If N is std::distance(b, e): Average case is O(N)
 //! (with a good hash function and with buckets_len >= N),worst case O(N2).
- //!
+ //!
 //! Throws: If value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
- //! or the copy constructor or invocation of hasher or key_equal throws.
+ //! or the copy constructor or invocation of hasher or key_equal throws.
 //!
 //! Notes: buckets array must be disposed only after
- //! *this is disposed.
+ //! *this is disposed.
 template<class Iterator>
 unordered_set_impl( Iterator b
 , Iterator e
 , const bucket_traits &b_traits
 , const hasher & hash_func = hasher()
 , const key_equal &equal_func = key_equal()
- , const value_traits &v_traits = value_traits())
+ , const value_traits &v_traits = value_traits())
 : table_(b_traits, hash_func, equal_func, v_traits)
 { table_.insert_unique(b, e); }

 //! Effects: to-do
- //!
- unordered_set_impl(BOOST_RV_REF(unordered_set_impl) x)
+ //!
+ unordered_set_impl(BOOST_RV_REF(unordered_set_impl) x)
 : table_(::boost::move(x.table_))
 {}

 //! Effects: to-do
- //!
- unordered_set_impl& operator=(BOOST_RV_REF(unordered_set_impl) x)
+ //!
+ unordered_set_impl& operator=(BOOST_RV_REF(unordered_set_impl) x)
 { table_ = ::boost::move(x.table_); return *this; }

- //! Effects: Detaches all elements from this. The objects in the unordered_set
+ //! Effects: Detaches all elements from this. The objects in the unordered_set
 //! are not deleted (i.e. no destructors are called).
- //!
- //! Complexity: Linear to the number of elements in the unordered_set, if
+ //!
+ //! Complexity: Linear to the number of elements in the unordered_set, if
 //! it's a safe-mode or auto-unlink value. Otherwise constant.
- //!
+ //!
 //! Throws: Nothing.
- ~unordered_set_impl()
+ ~unordered_set_impl()
 {}

 //! Effects: Returns an iterator pointing to the beginning of the unordered_set.
- //!
+ //!
 //! Complexity: Constant time if `cache_begin<>` is true. Amortized
 //! constant time with worst case (empty unordered_set) O(this->bucket_count())
- //!
+ //!
 //! Throws: Nothing.
 iterator begin()
 { return table_.begin(); }
@@ -189,7 +189,7 @@
 //!
 //! Complexity: Constant time if `cache_begin<>` is true. Amortized
 //! constant time with worst case (empty unordered_set) O(this->bucket_count())
- //!
+ //!
 //! Throws: Nothing.
 const_iterator begin() const
 { return table_.begin(); }
@@ -199,76 +199,76 @@
 //!
 //! Complexity: Constant time if `cache_begin<>` is true. Amortized
 //! constant time with worst case (empty unordered_set) O(this->bucket_count())
- //!
+ //!
 //! Throws: Nothing.
 const_iterator cbegin() const
 { return table_.cbegin(); }

 //! Effects: Returns an iterator pointing to the end of the unordered_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator end()
 { return table_.end(); }

 //! Effects: Returns a const_iterator pointing to the end of the unordered_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator end() const
 { return table_.end(); }

 //! Effects: Returns a const_iterator pointing to the end of the unordered_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator cend() const
 { return table_.cend(); }

 //! Effects: Returns the hasher object used by the unordered_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If hasher copy-constructor throws.
 hasher hash_function() const
 { return table_.hash_function(); }

 //! Effects: Returns the key_equal object used by the unordered_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If key_equal copy-constructor throws.
 key_equal key_eq() const
 { return table_.key_eq(); }

 //! Effects: Returns true if the container is empty.
- //!
+ //!
 //! Complexity: if constant-time size and cache_last options are disabled,
 //! average constant time (worst case, with empty() == true: O(this->bucket_count()).
 //! Otherwise constant.
- //!
+ //!
 //! Throws: Nothing.
 bool empty() const
 { return table_.empty(); }

 //! Effects: Returns the number of elements stored in the unordered_set.
- //!
+ //!
 //! Complexity: Linear to elements contained in *this if
 //! constant-time size option is disabled. Constant-time otherwise.
- //!
+ //!
 //! Throws: Nothing.
 size_type size() const
 { return table_.size(); }

 //! Requires: the hasher and the equality function unqualified swap
 //! call should not throw.
- //!
+ //!
 //! Effects: Swaps the contents of two unordered_sets.
 //! Swaps also the contained bucket array and equality and hasher functors.
- //!
+ //!
 //! Complexity: Constant.
 //!
 //! Throws: If the swap() call for the comparison or hash functors
@@ -281,7 +281,7 @@
 //! hash than the original node.
 //!
 //! Effects: Erases all the elements from *this
- //! calling Disposer::operator()(pointer), clones all the
+ //! calling Disposer::operator()(pointer), clones all the
 //! elements from src calling Cloner::operator()(const_reference )
 //! and inserts them on *this. The hash function and the equality
 //! predicate are copied from the source.
@@ -290,9 +290,9 @@
 //!
 //! If any operation throws, all cloned elements are unlinked and disposed
 //! calling Disposer::operator()(pointer).
- //!
+ //!
 //! Complexity: Linear to erased plus inserted elements.
- //!
+ //!
 //! Throws: If cloner or hasher throw or hash or equality predicate copying
 //! throws. Basic guarantee.
 template <class Cloner, class Disposer>
@@ -300,7 +300,7 @@
 { table_.clone_from(src.table_, cloner, disposer); }

 //! Requires: value must be an lvalue
- //!
+ //!
 //! Effects: Tries to inserts value into the unordered_set.
 //!
 //! Returns: If the value
@@ -308,40 +308,40 @@
 //! iterator to the new value and true. If there is an equivalent value
 //! returns a pair containing an iterator to the already present value
 //! and false.
- //!
+ //!
 //! Complexity: Average case O(1), worst case O(this->size()).
- //!
+ //!
 //! Throws: If the internal hasher or the equality functor throws. Strong guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 std::pair<iterator, bool> insert(reference value)
 { return table_.insert_unique(value); }

- //! Requires: Dereferencing iterator must yield an lvalue
+ //! Requires: Dereferencing iterator must yield an lvalue
 //! of type value_type.
- //!
+ //!
 //! Effects: Equivalent to this->insert(t) for each element in [b, e).
- //!
+ //!
 //! Complexity: Average case O(N), where N is std::distance(b, e).
 //! Worst case O(N*this->size()).
- //!
+ //!
 //! Throws: If the internal hasher or the equality functor throws. Basic guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 template<class Iterator>
 void insert(Iterator b, Iterator e)
 { table_.insert_unique(b, e); }

- //! Requires: "hasher" must be a hash function that induces
+ //! Requires: "hasher" must be a hash function that induces
 //! the same hash values as the stored hasher. The difference is that
 //! "hasher" hashes the given key instead of the value_type.
 //!
- //! "key_value_equal" must be a equality function that induces
+ //! "key_value_equal" must be a equality function that induces
 //! the same equality as key_equal. The difference is that
 //! "key_value_equal" compares an arbitrary key with the contained values.
- //!
+ //!
 //! Effects: Checks if a value can be inserted in the unordered_set, using
 //! a user provided key instead of the value itself.
 //!
@@ -350,11 +350,11 @@
 //! and false. If the value can be inserted returns true in the returned
 //! pair boolean and fills "commit_data" that is meant to be used with
 //! the "insert_commit" function.
- //!
+ //!
 //! Complexity: Average case O(1), worst case O(this->size()).
 //!
 //! Throws: If hasher or key_value_equal throw. Strong guarantee.
- //!
+ //!
 //! Notes: This function is used to improve performance when constructing
 //! a value_type is expensive: if there is an equivalent value
 //! the constructed object must be discarded. Many times, the part of the
@@ -378,16 +378,16 @@
 //! must have been obtained from a previous call to "insert_check".
 //! No objects should have been inserted or erased from the unordered_set between
 //! the "insert_check" that filled "commit_data" and the call to "insert_commit".
- //!
+ //!
 //! Effects: Inserts the value in the unordered_set using the information obtained
 //! from the "commit_data" that a previous "insert_check" filled.
 //!
 //! Returns: An iterator to the newly inserted object.
- //!
+ //!
 //! Complexity: Constant time.
 //!
 //! Throws: Nothing.
- //!
+ //!
 //! Notes: This function has only sense if a "insert_check" has been
 //! previously executed to fill "commit_data". No value should be inserted or
 //! erased between the "insert_check" and "insert_commit" calls.
@@ -396,61 +396,61 @@
 iterator insert_commit(reference value, const insert_commit_data &commit_data)
 { return table_.insert_unique_commit(value, commit_data); }

- //! Effects: Erases the element pointed to by i.
- //!
+ //! Effects: Erases the element pointed to by i.
+ //!
 //! Complexity: Average case O(1), worst case O(this->size()).
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased element. No destructors are called.
 void erase(const_iterator i)
 { table_.erase(i); }

- //! Effects: Erases the range pointed to by b end e.
- //!
+ //! Effects: Erases the range pointed to by b end e.
+ //!
 //! Complexity: Average case O(std::distance(b, e)),
 //! worst case O(this->size()).
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 void erase(const_iterator b, const_iterator e)
 { table_.erase(b, e); }

 //! Effects: Erases all the elements with the given value.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: Average case O(this->count(value)).
 //! Worst case O(this->size()).
- //!
+ //!
 //! Throws: If the internal hasher or the equality functor throws. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 size_type erase(const_reference value)
 { return table_.erase(value); }

- //! Requires: "hasher" must be a hash function that induces
+ //! Requires: "hasher" must be a hash function that induces
 //! the same hash values as the stored hasher. The difference is that
 //! "hasher" hashes the given key instead of the value_type.
 //!
- //! "key_value_equal" must be a equality function that induces
+ //! "key_value_equal" must be a equality function that induces
 //! the same equality as key_equal. The difference is that
 //! "key_value_equal" compares an arbitrary key with the contained values.
 //!
 //! Effects: Erases all the elements that have the same hash and
 //! compare equal with the given key.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: Average case O(this->count(value)).
 //! Worst case O(this->size()).
- //!
+ //!
 //! Throws: If hash_func or equal_func throw. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class KeyType, class KeyHasher, class KeyValueEqual>
@@ -459,14 +459,14 @@

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
 //!
- //! Effects: Erases the element pointed to by i.
+ //! Effects: Erases the element pointed to by i.
 //! Disposer::operator()(pointer) is called for the removed element.
- //!
+ //!
 //! Complexity: Average case O(1), worst case O(this->size()).
- //!
+ //!
 //! Throws: Nothing.
- //!
- //! Note: Invalidates the iterators
+ //!
+ //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
 void erase_and_dispose(const_iterator i, Disposer disposer
@@ -480,12 +480,12 @@
 //!
 //! Effects: Erases the range pointed to by b end e.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
+ //!
 //! Complexity: Average case O(std::distance(b, e)),
 //! worst case O(this->size()).
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
@@ -496,14 +496,14 @@
 //!
 //! Effects: Erases all the elements with the given value.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: Average case O(this->count(value)).
 //! Worst case O(this->size()).
- //!
+ //!
 //! Throws: If the internal hasher or the equality functor throws. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class Disposer>
@@ -517,39 +517,39 @@
 //! Disposer::operator()(pointer) is called for the removed elements.
 //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: Average case O(this->count(value)).
 //! Worst case O(this->size()).
- //!
+ //!
 //! Throws: If hash_func or equal_func throw. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class KeyType, class KeyHasher, class KeyValueEqual, class Disposer>
 size_type erase_and_dispose(const KeyType& key, KeyHasher hash_func, KeyValueEqual equal_func, Disposer disposer)
 { return table_.erase_and_dispose(key, hash_func, equal_func, disposer); }

- //! Effects: Erases all of the elements.
- //!
+ //! Effects: Erases all of the elements.
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 void clear()
 { return table_.clear(); }

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
- //!
- //! Effects: Erases all of the elements.
- //!
+ //!
+ //! Effects: Erases all of the elements.
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class Disposer>
@@ -557,25 +557,25 @@
 { return table_.clear_and_dispose(disposer); }

 //! Effects: Returns the number of contained elements with the given value
- //!
+ //!
 //! Complexity: Average case O(1), worst case O(this->size()).
- //!
+ //!
 //! Throws: If the internal hasher or the equality functor throws.
 size_type count(const_reference value) const
 { return table_.find(value) != end(); }

- //! Requires: "hash_func" must be a hash function that induces
+ //! Requires: "hash_func" must be a hash function that induces
 //! the same hash values as the stored hasher. The difference is that
 //! "hash_func" hashes the given key instead of the value_type.
 //!
- //! "equal_func" must be a equality function that induces
+ //! "equal_func" must be a equality function that induces
 //! the same equality as key_equal. The difference is that
 //! "equal_func" compares an arbitrary key with the contained values.
 //!
 //! Effects: Returns the number of contained elements with the given key
 //!
 //! Complexity: Average case O(1), worst case O(this->size()).
- //!
+ //!
 //! Throws: If hash_func or equal_func throw.
 template<class KeyType, class KeyHasher, class KeyValueEqual>
 size_type count(const KeyType& key, KeyHasher hash_func, KeyValueEqual equal_func) const
@@ -585,25 +585,25 @@
 //! "value" or end() if that element does not exist.
 //!
 //! Complexity: Average case O(1), worst case O(this->size()).
- //!
+ //!
 //! Throws: If the internal hasher or the equality functor throws.
 iterator find(const_reference value)
 { return table_.find(value); }

- //! Requires: "hash_func" must be a hash function that induces
+ //! Requires: "hash_func" must be a hash function that induces
 //! the same hash values as the stored hasher. The difference is that
 //! "hash_func" hashes the given key instead of the value_type.
 //!
- //! "equal_func" must be a equality function that induces
+ //! "equal_func" must be a equality function that induces
 //! the same equality as key_equal. The difference is that
 //! "equal_func" compares an arbitrary key with the contained values.
 //!
- //! Effects: Finds an iterator to the first element whose key is
+ //! Effects: Finds an iterator to the first element whose key is
 //! "key" according to the given hasher and equality functor or end() if
 //! that element does not exist.
 //!
 //! Complexity: Average case O(1), worst case O(this->size()).
- //!
+ //!
 //! Throws: If hash_func or equal_func throw.
 //!
 //! Note: This function is used when constructing a value_type
@@ -613,29 +613,29 @@
 iterator find(const KeyType& key, KeyHasher hash_func, KeyValueEqual equal_func)
 { return table_.find(key, hash_func, equal_func); }

- //! Effects: Finds a const_iterator to the first element whose key is
+ //! Effects: Finds a const_iterator to the first element whose key is
 //! "key" or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Average case O(1), worst case O(this->size()).
- //!
+ //!
 //! Throws: If the internal hasher or the equality functor throws.
 const_iterator find(const_reference value) const
 { return table_.find(value); }

- //! Requires: "hash_func" must be a hash function that induces
+ //! Requires: "hash_func" must be a hash function that induces
 //! the same hash values as the stored hasher. The difference is that
 //! "hash_func" hashes the given key instead of the value_type.
 //!
- //! "equal_func" must be a equality function that induces
+ //! "equal_func" must be a equality function that induces
 //! the same equality as key_equal. The difference is that
 //! "equal_func" compares an arbitrary key with the contained values.
 //!
- //! Effects: Finds an iterator to the first element whose key is
+ //! Effects: Finds an iterator to the first element whose key is
 //! "key" according to the given hasher and equality functor or end() if
 //! that element does not exist.
- //!
+ //!
 //! Complexity: Average case O(1), worst case O(this->size()).
- //!
+ //!
 //! Throws: If hash_func or equal_func throw.
 //!
 //! Note: This function is used when constructing a value_type
@@ -646,30 +646,30 @@
 { return table_.find(key, hash_func, equal_func); }

 //! Effects: Returns a range containing all elements with values equivalent
- //! to value. Returns std::make_pair(this->end(), this->end()) if no such
+ //! to value. Returns std::make_pair(this->end(), this->end()) if no such
 //! elements exist.
- //!
+ //!
 //! Complexity: Average case O(this->count(value)). Worst case O(this->size()).
- //!
+ //!
 //! Throws: If the internal hasher or the equality functor throws.
 std::pair<iterator,iterator> equal_range(const_reference value)
 { return table_.equal_range(value); }

- //! Requires: "hash_func" must be a hash function that induces
+ //! Requires: "hash_func" must be a hash function that induces
 //! the same hash values as the stored hasher. The difference is that
 //! "hash_func" hashes the given key instead of the value_type.
 //!
- //! "equal_func" must be a equality function that induces
+ //! "equal_func" must be a equality function that induces
 //! the same equality as key_equal. The difference is that
 //! "equal_func" compares an arbitrary key with the contained values.
 //!
 //! Effects: Returns a range containing all elements with equivalent
- //! keys. Returns std::make_pair(this->end(), this->end()) if no such
+ //! keys. Returns std::make_pair(this->end(), this->end()) if no such
 //! elements exist.
- //!
+ //!
 //! Complexity: Average case O(this->count(key, hash_func, hash_func)).
 //! Worst case O(this->size()).
- //!
+ //!
 //! Throws: If hash_func or the equal_func throw.
 //!
 //! Note: This function is used when constructing a value_type
@@ -680,31 +680,31 @@
 { return table_.equal_range(key, hash_func, equal_func); }

 //! Effects: Returns a range containing all elements with values equivalent
- //! to value. Returns std::make_pair(this->end(), this->end()) if no such
+ //! to value. Returns std::make_pair(this->end(), this->end()) if no such
 //! elements exist.
- //!
+ //!
 //! Complexity: Average case O(this->count(value)). Worst case O(this->size()).
- //!
+ //!
 //! Throws: If the internal hasher or the equality functor throws.
 std::pair<const_iterator, const_iterator>
 equal_range(const_reference value) const
 { return table_.equal_range(value); }

- //! Requires: "hash_func" must be a hash function that induces
+ //! Requires: "hash_func" must be a hash function that induces
 //! the same hash values as the stored hasher. The difference is that
 //! "hash_func" hashes the given key instead of the value_type.
 //!
- //! "equal_func" must be a equality function that induces
+ //! "equal_func" must be a equality function that induces
 //! the same equality as key_equal. The difference is that
 //! "equal_func" compares an arbitrary key with the contained values.
 //!
 //! Effects: Returns a range containing all elements with equivalent
- //! keys. Returns std::make_pair(this->end(), this->end()) if no such
+ //! keys. Returns std::make_pair(this->end(), this->end()) if no such
 //! elements exist.
- //!
+ //!
 //! Complexity: Average case O(this->count(key, hash_func, equal_func)).
 //! Worst case O(this->size()).
- //!
+ //!
 //! Throws: If the hash_func or equal_func throw.
 //!
 //! Note: This function is used when constructing a value_type
@@ -717,38 +717,38 @@

 //! Requires: value must be an lvalue and shall be in a unordered_set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid iterator belonging to the unordered_set
 //! that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If the internal hash function throws.
 iterator iterator_to(reference value)
 { return table_.iterator_to(value); }

 //! Requires: value must be an lvalue and shall be in a unordered_set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid const_iterator belonging to the
 //! unordered_set that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If the internal hash function throws.
 const_iterator iterator_to(const_reference value) const
 { return table_.iterator_to(value); }

 //! Requires: value must be an lvalue and shall be in a unordered_set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid local_iterator belonging to the unordered_set
 //! that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This static function is available only if the value traits
 //! is stateless.
 static local_iterator s_local_iterator_to(reference value)
@@ -756,14 +756,14 @@

 //! Requires: value must be an lvalue and shall be in a unordered_set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid const_local_iterator belonging to
 //! the unordered_set that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This static function is available only if the value traits
 //! is stateless.
 static const_local_iterator s_local_iterator_to(const_reference value)
@@ -771,33 +771,33 @@

 //! Requires: value must be an lvalue and shall be in a unordered_set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid local_iterator belonging to the unordered_set
 //! that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 local_iterator local_iterator_to(reference value)
 { return table_.local_iterator_to(value); }

 //! Requires: value must be an lvalue and shall be in a unordered_set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid const_local_iterator belonging to
 //! the unordered_set that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_local_iterator local_iterator_to(const_reference value) const
 { return table_.local_iterator_to(value); }

 //! Effects: Returns the number of buckets passed in the constructor
 //! or the last rehash function.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 size_type bucket_count() const
 { return table_.bucket_count(); }
@@ -805,33 +805,33 @@
 //! Requires: n is in the range [0, this->bucket_count()).
 //!
 //! Effects: Returns the number of elements in the nth bucket.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 size_type bucket_size(size_type n) const
 { return table_.bucket_size(n); }

 //! Effects: Returns the index of the bucket in which elements
 //! with keys equivalent to k would be found, if any such element existed.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If the hash functor throws.
 //!
 //! Note: the return value is in the range [0, this->bucket_count()).
 size_type bucket(const value_type& k) const
 { return table_.bucket(k); }

- //! Requires: "hash_func" must be a hash function that induces
+ //! Requires: "hash_func" must be a hash function that induces
 //! the same hash values as the stored hasher. The difference is that
 //! "hash_func" hashes the given key instead of the value_type.
 //!
 //! Effects: Returns the index of the bucket in which elements
 //! with keys equivalent to k would be found, if any such element existed.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If hash_func throws.
 //!
 //! Note: the return value is in the range [0, this->bucket_count()).
@@ -841,9 +841,9 @@

 //! Effects: Returns the bucket array pointer passed in the constructor
 //! or the last rehash function.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 bucket_ptr bucket_pointer() const
 { return table_.bucket_pointer(); }
@@ -852,13 +852,13 @@
 //!
 //! Effects: Returns a local_iterator pointing to the beginning
 //! of the sequence stored in the bucket n.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: [this->begin(n), this->end(n)) is a valid range
- //! containing all of the elements in the nth bucket.
+ //! containing all of the elements in the nth bucket.
 local_iterator begin(size_type n)
 { return table_.begin(n); }

@@ -866,13 +866,13 @@
 //!
 //! Effects: Returns a const_local_iterator pointing to the beginning
 //! of the sequence stored in the bucket n.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: [this->begin(n), this->end(n)) is a valid range
- //! containing all of the elements in the nth bucket.
+ //! containing all of the elements in the nth bucket.
 const_local_iterator begin(size_type n) const
 { return table_.begin(n); }

@@ -880,13 +880,13 @@
 //!
 //! Effects: Returns a const_local_iterator pointing to the beginning
 //! of the sequence stored in the bucket n.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: [this->begin(n), this->end(n)) is a valid range
- //! containing all of the elements in the nth bucket.
+ //! containing all of the elements in the nth bucket.
 const_local_iterator cbegin(size_type n) const
 { return table_.cbegin(n); }

@@ -894,13 +894,13 @@
 //!
 //! Effects: Returns a local_iterator pointing to the end
 //! of the sequence stored in the bucket n.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: [this->begin(n), this->end(n)) is a valid range
- //! containing all of the elements in the nth bucket.
+ //! containing all of the elements in the nth bucket.
 local_iterator end(size_type n)
 { return table_.end(n); }

@@ -908,13 +908,13 @@
 //!
 //! Effects: Returns a const_local_iterator pointing to the end
 //! of the sequence stored in the bucket n.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: [this->begin(n), this->end(n)) is a valid range
- //! containing all of the elements in the nth bucket.
+ //! containing all of the elements in the nth bucket.
 const_local_iterator end(size_type n) const
 { return table_.end(n); }

@@ -922,13 +922,13 @@
 //!
 //! Effects: Returns a const_local_iterator pointing to the end
 //! of the sequence stored in the bucket n.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: [this->begin(n), this->end(n)) is a valid range
- //! containing all of the elements in the nth bucket.
+ //! containing all of the elements in the nth bucket.
 const_local_iterator cend(size_type n) const
 { return table_.cend(n); }

@@ -938,22 +938,22 @@
 //! n can be bigger or smaller than this->bucket_count().
 //!
 //! Effects: Updates the internal reference with the new bucket erases
- //! the values from the old bucket and inserts then in the new one.
+ //! the values from the old bucket and inserts then in the new one.
 //!
 //! If store_hash option is true, this method does not use the hash function.
- //!
+ //!
 //! Complexity: Average case linear in this->size(), worst case quadratic.
- //!
+ //!
 //! Throws: If the hasher functor throws. Basic guarantee.
 void rehash(const bucket_traits &new_bucket_traits)
 { table_.rehash(new_bucket_traits); }

 //! Requires:
 //!
- //! Effects:
- //!
- //! Complexity:
- //!
+ //! Effects:
+ //!
+ //! Complexity:
+ //!
 //! Throws:
 //!
 //! Note: this method is only available if incremental<true> option is activated.
@@ -966,22 +966,22 @@

 //! Requires:
 //!
- //! Effects:
- //!
- //! Complexity:
- //!
- //! Throws:
+ //! Effects:
+ //!
+ //! Complexity:
+ //!
+ //! Throws:
 size_type split_count() const
 { return table_.split_count(); }

 //! Effects: Returns the nearest new bucket count optimized for
 //! the container that is bigger than n. This suggestion can be used
 //! to create bucket arrays with a size that will usually improve
- //! container's performance. If such value does not exist, the
+ //! container's performance. If such value does not exist, the
 //! higher possible value is returned.
- //!
+ //!
 //! Complexity: Amortized constant time.
- //!
+ //!
 //! Throws: Nothing.
 static size_type suggested_upper_bucket_count(size_type n)
 { return table_type::suggested_upper_bucket_count(n); }
@@ -989,11 +989,11 @@
 //! Effects: Returns the nearest new bucket count optimized for
 //! the container that is smaller than n. This suggestion can be used
 //! to create bucket arrays with a size that will usually improve
- //! container's performance. If such value does not exist, the
+ //! container's performance. If such value does not exist, the
 //! lower possible value is returned.
- //!
+ //!
 //! Complexity: Amortized constant time.
- //!
+ //!
 //! Throws: Nothing.
 static size_type suggested_lower_bucket_count(size_type n)
 { return table_type::suggested_lower_bucket_count(n); }
@@ -1016,7 +1016,7 @@
 /// @cond
 typedef unordered_set_impl
 < typename make_hashtable_opt
- <T, true,
+ <T, true,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4, O5, O6, O7, O8, O9, O10
 #else
@@ -1036,7 +1036,7 @@
template<class T, class ...Options>
#endif
class unordered_set
- : public make_unordered_set<T,
+ : public make_unordered_set<T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4, O5, O6, O7, O8, O9, O10
 #else
@@ -1045,7 +1045,7 @@
>::type
{
 typedef typename make_unordered_set
- <T,
+ <T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4, O5, O6, O7, O8, O9, O10
 #else
@@ -1070,7 +1070,7 @@
 unordered_set ( const bucket_traits &b_traits
 , const hasher & hash_func = hasher()
 , const key_equal &equal_func = key_equal()
- , const value_traits &v_traits = value_traits())
+ , const value_traits &v_traits = value_traits())
 : Base(b_traits, hash_func, equal_func, v_traits)
 {}

@@ -1080,7 +1080,7 @@
 , const bucket_traits &b_traits
 , const hasher & hash_func = hasher()
 , const key_equal &equal_func = key_equal()
- , const value_traits &v_traits = value_traits())
+ , const value_traits &v_traits = value_traits())
 : Base(b, e, b_traits, hash_func, equal_func, v_traits)
 {}

@@ -1095,7 +1095,7 @@
#endif

-//! The class template unordered_multiset is an intrusive container, that mimics most of
+//! The class template unordered_multiset is an intrusive container, that mimics most of
//! the interface of std::tr1::unordered_multiset as described in the C++ TR1.
//!
//! unordered_multiset is a semi-intrusive container: each object to be stored in the
@@ -1184,34 +1184,34 @@
 //!
 //! Effects: Constructs an empty unordered_multiset, storing a reference
 //! to the bucket array and copies of the hasher and equal functors.
- //!
- //! Complexity: Constant.
- //!
+ //!
+ //! Complexity: Constant.
+ //!
 //! Throws: If value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
- //! or the copy constructor or invocation of Hash or Equal throws.
+ //! or the copy constructor or invocation of Hash or Equal throws.
 //!
 //! Notes: buckets array must be disposed only after
- //! *this is disposed.
+ //! *this is disposed.
 unordered_multiset_impl ( const bucket_traits &b_traits
 , const hasher & hash_func = hasher()
 , const key_equal &equal_func = key_equal()
- , const value_traits &v_traits = value_traits())
+ , const value_traits &v_traits = value_traits())
 : table_(b_traits, hash_func, equal_func, v_traits)
 {}

 //! Requires: buckets must not be being used by any other resource
 //! and Dereferencing iterator must yield an lvalue of type value_type.
- //!
- //! Effects: Constructs an empty unordered_multiset and inserts elements from
+ //!
+ //! Effects: Constructs an empty unordered_multiset and inserts elements from
 //! [b, e).
- //!
+ //!
 //! Complexity: If N is std::distance(b, e): Average case is O(N)
 //! (with a good hash function and with buckets_len >= N),worst case O(N2).
- //!
+ //!
 //! Throws: If value_traits::node_traits::node
 //! constructor throws (this does not happen with predefined Boost.Intrusive hooks)
- //! or the copy constructor or invocation of hasher or key_equal throws.
+ //! or the copy constructor or invocation of hasher or key_equal throws.
 //!
 //! Notes: buckets array must be disposed only after
 //! *this is disposed.
@@ -1221,36 +1221,36 @@
 , const bucket_traits &b_traits
 , const hasher & hash_func = hasher()
 , const key_equal &equal_func = key_equal()
- , const value_traits &v_traits = value_traits())
+ , const value_traits &v_traits = value_traits())
 : table_(b_traits, hash_func, equal_func, v_traits)
 { table_.insert_equal(b, e); }

 //! Effects: to-do
- //!
- unordered_multiset_impl(BOOST_RV_REF(unordered_multiset_impl) x)
+ //!
+ unordered_multiset_impl(BOOST_RV_REF(unordered_multiset_impl) x)
 : table_(::boost::move(x.table_))
 {}

 //! Effects: to-do
- //!
- unordered_multiset_impl& operator=(BOOST_RV_REF(unordered_multiset_impl) x)
+ //!
+ unordered_multiset_impl& operator=(BOOST_RV_REF(unordered_multiset_impl) x)
 { table_ = ::boost::move(x.table_); return *this; }

- //! Effects: Detaches all elements from this. The objects in the unordered_multiset
+ //! Effects: Detaches all elements from this. The objects in the unordered_multiset
 //! are not deleted (i.e. no destructors are called).
- //!
- //! Complexity: Linear to the number of elements in the unordered_multiset, if
+ //!
+ //! Complexity: Linear to the number of elements in the unordered_multiset, if
 //! it's a safe-mode or auto-unlink value. Otherwise constant.
- //!
+ //!
 //! Throws: Nothing.
- ~unordered_multiset_impl()
+ ~unordered_multiset_impl()
 {}

 //! Effects: Returns an iterator pointing to the beginning of the unordered_multiset.
- //!
+ //!
 //! Complexity: Constant time if `cache_begin<>` is true. Amortized
 //! constant time with worst case (empty unordered_set) O(this->bucket_count())
- //!
+ //!
 //! Throws: Nothing.
 iterator begin()
 { return table_.begin(); }
@@ -1260,7 +1260,7 @@
 //!
 //! Complexity: Constant time if `cache_begin<>` is true. Amortized
 //! constant time with worst case (empty unordered_set) O(this->bucket_count())
- //!
+ //!
 //! Throws: Nothing.
 const_iterator begin() const
 { return table_.begin(); }
@@ -1270,77 +1270,77 @@
 //!
 //! Complexity: Constant time if `cache_begin<>` is true. Amortized
 //! constant time with worst case (empty unordered_set) O(this->bucket_count())
- //!
+ //!
 //! Throws: Nothing.
 const_iterator cbegin() const
 { return table_.cbegin(); }

 //! Effects: Returns an iterator pointing to the end of the unordered_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 iterator end()
 { return table_.end(); }

 //! Effects: Returns a const_iterator pointing to the end of the unordered_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator end() const
 { return table_.end(); }

 //! Effects: Returns a const_iterator pointing to the end of the unordered_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_iterator cend() const
 { return table_.cend(); }

 //! Effects: Returns the hasher object used by the unordered_set.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If hasher copy-constructor throws.
 hasher hash_function() const
 { return table_.hash_function(); }

 //! Effects: Returns the key_equal object used by the unordered_multiset.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If key_equal copy-constructor throws.
 key_equal key_eq() const
 { return table_.key_eq(); }

 //! Effects: Returns true if the container is empty.
- //!
+ //!
 //! Complexity: if constant-time size and cache_last options are disabled,
 //! average constant time (worst case, with empty() == true: O(this->bucket_count()).
 //! Otherwise constant.
- //!
+ //!
 //! Throws: Nothing.
 bool empty() const
 { return table_.empty(); }

 //! Effects: Returns the number of elements stored in the unordered_multiset.
- //!
+ //!
 //! Complexity: Linear to elements contained in *this if
 //! constant-time size option is disabled. Constant-time otherwise.
- //!
+ //!
 //! Throws: Nothing.
 size_type size() const
 { return table_.size(); }

 //! Requires: the hasher and the equality function unqualified swap
 //! call should not throw.
- //!
+ //!
 //! Effects: Swaps the contents of two unordered_multisets.
 //! Swaps also the contained bucket array and equality and hasher functors.
 //!
- //!
+ //!
 //! Complexity: Constant.
 //!
 //! Throws: If the swap() call for the comparison or hash functors
@@ -1353,7 +1353,7 @@
 //! hash than the original node.
 //!
 //! Effects: Erases all the elements from *this
- //! calling Disposer::operator()(pointer), clones all the
+ //! calling Disposer::operator()(pointer), clones all the
 //! elements from src calling Cloner::operator()(const_reference )
 //! and inserts them on *this. The hash function and the equality
 //! predicate are copied from the source.
@@ -1362,9 +1362,9 @@
 //!
 //! If any operation throws, all cloned elements are unlinked and disposed
 //! calling Disposer::operator()(pointer).
- //!
+ //!
 //! Complexity: Linear to erased plus inserted elements.
- //!
+ //!
 //! Throws: If cloner or hasher throw or hash or equality predicate copying
 //! throws. Basic guarantee.
 template <class Cloner, class Disposer>
@@ -1372,92 +1372,92 @@
 { table_.clone_from(src.table_, cloner, disposer); }

 //! Requires: value must be an lvalue
- //!
+ //!
 //! Effects: Inserts value into the unordered_multiset.
 //!
 //! Returns: An iterator to the new inserted value.
- //!
+ //!
 //! Complexity: Average case O(1), worst case O(this->size()).
- //!
+ //!
 //! Throws: If the internal hasher or the equality functor throws. Strong guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 iterator insert(reference value)
 { return table_.insert_equal(value); }

- //! Requires: Dereferencing iterator must yield an lvalue
+ //! Requires: Dereferencing iterator must yield an lvalue
 //! of type value_type.
- //!
+ //!
 //! Effects: Equivalent to this->insert(t) for each element in [b, e).
- //!
+ //!
 //! Complexity: Average case is O(N), where N is the
 //! size of the range.
- //!
+ //!
 //! Throws: If the internal hasher or the equality functor throws. Basic guarantee.
- //!
+ //!
 //! Note: Does not affect the validity of iterators and references.
 //! No copy-constructors are called.
 template<class Iterator>
 void insert(Iterator b, Iterator e)
 { table_.insert_equal(b, e); }

- //! Effects: Erases the element pointed to by i.
- //!
+ //! Effects: Erases the element pointed to by i.
+ //!
 //! Complexity: Average case O(1), worst case O(this->size()).
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased element. No destructors are called.
 void erase(const_iterator i)
 { table_.erase(i); }

- //! Effects: Erases the range pointed to by b end e.
- //!
+ //! Effects: Erases the range pointed to by b end e.
+ //!
 //! Complexity: Average case O(std::distance(b, e)),
 //! worst case O(this->size()).
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 void erase(const_iterator b, const_iterator e)
 { table_.erase(b, e); }

 //! Effects: Erases all the elements with the given value.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: Average case O(this->count(value)).
 //! Worst case O(this->size()).
- //!
+ //!
 //! Throws: If the internal hasher or the equality functor throws. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 size_type erase(const_reference value)
 { return table_.erase(value); }

- //! Requires: "hash_func" must be a hash function that induces
+ //! Requires: "hash_func" must be a hash function that induces
 //! the same hash values as the stored hasher. The difference is that
 //! "hash_func" hashes the given key instead of the value_type.
 //!
- //! "key_value_equal" must be a equality function that induces
+ //! "key_value_equal" must be a equality function that induces
 //! the same equality as key_equal. The difference is that
 //! "key_value_equal" compares an arbitrary key with the contained values.
 //!
 //! Effects: Erases all the elements that have the same hash and
 //! compare equal with the given key.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: Average case O(this->count(value)).
 //! Worst case O(this->size()).
- //!
+ //!
 //! Throws: If the hash_func or the equal_func functors throws.
 //! Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class KeyType, class KeyHasher, class KeyValueEqual>
@@ -1466,14 +1466,14 @@

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
 //!
- //! Effects: Erases the element pointed to by i.
+ //! Effects: Erases the element pointed to by i.
 //! Disposer::operator()(pointer) is called for the removed element.
- //!
+ //!
 //! Complexity: Average case O(1), worst case O(this->size()).
- //!
+ //!
 //! Throws: Nothing.
- //!
- //! Note: Invalidates the iterators
+ //!
+ //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
 void erase_and_dispose(const_iterator i, Disposer disposer
@@ -1493,12 +1493,12 @@
 //!
 //! Effects: Erases the range pointed to by b end e.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
+ //!
 //! Complexity: Average case O(std::distance(b, e)),
 //! worst case O(this->size()).
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class Disposer>
@@ -1509,14 +1509,14 @@
 //!
 //! Effects: Erases all the elements with the given value.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
+ //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: Average case O(this->count(value)).
 //! Worst case O(this->size()).
- //!
+ //!
 //! Throws: If the internal hasher or the equality functor throws. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class Disposer>
@@ -1530,12 +1530,12 @@
 //! Disposer::operator()(pointer) is called for the removed elements.
 //!
 //! Returns: The number of erased elements.
- //!
+ //!
 //! Complexity: Average case O(this->count(value)).
 //! Worst case O(this->size()).
- //!
+ //!
 //! Throws: If hash_func or equal_func throw. Basic guarantee.
- //!
+ //!
 //! Note: Invalidates the iterators
 //! to the erased elements.
 template<class KeyType, class KeyHasher, class KeyValueEqual, class Disposer>
@@ -1543,26 +1543,26 @@
 { return table_.erase_and_dispose(key, hash_func, equal_func, disposer); }

 //! Effects: Erases all the elements of the container.
- //!
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 void clear()
 { return table_.clear(); }

 //! Requires: Disposer::operator()(pointer) shouldn't throw.
- //!
+ //!
 //! Effects: Erases all the elements of the container.
- //!
+ //!
 //! Complexity: Linear to the number of elements on the container.
 //! Disposer::operator()(pointer) is called for the removed elements.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: Invalidates the iterators (but not the references)
 //! to the erased elements. No destructors are called.
 template<class Disposer>
@@ -1570,53 +1570,53 @@
 { return table_.clear_and_dispose(disposer); }

 //! Effects: Returns the number of contained elements with the given key
- //!
+ //!
 //! Complexity: Average case O(1), worst case O(this->size()).
- //!
+ //!
 //! Throws: If the internal hasher or the equality functor throws.
 size_type count(const_reference value) const
 { return table_.count(value); }

- //! Requires: "hash_func" must be a hash function that induces
+ //! Requires: "hash_func" must be a hash function that induces
 //! the same hash values as the stored hasher. The difference is that
 //! "hash_func" hashes the given key instead of the value_type.
 //!
- //! "key_value_equal" must be a equality function that induces
+ //! "key_value_equal" must be a equality function that induces
 //! the same equality as key_equal. The difference is that
 //! "key_value_equal" compares an arbitrary key with the contained values.
 //!
 //! Effects: Returns the number of contained elements with the given key
 //!
 //! Complexity: Average case O(1), worst case O(this->size()).
- //!
+ //!
 //! Throws: If the internal hasher or the equality functor throws.
 template<class KeyType, class KeyHasher, class KeyValueEqual>
 size_type count(const KeyType& key, KeyHasher hash_func, KeyValueEqual equal_func) const
 { return table_.count(key, hash_func, equal_func); }

- //! Effects: Finds an iterator to the first element whose value is
+ //! Effects: Finds an iterator to the first element whose value is
 //! "value" or end() if that element does not exist.
 //!
 //! Complexity: Average case O(1), worst case O(this->size()).
- //!
+ //!
 //! Throws: If the internal hasher or the equality functor throws.
 iterator find(const_reference value)
 { return table_.find(value); }

- //! Requires: "hash_func" must be a hash function that induces
+ //! Requires: "hash_func" must be a hash function that induces
 //! the same hash values as the stored hasher. The difference is that
 //! "hash_func" hashes the given key instead of the value_type.
 //!
- //! "key_value_equal" must be a equality function that induces
+ //! "key_value_equal" must be a equality function that induces
 //! the same equality as key_equal. The difference is that
 //! "key_value_equal" compares an arbitrary key with the contained values.
 //!
- //! Effects: Finds an iterator to the first element whose key is
+ //! Effects: Finds an iterator to the first element whose key is
 //! "key" according to the given hasher and equality functor or end() if
 //! that element does not exist.
 //!
 //! Complexity: Average case O(1), worst case O(this->size()).
- //!
+ //!
 //! Throws: If the internal hasher or the equality functor throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -1626,29 +1626,29 @@
 iterator find(const KeyType& key, KeyHasher hash_func, KeyValueEqual equal_func)
 { return table_.find(key, hash_func, equal_func); }

- //! Effects: Finds a const_iterator to the first element whose key is
+ //! Effects: Finds a const_iterator to the first element whose key is
 //! "key" or end() if that element does not exist.
- //!
+ //!
 //! Complexity: Average case O(1), worst case O(this->size()).
- //!
+ //!
 //! Throws: If the internal hasher or the equality functor throws.
 const_iterator find(const_reference value) const
 { return table_.find(value); }

- //! Requires: "hash_func" must be a hash function that induces
+ //! Requires: "hash_func" must be a hash function that induces
 //! the same hash values as the stored hasher. The difference is that
 //! "hash_func" hashes the given key instead of the value_type.
 //!
- //! "key_value_equal" must be a equality function that induces
+ //! "key_value_equal" must be a equality function that induces
 //! the same equality as key_equal. The difference is that
 //! "key_value_equal" compares an arbitrary key with the contained values.
 //!
- //! Effects: Finds an iterator to the first element whose key is
+ //! Effects: Finds an iterator to the first element whose key is
 //! "key" according to the given hasher and equality functor or end() if
 //! that element does not exist.
- //!
+ //!
 //! Complexity: Average case O(1), worst case O(this->size()).
- //!
+ //!
 //! Throws: If the internal hasher or the equality functor throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -1659,30 +1659,30 @@
 { return table_.find(key, hash_func, equal_func); }

 //! Effects: Returns a range containing all elements with values equivalent
- //! to value. Returns std::make_pair(this->end(), this->end()) if no such
+ //! to value. Returns std::make_pair(this->end(), this->end()) if no such
 //! elements exist.
- //!
+ //!
 //! Complexity: Average case O(this->count(value)). Worst case O(this->size()).
- //!
+ //!
 //! Throws: If the internal hasher or the equality functor throws.
 std::pair<iterator,iterator> equal_range(const_reference value)
 { return table_.equal_range(value); }

- //! Requires: "hash_func" must be a hash function that induces
+ //! Requires: "hash_func" must be a hash function that induces
 //! the same hash values as the stored hasher. The difference is that
 //! "hash_func" hashes the given key instead of the value_type.
 //!
- //! "key_value_equal" must be a equality function that induces
+ //! "key_value_equal" must be a equality function that induces
 //! the same equality as key_equal. The difference is that
 //! "key_value_equal" compares an arbitrary key with the contained values.
 //!
 //! Effects: Returns a range containing all elements with equivalent
- //! keys. Returns std::make_pair(this->end(), this->end()) if no such
+ //! keys. Returns std::make_pair(this->end(), this->end()) if no such
 //! elements exist.
- //!
+ //!
 //! Complexity: Average case O(this->count(key, hash_func, equal_func)).
 //! Worst case O(this->size()).
- //!
+ //!
 //! Throws: If the internal hasher or the equality functor throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -1694,31 +1694,31 @@
 { return table_.equal_range(key, hash_func, equal_func); }

 //! Effects: Returns a range containing all elements with values equivalent
- //! to value. Returns std::make_pair(this->end(), this->end()) if no such
+ //! to value. Returns std::make_pair(this->end(), this->end()) if no such
 //! elements exist.
- //!
+ //!
 //! Complexity: Average case O(this->count(value)). Worst case O(this->size()).
- //!
+ //!
 //! Throws: If the internal hasher or the equality functor throws.
 std::pair<const_iterator, const_iterator>
 equal_range(const_reference value) const
 { return table_.equal_range(value); }

- //! Requires: "hash_func" must be a hash function that induces
+ //! Requires: "hash_func" must be a hash function that induces
 //! the same hash values as the stored hasher. The difference is that
 //! "hash_func" hashes the given key instead of the value_type.
 //!
- //! "key_value_equal" must be a equality function that induces
+ //! "key_value_equal" must be a equality function that induces
 //! the same equality as key_equal. The difference is that
 //! "key_value_equal" compares an arbitrary key with the contained values.
 //!
 //! Effects: Returns a range containing all elements with equivalent
- //! keys. Returns std::make_pair(this->end(), this->end()) if no such
+ //! keys. Returns std::make_pair(this->end(), this->end()) if no such
 //! elements exist.
- //!
+ //!
 //! Complexity: Average case O(this->count(key, hash_func, equal_func)).
 //! Worst case O(this->size()).
- //!
+ //!
 //! Throws: If the internal hasher or the equality functor throws.
 //!
 //! Note: This function is used when constructing a value_type
@@ -1731,38 +1731,38 @@

 //! Requires: value must be an lvalue and shall be in a unordered_multiset of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid iterator belonging to the unordered_multiset
 //! that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If the hash function throws.
 iterator iterator_to(reference value)
 { return table_.iterator_to(value); }

 //! Requires: value must be an lvalue and shall be in a unordered_multiset of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid const_iterator belonging to the
 //! unordered_multiset that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If the hash function throws.
 const_iterator iterator_to(const_reference value) const
 { return table_.iterator_to(value); }

 //! Requires: value must be an lvalue and shall be in a unordered_set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid local_iterator belonging to the unordered_set
 //! that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This static function is available only if the value traits
 //! is stateless.
 static local_iterator s_local_iterator_to(reference value)
@@ -1770,14 +1770,14 @@

 //! Requires: value must be an lvalue and shall be in a unordered_set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid const_local_iterator belonging to
 //! the unordered_set that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: This static function is available only if the value traits
 //! is stateless.
 static const_local_iterator s_local_iterator_to(const_reference value)
@@ -1785,33 +1785,33 @@

 //! Requires: value must be an lvalue and shall be in a unordered_set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid local_iterator belonging to the unordered_set
 //! that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 local_iterator local_iterator_to(reference value)
 { return table_.local_iterator_to(value); }

 //! Requires: value must be an lvalue and shall be in a unordered_set of
 //! appropriate type. Otherwise the behavior is undefined.
- //!
+ //!
 //! Effects: Returns: a valid const_local_iterator belonging to
 //! the unordered_set that points to the value
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 const_local_iterator local_iterator_to(const_reference value) const
 { return table_.local_iterator_to(value); }

 //! Effects: Returns the number of buckets passed in the constructor
 //! or the last rehash function.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 size_type bucket_count() const
 { return table_.bucket_count(); }
@@ -1819,33 +1819,33 @@
 //! Requires: n is in the range [0, this->bucket_count()).
 //!
 //! Effects: Returns the number of elements in the nth bucket.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 size_type bucket_size(size_type n) const
 { return table_.bucket_size(n); }

 //! Effects: Returns the index of the bucket in which elements
 //! with keys equivalent to k would be found, if any such element existed.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If the hash functor throws.
 //!
 //! Note: the return value is in the range [0, this->bucket_count()).
 size_type bucket(const value_type& k) const
 { return table_.bucket(k); }

- //! Requires: "hash_func" must be a hash function that induces
+ //! Requires: "hash_func" must be a hash function that induces
 //! the same hash values as the stored hasher. The difference is that
 //! "hash_func" hashes the given key instead of the value_type.
 //!
 //! Effects: Returns the index of the bucket in which elements
 //! with keys equivalent to k would be found, if any such element existed.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: If the hash functor throws.
 //!
 //! Note: the return value is in the range [0, this->bucket_count()).
@@ -1855,9 +1855,9 @@

 //! Effects: Returns the bucket array pointer passed in the constructor
 //! or the last rehash function.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
 bucket_ptr bucket_pointer() const
 { return table_.bucket_pointer(); }
@@ -1866,13 +1866,13 @@
 //!
 //! Effects: Returns a local_iterator pointing to the beginning
 //! of the sequence stored in the bucket n.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: [this->begin(n), this->end(n)) is a valid range
- //! containing all of the elements in the nth bucket.
+ //! containing all of the elements in the nth bucket.
 local_iterator begin(size_type n)
 { return table_.begin(n); }

@@ -1880,13 +1880,13 @@
 //!
 //! Effects: Returns a const_local_iterator pointing to the beginning
 //! of the sequence stored in the bucket n.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: [this->begin(n), this->end(n)) is a valid range
- //! containing all of the elements in the nth bucket.
+ //! containing all of the elements in the nth bucket.
 const_local_iterator begin(size_type n) const
 { return table_.begin(n); }

@@ -1894,13 +1894,13 @@
 //!
 //! Effects: Returns a const_local_iterator pointing to the beginning
 //! of the sequence stored in the bucket n.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: [this->begin(n), this->end(n)) is a valid range
- //! containing all of the elements in the nth bucket.
+ //! containing all of the elements in the nth bucket.
 const_local_iterator cbegin(size_type n) const
 { return table_.cbegin(n); }

@@ -1908,13 +1908,13 @@
 //!
 //! Effects: Returns a local_iterator pointing to the end
 //! of the sequence stored in the bucket n.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: [this->begin(n), this->end(n)) is a valid range
- //! containing all of the elements in the nth bucket.
+ //! containing all of the elements in the nth bucket.
 local_iterator end(size_type n)
 { return table_.end(n); }

@@ -1922,13 +1922,13 @@
 //!
 //! Effects: Returns a const_local_iterator pointing to the end
 //! of the sequence stored in the bucket n.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: [this->begin(n), this->end(n)) is a valid range
- //! containing all of the elements in the nth bucket.
+ //! containing all of the elements in the nth bucket.
 const_local_iterator end(size_type n) const
 { return table_.end(n); }

@@ -1936,13 +1936,13 @@
 //!
 //! Effects: Returns a const_local_iterator pointing to the end
 //! of the sequence stored in the bucket n.
- //!
+ //!
 //! Complexity: Constant.
- //!
+ //!
 //! Throws: Nothing.
- //!
+ //!
 //! Note: [this->begin(n), this->end(n)) is a valid range
- //! containing all of the elements in the nth bucket.
+ //! containing all of the elements in the nth bucket.
 const_local_iterator cend(size_type n) const
 { return table_.cend(n); }

@@ -1952,22 +1952,22 @@
 //! n can be bigger or smaller than this->bucket_count().
 //!
 //! Effects: Updates the internal reference with the new bucket erases
- //! the values from the old bucket and inserts then in the new one.
+ //! the values from the old bucket and inserts then in the new one.
 //!
 //! If store_hash option is true, this method does not use the hash function.
- //!
+ //!
 //! Complexity: Average case linear in this->size(), worst case quadratic.
- //!
+ //!
 //! Throws: If the hasher functor throws.
 void rehash(const bucket_traits &new_bucket_traits)
 { table_.rehash(new_bucket_traits); }

 //! Requires:
 //!
- //! Effects:
- //!
- //! Complexity:
- //!
+ //! Effects:
+ //!
+ //! Complexity:
+ //!
 //! Throws:
 //!
 //! Note: this method is only available if incremental<true> option is activated.
@@ -1980,22 +1980,22 @@

 //! Requires:
 //!
- //! Effects:
- //!
- //! Complexity:
- //!
- //! Throws:
+ //! Effects:
+ //!
+ //! Complexity:
+ //!
+ //! Throws:
 size_type split_count() const
 { return table_.split_count(); }

 //! Effects: Returns the nearest new bucket count optimized for
 //! the container that is bigger than n. This suggestion can be used
 //! to create bucket arrays with a size that will usually improve
- //! container's performance. If such value does not exist, the
+ //! container's performance. If such value does not exist, the
 //! higher possible value is returned.
- //!
+ //!
 //! Complexity: Amortized constant time.
- //!
+ //!
 //! Throws: Nothing.
 static size_type suggested_upper_bucket_count(size_type n)
 { return table_type::suggested_upper_bucket_count(n); }
@@ -2003,11 +2003,11 @@
 //! Effects: Returns the nearest new bucket count optimized for
 //! the container that is smaller than n. This suggestion can be used
 //! to create bucket arrays with a size that will usually improve
- //! container's performance. If such value does not exist, the
+ //! container's performance. If such value does not exist, the
 //! lower possible value is returned.
- //!
+ //!
 //! Complexity: Amortized constant time.
- //!
+ //!
 //! Throws: Nothing.
 static size_type suggested_lower_bucket_count(size_type n)
 { return table_type::suggested_lower_bucket_count(n); }
@@ -2030,7 +2030,7 @@
 /// @cond
 typedef unordered_multiset_impl
 < typename make_hashtable_opt
- <T, false,
+ <T, false,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4, O5, O6, O7, O8, O9, O10
 #else
@@ -2050,7 +2050,7 @@
template<class T, class ...Options>
#endif
class unordered_multiset
- : public make_unordered_multiset<T,
+ : public make_unordered_multiset<T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4, O5, O6, O7, O8, O9, O10
 #else
@@ -2059,7 +2059,7 @@
>::type
{
 typedef typename make_unordered_multiset
- <T,
+ <T,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4, O5, O6, O7, O8, O9, O10
 #else
@@ -2083,7 +2083,7 @@
 unordered_multiset( const bucket_traits &b_traits
 , const hasher & hash_func = hasher()
 , const key_equal &equal_func = key_equal()
- , const value_traits &v_traits = value_traits())
+ , const value_traits &v_traits = value_traits())
 : Base(b_traits, hash_func, equal_func, v_traits)
 {}

@@ -2093,7 +2093,7 @@
 , const bucket_traits &b_traits
 , const hasher & hash_func = hasher()
 , const key_equal &equal_func = key_equal()
- , const value_traits &v_traits = value_traits())
+ , const value_traits &v_traits = value_traits())
 : Base(b, e, b_traits, hash_func, equal_func, v_traits)
 {}

@@ -2107,8 +2107,8 @@

#endif

-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Modified: branches/release/boost/intrusive/unordered_set_hook.hpp
==============================================================================
--- branches/release/boost/intrusive/unordered_set_hook.hpp (original)
+++ branches/release/boost/intrusive/unordered_set_hook.hpp 2012-05-24 12:57:51 EDT (Thu, 24 May 2012)
@@ -95,10 +95,10 @@
 { n->prev_in_group_ = prev; }

 static std::size_t get_hash(const const_node_ptr & n)
- { return n->hash_; }
+ { return n->hash_; }

 static void set_hash(const node_ptr & n, std::size_t h)
- { n->hash_ = h; }
+ { n->hash_ = h; }
};

template<class NodeTraits>
@@ -147,12 +147,12 @@
{
 typedef typename detail::if_c
 < (StoreHash || OptimizeMultiKey)
- , unordered_node_traits<VoidPointer, StoreHash, OptimizeMultiKey>
- , slist_node_traits<VoidPointer>
+ , unordered_node_traits<VoidPointer, StoreHash, OptimizeMultiKey>
+ , slist_node_traits<VoidPointer>
>::type node_traits_type;
 typedef typename detail::if_c
 < OptimizeMultiKey
- , unordered_algorithms<node_traits_type>
+ , unordered_algorithms<node_traits_type>
 , circular_slist_algorithms<node_traits_type>
>::type type;
};
@@ -169,7 +169,7 @@
{
 /// @cond
 typedef typename pack_options
- < hook_defaults,
+ < hook_defaults,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
@@ -190,16 +190,16 @@
 typedef implementation_defined type;
};

-//! Derive a class from unordered_set_base_hook in order to store objects in
-//! in an unordered_set/unordered_multi_set. unordered_set_base_hook holds the data necessary to maintain
+//! Derive a class from unordered_set_base_hook in order to store objects in
+//! in an unordered_set/unordered_multi_set. unordered_set_base_hook holds the data necessary to maintain
//! the unordered_set/unordered_multi_set and provides an appropriate value_traits class for unordered_set/unordered_multi_set.
-//!
+//!
//! The hook admits the following options: \c tag<>, \c void_pointer<>,
//! \c link_mode<>, \c store_hash<> and \c optimize_multikey<>.
//!
-//! \c tag<> defines a tag to identify the node.
-//! The same tag value can be used in different classes, but if a class is
-//! derived from more than one \c list_base_hook, then each \c list_base_hook needs its
+//! \c tag<> defines a tag to identify the node.
+//! The same tag value can be used in different classes, but if a class is
+//! derived from more than one \c list_base_hook, then each \c list_base_hook needs its
//! unique tag.
//!
//! \c void_pointer<> is the pointer type that will be used internally in the hook
@@ -232,27 +232,27 @@
 public:
 //! Effects: If link_mode is \c auto_unlink or \c safe_link
 //! initializes the node to an unlinked state.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 unordered_set_base_hook();

 //! Effects: If link_mode is \c auto_unlink or \c safe_link
 //! initializes the node to an unlinked state. The argument is ignored.
- //!
- //! Throws: Nothing.
- //!
+ //!
+ //! Throws: Nothing.
+ //!
 //! Rationale: Providing a copy-constructor
- //! makes classes using the hook STL-compliant without forcing the
+ //! makes classes using the hook STL-compliant without forcing the
 //! user to do some additional work. \c swap can be used to emulate
 //! move-semantics.
 unordered_set_base_hook(const unordered_set_base_hook& );

 //! Effects: Empty function. The argument is ignored.
- //!
- //! Throws: Nothing.
- //!
- //! Rationale: Providing an assignment operator
- //! makes classes using the hook STL-compliant without forcing the
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Rationale: Providing an assignment operator
+ //! makes classes using the hook STL-compliant without forcing the
 //! user to do some additional work. \c swap can be used to emulate
 //! move-semantics.
 unordered_set_base_hook& operator=(const unordered_set_base_hook& );
@@ -261,37 +261,37 @@
 //! nothing (ie. no code is generated). If link_mode is \c safe_link and the
 //! object is stored in an unordered_set an assertion is raised. If link_mode is
 //! \c auto_unlink and \c is_linked() is true, the node is unlinked.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 ~unordered_set_base_hook();

- //! Effects: Swapping two nodes swaps the position of the elements
- //! related to those nodes in one or two containers. That is, if the node
- //! this is part of the element e1, the node x is part of the element e2
- //! and both elements are included in the containers s1 and s2, then after
- //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1
- //! at the position of e1. If one element is not in a container, then
- //! after the swap-operation the other element is not in a container.
- //! Iterators to e1 and e2 related to those nodes are invalidated.
+ //! Effects: Swapping two nodes swaps the position of the elements
+ //! related to those nodes in one or two containers. That is, if the node
+ //! this is part of the element e1, the node x is part of the element e2
+ //! and both elements are included in the containers s1 and s2, then after
+ //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1
+ //! at the position of e1. If one element is not in a container, then
+ //! after the swap-operation the other element is not in a container.
+ //! Iterators to e1 and e2 related to those nodes are invalidated.
 //!
- //! Complexity: Constant
+ //! Complexity: Constant
 //!
- //! Throws: Nothing.
+ //! Throws: Nothing.
 void swap_nodes(unordered_set_base_hook &other);

 //! Precondition: link_mode must be \c safe_link or \c auto_unlink.
 //!
 //! Returns: true, if the node belongs to a container, false
- //! otherwise. This function can be used to test whether \c unordered_set::iterator_to
- //! will return a valid iterator.
+ //! otherwise. This function can be used to test whether \c unordered_set::iterator_to
+ //! will return a valid iterator.
 //!
- //! Complexity: Constant
+ //! Complexity: Constant
 bool is_linked() const;

 //! Effects: Removes the node if it's inserted in a container.
 //! This function is only allowed if link_mode is \c auto_unlink.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 void unlink();
 #endif
};
@@ -308,7 +308,7 @@
{
 /// @cond
 typedef typename pack_options
- < hook_defaults,
+ < hook_defaults,
 #if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
 O1, O2, O3, O4
 #else
@@ -332,7 +332,7 @@
//! Put a public data member unordered_set_member_hook in order to store objects of this class in
//! an unordered_set/unordered_multi_set. unordered_set_member_hook holds the data necessary for maintaining the
//! unordered_set/unordered_multi_set and provides an appropriate value_traits class for unordered_set/unordered_multi_set.
-//!
+//!
//! The hook admits the following options: \c void_pointer<>,
//! \c link_mode<> and \c store_hash<>.
//!
@@ -362,27 +362,27 @@
 public:
 //! Effects: If link_mode is \c auto_unlink or \c safe_link
 //! initializes the node to an unlinked state.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 unordered_set_member_hook();

 //! Effects: If link_mode is \c auto_unlink or \c safe_link
 //! initializes the node to an unlinked state. The argument is ignored.
- //!
- //! Throws: Nothing.
- //!
+ //!
+ //! Throws: Nothing.
+ //!
 //! Rationale: Providing a copy-constructor
- //! makes classes using the hook STL-compliant without forcing the
+ //! makes classes using the hook STL-compliant without forcing the
 //! user to do some additional work. \c swap can be used to emulate
 //! move-semantics.
 unordered_set_member_hook(const unordered_set_member_hook& );

 //! Effects: Empty function. The argument is ignored.
- //!
- //! Throws: Nothing.
- //!
- //! Rationale: Providing an assignment operator
- //! makes classes using the hook STL-compliant without forcing the
+ //!
+ //! Throws: Nothing.
+ //!
+ //! Rationale: Providing an assignment operator
+ //! makes classes using the hook STL-compliant without forcing the
 //! user to do some additional work. \c swap can be used to emulate
 //! move-semantics.
 unordered_set_member_hook& operator=(const unordered_set_member_hook& );
@@ -391,43 +391,43 @@
 //! nothing (ie. no code is generated). If link_mode is \c safe_link and the
 //! object is stored in an unordered_set an assertion is raised. If link_mode is
 //! \c auto_unlink and \c is_linked() is true, the node is unlinked.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 ~unordered_set_member_hook();

- //! Effects: Swapping two nodes swaps the position of the elements
- //! related to those nodes in one or two containers. That is, if the node
- //! this is part of the element e1, the node x is part of the element e2
- //! and both elements are included in the containers s1 and s2, then after
- //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1
- //! at the position of e1. If one element is not in a container, then
- //! after the swap-operation the other element is not in a container.
- //! Iterators to e1 and e2 related to those nodes are invalidated.
+ //! Effects: Swapping two nodes swaps the position of the elements
+ //! related to those nodes in one or two containers. That is, if the node
+ //! this is part of the element e1, the node x is part of the element e2
+ //! and both elements are included in the containers s1 and s2, then after
+ //! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1
+ //! at the position of e1. If one element is not in a container, then
+ //! after the swap-operation the other element is not in a container.
+ //! Iterators to e1 and e2 related to those nodes are invalidated.
 //!
- //! Complexity: Constant
+ //! Complexity: Constant
 //!
- //! Throws: Nothing.
+ //! Throws: Nothing.
 void swap_nodes(unordered_set_member_hook &other);

 //! Precondition: link_mode must be \c safe_link or \c auto_unlink.
 //!
 //! Returns: true, if the node belongs to a container, false
- //! otherwise. This function can be used to test whether \c unordered_set::iterator_to
- //! will return a valid iterator.
+ //! otherwise. This function can be used to test whether \c unordered_set::iterator_to
+ //! will return a valid iterator.
 //!
- //! Complexity: Constant
+ //! Complexity: Constant
 bool is_linked() const;

 //! Effects: Removes the node if it's inserted in a container.
 //! This function is only allowed if link_mode is \c auto_unlink.
- //!
- //! Throws: Nothing.
+ //!
+ //! Throws: Nothing.
 void unlink();
 #endif
};

-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost

#include <boost/intrusive/detail/config_end.hpp>

Date view	Thread view	Subject view	Author view

Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk