[Boost-commit] svn:boost r78589 - in branches/release/boost/container: . detail

Subject: [Boost-commit] svn:boost r78589 - in branches/release/boost/container: . detail
From: igaztanaga_at_[hidden]
Date: 2012-05-24 12:36:43

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

Log:
Merged from trunk
Properties modified: 
   branches/release/boost/container/   (props changed)
Text files modified: 
   branches/release/boost/container/allocator_traits.hpp                |    34 +-                                      
   branches/release/boost/container/container_fwd.hpp                   |    12                                         
   branches/release/boost/container/deque.hpp                           |   348 ++++++++++----------                    
   branches/release/boost/container/detail/adaptive_node_pool_impl.hpp  |    18                                         
   branches/release/boost/container/detail/advanced_insert_int.hpp      |     8                                         
   branches/release/boost/container/detail/algorithms.hpp               |     2                                         
   branches/release/boost/container/detail/allocation_type.hpp          |     2                                         
   branches/release/boost/container/detail/destroyers.hpp               |     8                                         
   branches/release/boost/container/detail/flat_tree.hpp                |   214 ++++++++----                            
   branches/release/boost/container/detail/function_detector.hpp        |     4                                         
   branches/release/boost/container/detail/iterators.hpp                |    40 +-                                      
   branches/release/boost/container/detail/math_functions.hpp           |     4                                         
   branches/release/boost/container/detail/mpl.hpp                      |    20                                         
   branches/release/boost/container/detail/node_alloc_holder.hpp        |     8                                         
   branches/release/boost/container/detail/node_pool_impl.hpp           |    20                                         
   branches/release/boost/container/detail/pair.hpp                     |     6                                         
   branches/release/boost/container/detail/preprocessor.hpp             |     2                                         
   branches/release/boost/container/detail/transform_iterator.hpp       |     6                                         
   branches/release/boost/container/detail/tree.hpp                     |   132 ++++----                                
   branches/release/boost/container/detail/type_traits.hpp              |     4                                         
   branches/release/boost/container/detail/utilities.hpp                |     4                                         
   branches/release/boost/container/detail/value_init.hpp               |     6                                         
   branches/release/boost/container/detail/variadic_templates_tools.hpp |     4                                         
   branches/release/boost/container/detail/version_type.hpp             |     2                                         
   branches/release/boost/container/flat_map.hpp                        |   633 +++++++++++++++++++++------------------ 
   branches/release/boost/container/flat_set.hpp                        |   575 +++++++++++++++++++-----------------    
   branches/release/boost/container/list.hpp                            |   346 ++++++++++----------                    
   branches/release/boost/container/map.hpp                             |   566 +++++++++++++++++-----------------      
   branches/release/boost/container/scoped_allocator.hpp                |   210 ++++++------                            
   branches/release/boost/container/set.hpp                             |   536 ++++++++++++++++----------------        
   branches/release/boost/container/slist.hpp                           |   484 +++++++++++++++---------------          
   branches/release/boost/container/stable_vector.hpp                   |   194 ++++++------                            
   branches/release/boost/container/string.hpp                          |   580 ++++++++++++++++++------------------    
   branches/release/boost/container/vector.hpp                          |   347 +++++++++++----------                   
   34 files changed, 2768 insertions(+), 2611 deletions(-)

Modified: branches/release/boost/container/allocator_traits.hpp
==============================================================================
--- branches/release/boost/container/allocator_traits.hpp	(original)
+++ branches/release/boost/container/allocator_traits.hpp	2012-05-24 12:36:39 EDT (Thu, 24 May 2012)
@@ -66,10 +66,10 @@
 
    #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
       //! Alloc::pointer if such a type exists; otherwise, value_type*
-      //! 
+      //!
       typedef unspecified pointer;
       //! Alloc::const_pointer if such a type exists ; otherwise, pointer_traits<pointer>::rebind<const
-      //! 
+      //!
       typedef unspecified const_pointer;
       //! Non-standard extension
       //! Alloc::reference if such a type exists; otherwise, value_type&
@@ -78,16 +78,16 @@
       //! Alloc::const_reference if such a type exists ; otherwise, const value_type&
       typedef unspecified const_reference;
       //! Alloc::void_pointer if such a type exists ; otherwise, pointer_traits<pointer>::rebind<void>.
-      //! 
+      //!
       typedef unspecified void_pointer;
       //! Alloc::const_void_pointer if such a type exists ; otherwis e, pointer_traits<pointer>::rebind<const
-      //! 
+      //!
       typedef unspecified const_void_pointer;
       //! Alloc::difference_type if such a type exists ; otherwise, pointer_traits<pointer>::difference_type.
-      //! 
+      //!
       typedef unspecified difference_type;
       //! Alloc::size_type if such a type exists ; otherwise, make_unsigned<difference_type>::type
-      //! 
+      //!
       typedef unspecified size_type;
       //! Alloc::propagate_on_container_copy_assignment if such a type exists, otherwise an integral_constant
       //! type with internal constant static member `value` == false.
@@ -99,9 +99,9 @@
       //! type with internal constant static member `value` == false.
       typedef unspecified propagate_on_container_swap;
       //! Defines an allocator: Alloc::rebind<T>::other if such a type exists; otherwise, Alloc<T, Args>
-      //! if Alloc is a class template instantiation of the form Alloc<U, Args>, where Args is zero or 
+      //! if Alloc is a class template instantiation of the form Alloc<U, Args>, where Args is zero or
       //! more type arguments ; otherwise, the instantiation of rebind_alloc is ill-formed.
-      //! 
+      //!
       //! In C++03 compilers `rebind_alloc` is a struct derived from an allocator
       //! deduced by previously detailed rules.
       template <class T> using rebind_alloc = unspecified;
@@ -122,7 +122,7 @@
          pointer, value_type*)
             pointer;
       //const_pointer
-      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_EVAL_DEFAULT(boost::container::container_detail::, Alloc, 
+      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_EVAL_DEFAULT(boost::container::container_detail::, Alloc,
          const_pointer, typename boost::intrusive::pointer_traits<pointer>::template
             rebind_pointer<const value_type>)
                const_pointer;
@@ -131,11 +131,11 @@
          reference, typename container_detail::unvoid<value_type>::type&)
             reference;
       //const_reference
-      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::container_detail::, Alloc, 
+      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::container_detail::, Alloc,
          const_reference, const typename container_detail::unvoid<value_type>::type&)
                const_reference;
       //void_pointer
-      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_EVAL_DEFAULT(boost::container::container_detail::, Alloc, 
+      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_EVAL_DEFAULT(boost::container::container_detail::, Alloc,
          void_pointer, typename boost::intrusive::pointer_traits<pointer>::template
             rebind_pointer<void>)
                void_pointer;
@@ -203,12 +203,12 @@
    #endif   //BOOST_CONTAINER_DOXYGEN_INVOKED
 
    //! <b>Returns</b>: `a.allocate(n)`
-   //! 
+   //!
    static pointer allocate(Alloc &a, size_type n)
    {  return a.allocate(n);  }
 
    //! <b>Returns</b>: `a.deallocate(p, n)`
-   //! 
+   //!
    //! <b>Throws</b>: Nothing
    static void deallocate(Alloc &a, pointer p, size_type n)
    {  return a.deallocate(p, n);  }
@@ -260,7 +260,7 @@
    }
 
    #if !defined(BOOST_NO_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-      //! <b>Effects</b>: calls `a.construct(p, std::forward<Args>(args)...)` if that call is well-formed; 
+      //! <b>Effects</b>: calls `a.construct(p, std::forward<Args>(args)...)` if that call is well-formed;
       //! otherwise, invokes `::new (static_cast<void*>(p)) T(std::forward<Args>(args)...)`
       template <class T, class ...Args>
       static void construct(Alloc & a, T* p, BOOST_FWD_REF(Args)... args)
@@ -300,8 +300,8 @@
 
       #if !defined(BOOST_NO_VARIADIC_TEMPLATES)
          template<class T, class ...Args>
-         static void priv_construct(boost::false_type, Alloc &a, T *p, BOOST_FWD_REF(Args) ...args)                    
-         {                                                                                                  
+         static void priv_construct(boost::false_type, Alloc &a, T *p, BOOST_FWD_REF(Args) ...args)                   
+         {                                                                                                 
             const bool value = boost::container::container_detail::
                   has_member_function_callable_with_construct
                      < Alloc, T*, Args... >::value;
@@ -336,7 +336,7 @@
          //
          #define BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS)
          #include BOOST_PP_LOCAL_ITERATE()
-      
+     
          private:
          #define BOOST_PP_LOCAL_MACRO(n)                                                                    \
          template<class T  BOOST_PP_ENUM_TRAILING_PARAMS(n, class P) >                                      \

Modified: branches/release/boost/container/container_fwd.hpp
==============================================================================
--- branches/release/boost/container/container_fwd.hpp	(original)
+++ branches/release/boost/container/container_fwd.hpp	2012-05-24 12:36:39 EDT (Thu, 24 May 2012)
@@ -21,8 +21,8 @@
 
 /// @cond
 
-namespace boost{ 
-namespace intrusive{ 
+namespace boost{
+namespace intrusive{
    //Create namespace to avoid compilation errors
 }}
 
@@ -32,9 +32,9 @@
 
 }}}
 
-#include <utility> 
-#include <memory> 
-#include <functional> 
+#include <utility>
+#include <memory>
+#include <functional>
 #include <iosfwd>
 #include <string>
 
@@ -127,7 +127,7 @@
 //basic_string class
 template <class CharT
          ,class Traits = std::char_traits<CharT>
-         ,class A  = std::allocator<CharT> > 
+         ,class A  = std::allocator<CharT> >
 class basic_string;
 
 //! Type used to tag that the input range is

Modified: branches/release/boost/container/deque.hpp
==============================================================================
--- branches/release/boost/container/deque.hpp	(original)
+++ branches/release/boost/container/deque.hpp	2012-05-24 12:36:39 EDT (Thu, 24 May 2012)
@@ -90,7 +90,7 @@
 
 // Note: this function is simply a kludge to work around several compilers'
 //  bugs in handling constant expressions.
-inline std::size_t deque_buf_size(std::size_t size) 
+inline std::size_t deque_buf_size(std::size_t size)
    {  return size < 512 ? std::size_t(512 / size) : std::size_t(1);  }
 
 // Deque base class.  It has two purposes.  First, its constructor
@@ -128,16 +128,16 @@
 
    static size_type s_buffer_size() { return deque_buf_size(sizeof(T)); }
 
-   val_alloc_ptr priv_allocate_node() 
+   val_alloc_ptr priv_allocate_node()
       {  return this->alloc().allocate(s_buffer_size());  }
 
-   void priv_deallocate_node(val_alloc_ptr p) 
+   void priv_deallocate_node(val_alloc_ptr p)
       {  this->alloc().deallocate(p, s_buffer_size());  }
 
-   ptr_alloc_ptr priv_allocate_map(size_type n) 
+   ptr_alloc_ptr priv_allocate_map(size_type n)
       { return this->ptr_alloc().allocate(n); }
 
-   void priv_deallocate_map(ptr_alloc_ptr p, size_type n) 
+   void priv_deallocate_map(ptr_alloc_ptr p, size_type n)
       { this->ptr_alloc().deallocate(p, n); }
 
  public:
@@ -145,7 +145,7 @@
    //  For any nonsingular iterator i:
    //    i.node is the address of an element in the map array.  The
    //      contents of i.node is a pointer to the beginning of a node.
-   //    i.first == //(i.node) 
+   //    i.first == //(i.node)
    //    i.last  == i.first + node_size
    //    i.cur is a pointer in the range [i.first, i.last).  NOTE:
    //      the implication of this is that i.cur is always a dereferenceable
@@ -160,14 +160,14 @@
    //    [start.cur, start.last) and [finish.first, finish.cur) are initialized
    //    objects, and [start.first, start.cur) and [finish.cur, finish.last)
    //    are uninitialized storage.
-   //  [map, map + map_size) is a valid, non-empty range.  
-   //  [start.node, finish.node] is a valid range contained within 
-   //    [map, map + map_size).  
+   //  [map, map + map_size) is a valid, non-empty range. 
+   //  [start.node, finish.node] is a valid range contained within
+   //    [map, map + map_size). 
    //  A pointer in the range [map, map + map_size) points to an allocated node
    //    if and only if the pointer is in the range [start.node, finish.node].
-   class const_iterator 
-      : public std::iterator<std::random_access_iterator_tag, 
-                              val_alloc_val,  val_alloc_diff, 
+   class const_iterator
+      : public std::iterator<std::random_access_iterator_tag,
+                              val_alloc_val,  val_alloc_diff,
                               val_alloc_cptr, val_alloc_cref>
    {
       public:
@@ -185,30 +185,30 @@
       friend class deque<T, A>;
       friend class deque_base<T, A>;
 
-      protected: 
+      protected:
       val_alloc_ptr  m_cur;
       val_alloc_ptr  m_first;
       val_alloc_ptr  m_last;
       index_pointer  m_node;
 
-      public: 
-      const_iterator(val_alloc_ptr x, index_pointer y) 
+      public:
+      const_iterator(val_alloc_ptr x, index_pointer y)
          : m_cur(x), m_first(*y),
            m_last(*y + s_buffer_size()), m_node(y) {}
 
       const_iterator() : m_cur(0), m_first(0), m_last(0), m_node(0) {}
 
       const_iterator(const const_iterator& x)
-         : m_cur(x.m_cur),   m_first(x.m_first), 
+         : m_cur(x.m_cur),   m_first(x.m_first),
            m_last(x.m_last), m_node(x.m_node) {}
 
-      reference operator*() const 
+      reference operator*() const
          { return *this->m_cur; }
 
-      pointer operator->() const 
+      pointer operator->() const
          { return this->m_cur; }
 
-      difference_type operator-(const self_t& x) const 
+      difference_type operator-(const self_t& x) const
       {
          if(!this->m_cur && !x.m_cur){
             return 0;
@@ -217,24 +217,24 @@
             (this->m_cur - this->m_first) + (x.m_last - x.m_cur);
       }
 
-      self_t& operator++() 
+      self_t& operator++()
       {
          ++this->m_cur;
          if (this->m_cur == this->m_last) {
             this->priv_set_node(this->m_node + 1);
             this->m_cur = this->m_first;
          }
-         return *this; 
+         return *this;
       }
 
-      self_t operator++(int)  
+      self_t operator++(int) 
       {
          self_t tmp = *this;
          ++*this;
          return tmp;
       }
 
-      self_t& operator--() 
+      self_t& operator--()
       {
          if (this->m_cur == this->m_first) {
             this->priv_set_node(this->m_node - 1);
@@ -244,7 +244,7 @@
          return *this;
       }
 
-      self_t operator--(int) 
+      self_t operator--(int)
       {
          self_t tmp = *this;
          --*this;
@@ -261,7 +261,7 @@
             offset > 0 ? offset / difference_type(this->s_buffer_size())
                         : -difference_type((-offset - 1) / this->s_buffer_size()) - 1;
             this->priv_set_node(this->m_node + node_offset);
-            this->m_cur = this->m_first + 
+            this->m_cur = this->m_first +
             (offset - node_offset * difference_type(this->s_buffer_size()));
          }
          return *this;
@@ -270,37 +270,37 @@
       self_t operator+(difference_type n) const
          {  self_t tmp = *this; return tmp += n;  }
 
-      self_t& operator-=(difference_type n) 
+      self_t& operator-=(difference_type n)
          { return *this += -n; }
-       
-      self_t operator-(difference_type n) const 
+      
+      self_t operator-(difference_type n) const
          {  self_t tmp = *this; return tmp -= n;  }
 
-      reference operator[](difference_type n) const 
+      reference operator[](difference_type n) const
          { return *(*this + n); }
 
-      bool operator==(const self_t& x) const 
+      bool operator==(const self_t& x) const
          { return this->m_cur == x.m_cur; }
 
-      bool operator!=(const self_t& x) const 
+      bool operator!=(const self_t& x) const
          { return !(*this == x); }
 
-      bool operator<(const self_t& x) const 
+      bool operator<(const self_t& x) const
       {
-         return (this->m_node == x.m_node) ? 
+         return (this->m_node == x.m_node) ?
             (this->m_cur < x.m_cur) : (this->m_node < x.m_node);
       }
 
-      bool operator>(const self_t& x) const  
+      bool operator>(const self_t& x) const 
          { return x < *this; }
 
-      bool operator<=(const self_t& x) const 
+      bool operator<=(const self_t& x) const
          { return !(x < *this); }
 
-      bool operator>=(const self_t& x) const 
+      bool operator>=(const self_t& x) const
          { return !(*this < x); }
 
-      void priv_set_node(index_pointer new_node) 
+      void priv_set_node(index_pointer new_node)
       {
          this->m_node = new_node;
          this->m_first = *new_node;
@@ -343,12 +343,12 @@
       reference operator[](difference_type n) const { return *(*this + n); }
 
       //Increment / Decrement
-      iterator& operator++()  
+      iterator& operator++() 
          { this->const_iterator::operator++(); return *this;  }
 
       iterator operator++(int)
          { iterator tmp = *this; ++*this; return tmp; }
-      
+     
       iterator& operator--()
          {  this->const_iterator::operator--(); return *this;  }
 
@@ -379,7 +379,7 @@
       :  members_(a)
    { this->priv_initialize_map(num_elements); }
 
-   explicit deque_base(const allocator_type& a) 
+   explicit deque_base(const allocator_type& a)
       :  members_(a)
    {}
 
@@ -402,7 +402,7 @@
 
    private:
    deque_base(const deque_base&);
-  
+ 
    protected:
 
    void swap_members(deque_base &x)
@@ -423,7 +423,7 @@
 
          ptr_alloc_ptr nstart = this->members_.m_map + (this->members_.m_map_size - num_nodes) / 2;
          ptr_alloc_ptr nfinish = nstart + num_nodes;
-             
+            
          BOOST_TRY {
             this->priv_create_nodes(nstart, nfinish);
          }
@@ -508,16 +508,16 @@
       iterator        m_finish;
    } members_;
 
-   ptr_alloc_t &ptr_alloc() 
+   ptr_alloc_t &ptr_alloc()
    {  return members_;  }
-   
-   const ptr_alloc_t &ptr_alloc() const 
+  
+   const ptr_alloc_t &ptr_alloc() const
    {  return members_;  }
 
-   allocator_type &alloc() 
+   allocator_type &alloc()
    {  return members_;  }
-   
-   const allocator_type &alloc() const 
+  
+   const allocator_type &alloc() const
    {  return members_;  }
 };
 /// @endcond
@@ -574,7 +574,7 @@
    private:                      // Internal typedefs
    BOOST_COPYABLE_AND_MOVABLE(deque)
    typedef ptr_alloc_ptr index_pointer;
-   static size_type s_buffer_size() 
+   static size_type s_buffer_size()
       { return Base::s_buffer_size(); }
    typedef container_detail::advanced_insert_aux_int<iterator> advanced_insert_aux_int_t;
    typedef repeat_iterator<T, difference_type>  r_iterator;
@@ -586,175 +586,175 @@
    public:
 
    //! <b>Effects</b>: Returns a copy of the internal allocator.
-   //! 
+   //!
    //! <b>Throws</b>: If allocator's copy constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    allocator_type get_allocator() const BOOST_CONTAINER_NOEXCEPT
    { return Base::alloc(); }
 
    //! <b>Effects</b>: Returns a reference to the internal allocator.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   //! 
+   //!
    //! <b>Note</b>: Non-standard extension.
    const stored_allocator_type &get_stored_allocator() const BOOST_CONTAINER_NOEXCEPT
    {  return Base::alloc(); }
 
    //! <b>Effects</b>: Returns a reference to the internal allocator.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   //! 
+   //!
    //! <b>Note</b>: Non-standard extension.
    stored_allocator_type &get_stored_allocator() BOOST_CONTAINER_NOEXCEPT
    {  return Base::alloc(); }
 
    //! <b>Effects</b>: Returns an iterator to the first element contained in the deque.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    iterator begin() BOOST_CONTAINER_NOEXCEPT
       { return this->members_.m_start; }
 
    //! <b>Effects</b>: Returns an iterator to the end of the deque.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    iterator end() BOOST_CONTAINER_NOEXCEPT
       { return this->members_.m_finish; }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the deque.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_iterator begin() const BOOST_CONTAINER_NOEXCEPT
       { return this->members_.m_start; }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the deque.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_iterator end() const BOOST_CONTAINER_NOEXCEPT
       { return this->members_.m_finish; }
 
-   //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning 
-   //! of the reversed deque. 
-   //! 
+   //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning
+   //! of the reversed deque.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    reverse_iterator rbegin() BOOST_CONTAINER_NOEXCEPT
       { return reverse_iterator(this->members_.m_finish); }
 
    //! <b>Effects</b>: Returns a reverse_iterator pointing to the end
-   //! of the reversed deque. 
-   //! 
+   //! of the reversed deque.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    reverse_iterator rend() BOOST_CONTAINER_NOEXCEPT
       { return reverse_iterator(this->members_.m_start); }
 
-   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning 
-   //! of the reversed deque. 
-   //! 
+   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
+   //! of the reversed deque.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_reverse_iterator rbegin() const BOOST_CONTAINER_NOEXCEPT
       { return const_reverse_iterator(this->members_.m_finish); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
-   //! of the reversed deque. 
-   //! 
+   //! of the reversed deque.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_reverse_iterator rend() const BOOST_CONTAINER_NOEXCEPT
       { return const_reverse_iterator(this->members_.m_start); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the deque.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_iterator cbegin() const BOOST_CONTAINER_NOEXCEPT
       { return this->members_.m_start; }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the deque.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_iterator cend() const BOOST_CONTAINER_NOEXCEPT
       { return this->members_.m_finish; }
 
-   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning 
-   //! of the reversed deque. 
-   //! 
+   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
+   //! of the reversed deque.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_reverse_iterator crbegin() const BOOST_CONTAINER_NOEXCEPT
       { return const_reverse_iterator(this->members_.m_finish); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
-   //! of the reversed deque. 
-   //! 
+   //! of the reversed deque.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_reverse_iterator crend() const BOOST_CONTAINER_NOEXCEPT
       { return const_reverse_iterator(this->members_.m_start); }
 
    //! <b>Requires</b>: size() > n.
    //!
-   //! <b>Effects</b>: Returns a reference to the nth element 
+   //! <b>Effects</b>: Returns a reference to the nth element
    //!   from the beginning of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    reference operator[](size_type n) BOOST_CONTAINER_NOEXCEPT
       { return this->members_.m_start[difference_type(n)]; }
 
    //! <b>Requires</b>: size() > n.
    //!
-   //! <b>Effects</b>: Returns a const reference to the nth element 
+   //! <b>Effects</b>: Returns a const reference to the nth element
    //!   from the beginning of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_reference operator[](size_type n) const BOOST_CONTAINER_NOEXCEPT
       { return this->members_.m_start[difference_type(n)]; }
 
    //! <b>Requires</b>: size() > n.
    //!
-   //! <b>Effects</b>: Returns a reference to the nth element 
+   //! <b>Effects</b>: Returns a reference to the nth element
    //!   from the beginning of the container.
-   //! 
+   //!
    //! <b>Throws</b>: std::range_error if n >= size()
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    reference at(size_type n)
       { this->priv_range_check(n); return (*this)[n]; }
 
    //! <b>Requires</b>: size() > n.
    //!
-   //! <b>Effects</b>: Returns a const reference to the nth element 
+   //! <b>Effects</b>: Returns a const reference to the nth element
    //!   from the beginning of the container.
-   //! 
+   //!
    //! <b>Throws</b>: std::range_error if n >= size()
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_reference at(size_type n) const
       { this->priv_range_check(n); return (*this)[n]; }
@@ -763,20 +763,20 @@
    //!
    //! <b>Effects</b>: Returns a reference to the first
    //!   element of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    reference front() BOOST_CONTAINER_NOEXCEPT
       { return *this->members_.m_start; }
 
    //! <b>Requires</b>: !empty()
    //!
-   //! <b>Effects</b>: Returns a const reference to the first element 
+   //! <b>Effects</b>: Returns a const reference to the first element
    //!   from the beginning of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_reference front() const BOOST_CONTAINER_NOEXCEPT
       { return *this->members_.m_start; }
@@ -785,9 +785,9 @@
    //!
    //! <b>Effects</b>: Returns a reference to the last
    //!   element of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    reference back() BOOST_CONTAINER_NOEXCEPT
       {  return *(end()-1); }
@@ -796,52 +796,52 @@
    //!
    //! <b>Effects</b>: Returns a const reference to the last
    //!   element of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_reference back() const BOOST_CONTAINER_NOEXCEPT
       {  return *(cend()-1);  }
 
    //! <b>Effects</b>: Returns the number of the elements contained in the deque.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    size_type size() const BOOST_CONTAINER_NOEXCEPT
       { return this->members_.m_finish - this->members_.m_start; }
 
    //! <b>Effects</b>: Returns the largest possible size of the deque.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    size_type max_size() const BOOST_CONTAINER_NOEXCEPT
       { return allocator_traits_type::max_size(this->alloc()); }
 
    //! <b>Effects</b>: Returns true if the deque contains no elements.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    bool empty() const BOOST_CONTAINER_NOEXCEPT
    { return this->members_.m_finish == this->members_.m_start; }
 
    //! <b>Effects</b>: Default constructors a deque.
-   //! 
+   //!
    //! <b>Throws</b>: If allocator_type's default constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   deque() 
+   deque()
       : Base()
    {}
 
    //! <b>Effects</b>: Constructs a deque taking the allocator as parameter.
-   //! 
+   //!
    //! <b>Throws</b>: If allocator_type's copy constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   explicit deque(const allocator_type& a) 
+   explicit deque(const allocator_type& a)
       : Base(a)
    {}
 
@@ -850,7 +850,7 @@
    //!
    //! <b>Throws</b>: If allocator_type's default constructor or copy constructor
    //!   throws or T's default or copy constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear to n.
    explicit deque(size_type n)
       : Base(n, allocator_type())
@@ -865,7 +865,7 @@
    //!
    //! <b>Throws</b>: If allocator_type's default constructor or copy constructor
    //!   throws or T's default or copy constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear to n.
    deque(size_type n, const value_type& value,
          const allocator_type& a = allocator_type())
@@ -875,7 +875,7 @@
    //! <b>Effects</b>: Copy constructs a deque.
    //!
    //! <b>Postcondition</b>: x == *this.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear to the elements x contains.
    deque(const deque& x)
       :  Base(allocator_traits_type::select_on_container_copy_construction(x.alloc()))
@@ -890,19 +890,19 @@
    //! <b>Effects</b>: Move constructor. Moves mx's resources to *this.
    //!
    //! <b>Throws</b>: If allocator_type's copy constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   deque(BOOST_RV_REF(deque) x) 
+   deque(BOOST_RV_REF(deque) x)
       :  Base(boost::move(static_cast<Base&>(x)))
    {  this->swap_members(x);   }
 
    //! <b>Effects</b>: Copy constructs a vector using the specified allocator.
    //!
    //! <b>Postcondition</b>: x == *this.
-   //! 
+   //!
    //! <b>Throws</b>: If allocation
    //!   throws or T's copy constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear to the elements x contains.
    deque(const deque& x, const allocator_type &a)
       :  Base(a)
@@ -919,9 +919,9 @@
    //!                 Otherwise copies values from x to *this.
    //!
    //! <b>Throws</b>: If allocation or T's copy constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant if a == mx.get_allocator(), linear otherwise.
-   deque(BOOST_RV_REF(deque) mx, const allocator_type &a) 
+   deque(BOOST_RV_REF(deque) mx, const allocator_type &a)
       :  Base(a)
    {
       if(mx.alloc() == a){
@@ -945,7 +945,7 @@
    //! <b>Complexity</b>: Linear to the range [first, last).
    template <class InpIt>
    deque(InpIt first, InpIt last, const allocator_type& a = allocator_type())
-      : Base(a) 
+      : Base(a)
    {
       //Dispatch depending on integer/iterator
       const bool aux_boolean = container_detail::is_convertible<InpIt, size_type>::value;
@@ -966,13 +966,13 @@
 
    //! <b>Effects</b>: Makes *this contain the same elements as x.
    //!
-   //! <b>Postcondition</b>: this->size() == x.size(). *this contains a copy 
-   //! of each of x's elements. 
+   //! <b>Postcondition</b>: this->size() == x.size(). *this contains a copy
+   //! of each of x's elements.
    //!
    //! <b>Throws</b>: If memory allocation throws or T's copy constructor throws.
    //!
    //! <b>Complexity</b>: Linear to the number of elements in x.
-   deque& operator= (BOOST_COPY_ASSIGN_REF(deque) x) 
+   deque& operator= (BOOST_COPY_ASSIGN_REF(deque) x)
    {
       if (&x != this){
          allocator_type &this_alloc     = this->alloc();
@@ -1132,7 +1132,7 @@
             );
          ++this->members_.m_start.m_cur;
       }
-      else 
+      else
          this->priv_pop_front_aux();
    }
 
@@ -1180,7 +1180,7 @@
    //!
    //! <b>Complexity</b>: Linear to std::distance [first, last).
    template <class InpIt>
-   void insert(const_iterator pos, InpIt first, InpIt last) 
+   void insert(const_iterator pos, InpIt first, InpIt last)
    {
       //Dispatch depending on integer/iterator
       const bool aux_boolean = container_detail::is_convertible<InpIt, size_type>::value;
@@ -1340,10 +1340,10 @@
    //! <b>Throws</b>: If memory allocation throws, or T's copy constructor throws.
    //!
    //! <b>Complexity</b>: Linear to the difference between size() and new_size.
-   void resize(size_type new_size, const value_type& x) 
+   void resize(size_type new_size, const value_type& x)
    {
       const size_type len = size();
-      if (new_size < len) 
+      if (new_size < len)
          this->erase(this->members_.m_start + new_size, this->members_.m_finish);
       else
          this->insert(this->members_.m_finish, new_size - len, x);
@@ -1355,10 +1355,10 @@
    //! <b>Throws</b>: If memory allocation throws, or T's copy constructor throws.
    //!
    //! <b>Complexity</b>: Linear to the difference between size() and new_size.
-   void resize(size_type new_size) 
+   void resize(size_type new_size)
    {
       const size_type len = size();
-      if (new_size < len) 
+      if (new_size < len)
          this->priv_erase_last_n(len - new_size);
       else{
          size_type n = new_size - this->size();
@@ -1371,7 +1371,7 @@
    //!
    //! <b>Throws</b>: Nothing.
    //!
-   //! <b>Complexity</b>: Linear to the elements between pos and the 
+   //! <b>Complexity</b>: Linear to the elements between pos and the
    //!   last element (if pos is near the end) or the first element
    //!   if(pos is near the beginning).
    //!   Constant if pos is the first or the last element.
@@ -1396,7 +1396,7 @@
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Linear to the distance between first and
-   //!   last plus the elements between pos and the 
+   //!   last plus the elements between pos and the
    //!   last element (if pos is near the end) or the first element
    //!   if(pos is near the beginning).
    iterator erase(const_iterator first, const_iterator last) BOOST_CONTAINER_NOEXCEPT
@@ -1486,10 +1486,10 @@
 
    /// @cond
    private:
-   void priv_range_check(size_type n) const 
+   void priv_range_check(size_type n) const
       {  if (n >= this->size())  BOOST_RETHROW std::out_of_range("deque");   }
 
-   iterator priv_insert(const_iterator position, const value_type &x) 
+   iterator priv_insert(const_iterator position, const value_type &x)
    {
       if (position == cbegin()){
          this->push_front(x);
@@ -1506,7 +1506,7 @@
       }
    }
 
-   iterator priv_insert(const_iterator position, BOOST_RV_REF(value_type) mx) 
+   iterator priv_insert(const_iterator position, BOOST_RV_REF(value_type) mx)
    {
       if (position == cbegin()) {
          this->push_front(boost::move(mx));
@@ -1609,7 +1609,7 @@
    }
 
    template <class FwdIt>
-   void priv_insert_aux(const_iterator pos, FwdIt first, FwdIt last, std::forward_iterator_tag) 
+   void priv_insert_aux(const_iterator pos, FwdIt first, FwdIt last, std::forward_iterator_tag)
    {  this->priv_insert_aux(pos, first, last);  }
 
   // assign(), a generalized assignment member function.  Two
@@ -1629,14 +1629,14 @@
    }
 
    template <class Integer>
-   void priv_initialize_dispatch(Integer n, Integer x, container_detail::true_) 
+   void priv_initialize_dispatch(Integer n, Integer x, container_detail::true_)
    {
       this->priv_initialize_map(n);
       this->priv_fill_initialize(x);
    }
 
    template <class InpIt>
-   void priv_initialize_dispatch(InpIt first, InpIt last, container_detail::false_) 
+   void priv_initialize_dispatch(InpIt first, InpIt last, container_detail::false_)
    {
       typedef typename std::iterator_traits<InpIt>::iterator_category ItCat;
       this->priv_range_initialize(first, last, ItCat());
@@ -1667,7 +1667,7 @@
       { this->priv_fill_assign((size_type) n, (value_type)val); }
 
    template <class InpIt>
-   void priv_assign_dispatch(InpIt first, InpIt last, container_detail::false_) 
+   void priv_assign_dispatch(InpIt first, InpIt last, container_detail::false_)
    {
       typedef typename std::iterator_traits<InpIt>::iterator_category ItCat;
       this->priv_assign_aux(first, last, ItCat());
@@ -1700,11 +1700,11 @@
    }
 
    template <class Integer>
-   void priv_insert_dispatch(const_iterator pos, Integer n, Integer x, container_detail::true_) 
+   void priv_insert_dispatch(const_iterator pos, Integer n, Integer x, container_detail::true_)
    {  this->priv_fill_insert(pos, (size_type) n, (value_type)x); }
 
    template <class InpIt>
-   void priv_insert_dispatch(const_iterator pos,InpIt first, InpIt last, container_detail::false_) 
+   void priv_insert_dispatch(const_iterator pos,InpIt first, InpIt last, container_detail::false_)
    {
       typedef typename std::iterator_traits<InpIt>::iterator_category ItCat;
       this->priv_insert_aux(pos, first, last, ItCat());
@@ -1739,7 +1739,7 @@
          iterator old_start = this->members_.m_start;
          pos = this->members_.m_start + elemsbefore;
          if (elemsbefore >= difference_type(n)) {
-            iterator start_n = this->members_.m_start + difference_type(n); 
+            iterator start_n = this->members_.m_start + difference_type(n);
             ::boost::container::uninitialized_move_alloc
                (this->alloc(), this->members_.m_start, start_n, new_start);
             this->members_.m_start = new_start;
@@ -1760,7 +1760,7 @@
       else {
          iterator new_finish = this->priv_reserve_elements_at_back(n);
          iterator old_finish = this->members_.m_finish;
-         const difference_type elemsafter = 
+         const difference_type elemsafter =
             difference_type(length) - elemsbefore;
          pos = this->members_.m_finish - elemsafter;
          if (elemsafter >= difference_type(n)) {
@@ -1814,7 +1814,7 @@
 
    // Precondition: this->members_.m_start and this->members_.m_finish have already been initialized,
    // but none of the deque's elements have yet been constructed.
-   void priv_fill_initialize(const value_type& value) 
+   void priv_fill_initialize(const value_type& value)
    {
       index_pointer cur;
       BOOST_TRY {
@@ -1856,8 +1856,8 @@
 
       index_pointer cur_node;
       BOOST_TRY {
-         for (cur_node = this->members_.m_start.m_node; 
-               cur_node < this->members_.m_finish.m_node; 
+         for (cur_node = this->members_.m_start.m_node;
+               cur_node < this->members_.m_finish.m_node;
                ++cur_node) {
             FwdIt mid = first;
             std::advance(mid, this->s_buffer_size());
@@ -1887,9 +1887,9 @@
          );
    }
 
-   // Called only if this->members_.m_start.m_cur == this->members_.m_start.m_last - 1.  Note that 
-   // if the deque has at least one element (a precondition for this member 
-   // function), and if this->members_.m_start.m_cur == this->members_.m_start.m_last, then the deque 
+   // Called only if this->members_.m_start.m_cur == this->members_.m_start.m_last - 1.  Note that
+   // if the deque has at least one element (a precondition for this member
+   // function), and if this->members_.m_start.m_cur == this->members_.m_start.m_last, then the deque
    // must have at least two nodes.
    void priv_pop_front_aux()
    {
@@ -1900,14 +1900,14 @@
       this->priv_deallocate_node(this->members_.m_start.m_first);
       this->members_.m_start.priv_set_node(this->members_.m_start.m_node + 1);
       this->members_.m_start.m_cur = this->members_.m_start.m_first;
-   }      
+   }     
 
-   iterator priv_reserve_elements_at_front(size_type n) 
+   iterator priv_reserve_elements_at_front(size_type n)
    {
       size_type vacancies = this->members_.m_start.m_cur - this->members_.m_start.m_first;
       if (n > vacancies){
          size_type new_elems = n-vacancies;
-         size_type new_nodes = (new_elems + this->s_buffer_size() - 1) / 
+         size_type new_nodes = (new_elems + this->s_buffer_size() - 1) /
             this->s_buffer_size();
          size_type s = (size_type)(this->members_.m_start.m_node - this->members_.m_map);
          if (new_nodes > s){
@@ -1920,7 +1920,7 @@
          }
          BOOST_CATCH(...) {
             for (size_type j = 1; j < i; ++j)
-               this->priv_deallocate_node(*(this->members_.m_start.m_node - j));      
+               this->priv_deallocate_node(*(this->members_.m_start.m_node - j));     
             BOOST_RETHROW
          }
          BOOST_CATCH_END
@@ -1928,7 +1928,7 @@
       return this->members_.m_start - difference_type(n);
    }
 
-   iterator priv_reserve_elements_at_back(size_type n) 
+   iterator priv_reserve_elements_at_back(size_type n)
    {
       size_type vacancies = (this->members_.m_finish.m_last - this->members_.m_finish.m_cur) - 1;
       if (n > vacancies){
@@ -1945,7 +1945,7 @@
          }
          BOOST_CATCH(...) {
             for (size_type j = 1; j < i; ++j)
-               this->priv_deallocate_node(*(this->members_.m_finish.m_node + j));      
+               this->priv_deallocate_node(*(this->members_.m_finish.m_node + j));     
             BOOST_RETHROW
          }
          BOOST_CATCH_END
@@ -1960,7 +1960,7 @@
 
       index_pointer new_nstart;
       if (this->members_.m_map_size > 2 * new_num_nodes) {
-         new_nstart = this->members_.m_map + (this->members_.m_map_size - new_num_nodes) / 2 
+         new_nstart = this->members_.m_map + (this->members_.m_map_size - new_num_nodes) / 2
                            + (add_at_front ? nodes_to_add : 0);
          if (new_nstart < this->members_.m_start.m_node)
             boost::move(this->members_.m_start.m_node, this->members_.m_finish.m_node + 1, new_nstart);
@@ -1969,7 +1969,7 @@
                (this->members_.m_start.m_node, this->members_.m_finish.m_node + 1, new_nstart + old_num_nodes);
       }
       else {
-         size_type new_map_size = 
+         size_type new_map_size =
             this->members_.m_map_size + container_detail::max_value(this->members_.m_map_size, nodes_to_add) + 2;
 
          index_pointer new_map = this->priv_allocate_map(new_map_size);
@@ -1998,29 +1998,29 @@
 
 template <class T, class A>
 inline bool operator<(const deque<T, A>& x,
-                      const deque<T, A>& y) 
+                      const deque<T, A>& y)
 {
    return lexicographical_compare(x.begin(), x.end(), y.begin(), y.end());
 }
 
 template <class T, class A>
 inline bool operator!=(const deque<T, A>& x,
-                       const deque<T, A>& y) 
+                       const deque<T, A>& y)
    {  return !(x == y);   }
 
 template <class T, class A>
 inline bool operator>(const deque<T, A>& x,
-                      const deque<T, A>& y) 
+                      const deque<T, A>& y)
    {  return y < x; }
 
 template <class T, class A>
 inline bool operator<=(const deque<T, A>& x,
-                       const deque<T, A>& y) 
+                       const deque<T, A>& y)
    {  return !(y < x); }
 
 template <class T, class A>
 inline bool operator>=(const deque<T, A>& x,
-                       const deque<T, A>& y) 
+                       const deque<T, A>& y)
    {  return !(x < y); }
 
 

Modified: branches/release/boost/container/detail/adaptive_node_pool_impl.hpp
==============================================================================
--- branches/release/boost/container/detail/adaptive_node_pool_impl.hpp	(original)
+++ branches/release/boost/container/detail/adaptive_node_pool_impl.hpp	2012-05-24 12:36:39 EDT (Thu, 24 May 2012)
@@ -51,11 +51,11 @@
       , bi::optimize_size<true>
       , bi::constant_time_size<false>
       , bi::link_mode<bi::normal_link> >::type multiset_hook_t;
-   
+  
    typedef hdr_offset_holder_t<SizeType> hdr_offset_holder;
 
    struct block_info_t
-      :  
+      : 
          public hdr_offset_holder,
          public multiset_hook_t
    {
@@ -89,7 +89,7 @@
    const size_type divisor  = overhead_percent*real_node_size;
    const size_type dividend = hdr_offset_size*100;
    size_type elements_per_subblock = (dividend - 1)/divisor + 1;
-   size_type candidate_power_of_2 = 
+   size_type candidate_power_of_2 =
       upper_power_of_2(elements_per_subblock*real_node_size + hdr_offset_size);
    bool overhead_satisfied = false;
    //Now calculate the wors-case overhead for a subblock
@@ -228,7 +228,7 @@
    {
       priv_invariants();
       //If there are no free nodes we allocate a new block
-      if (m_block_multiset.empty()){ 
+      if (m_block_multiset.empty()){
          priv_alloc_block(1);
       }
       //We take the first free node the multiset can't be empty
@@ -248,7 +248,7 @@
       priv_invariants();
    }
 
-   //!Allocates n nodes. 
+   //!Allocates n nodes.
    //!Can throw
    multiallocation_chain allocate_nodes(const size_type n)
    {
@@ -448,7 +448,7 @@
    #undef BOOST_CONTAINER_ADAPTIVE_NODE_POOL_CHECK_INVARIANTS
    {
       //We iterate through the block tree to free the memory
-      block_iterator it(m_block_multiset.begin()), 
+      block_iterator it(m_block_multiset.begin()),
                      itend(m_block_multiset.end()), to_deallocate;
       if(it != itend){
          for(++it; it != itend; ++it){
@@ -559,9 +559,9 @@
          ++m_totally_free_blocks;
          block_info_t *c_info = new(mem_address)block_info_t();
          m_block_multiset.insert(m_block_multiset.end(), *c_info);
-         
+        
          mem_address += HdrSize;
-         //We initialize all Nodes in Node Block to insert 
+         //We initialize all Nodes in Node Block to insert
          //them in the free Node list
          typename free_nodes_t::iterator prev_insert_pos = c_info->free_nodes.before_begin();
          for(size_type i = 0; i < m_real_num_node; ++i){
@@ -605,7 +605,7 @@
          }
          {
             char *pNode = hdr_addr + HdrSize;
-            //We initialize all Nodes in Node Block to insert 
+            //We initialize all Nodes in Node Block to insert
             //them in the free Node list
             for(size_type i = 0; i < hdr_subblock_elements; ++i){
                prev_insert_pos = c_info->free_nodes.insert_after(prev_insert_pos, *new (pNode) node_t);

Modified: branches/release/boost/container/detail/advanced_insert_int.hpp
==============================================================================
--- branches/release/boost/container/detail/advanced_insert_int.hpp	(original)
+++ branches/release/boost/container/detail/advanced_insert_int.hpp	2012-05-24 12:36:39 EDT (Thu, 24 May 2012)
@@ -183,7 +183,7 @@
 namespace container_detail {
 
 
-//This class template will adapt emplace construction insertions of movable types 
+//This class template will adapt emplace construction insertions of movable types
 //to advanced_insert_aux_int
 template<class A, class Iterator, class ...Args>
 struct advanced_insert_aux_non_movable_emplace
@@ -254,7 +254,7 @@
    bool used_;
 };
 
-//This class template will adapt emplace construction insertions of movable types 
+//This class template will adapt emplace construction insertions of movable types
 //to advanced_insert_aux_int
 template<class A, class Iterator, class ...Args>
 struct advanced_insert_aux_emplace
@@ -323,11 +323,11 @@
 
 #else //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
 
-#include <boost/container/detail/preprocessor.hpp> 
+#include <boost/container/detail/preprocessor.hpp>
 #include <boost/container/detail/value_init.hpp>
 
 namespace boost {
-namespace container { 
+namespace container {
 namespace container_detail {
 
 #define BOOST_PP_LOCAL_MACRO(n)                                                     \

Modified: branches/release/boost/container/detail/algorithms.hpp
==============================================================================
--- branches/release/boost/container/detail/algorithms.hpp	(original)
+++ branches/release/boost/container/detail/algorithms.hpp	2012-05-24 12:36:39 EDT (Thu, 24 May 2012)
@@ -51,7 +51,7 @@
    ei.construct_in_place(a, dest);
 }
 
-}  //namespace container { 
+}  //namespace container {
 }  //namespace boost {
 
 #include <boost/container/detail/config_end.hpp>

Modified: branches/release/boost/container/detail/allocation_type.hpp
==============================================================================
--- branches/release/boost/container/detail/allocation_type.hpp	(original)
+++ branches/release/boost/container/detail/allocation_type.hpp	2012-05-24 12:36:39 EDT (Thu, 24 May 2012)
@@ -23,7 +23,7 @@
 
 /// @cond
 enum allocation_type_v
-{   
+{  
    // constants for allocation commands
    allocate_new_v   = 0x01,
    expand_fwd_v     = 0x02,

Modified: branches/release/boost/container/detail/destroyers.hpp
==============================================================================
--- branches/release/boost/container/detail/destroyers.hpp	(original)
+++ branches/release/boost/container/detail/destroyers.hpp	2012-05-24 12:36:39 EDT (Thu, 24 May 2012)
@@ -24,7 +24,7 @@
 #include <boost/container/allocator_traits.hpp>
 
 namespace boost {
-namespace container { 
+namespace container {
 namespace container_detail {
 
 //!A deleter for scoped_ptr that deallocates the memory
@@ -88,7 +88,7 @@
 
    void increment_size_backwards(size_type inc)
    {  m_n += inc;   m_p -= inc;  }
-   
+  
    ~scoped_destructor_n()
    {
       if(!m_p) return;
@@ -185,8 +185,8 @@
 };
 
 
-}  //namespace container_detail { 
-}  //namespace container { 
+}  //namespace container_detail {
+}  //namespace container {
 }  //namespace boost {
 
 #include <boost/container/detail/config_end.hpp>

Modified: branches/release/boost/container/detail/flat_tree.hpp
==============================================================================
--- branches/release/boost/container/detail/flat_tree.hpp	(original)
+++ branches/release/boost/container/detail/flat_tree.hpp	2012-05-24 12:36:39 EDT (Thu, 24 May 2012)
@@ -48,24 +48,24 @@
    typedef Value              first_argument_type;
    typedef Value              second_argument_type;
    typedef bool               return_type;
-   public:     
+   public:    
    flat_tree_value_compare()
       : Compare()
    {}
 
-   flat_tree_value_compare(const Compare &pred) 
+   flat_tree_value_compare(const Compare &pred)
       : Compare(pred)
    {}
 
    bool operator()(const Value& lhs, const Value& rhs) const
-   { 
+   {
       KeyOfValue key_extract;
-      return Compare::operator()(key_extract(lhs), key_extract(rhs)); 
+      return Compare::operator()(key_extract(lhs), key_extract(rhs));
    }
 
    const Compare &get_comp() const
       {  return *this;  }
-   
+  
    Compare &get_comp()
       {  return *this;  }
 };
@@ -81,7 +81,7 @@
    typedef std::reverse_iterator<const_iterator>      const_reverse_iterator;
 };
 
-template <class Key, class Value, class KeyOfValue, 
+template <class Key, class Value, class KeyOfValue,
           class Compare, class A>
 class flat_tree
 {
@@ -92,7 +92,7 @@
    typedef flat_tree_value_compare<Compare, Value, KeyOfValue> value_compare;
 
  private:
-   struct Data 
+   struct Data
       //Inherit from value_compare to do EBO
       : public value_compare
    {
@@ -119,12 +119,12 @@
          : value_compare(boost::move(static_cast<value_compare&>(d))), m_vect(boost::move(d.m_vect), a)
       {}
 
-      Data(const Compare &comp) 
+      Data(const Compare &comp)
          : value_compare(comp), m_vect()
       {}
 
       Data(const Compare &comp,
-           const allocator_t &alloc) 
+           const allocator_t &alloc)
          : value_compare(comp), m_vect(alloc)
       {}
 
@@ -191,7 +191,7 @@
       : m_data(comp, a)
    { }
 
-   flat_tree(const flat_tree& x) 
+   flat_tree(const flat_tree& x)
       :  m_data(x.m_data)
    { }
 
@@ -199,7 +199,7 @@
       :  m_data(boost::move(x.m_data))
    { }
 
-   flat_tree(const flat_tree& x, const allocator_type &a) 
+   flat_tree(const flat_tree& x, const allocator_type &a)
       :  m_data(x.m_data, a)
    { }
 
@@ -223,66 +223,66 @@
    flat_tree&  operator=(BOOST_RV_REF(flat_tree) mx)
    {  m_data = boost::move(mx.m_data); return *this;  }
 
-   public:    
+   public:   
    // accessors:
-   Compare key_comp() const 
+   Compare key_comp() const
    { return this->m_data.get_comp(); }
 
-   allocator_type get_allocator() const 
+   allocator_type get_allocator() const
    { return this->m_data.m_vect.get_allocator(); }
 
-   const stored_allocator_type &get_stored_allocator() const 
+   const stored_allocator_type &get_stored_allocator() const
    {  return this->m_data.m_vect.get_stored_allocator(); }
 
    stored_allocator_type &get_stored_allocator()
    {  return this->m_data.m_vect.get_stored_allocator(); }
 
-   iterator begin() 
+   iterator begin()
    { return this->m_data.m_vect.begin(); }
 
-   const_iterator begin() const 
+   const_iterator begin() const
    { return this->cbegin(); }
 
-   const_iterator cbegin() const 
+   const_iterator cbegin() const
    { return this->m_data.m_vect.begin(); }
 
-   iterator end() 
+   iterator end()
    { return this->m_data.m_vect.end(); }
 
-   const_iterator end() const 
+   const_iterator end() const
    { return this->cend(); }
 
-   const_iterator cend() const 
+   const_iterator cend() const
    { return this->m_data.m_vect.end(); }
 
-   reverse_iterator rbegin() 
+   reverse_iterator rbegin()
    { return reverse_iterator(this->end()); }
 
-   const_reverse_iterator rbegin() const 
+   const_reverse_iterator rbegin() const
    {  return this->crbegin();  }
 
-   const_reverse_iterator crbegin() const 
+   const_reverse_iterator crbegin() const
    {  return const_reverse_iterator(this->cend());  }
 
-   reverse_iterator rend() 
+   reverse_iterator rend()
    { return reverse_iterator(this->begin()); }
 
-   const_reverse_iterator rend() const 
-   { return this->crend(); } 
+   const_reverse_iterator rend() const
+   { return this->crend(); }
 
-   const_reverse_iterator crend() const 
-   { return const_reverse_iterator(this->cbegin()); } 
+   const_reverse_iterator crend() const
+   { return const_reverse_iterator(this->cbegin()); }
 
-   bool empty() const 
+   bool empty() const
    { return this->m_data.m_vect.empty(); }
 
-   size_type size() const 
+   size_type size() const
    { return this->m_data.m_vect.size(); }
 
-   size_type max_size() const 
+   size_type max_size() const
    { return this->m_data.m_vect.max_size(); }
 
-   void swap(flat_tree& other) 
+   void swap(flat_tree& other)
    {  this->m_data.swap(other.m_data);  }
 
    public:
@@ -365,7 +365,7 @@
    template <class InIt>
    void insert_equal(InIt first, InIt last)
    {
-      typedef typename 
+      typedef typename
          std::iterator_traits<InIt>::iterator_category ItCat;
       this->priv_insert_equal(first, last, ItCat());
    }
@@ -373,11 +373,19 @@
    template <class InIt>
    void insert_equal(ordered_range_t, InIt first, InIt last)
    {
-      typedef typename 
+      typedef typename
          std::iterator_traits<InIt>::iterator_category ItCat;
       this->priv_insert_equal(ordered_range_t(), first, last, ItCat());
    }
 
+   template <class InIt>
+   void insert_unique(ordered_unique_range_t, InIt first, InIt last)
+   {
+      typedef typename
+         std::iterator_traits<InIt>::iterator_category ItCat;
+      this->priv_insert_unique(ordered_unique_range_t(), first, last, ItCat());
+   }
+
    #ifdef BOOST_CONTAINER_PERFECT_FORWARDING
 
    template <class... Args>
@@ -557,8 +565,8 @@
       const Compare &key_comp = this->m_data.get_comp();
       iterator i = this->lower_bound(k);
 
-      if (i != this->end() && key_comp(k, KeyOfValue()(*i))){  
-         i = this->end();  
+      if (i != this->end() && key_comp(k, KeyOfValue()(*i))){ 
+         i = this->end(); 
       }
       return i;
    }
@@ -568,8 +576,8 @@
       const Compare &key_comp = this->m_data.get_comp();
       const_iterator i = this->lower_bound(k);
 
-      if (i != this->end() && key_comp(k, KeyOfValue()(*i))){  
-         i = this->end();  
+      if (i != this->end() && key_comp(k, KeyOfValue()(*i))){ 
+         i = this->end(); 
       }
       return i;
    }
@@ -599,10 +607,10 @@
    std::pair<const_iterator, const_iterator> equal_range(const key_type& k) const
    {  return this->priv_equal_range(this->begin(), this->end(), k);  }
 
-   size_type capacity() const           
+   size_type capacity() const          
    { return this->m_data.m_vect.capacity(); }
 
-   void reserve(size_type count)       
+   void reserve(size_type count)      
    { this->m_data.m_vect.reserve(count);   }
 
    private:
@@ -631,12 +639,12 @@
             data.position = pos;
          }
          else{
-            data.position = 
+            data.position =
                this->priv_upper_bound(this->cbegin(), pos, KeyOfValue()(val));
          }
       }
       else{
-         data.position = 
+         data.position =
             this->priv_lower_bound(pos, this->cend(), KeyOfValue()(val));
       }
    }
@@ -756,7 +764,7 @@
          }
          else{
             first = ++middle;
-            len = len - half - 1;  
+            len = len - half - 1; 
          }
       }
       return first;
@@ -801,28 +809,82 @@
       const size_type BurstSize = 16;
       size_type positions[BurstSize];
 
+      //Prereserve all memory so that iterators are not invalidated
+      this->reserve(this->size()+len);
+      const const_iterator beg(this->cbegin());
+      const_iterator pos(beg);
+      //Loop in burst sizes
       while(len){
          const size_type burst = len < BurstSize ? len : BurstSize;
+         const const_iterator cend(this->cend());
          len -= burst;
-         const iterator beg(this->cbegin());
-         iterator pos;
          for(size_type i = 0; i != burst; ++i){
-            pos = this->upper_bound(KeyOfValue()(*first));
+            //Get the insertion position for each key
+            pos = const_cast<const flat_tree&>(*this).priv_upper_bound(pos, cend, KeyOfValue()(*first));
             positions[i] = static_cast<size_type>(pos - beg);
             ++first;
          }
+         //Insert all in a single step in the precalculated positions
          this->m_data.m_vect.insert_ordered_at(burst, positions + burst, first);
+         //Next search position updated
+         pos += burst;
       }
    }
 
+   template <class BidirIt>
+   void priv_insert_unique(ordered_unique_range_t, BidirIt first, BidirIt last, std::bidirectional_iterator_tag)
+   {
+      size_type len = static_cast<size_type>(std::distance(first, last));
+      const size_type BurstSize = 16;
+      size_type positions[BurstSize];
+      size_type skips[BurstSize];
+
+      //Prereserve all memory so that iterators are not invalidated
+      this->reserve(this->size()+len);
+      const const_iterator beg(this->cbegin());
+      const_iterator pos(beg);
+      const value_compare &value_comp = this->m_data;
+      //Loop in burst sizes
+      while(len){
+         skips[0u] = 0u;
+         const size_type burst = len < BurstSize ? len : BurstSize;
+         size_type unique_burst = 0u;
+         const const_iterator cend(this->cend());
+         while(unique_burst < burst && len > 0){
+            //Get the insertion position for each key
+            const value_type & val = *first++;
+            --len;
+            pos = const_cast<const flat_tree&>(*this).priv_lower_bound(pos, cend, KeyOfValue()(val));
+            //Check if already present
+            if(pos != cend && !value_comp(*pos, val)){
+               ++skips[unique_burst];
+               continue;
+            }
+
+            //If not present, calculate position
+            positions[unique_burst] = static_cast<size_type>(pos - beg);
+            if(++unique_burst < burst)
+               skips[unique_burst] = 0u;
+         }
+         //Insert all in a single step in the precalculated positions
+         this->m_data.m_vect.insert_ordered_at(unique_burst, positions + unique_burst, skips + unique_burst, first);
+         //Next search position updated
+         pos += unique_burst;
+      }
+   }
+/*
    template <class FwdIt>
    void priv_insert_equal_forward(ordered_range_t, FwdIt first, FwdIt last, std::forward_iterator_tag)
    {  this->priv_insert_equal(first, last, std::forward_iterator_tag());   }
-
+*/
    template <class InIt>
    void priv_insert_equal(ordered_range_t, InIt first, InIt last, std::input_iterator_tag)
    {  this->priv_insert_equal(first, last, std::input_iterator_tag());  }
 
+   template <class InIt>
+   void priv_insert_unique(ordered_unique_range_t, InIt first, InIt last, std::input_iterator_tag)
+   {  this->priv_insert_unique(first, last, std::input_iterator_tag());  }
+/*
    template <class FwdIt>
    void priv_insert_equal_forward(FwdIt first, FwdIt last, std::forward_iterator_tag)
    {
@@ -830,7 +892,7 @@
       this->reserve(this->size()+len);
       this->priv_insert_equal(first, last, std::input_iterator_tag());
    }
-
+*/
    template <class InIt>
    void priv_insert_equal(InIt first, InIt last, std::input_iterator_tag)
    {
@@ -839,59 +901,59 @@
    }
 };
 
-template <class Key, class Value, class KeyOfValue, 
+template <class Key, class Value, class KeyOfValue,
           class Compare, class A>
-inline bool 
-operator==(const flat_tree<Key,Value,KeyOfValue,Compare,A>& x, 
+inline bool
+operator==(const flat_tree<Key,Value,KeyOfValue,Compare,A>& x,
            const flat_tree<Key,Value,KeyOfValue,Compare,A>& y)
 {
   return x.size() == y.size() &&
          std::equal(x.begin(), x.end(), y.begin());
 }
 
-template <class Key, class Value, class KeyOfValue, 
+template <class Key, class Value, class KeyOfValue,
           class Compare, class A>
-inline bool 
-operator<(const flat_tree<Key,Value,KeyOfValue,Compare,A>& x, 
+inline bool
+operator<(const flat_tree<Key,Value,KeyOfValue,Compare,A>& x,
           const flat_tree<Key,Value,KeyOfValue,Compare,A>& y)
 {
-  return std::lexicographical_compare(x.begin(), x.end(), 
+  return std::lexicographical_compare(x.begin(), x.end(),
                                       y.begin(), y.end());
 }
 
-template <class Key, class Value, class KeyOfValue, 
+template <class Key, class Value, class KeyOfValue,
           class Compare, class A>
-inline bool 
-operator!=(const flat_tree<Key,Value,KeyOfValue,Compare,A>& x, 
-           const flat_tree<Key,Value,KeyOfValue,Compare,A>& y) 
+inline bool
+operator!=(const flat_tree<Key,Value,KeyOfValue,Compare,A>& x,
+           const flat_tree<Key,Value,KeyOfValue,Compare,A>& y)
    {  return !(x == y); }
 
-template <class Key, class Value, class KeyOfValue, 
+template <class Key, class Value, class KeyOfValue,
           class Compare, class A>
-inline bool 
-operator>(const flat_tree<Key,Value,KeyOfValue,Compare,A>& x, 
-          const flat_tree<Key,Value,KeyOfValue,Compare,A>& y) 
+inline bool
+operator>(const flat_tree<Key,Value,KeyOfValue,Compare,A>& x,
+          const flat_tree<Key,Value,KeyOfValue,Compare,A>& y)
    {  return y < x;  }
 
-template <class Key, class Value, class KeyOfValue, 
+template <class Key, class Value, class KeyOfValue,
           class Compare, class A>
-inline bool 
-operator<=(const flat_tree<Key,Value,KeyOfValue,Compare,A>& x, 
-           const flat_tree<Key,Value,KeyOfValue,Compare,A>& y) 
+inline bool
+operator<=(const flat_tree<Key,Value,KeyOfValue,Compare,A>& x,
+           const flat_tree<Key,Value,KeyOfValue,Compare,A>& y)
    {  return !(y < x);  }
 
-template <class Key, class Value, class KeyOfValue, 
+template <class Key, class Value, class KeyOfValue,
           class Compare, class A>
-inline bool 
-operator>=(const flat_tree<Key,Value,KeyOfValue,Compare,A>& x, 
-           const flat_tree<Key,Value,KeyOfValue,Compare,A>& y) 
+inline bool
+operator>=(const flat_tree<Key,Value,KeyOfValue,Compare,A>& x,
+           const flat_tree<Key,Value,KeyOfValue,Compare,A>& y)
    {  return !(x < y);  }
 
 
-template <class Key, class Value, class KeyOfValue, 
+template <class Key, class Value, class KeyOfValue,
           class Compare, class A>
-inline void 
-swap(flat_tree<Key,Value,KeyOfValue,Compare,A>& x, 
+inline void
+swap(flat_tree<Key,Value,KeyOfValue,Compare,A>& x,
      flat_tree<Key,Value,KeyOfValue,Compare,A>& y)
    {  x.swap(y);  }
 
@@ -901,7 +963,7 @@
 /*
 //!has_trivial_destructor_after_move<> == true_type
 //!specialization for optimizations
-template <class K, class V, class KOV, 
+template <class K, class V, class KOV,
 class C, class A>
 struct has_trivial_destructor_after_move<boost::container::container_detail::flat_tree<K, V, KOV, C, A> >
 {

Modified: branches/release/boost/container/detail/function_detector.hpp
==============================================================================
--- branches/release/boost/container/detail/function_detector.hpp	(original)
+++ branches/release/boost/container/detail/function_detector.hpp	2012-05-24 12:36:39 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::container::function_detector { 
+}}} //namespace boost::container::function_detector {
 
 #define BOOST_CONTAINER_DETECT_FUNCTION(Class, InstantiationKey, ReturnType, Identifier, Params) \
     ::boost::container::function_detector::DetectMember_##InstantiationKey_##Identifier< Class,\

Modified: branches/release/boost/container/detail/iterators.hpp
==============================================================================
--- branches/release/boost/container/detail/iterators.hpp	(original)
+++ branches/release/boost/container/detail/iterators.hpp	2012-05-24 12:36:39 EDT (Thu, 24 May 2012)
@@ -33,7 +33,7 @@
 #include <iterator>
 
 namespace boost {
-namespace container { 
+namespace container {
 
 template <class T, class Difference = std::ptrdiff_t>
 class constant_iterator
@@ -50,9 +50,9 @@
    constant_iterator()
       :  m_ptr(0), m_num(0){}
 
-   constant_iterator& operator++() 
+   constant_iterator& operator++()
    { increment();   return *this;   }
-   
+  
    constant_iterator operator++(int)
    {
       constant_iterator result (*this);
@@ -60,9 +60,9 @@
       return result;
    }
 
-   constant_iterator& operator--() 
+   constant_iterator& operator--()
    { decrement();   return *this;   }
-   
+  
    constant_iterator operator--(int)
    {
       constant_iterator result (*this);
@@ -161,9 +161,9 @@
    default_construct_iterator()
       :  m_num(0){}
 
-   default_construct_iterator& operator++() 
+   default_construct_iterator& operator++()
    { increment();   return *this;   }
-   
+  
    default_construct_iterator operator++(int)
    {
       default_construct_iterator result (*this);
@@ -171,9 +171,9 @@
       return result;
    }
 
-   default_construct_iterator& operator--() 
+   default_construct_iterator& operator--()
    { decrement();   return *this;   }
-   
+  
    default_construct_iterator operator--(int)
    {
       default_construct_iterator result (*this);
@@ -247,7 +247,7 @@
    {  return other.m_num < m_num;   }
 
    const T & dereference() const
-   { 
+   {
       static T dummy;
       return dummy;
    }
@@ -273,9 +273,9 @@
    repeat_iterator()
       :  m_ptr(0), m_num(0){}
 
-   this_type& operator++() 
+   this_type& operator++()
    { increment();   return *this;   }
-   
+  
    this_type operator++(int)
    {
       this_type result (*this);
@@ -283,9 +283,9 @@
       return result;
    }
 
-   this_type& operator--() 
+   this_type& operator--()
    { increment();   return *this;   }
-   
+  
    this_type operator--(int)
    {
       this_type result (*this);
@@ -384,9 +384,9 @@
    emplace_iterator()
       :  m_num(0), m_pe(0){}
 
-   this_type& operator++() 
+   this_type& operator++()
    { increment();   return *this;   }
-   
+  
    this_type operator++(int)
    {
       this_type result (*this);
@@ -394,9 +394,9 @@
       return result;
    }
 
-   this_type& operator--() 
+   this_type& operator--()
    { decrement();   return *this;   }
-   
+  
    this_type operator--(int)
    {
       this_type result (*this);
@@ -475,7 +475,7 @@
    {  return other.m_num < m_num;   }
 
    const T & dereference() const
-   { 
+   {
       static T dummy;
       return dummy;
    }
@@ -539,7 +539,7 @@
 
 #endif
 
-}  //namespace container { 
+}  //namespace container {
 }  //namespace boost {
 
 #include <boost/container/detail/config_end.hpp>

Modified: branches/release/boost/container/detail/math_functions.hpp
==============================================================================
--- branches/release/boost/container/detail/math_functions.hpp	(original)
+++ branches/release/boost/container/detail/math_functions.hpp	2012-05-24 12:36:39 EDT (Thu, 24 May 2012)
@@ -4,7 +4,7 @@
 // (C) Copyright Ion Gaztanaga 2007-2012.
 //
 // Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at 
+//    (See accompanying file LICENSE_1_0.txt or copy at
 //    http://www.boost.org/LICENSE_1_0.txt)
 //
 // See http://www.boost.org/libs/container for documentation.
@@ -94,7 +94,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)

Modified: branches/release/boost/container/detail/mpl.hpp
==============================================================================
--- branches/release/boost/container/detail/mpl.hpp	(original)
+++ branches/release/boost/container/detail/mpl.hpp	2012-05-24 12:36:39 EDT (Thu, 24 May 2012)
@@ -20,7 +20,7 @@
 #include <cstddef>
 
 namespace boost {
-namespace container { 
+namespace container {
 namespace container_detail {
 
 template <class T, T val>
@@ -109,24 +109,24 @@
 
 
 template <class Pair>
-struct select1st 
-//   : public std::unary_function<Pair, typename Pair::first_type> 
+struct select1st
+//   : public std::unary_function<Pair, typename Pair::first_type>
 {
    template<class OtherPair>
-   const typename Pair::first_type& operator()(const OtherPair& x) const 
+   const typename Pair::first_type& operator()(const OtherPair& x) const
    {  return x.first;   }
 
-   const typename Pair::first_type& operator()(const typename Pair::first_type& x) const 
+   const typename Pair::first_type& operator()(const typename Pair::first_type& x) const
    {  return x;   }
 };
 
 // identity is an extension: it is not part of the standard.
 template <class T>
-struct identity 
-//   : public std::unary_function<T,T> 
+struct identity
+//   : public std::unary_function<T,T>
 {
    typedef T type;
-   const T& operator()(const T& x) const 
+   const T& operator()(const T& x) const
    { return x; }
 };
 
@@ -152,8 +152,8 @@
 template <> struct unvoid<void> { struct type { }; };
 template <> struct unvoid<const void> { struct type { }; };
 
-}  //namespace container_detail { 
-}  //namespace container { 
+}  //namespace container_detail {
+}  //namespace container {
 }  //namespace boost {
 
 #endif   //#ifndef BOOST_CONTAINER_CONTAINER_DETAIL_MPL_HPP

Modified: branches/release/boost/container/detail/node_alloc_holder.hpp
==============================================================================
--- branches/release/boost/container/detail/node_alloc_holder.hpp	(original)
+++ branches/release/boost/container/detail/node_alloc_holder.hpp	2012-05-24 12:36:39 EDT (Thu, 24 May 2012)
@@ -189,11 +189,11 @@
    public:
 
    //Constructors for sequence containers
-   node_alloc_holder() 
+   node_alloc_holder()
       : members_()
    {}
 
-   explicit node_alloc_holder(const ValAlloc &a) 
+   explicit node_alloc_holder(const ValAlloc &a)
       : members_(a)
    {}
 
@@ -206,7 +206,7 @@
    {  this->icont().swap(x.icont());  }
 
    //Constructors for associative containers
-   explicit node_alloc_holder(const ValAlloc &a, const Pred &c) 
+   explicit node_alloc_holder(const ValAlloc &a, const Pred &c)
       : members_(a, c)
    {}
 
@@ -224,7 +224,7 @@
    {  this->icont().swap(x.icont());  }
 
    void copy_assign_alloc(const node_alloc_holder &x)
-   {  
+   { 
       container_detail::bool_<allocator_traits_type::propagate_on_container_copy_assignment::value> flag;
       container_detail::assign_alloc( static_cast<NodeAlloc &>(this->members_)
                                     , static_cast<const NodeAlloc &>(x.members_), flag);

Modified: branches/release/boost/container/detail/node_pool_impl.hpp
==============================================================================
--- branches/release/boost/container/detail/node_pool_impl.hpp	(original)
+++ branches/release/boost/container/detail/node_pool_impl.hpp	2012-05-24 12:36:39 EDT (Thu, 24 May 2012)
@@ -86,12 +86,12 @@
 
    void *allocate_node()
    {  return priv_alloc_node();  }
-   
+  
    //!Deallocates an array pointed by ptr. Never throws
    void deallocate_node(void *ptr)
    {  priv_dealloc_node(ptr); }
 
-   //!Allocates a singly linked list of n nodes ending in null pointer. 
+   //!Allocates a singly linked list of n nodes ending in null pointer.
    multiallocation_chain allocate_nodes(const size_type n)
    {
       //Preallocate all needed blocks to fulfill the request
@@ -238,7 +238,7 @@
       push_in_list(free_nodes_t &l, typename free_nodes_t::iterator &it)
          :  slist_(l), last_it_(it)
       {}
-      
+     
       void operator()(typename free_nodes_t::pointer p) const
       {
          slist_.push_front(*p);
@@ -258,10 +258,10 @@
       is_between(const void *addr, std::size_t size)
          :  beg_(static_cast<const char *>(addr)), end_(beg_+size)
       {}
-      
+     
       bool operator()(typename free_nodes_t::const_reference v) const
       {
-         return (beg_ <= reinterpret_cast<const char *>(&v) && 
+         return (beg_ <= reinterpret_cast<const char *>(&v) &&
                  end_ >  reinterpret_cast<const char *>(&v));
       }
       private:
@@ -299,7 +299,7 @@
    {
       if(!num_blocks)
          return;
-      size_type blocksize = 
+      size_type blocksize =
          get_rounded_size(m_real_node_size*m_nodes_per_block, (size_type)alignment_of<node_t>::value);
 
       try{
@@ -311,7 +311,7 @@
             char *pBlock = pNode;
             m_blocklist.push_front(get_block_hook(pBlock, blocksize));
 
-            //We initialize all Nodes in Node Block to insert 
+            //We initialize all Nodes in Node Block to insert
             //them in the free Node list
             for(size_type i = 0; i < m_nodes_per_block; ++i, pNode += m_real_node_size){
                m_freelist.push_front(*new (pNode) node_t);
@@ -335,13 +335,13 @@
    private:
    //!Returns a reference to the block hook placed in the end of the block
    static node_t & get_block_hook (void *block, size_type blocksize)
-   {  
-      return *reinterpret_cast<node_t*>(reinterpret_cast<char*>(block) + blocksize);  
+   { 
+      return *reinterpret_cast<node_t*>(reinterpret_cast<char*>(block) + blocksize); 
    }
 
    //!Returns the starting address of the block reference to the block hook placed in the end of the block
    void *get_block_from_hook (node_t *hook, size_type blocksize)
-   {  
+   { 
       return (reinterpret_cast<char*>(hook) - blocksize);
    }
 

Modified: branches/release/boost/container/detail/pair.hpp
==============================================================================
--- branches/release/boost/container/detail/pair.hpp	(original)
+++ branches/release/boost/container/detail/pair.hpp	2012-05-24 12:36:39 EDT (Thu, 24 May 2012)
@@ -35,7 +35,7 @@
 #endif
 
 namespace boost {
-namespace container { 
+namespace container {
 namespace container_detail {
 
 template <class T1, class T2>
@@ -313,8 +313,8 @@
    swap(x.second, y.second);
 }
 
-}  //namespace container_detail { 
-}  //namespace container { 
+}  //namespace container_detail {
+}  //namespace container {
 
 
 //Without this specialization recursive flat_(multi)map instantiation fails

Modified: branches/release/boost/container/detail/preprocessor.hpp
==============================================================================
--- branches/release/boost/container/detail/preprocessor.hpp	(original)
+++ branches/release/boost/container/detail/preprocessor.hpp	2012-05-24 12:36:39 EDT (Thu, 24 May 2012)
@@ -27,7 +27,7 @@
 //#error "This file is not needed when perfect forwarding is available"
 #endif   //BOOST_CONTAINER_PERFECT_FORWARDING
 
-#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/container/detail/transform_iterator.hpp
==============================================================================
--- branches/release/boost/container/detail/transform_iterator.hpp	(original)
+++ branches/release/boost/container/detail/transform_iterator.hpp	2012-05-24 12:36:39 EDT (Thu, 24 May 2012)
@@ -24,7 +24,7 @@
 #include <iterator>
 
 namespace boost {
-namespace container { 
+namespace container {
 
 template <class PseudoReference>
 struct operator_arrow_proxy
@@ -74,7 +74,7 @@
    {}
 
    //Constructors
-   transform_iterator& operator++() 
+   transform_iterator& operator++()
    { increment();   return *this;   }
 
    transform_iterator operator++(int)
@@ -168,7 +168,7 @@
    return transform_iterator<Iterator, UnaryFunc>(it, fun);
 }
 
-}  //namespace container { 
+}  //namespace container {
 }  //namespace boost {
 
 #include <boost/container/detail/config_end.hpp>

Modified: branches/release/boost/container/detail/tree.hpp
==============================================================================
--- branches/release/boost/container/detail/tree.hpp	(original)
+++ branches/release/boost/container/detail/tree.hpp	2012-05-24 12:36:39 EDT (Thu, 24 May 2012)
@@ -45,7 +45,7 @@
    :  public KeyCompare
 {
    typedef Value        value_type;
-   typedef KeyCompare   key_compare; 
+   typedef KeyCompare   key_compare;
    typedef KeyOfValue   key_of_value;
    typedef Key          key_type;
 
@@ -203,13 +203,13 @@
 
 namespace container_detail {
 
-template <class Key, class Value, class KeyOfValue, 
+template <class Key, class Value, class KeyOfValue,
           class KeyCompare, class A>
 class rbtree
    : protected container_detail::node_alloc_holder
       < A
       , typename container_detail::intrusive_rbtree_type
-         <A, value_compare_impl<Key, Value, KeyCompare, KeyOfValue>  
+         <A, value_compare_impl<Key, Value, KeyCompare, KeyOfValue> 
          >::type
       , KeyCompare
       >
@@ -218,7 +218,7 @@
          < A, value_compare_impl
             <Key, Value, KeyCompare, KeyOfValue>
          >::type                                            Icont;
-   typedef container_detail::node_alloc_holder  
+   typedef container_detail::node_alloc_holder 
       <A, Icont, KeyCompare>                                AllocHolder;
    typedef typename AllocHolder::NodePtr                    NodePtr;
    typedef rbtree < Key, Value, KeyOfValue
@@ -398,17 +398,17 @@
       {}
 
       //Pointer like operators
-      const_reference operator*()  const 
+      const_reference operator*()  const
       { return  m_it->get_data();  }
 
-      const_pointer   operator->() const 
+      const_pointer   operator->() const
       { return  const_pointer(&m_it->get_data()); }
 
       //Increment / Decrement
-      const_iterator& operator++()       
+      const_iterator& operator++()      
       { prot_incr();  return *this; }
 
-      const_iterator operator++(int)      
+      const_iterator operator++(int)     
       { iiterator tmp = m_it; ++*this; return const_iterator(tmp);  }
 
       const_iterator& operator--()
@@ -432,7 +432,7 @@
       explicit iterator(iiterator it)
          :  const_iterator(it)
       {}
-   
+  
       iiterator get()
       {  return this->m_it;   }
 
@@ -451,12 +451,12 @@
          {  return boost::intrusive::pointer_traits<pointer>::pointer_to(this->m_it->get_data());  }
 
       //Increment / Decrement
-      iterator& operator++()  
+      iterator& operator++() 
          { this->prot_incr(); return *this;  }
 
       iterator operator++(int)
          { iiterator tmp = this->m_it; ++*this; return iterator(tmp); }
-      
+     
       iterator& operator--()
          {  this->prot_decr(); return *this;  }
 
@@ -493,18 +493,18 @@
       priv_create_and_insert_ordered_nodes(first, last, alloc_version(), ItCat());
    }
 
-   rbtree(const rbtree& x) 
+   rbtree(const rbtree& x)
       :  AllocHolder(x, x.key_comp())
    {
       this->icont().clone_from
          (x.icont(), typename AllocHolder::cloner(*this), Destroyer(this->node_alloc()));
    }
 
-   rbtree(BOOST_RV_REF(rbtree) x) 
+   rbtree(BOOST_RV_REF(rbtree) x)
       :  AllocHolder(::boost::move(static_cast<AllocHolder&>(x)), x.key_comp())
    {}
 
-   rbtree(const rbtree& x, const allocator_type &a) 
+   rbtree(const rbtree& x, const allocator_type &a)
       :  AllocHolder(a, x.key_comp())
    {
       this->icont().clone_from
@@ -593,18 +593,18 @@
       return *this;
    }
 
-   public:    
+   public:   
    // accessors:
-   value_compare value_comp() const 
+   value_compare value_comp() const
    {  return this->icont().value_comp().value_comp(); }
 
-   key_compare key_comp() const 
+   key_compare key_comp() const
    {  return this->icont().value_comp().value_comp().key_comp(); }
 
-   allocator_type get_allocator() const 
+   allocator_type get_allocator() const
    {  return allocator_type(this->node_alloc()); }
 
-   const stored_allocator_type &get_stored_allocator() const 
+   const stored_allocator_type &get_stored_allocator() const
    {  return this->node_alloc(); }
 
    stored_allocator_type &get_stored_allocator()
@@ -635,46 +635,46 @@
    {  return this->crend();   }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_iterator cbegin() const 
+   const_iterator cbegin() const
    { return const_iterator(this->non_const_icont().begin()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_iterator cend() const 
+   const_iterator cend() const
    { return const_iterator(this->non_const_icont().end()); }
 
-   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning 
-   //! of the reversed container. 
-   //! 
+   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator crbegin() const 
-   { return const_reverse_iterator(cend()); } 
+   const_reverse_iterator crbegin() const
+   { return const_reverse_iterator(cend()); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
-   //! of the reversed container. 
-   //! 
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator crend() const 
+   const_reverse_iterator crend() const
    { return const_reverse_iterator(cbegin()); }
 
-   bool empty() const 
+   bool empty() const
    {  return !this->size();  }
 
-   size_type size() const 
+   size_type size() const
    {  return this->icont().size();   }
 
-   size_type max_size() const 
+   size_type max_size() const
    {  return AllocHolder::max_size();  }
 
    void swap(ThisType& x)
@@ -688,7 +688,7 @@
    std::pair<iterator,bool> insert_unique_check
       (const key_type& key, insert_commit_data &data)
    {
-      std::pair<iiterator, bool> ret = 
+      std::pair<iiterator, bool> ret =
          this->icont().insert_unique_check(key, KeyNodeCompare(value_comp()), data);
       return std::pair<iterator, bool>(iterator(ret.first), ret.second);
    }
@@ -696,7 +696,7 @@
    std::pair<iterator,bool> insert_unique_check
       (const_iterator hint, const key_type& key, insert_commit_data &data)
    {
-      std::pair<iiterator, bool> ret = 
+      std::pair<iiterator, bool> ret =
          this->icont().insert_unique_check(hint.get(), key, KeyNodeCompare(value_comp()), data);
       return std::pair<iterator, bool>(iterator(ret.first), ret.second);
    }
@@ -915,7 +915,7 @@
    iterator erase(const_iterator first, const_iterator last)
    {  return iterator(AllocHolder::erase_range(first.get(), last.get(), alloc_version())); }
 
-   void clear() 
+   void clear()
    {  AllocHolder::clear(alloc_version());  }
 
    // set operations:
@@ -941,14 +941,14 @@
    {  return const_iterator(this->non_const_icont().upper_bound(k, KeyNodeCompare(value_comp())));  }
 
    std::pair<iterator,iterator> equal_range(const key_type& k)
-   {  
+   { 
       std::pair<iiterator, iiterator> ret =
          this->icont().equal_range(k, KeyNodeCompare(value_comp()));
       return std::pair<iterator,iterator>(iterator(ret.first), iterator(ret.second));
    }
 
    std::pair<const_iterator, const_iterator> equal_range(const key_type& k) const
-   {  
+   { 
       std::pair<iiterator, iiterator> ret =
          this->non_const_icont().equal_range(k, KeyNodeCompare(value_comp()));
       return std::pair<const_iterator,const_iterator>
@@ -1060,63 +1060,63 @@
    }
 };
 
-template <class Key, class Value, class KeyOfValue, 
+template <class Key, class Value, class KeyOfValue,
           class KeyCompare, class A>
-inline bool 
-operator==(const rbtree<Key,Value,KeyOfValue,KeyCompare,A>& x, 
+inline bool
+operator==(const rbtree<Key,Value,KeyOfValue,KeyCompare,A>& x,
            const rbtree<Key,Value,KeyOfValue,KeyCompare,A>& y)
 {
   return x.size() == y.size() &&
          std::equal(x.begin(), x.end(), y.begin());
 }
 
-template <class Key, class Value, class KeyOfValue, 
+template <class Key, class Value, class KeyOfValue,
           class KeyCompare, class A>
-inline bool 
-operator<(const rbtree<Key,Value,KeyOfValue,KeyCompare,A>& x, 
+inline bool
+operator<(const rbtree<Key,Value,KeyOfValue,KeyCompare,A>& x,
           const rbtree<Key,Value,KeyOfValue,KeyCompare,A>& y)
 {
-  return std::lexicographical_compare(x.begin(), x.end(), 
+  return std::lexicographical_compare(x.begin(), x.end(),
                                       y.begin(), y.end());
 }
 
-template <class Key, class Value, class KeyOfValue, 
+template <class Key, class Value, class KeyOfValue,
           class KeyCompare, class A>
-inline bool 
-operator!=(const rbtree<Key,Value,KeyOfValue,KeyCompare,A>& x, 
+inline bool
+operator!=(const rbtree<Key,Value,KeyOfValue,KeyCompare,A>& x,
            const rbtree<Key,Value,KeyOfValue,KeyCompare,A>& y) {
   return !(x == y);
 }
 
-template <class Key, class Value, class KeyOfValue, 
+template <class Key, class Value, class KeyOfValue,
           class KeyCompare, class A>
-inline bool 
-operator>(const rbtree<Key,Value,KeyOfValue,KeyCompare,A>& x, 
+inline bool
+operator>(const rbtree<Key,Value,KeyOfValue,KeyCompare,A>& x,
           const rbtree<Key,Value,KeyOfValue,KeyCompare,A>& y) {
   return y < x;
 }
 
-template <class Key, class Value, class KeyOfValue, 
+template <class Key, class Value, class KeyOfValue,
           class KeyCompare, class A>
-inline bool 
-operator<=(const rbtree<Key,Value,KeyOfValue,KeyCompare,A>& x, 
+inline bool
+operator<=(const rbtree<Key,Value,KeyOfValue,KeyCompare,A>& x,
            const rbtree<Key,Value,KeyOfValue,KeyCompare,A>& y) {
   return !(y < x);
 }
 
-template <class Key, class Value, class KeyOfValue, 
+template <class Key, class Value, class KeyOfValue,
           class KeyCompare, class A>
-inline bool 
-operator>=(const rbtree<Key,Value,KeyOfValue,KeyCompare,A>& x, 
+inline bool
+operator>=(const rbtree<Key,Value,KeyOfValue,KeyCompare,A>& x,
            const rbtree<Key,Value,KeyOfValue,KeyCompare,A>& y) {
   return !(x < y);
 }
 
 
-template <class Key, class Value, class KeyOfValue, 
+template <class Key, class Value, class KeyOfValue,
           class KeyCompare, class A>
-inline void 
-swap(rbtree<Key,Value,KeyOfValue,KeyCompare,A>& x, 
+inline void
+swap(rbtree<Key,Value,KeyOfValue,KeyCompare,A>& x,
      rbtree<Key,Value,KeyOfValue,KeyCompare,A>& y)
 {
   x.swap(y);
@@ -1127,7 +1127,7 @@
 /*
 //!has_trivial_destructor_after_move<> == true_type
 //!specialization for optimizations
-template <class K, class V, class KOV, 
+template <class K, class V, class KOV,
 class C, class A>
 struct has_trivial_destructor_after_move
    <boost::container::container_detail::rbtree<K, V, KOV, C, A> >

Modified: branches/release/boost/container/detail/type_traits.hpp
==============================================================================
--- branches/release/boost/container/detail/type_traits.hpp	(original)
+++ branches/release/boost/container/detail/type_traits.hpp	2012-05-24 12:36:39 EDT (Thu, 24 May 2012)
@@ -24,7 +24,7 @@
 #include <boost/move/move.hpp>
 
 namespace boost {
-namespace container { 
+namespace container {
 namespace container_detail {
 
 struct nat{};
@@ -202,7 +202,7 @@
 };
 
 } // namespace container_detail
-}  //namespace container { 
+}  //namespace container {
 }  //namespace boost {
 
 #include <boost/container/detail/config_end.hpp>

Modified: branches/release/boost/container/detail/utilities.hpp
==============================================================================
--- branches/release/boost/container/detail/utilities.hpp	(original)
+++ branches/release/boost/container/detail/utilities.hpp	2012-05-24 12:36:39 EDT (Thu, 24 May 2012)
@@ -150,7 +150,7 @@
    && !::boost::is_fundamental<_TypeT>::value
 };
 
-}; 
+};
 */
 
 template<class T>
@@ -233,7 +233,7 @@
 template
    <typename A,
     typename F, // F models ForwardIterator
-    typename T> 
+    typename T>
 void uninitialized_fill_alloc(A &a, F f, F l, const T &t)
 {
    while (f != l) {

Modified: branches/release/boost/container/detail/value_init.hpp
==============================================================================
--- branches/release/boost/container/detail/value_init.hpp	(original)
+++ branches/release/boost/container/detail/value_init.hpp	2012-05-24 12:36:39 EDT (Thu, 24 May 2012)
@@ -21,7 +21,7 @@
 #include <boost/container/detail/workaround.hpp>
 
 namespace boost {
-namespace container { 
+namespace container {
 namespace container_detail {
 
 template<class T>
@@ -36,8 +36,8 @@
    T m_t;
 };
 
-}  //namespace container_detail { 
-}  //namespace container { 
+}  //namespace container_detail {
+}  //namespace container {
 }  //namespace boost {
 
 #include <boost/container/detail/config_end.hpp>

Modified: branches/release/boost/container/detail/variadic_templates_tools.hpp
==============================================================================
--- branches/release/boost/container/detail/variadic_templates_tools.hpp	(original)
+++ branches/release/boost/container/detail/variadic_templates_tools.hpp	2012-05-24 12:36:39 EDT (Thu, 24 May 2012)
@@ -21,7 +21,7 @@
 #include <cstddef>   //std::size_t
 
 namespace boost {
-namespace container { 
+namespace container {
 namespace container_detail {
 
 template<typename... Values>
@@ -136,7 +136,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/container/detail/version_type.hpp
==============================================================================
--- branches/release/boost/container/detail/version_type.hpp	(original)
+++ branches/release/boost/container/detail/version_type.hpp	2012-05-24 12:36:39 EDT (Thu, 24 May 2012)
@@ -38,7 +38,7 @@
 
 namespace impl{
 
-template <class T, 
+template <class T,
           bool = container_detail::is_convertible<version_type<T, 0>, typename T::version>::value>
 struct extract_version
 {

Modified: branches/release/boost/container/flat_map.hpp
==============================================================================
--- branches/release/boost/container/flat_map.hpp	(original)
+++ branches/release/boost/container/flat_map.hpp	2012-05-24 12:36:39 EDT (Thu, 24 May 2012)
@@ -47,11 +47,11 @@
 class flat_map;
 
 template <class Key, class T, class Pred, class A>
-inline bool operator==(const flat_map<Key,T,Pred,A>& x, 
+inline bool operator==(const flat_map<Key,T,Pred,A>& x,
                        const flat_map<Key,T,Pred,A>& y);
 
 template <class Key, class T, class Pred, class A>
-inline bool operator<(const flat_map<Key,T,Pred,A>& x, 
+inline bool operator<(const flat_map<Key,T,Pred,A>& x,
                       const flat_map<Key,T,Pred,A>& y);
 
 namespace container_detail{
@@ -73,12 +73,12 @@
 /// @endcond
 
 //! A flat_map is a kind of associative container that supports unique keys (contains at
-//! most one of each key value) and provides for fast retrieval of values of another 
+//! most one of each key value) and provides for fast retrieval of values of another
 //! type T based on the keys. The flat_map class supports random-access iterators.
-//! 
-//! A flat_map satisfies all of the requirements of a container and of a reversible 
-//! container and of an associative container. A flat_map also provides 
-//! most operations described for unique keys. For a 
+//!
+//! A flat_map satisfies all of the requirements of a container and of a reversible
+//! container and of an associative container. A flat_map also provides
+//! most operations described for unique keys. For a
 //! flat_map<Key,T> the key_type is Key and the value_type is std::pair<Key,T>
 //! (unlike std::map<Key, T> which value_type is std::pair<<b>const</b> Key, T>).
 //!
@@ -86,35 +86,35 @@
 //!
 //! A is the allocator to allocate the value_types
 //! (e.g. <i>allocator< std::pair<Key, T> ></i>).
-//! 
+//!
 //! flat_map is similar to std::map but it's implemented like an ordered vector.
 //! This means that inserting a new element into a flat_map invalidates
 //! previous iterators and references
 //!
-//! Erasing an element of a flat_map invalidates iterators and references 
+//! Erasing an element of a flat_map invalidates iterators and references
 //! pointing to elements that come after (their keys are bigger) the erased element.
 #ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
 template <class Key, class T, class Pred = std::less< std::pair< Key, T> >, class A = std::allocator<T> >
 #else
 template <class Key, class T, class Pred, class A>
 #endif
-class flat_map 
+class flat_map
 {
    /// @cond
    private:
    BOOST_COPYABLE_AND_MOVABLE(flat_map)
    //This is the tree that we should store if pair was movable
-   typedef container_detail::flat_tree<Key, 
-                           std::pair<Key, T>, 
-                           container_detail::select1st< std::pair<Key, T> >, 
-                           Pred, 
+   typedef container_detail::flat_tree<Key,
+                           std::pair<Key, T>,
+                           container_detail::select1st< std::pair<Key, T> >,
+                           Pred,
                            A> tree_t;
 
    //This is the real tree stored here. It's based on a movable pair
-   typedef container_detail::flat_tree<Key, 
-                           container_detail::pair<Key, T>, 
-                           container_detail::select1st<container_detail::pair<Key, T> >, 
-                           Pred, 
+   typedef container_detail::flat_tree<Key,
+                           container_detail::pair<Key, T>,
+                           container_detail::select1st<container_detail::pair<Key, T> >,
+                           Pred,
                            typename allocator_traits<A>::template portable_rebind_alloc
                               <container_detail::pair<Key, T> >::type> impl_tree_t;
    impl_tree_t m_flat_tree;  // flat tree representing flat_map
@@ -165,7 +165,7 @@
       get_flat_tree_iterators
          <pointer>::const_reverse_iterator                  const_reverse_iterator;
    typedef A                                                allocator_type;
-   
+  
    //!Standard extension
    typedef A                                                stored_allocator_type;
 
@@ -174,61 +174,63 @@
 
    public:
    //! <b>Effects</b>: Default constructs an empty flat_map.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   flat_map() 
+   flat_map()
       : m_flat_tree() {}
 
    //! <b>Effects</b>: Constructs an empty flat_map using the specified
    //! comparison object and allocator.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   explicit flat_map(const Pred& comp, const allocator_type& a = allocator_type()) 
+   explicit flat_map(const Pred& comp, const allocator_type& a = allocator_type())
       : m_flat_tree(comp, container_detail::force<impl_allocator_type>(a)) {}
 
-   //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and 
+   //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
    //! allocator, and inserts elements from the range [first ,last ).
-   //! 
-   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using 
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
    //! comp and otherwise N logN, where N is last - first.
    template <class InputIterator>
    flat_map(InputIterator first, InputIterator last, const Pred& comp = Pred(),
          const allocator_type& a = allocator_type())
-      : m_flat_tree(comp, container_detail::force<impl_allocator_type>(a)) 
+      : m_flat_tree(comp, container_detail::force<impl_allocator_type>(a))
       { m_flat_tree.insert_unique(first, last); }
 
-   //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and 
+   //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
    //! allocator, and inserts elements from the ordered unique range [first ,last). This function
    //! is more efficient than the normal range creation for ordered ranges.
    //!
    //! <b>Requires</b>: [first ,last) must be ordered according to the predicate and must be
    //! unique values.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
    template <class InputIterator>
    flat_map( ordered_unique_range_t, InputIterator first, InputIterator last
            , const Pred& comp = Pred(), const allocator_type& a = allocator_type())
-      : m_flat_tree(ordered_range, first, last, comp, a) 
+      : m_flat_tree(ordered_range, first, last, comp, a)
    {}
 
    //! <b>Effects</b>: Copy constructs a flat_map.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear in x.size().
-   flat_map(const flat_map& x) 
+   flat_map(const flat_map& x)
       : m_flat_tree(x.m_flat_tree) {}
 
    //! <b>Effects</b>: Move constructs a flat_map.
    //!   Constructs *this using x's resources.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   //! 
+   //!
    //! <b>Postcondition</b>: x is emptied.
-   flat_map(BOOST_RV_REF(flat_map) x) 
+   flat_map(BOOST_RV_REF(flat_map) x)
       : m_flat_tree(boost::move(x.m_flat_tree))
    {}
 
    //! <b>Effects</b>: Copy constructs a flat_map using the specified allocator.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear in x.size().
    flat_map(const flat_map& x, const allocator_type &a)
       : m_flat_tree(x.m_flat_tree, a)
@@ -236,194 +238,194 @@
 
    //! <b>Effects</b>: Move constructs a flat_map using the specified allocator.
    //!   Constructs *this using x's resources.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant if x.get_allocator() == a, linear otherwise.
-   flat_map(BOOST_RV_REF(flat_map) x, const allocator_type &a) 
+   flat_map(BOOST_RV_REF(flat_map) x, const allocator_type &a)
       : m_flat_tree(boost::move(x.m_flat_tree), a)
    {}
 
    //! <b>Effects</b>: Makes *this a copy of x.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear in x.size().
    flat_map& operator=(BOOST_COPY_ASSIGN_REF(flat_map) x)
    {  m_flat_tree = x.m_flat_tree;   return *this;  }
 
    //! <b>Effects</b>: Move constructs a flat_map.
    //!   Constructs *this using x's resources.
-   //! 
+   //!
    //! <b>Complexity</b>: Construct.
-   //! 
+   //!
    //! <b>Postcondition</b>: x is emptied.
    flat_map& operator=(BOOST_RV_REF(flat_map) mx)
    {  m_flat_tree = boost::move(mx.m_flat_tree);   return *this;  }
 
    //! <b>Effects</b>: Returns the comparison object out
    //!   of which a was constructed.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   key_compare key_comp() const 
+   key_compare key_comp() const
       { return container_detail::force<key_compare>(m_flat_tree.key_comp()); }
 
    //! <b>Effects</b>: Returns an object of value_compare constructed out
    //!   of the comparison object.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   value_compare value_comp() const 
+   value_compare value_comp() const
       { return value_compare(container_detail::force<key_compare>(m_flat_tree.key_comp())); }
 
    //! <b>Effects</b>: Returns a copy of the Allocator that
    //!   was passed to the object's constructor.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   allocator_type get_allocator() const 
+   allocator_type get_allocator() const
       { return container_detail::force<allocator_type>(m_flat_tree.get_allocator()); }
 
-   const stored_allocator_type &get_stored_allocator() const 
+   const stored_allocator_type &get_stored_allocator() const
       { return container_detail::force<stored_allocator_type>(m_flat_tree.get_stored_allocator()); }
 
    stored_allocator_type &get_stored_allocator()
       { return container_detail::force<stored_allocator_type>(m_flat_tree.get_stored_allocator()); }
 
    //! <b>Effects</b>: Returns an iterator to the first element contained in the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   iterator begin() 
+   iterator begin()
       { return container_detail::force_copy<iterator>(m_flat_tree.begin()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_iterator begin() const 
+   const_iterator begin() const
       { return container_detail::force<const_iterator>(m_flat_tree.begin()); }
 
    //! <b>Effects</b>: Returns an iterator to the end of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   iterator end() 
+   iterator end()
       { return container_detail::force_copy<iterator>(m_flat_tree.end()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_iterator end() const 
+   const_iterator end() const
       { return container_detail::force<const_iterator>(m_flat_tree.end()); }
 
-   //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning 
-   //! of the reversed container. 
-   //! 
+   //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   reverse_iterator rbegin() 
+   reverse_iterator rbegin()
       { return container_detail::force<reverse_iterator>(m_flat_tree.rbegin()); }
 
-   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning 
-   //! of the reversed container. 
-   //! 
+   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator rbegin() const 
+   const_reverse_iterator rbegin() const
       { return container_detail::force<const_reverse_iterator>(m_flat_tree.rbegin()); }
 
    //! <b>Effects</b>: Returns a reverse_iterator pointing to the end
-   //! of the reversed container. 
-   //! 
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   reverse_iterator rend() 
+   reverse_iterator rend()
       { return container_detail::force<reverse_iterator>(m_flat_tree.rend()); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
-   //! of the reversed container. 
-   //! 
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator rend() const 
+   const_reverse_iterator rend() const
       { return container_detail::force<const_reverse_iterator>(m_flat_tree.rend()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_iterator cbegin() const 
+   const_iterator cbegin() const
       { return container_detail::force<const_iterator>(m_flat_tree.cbegin()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_iterator cend() const 
+   const_iterator cend() const
       { return container_detail::force<const_iterator>(m_flat_tree.cend()); }
 
-   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning 
-   //! of the reversed container. 
-   //! 
+   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator crbegin() const 
+   const_reverse_iterator crbegin() const
       { return container_detail::force<const_reverse_iterator>(m_flat_tree.crbegin()); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
-   //! of the reversed container. 
-   //! 
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator crend() const 
+   const_reverse_iterator crend() const
       { return container_detail::force<const_reverse_iterator>(m_flat_tree.crend()); }
 
    //! <b>Effects</b>: Returns true if the container contains no elements.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   bool empty() const 
+   bool empty() const
       { return m_flat_tree.empty(); }
 
    //! <b>Effects</b>: Returns the number of the elements contained in the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   size_type size() const 
+   size_type size() const
       { return m_flat_tree.size(); }
 
    //! <b>Effects</b>: Returns the largest possible size of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   size_type max_size() const 
+   size_type max_size() const
       { return m_flat_tree.max_size(); }
 
    #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-   //! Effects: If there is no key equivalent to x in the flat_map, inserts 
+   //! Effects: If there is no key equivalent to x in the flat_map, inserts
    //!   value_type(x, T()) into the flat_map.
-   //! 
+   //!
    //! Returns: A reference to the mapped_type corresponding to x in *this.
-   //! 
+   //!
    //! Complexity: Logarithmic.
    mapped_type &operator[](const key_type& k);
 
-   //! Effects: If there is no key equivalent to x in the flat_map, inserts 
+   //! Effects: If there is no key equivalent to x in the flat_map, inserts
    //! value_type(move(x), T()) into the flat_map (the key is move-constructed)
-   //! 
+   //!
    //! Returns: A reference to the mapped_type corresponding to x in *this.
-   //! 
+   //!
    //! Complexity: Logarithmic.
    mapped_type &operator[](key_type &&k) ;
 
@@ -463,10 +465,10 @@
    void swap(flat_map& x)
    { m_flat_tree.swap(x.m_flat_tree); }
 
-   //! <b>Effects</b>: Inserts x if and only if there is no element in the container 
+   //! <b>Effects</b>: Inserts x if and only if there is no element in the container
    //!   with key equivalent to the key of x.
    //!
-   //! <b>Returns</b>: The bool component of the returned pair is true if and only 
+   //! <b>Returns</b>: The bool component of the returned pair is true if and only
    //!   if the insertion takes place, and the iterator component of the pair
    //!   points to the element with key equivalent to the key of x.
    //!
@@ -474,14 +476,14 @@
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   std::pair<iterator,bool> insert(const value_type& x) 
+   std::pair<iterator,bool> insert(const value_type& x)
       { return container_detail::force<std::pair<iterator,bool> >(
          m_flat_tree.insert_unique(container_detail::force<impl_value_type>(x))); }
 
    //! <b>Effects</b>: Inserts a new value_type move constructed from the pair if and
    //! only if there is no element in the container with key equivalent to the key of x.
    //!
-   //! <b>Returns</b>: The bool component of the returned pair is true if and only 
+   //! <b>Returns</b>: The bool component of the returned pair is true if and only
    //!   if the insertion takes place, and the iterator component of the pair
    //!   points to the element with key equivalent to the key of x.
    //!
@@ -489,14 +491,14 @@
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   std::pair<iterator,bool> insert(BOOST_RV_REF(value_type) x) 
+   std::pair<iterator,bool> insert(BOOST_RV_REF(value_type) x)
    {  return container_detail::force<std::pair<iterator,bool> >(
       m_flat_tree.insert_unique(boost::move(container_detail::force<impl_value_type>(x)))); }
 
    //! <b>Effects</b>: Inserts a new value_type move constructed from the pair if and
    //! only if there is no element in the container with key equivalent to the key of x.
    //!
-   //! <b>Returns</b>: The bool component of the returned pair is true if and only 
+   //! <b>Returns</b>: The bool component of the returned pair is true if and only
    //!   if the insertion takes place, and the iterator component of the pair
    //!   points to the element with key equivalent to the key of x.
    //!
@@ -504,13 +506,13 @@
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   std::pair<iterator,bool> insert(BOOST_RV_REF(movable_value_type) x) 
+   std::pair<iterator,bool> insert(BOOST_RV_REF(movable_value_type) x)
    {
       return container_detail::force<std::pair<iterator,bool> >
       (m_flat_tree.insert_unique(boost::move(x)));
    }
 
-   //! <b>Effects</b>: Inserts a copy of x in the container if and only if there is 
+   //! <b>Effects</b>: Inserts a copy of x in the container if and only if there is
    //!   no element in the container with key equivalent to the key of x.
    //!   p is a hint pointing to where the insert should start to search.
    //!
@@ -558,7 +560,7 @@
 
    //! <b>Requires</b>: first, last are not iterators into *this.
    //!
-   //! <b>Effects</b>: inserts each element from the range [first,last) if and only 
+   //! <b>Effects</b>: inserts each element from the range [first,last) if and only
    //!   if there is no element with key equivalent to the key of that element.
    //!
    //! <b>Complexity</b>: At most N log(size()+N) (N is the distance from first to last)
@@ -566,16 +568,33 @@
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class InputIterator>
-   void insert(InputIterator first, InputIterator last) 
+   void insert(InputIterator first, InputIterator last)
    {  m_flat_tree.insert_unique(first, last);  }
 
+   //! <b>Requires</b>: first, last are not iterators into *this.
+   //!
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate and must be
+   //! unique values.
+   //!
+   //! <b>Effects</b>: inserts each element from the range [first,last) if and only
+   //!   if there is no element with key equivalent to the key of that element. This
+   //!   function is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Complexity</b>: At most N log(size()+N) (N is the distance from first to last)
+   //!   search time plus N*size() insertion time.
+   //!
+   //! <b>Note</b>: If an element is inserted it might invalidate elements.
+   template <class InputIterator>
+   void insert(ordered_unique_range_t, InputIterator first, InputIterator last)
+      {  m_flat_tree.insert_unique(ordered_unique_range, first, last); }
+
    #if defined(BOOST_CONTAINER_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
    //! <b>Effects</b>: Inserts an object x of type T constructed with
-   //!   std::forward<Args>(args)... if and only if there is no element in the container 
+   //!   std::forward<Args>(args)... if and only if there is no element in the container
    //!   with key equivalent to the key of x.
    //!
-   //! <b>Returns</b>: The bool component of the returned pair is true if and only 
+   //! <b>Returns</b>: The bool component of the returned pair is true if and only
    //!   if the insertion takes place, and the iterator component of the pair
    //!   points to the element with key equivalent to the key of x.
    //!
@@ -588,7 +607,7 @@
    {  return container_detail::force_copy< std::pair<iterator, bool> >(m_flat_tree.emplace_unique(boost::forward<Args>(args)...)); }
 
    //! <b>Effects</b>: Inserts an object of type T constructed with
-   //!   std::forward<Args>(args)... in the container if and only if there is 
+   //!   std::forward<Args>(args)... in the container if and only if there is
    //!   no element in the container with key equivalent to the key of x.
    //!   p is a hint pointing to where the insert should start to search.
    //!
@@ -627,14 +646,14 @@
    //! <b>Effects</b>: Erases the element pointed to by position.
    //!
    //! <b>Returns</b>: Returns an iterator pointing to the element immediately
-   //!   following q prior to the element being erased. If no such element exists, 
+   //!   following q prior to the element being erased. If no such element exists,
    //!   returns end().
    //!
    //! <b>Complexity</b>: Linear to the elements with keys bigger than position
    //!
    //! <b>Note</b>: Invalidates elements with keys
    //!   not less than the erased element.
-   iterator erase(const_iterator position) 
+   iterator erase(const_iterator position)
       { return container_detail::force_copy<iterator>(m_flat_tree.erase(container_detail::force<impl_const_iterator>(position))); }
 
    //! <b>Effects</b>: Erases all elements in the container with key equivalent to x.
@@ -643,7 +662,7 @@
    //!
    //! <b>Complexity</b>: Logarithmic search time plus erasure time
    //!   linear to the elements with bigger keys.
-   size_type erase(const key_type& x) 
+   size_type erase(const key_type& x)
       { return m_flat_tree.erase(x); }
 
    //! <b>Effects</b>: Erases all the elements in the range [first, last).
@@ -663,7 +682,7 @@
    //! <b>Postcondition</b>: size() == 0.
    //!
    //! <b>Complexity</b>: linear in size().
-   void clear() 
+   void clear()
       { m_flat_tree.clear(); }
 
    //! <b>Effects</b>: Tries to deallocate the excess of memory created
@@ -679,81 +698,81 @@
    //!   equivalent to x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   iterator find(const key_type& x) 
+   iterator find(const key_type& x)
       { return container_detail::force_copy<iterator>(m_flat_tree.find(x)); }
 
    //! <b>Returns</b>: A const_iterator pointing to an element with the key
    //!   equivalent to x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic.s
-   const_iterator find(const key_type& x) const 
+   const_iterator find(const key_type& x) const
       { return container_detail::force<const_iterator>(m_flat_tree.find(x)); }
 
    //! <b>Returns</b>: The number of elements with key equivalent to x.
    //!
    //! <b>Complexity</b>: log(size())+count(k)
-   size_type count(const key_type& x) const 
+   size_type count(const key_type& x) const
       {  return m_flat_tree.find(x) == m_flat_tree.end() ? 0 : 1;  }
 
    //! <b>Returns</b>: An iterator pointing to the first element with key not less
    //!   than k, or a.end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic
-   iterator lower_bound(const key_type& x) 
+   iterator lower_bound(const key_type& x)
       {  return container_detail::force_copy<iterator>(m_flat_tree.lower_bound(x)); }
 
    //! <b>Returns</b>: A const iterator pointing to the first element with key not
    //!   less than k, or a.end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic
-   const_iterator lower_bound(const key_type& x) const 
+   const_iterator lower_bound(const key_type& x) const
       {  return container_detail::force<const_iterator>(m_flat_tree.lower_bound(x)); }
 
    //! <b>Returns</b>: An iterator pointing to the first element with key not less
    //!   than x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic
-   iterator upper_bound(const key_type& x) 
+   iterator upper_bound(const key_type& x)
       {  return container_detail::force_copy<iterator>(m_flat_tree.upper_bound(x)); }
 
    //! <b>Returns</b>: A const iterator pointing to the first element with key not
    //!   less than x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic
-   const_iterator upper_bound(const key_type& x) const 
+   const_iterator upper_bound(const key_type& x) const
       {  return container_detail::force<const_iterator>(m_flat_tree.upper_bound(x)); }
 
    //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
    //!
    //! <b>Complexity</b>: Logarithmic
-   std::pair<iterator,iterator> equal_range(const key_type& x) 
+   std::pair<iterator,iterator> equal_range(const key_type& x)
       {  return container_detail::force_copy<std::pair<iterator,iterator> >(m_flat_tree.equal_range(x)); }
 
    //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
    //!
    //! <b>Complexity</b>: Logarithmic
-   std::pair<const_iterator,const_iterator> equal_range(const key_type& x) const 
+   std::pair<const_iterator,const_iterator> equal_range(const key_type& x) const
       {  return container_detail::force_copy<std::pair<const_iterator,const_iterator> >(m_flat_tree.equal_range(x)); }
 
    //! <b>Effects</b>: Number of elements for which memory has been allocated.
    //!   capacity() is always greater than or equal to size().
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   size_type capacity() const           
+   size_type capacity() const          
       { return m_flat_tree.capacity(); }
 
    //! <b>Effects</b>: If n is less than or equal to capacity(), this call has no
    //!   effect. Otherwise, it is a request for allocation of additional memory.
    //!   If the request is successful, then capacity() is greater than or equal to
    //!   n; otherwise, capacity() is unchanged. In either case, size() is unchanged.
-   //! 
+   //!
    //! <b>Throws</b>: If memory allocation allocation throws or T's copy constructor throws.
    //!
    //! <b>Note</b>: If capacity() is less than "count", iterators and references to
    //!   to values might be invalidated.
-   void reserve(size_type count)       
+   void reserve(size_type count)      
       { m_flat_tree.reserve(count);   }
 
    /// @cond
@@ -775,7 +794,7 @@
       }
       return (*i).second;
    }
-   mapped_type &priv_subscript(BOOST_RV_REF(key_type) mk) 
+   mapped_type &priv_subscript(BOOST_RV_REF(key_type) mk)
    {
       key_type &k = mk;
       iterator i = lower_bound(k);
@@ -790,38 +809,38 @@
 };
 
 template <class Key, class T, class Pred, class A>
-inline bool operator==(const flat_map<Key,T,Pred,A>& x, 
-                       const flat_map<Key,T,Pred,A>& y) 
+inline bool operator==(const flat_map<Key,T,Pred,A>& x,
+                       const flat_map<Key,T,Pred,A>& y)
    {  return x.m_flat_tree == y.m_flat_tree;  }
 
 template <class Key, class T, class Pred, class A>
-inline bool operator<(const flat_map<Key,T,Pred,A>& x, 
-                      const flat_map<Key,T,Pred,A>& y) 
+inline bool operator<(const flat_map<Key,T,Pred,A>& x,
+                      const flat_map<Key,T,Pred,A>& y)
    {  return x.m_flat_tree < y.m_flat_tree;   }
 
 template <class Key, class T, class Pred, class A>
-inline bool operator!=(const flat_map<Key,T,Pred,A>& x, 
-                       const flat_map<Key,T,Pred,A>& y) 
+inline bool operator!=(const flat_map<Key,T,Pred,A>& x,
+                       const flat_map<Key,T,Pred,A>& y)
    {  return !(x == y); }
 
 template <class Key, class T, class Pred, class A>
-inline bool operator>(const flat_map<Key,T,Pred,A>& x, 
-                      const flat_map<Key,T,Pred,A>& y) 
+inline bool operator>(const flat_map<Key,T,Pred,A>& x,
+                      const flat_map<Key,T,Pred,A>& y)
    {  return y < x;  }
 
 template <class Key, class T, class Pred, class A>
-inline bool operator<=(const flat_map<Key,T,Pred,A>& x, 
-                       const flat_map<Key,T,Pred,A>& y) 
+inline bool operator<=(const flat_map<Key,T,Pred,A>& x,
+                       const flat_map<Key,T,Pred,A>& y)
    {  return !(y < x);  }
 
 template <class Key, class T, class Pred, class A>
-inline bool operator>=(const flat_map<Key,T,Pred,A>& x, 
-                       const flat_map<Key,T,Pred,A>& y) 
+inline bool operator>=(const flat_map<Key,T,Pred,A>& x,
+                       const flat_map<Key,T,Pred,A>& y)
    {  return !(x < y);  }
 
 template <class Key, class T, class Pred, class A>
-inline void swap(flat_map<Key,T,Pred,A>& x, 
-                 flat_map<Key,T,Pred,A>& y) 
+inline void swap(flat_map<Key,T,Pred,A>& x,
+                 flat_map<Key,T,Pred,A>& y)
    {  x.swap(y);  }
 
 /// @cond
@@ -847,21 +866,21 @@
 class flat_multimap;
 
 template <class Key, class T, class Pred, class A>
-inline bool operator==(const flat_multimap<Key,T,Pred,A>& x, 
+inline bool operator==(const flat_multimap<Key,T,Pred,A>& x,
                        const flat_multimap<Key,T,Pred,A>& y);
 
 template <class Key, class T, class Pred, class A>
-inline bool operator<(const flat_multimap<Key,T,Pred,A>& x, 
+inline bool operator<(const flat_multimap<Key,T,Pred,A>& x,
                       const flat_multimap<Key,T,Pred,A>& y);
 /// @endcond
 
-//! A flat_multimap is a kind of associative container that supports equivalent keys 
-//! (possibly containing multiple copies of the same key value) and provides for 
-//! fast retrieval of values of another type T based on the keys. The flat_multimap 
+//! A flat_multimap is a kind of associative container that supports equivalent keys
+//! (possibly containing multiple copies of the same key value) and provides for
+//! fast retrieval of values of another type T based on the keys. The flat_multimap
 //! class supports random-access iterators.
-//! 
-//! A flat_multimap satisfies all of the requirements of a container and of a reversible 
-//! container and of an associative container. For a 
+//!
+//! A flat_multimap satisfies all of the requirements of a container and of a reversible
+//! container and of an associative container. For a
 //! flat_multimap<Key,T> the key_type is Key and the value_type is std::pair<Key,T>
 //! (unlike std::multimap<Key, T> which value_type is std::pair<<b>const</b> Key, T>).
 //!
@@ -874,21 +893,21 @@
 #else
 template <class Key, class T, class Pred, class A>
 #endif
-class flat_multimap 
+class flat_multimap
 {
    /// @cond
    private:
    BOOST_COPYABLE_AND_MOVABLE(flat_multimap)
-   typedef container_detail::flat_tree<Key, 
-                           std::pair<Key, T>, 
-                           container_detail::select1st< std::pair<Key, T> >, 
-                           Pred, 
+   typedef container_detail::flat_tree<Key,
+                           std::pair<Key, T>,
+                           container_detail::select1st< std::pair<Key, T> >,
+                           Pred,
                            A> tree_t;
    //This is the real tree stored here. It's based on a movable pair
-   typedef container_detail::flat_tree<Key, 
-                           container_detail::pair<Key, T>, 
-                           container_detail::select1st<container_detail::pair<Key, T> >, 
-                           Pred, 
+   typedef container_detail::flat_tree<Key,
+                           container_detail::pair<Key, T>,
+                           container_detail::select1st<container_detail::pair<Key, T> >,
+                           Pred,
                            typename allocator_traits<A>::template portable_rebind_alloc
                               <container_detail::pair<Key, T> >::type> impl_tree_t;
    impl_tree_t m_flat_tree;  // flat tree representing flat_map
@@ -943,14 +962,14 @@
    typedef impl_value_type                                  movable_value_type;
 
    //! <b>Effects</b>: Default constructs an empty flat_map.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   flat_multimap() 
+   flat_multimap()
       : m_flat_tree() {}
 
    //! <b>Effects</b>: Constructs an empty flat_multimap using the specified comparison
    //!   object and allocator.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    explicit flat_multimap(const Pred& comp,
                           const allocator_type& a = allocator_type())
@@ -958,49 +977,51 @@
 
    //! <b>Effects</b>: Constructs an empty flat_multimap using the specified comparison object
    //!   and allocator, and inserts elements from the range [first ,last ).
-   //! 
-   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using 
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
    //! comp and otherwise N logN, where N is last - first.
    template <class InputIterator>
    flat_multimap(InputIterator first, InputIterator last,
             const Pred& comp        = Pred(),
             const allocator_type& a = allocator_type())
-      : m_flat_tree(comp, container_detail::force<impl_allocator_type>(a)) 
+      : m_flat_tree(comp, container_detail::force<impl_allocator_type>(a))
       { m_flat_tree.insert_equal(first, last); }
 
-   //! <b>Effects</b>: Constructs an empty flat_multimap using the specified comparison object and 
+   //! <b>Effects</b>: Constructs an empty flat_multimap using the specified comparison object and
    //! allocator, and inserts elements from the ordered range [first ,last). This function
    //! is more efficient than the normal range creation for ordered ranges.
    //!
    //! <b>Requires</b>: [first ,last) must be ordered according to the predicate.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
    template <class InputIterator>
    flat_multimap(ordered_range_t, InputIterator first, InputIterator last,
             const Pred& comp        = Pred(),
             const allocator_type& a = allocator_type())
-      : m_flat_tree(ordered_range, first, last, comp, a) 
+      : m_flat_tree(ordered_range, first, last, comp, a)
    {}
 
    //! <b>Effects</b>: Copy constructs a flat_multimap.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear in x.size().
-   flat_multimap(const flat_multimap& x) 
+   flat_multimap(const flat_multimap& x)
       : m_flat_tree(x.m_flat_tree) { }
 
    //! <b>Effects</b>: Move constructs a flat_multimap. Constructs *this using x's resources.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   //! 
+   //!
    //! <b>Postcondition</b>: x is emptied.
-   flat_multimap(BOOST_RV_REF(flat_multimap) x) 
+   flat_multimap(BOOST_RV_REF(flat_multimap) x)
       : m_flat_tree(boost::move(x.m_flat_tree))
    { }
 
    //! <b>Effects</b>: Copy constructs a flat_multimap using the specified allocator.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear in x.size().
-   flat_multimap(const flat_multimap& x, const allocator_type &a) 
+   flat_multimap(const flat_multimap& x, const allocator_type &a)
       : m_flat_tree(x.m_flat_tree, a)
    {}
 
@@ -1008,173 +1029,173 @@
    //!                 Constructs *this using x's resources.
    //!
    //! <b>Complexity</b>: Constant if a == x.get_allocator(), linear otherwise.
-   flat_multimap(BOOST_RV_REF(flat_multimap) x, const allocator_type &a) 
+   flat_multimap(BOOST_RV_REF(flat_multimap) x, const allocator_type &a)
       : m_flat_tree(boost::move(x.m_flat_tree), a)
    { }
 
    //! <b>Effects</b>: Makes *this a copy of x.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear in x.size().
-   flat_multimap& operator=(BOOST_COPY_ASSIGN_REF(flat_multimap) x) 
+   flat_multimap& operator=(BOOST_COPY_ASSIGN_REF(flat_multimap) x)
       {  m_flat_tree = x.m_flat_tree;   return *this;  }
 
    //! <b>Effects</b>: this->swap(x.get()).
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   flat_multimap& operator=(BOOST_RV_REF(flat_multimap) mx) 
+   flat_multimap& operator=(BOOST_RV_REF(flat_multimap) mx)
       {  m_flat_tree = boost::move(mx.m_flat_tree);   return *this;  }
 
    //! <b>Effects</b>: Returns the comparison object out
    //!   of which a was constructed.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   key_compare key_comp() const 
+   key_compare key_comp() const
       { return container_detail::force<key_compare>(m_flat_tree.key_comp()); }
 
    //! <b>Effects</b>: Returns an object of value_compare constructed out
    //!   of the comparison object.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   value_compare value_comp() const 
+   value_compare value_comp() const
       { return value_compare(container_detail::force<key_compare>(m_flat_tree.key_comp())); }
 
    //! <b>Effects</b>: Returns a copy of the Allocator that
    //!   was passed to the object's constructor.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   allocator_type get_allocator() const 
+   allocator_type get_allocator() const
       { return container_detail::force<allocator_type>(m_flat_tree.get_allocator()); }
 
-   const stored_allocator_type &get_stored_allocator() const 
+   const stored_allocator_type &get_stored_allocator() const
       { return container_detail::force<stored_allocator_type>(m_flat_tree.get_stored_allocator()); }
 
    stored_allocator_type &get_stored_allocator()
       { return container_detail::force<stored_allocator_type>(m_flat_tree.get_stored_allocator()); }
 
    //! <b>Effects</b>: Returns an iterator to the first element contained in the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   iterator begin() 
+   iterator begin()
       { return container_detail::force_copy<iterator>(m_flat_tree.begin()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_iterator begin() const 
+   const_iterator begin() const
       { return container_detail::force<const_iterator>(m_flat_tree.begin()); }
 
    //! <b>Effects</b>: Returns an iterator to the end of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   iterator end() 
+   iterator end()
       { return container_detail::force_copy<iterator>(m_flat_tree.end()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_iterator end() const 
+   const_iterator end() const
       { return container_detail::force<const_iterator>(m_flat_tree.end()); }
 
-   //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning 
-   //! of the reversed container. 
-   //! 
+   //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   reverse_iterator rbegin() 
+   reverse_iterator rbegin()
       { return container_detail::force<reverse_iterator>(m_flat_tree.rbegin()); }
 
-   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning 
-   //! of the reversed container. 
-   //! 
+   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator rbegin() const 
+   const_reverse_iterator rbegin() const
       { return container_detail::force<const_reverse_iterator>(m_flat_tree.rbegin()); }
 
    //! <b>Effects</b>: Returns a reverse_iterator pointing to the end
-   //! of the reversed container. 
-   //! 
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   reverse_iterator rend() 
+   reverse_iterator rend()
       { return container_detail::force<reverse_iterator>(m_flat_tree.rend()); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
-   //! of the reversed container. 
-   //! 
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator rend() const 
+   const_reverse_iterator rend() const
       { return container_detail::force<const_reverse_iterator>(m_flat_tree.rend()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_iterator cbegin() const 
+   const_iterator cbegin() const
       { return container_detail::force<const_iterator>(m_flat_tree.cbegin()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_iterator cend() const 
+   const_iterator cend() const
       { return container_detail::force<const_iterator>(m_flat_tree.cend()); }
 
-   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning 
-   //! of the reversed container. 
-   //! 
+   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator crbegin() const 
+   const_reverse_iterator crbegin() const
       { return container_detail::force<const_reverse_iterator>(m_flat_tree.crbegin()); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
-   //! of the reversed container. 
-   //! 
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator crend() const 
+   const_reverse_iterator crend() const
       { return container_detail::force<const_reverse_iterator>(m_flat_tree.crend()); }
 
    //! <b>Effects</b>: Returns true if the container contains no elements.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   bool empty() const 
+   bool empty() const
       { return m_flat_tree.empty(); }
 
    //! <b>Effects</b>: Returns the number of the elements contained in the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   size_type size() const 
+   size_type size() const
       { return m_flat_tree.size(); }
 
    //! <b>Effects</b>: Returns the largest possible size of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   size_type max_size() const 
+   size_type max_size() const
       { return m_flat_tree.max_size(); }
 
    //! <b>Effects</b>: Swaps the contents of *this and x.
@@ -1186,33 +1207,33 @@
    { m_flat_tree.swap(x.m_flat_tree); }
 
    //! <b>Effects</b>: Inserts x and returns the iterator pointing to the
-   //!   newly inserted element. 
+   //!   newly inserted element.
    //!
    //! <b>Complexity</b>: Logarithmic search time plus linear insertion
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(const value_type& x) 
+   iterator insert(const value_type& x)
       { return container_detail::force_copy<iterator>(m_flat_tree.insert_equal(container_detail::force<impl_value_type>(x))); }
 
-   //! <b>Effects</b>: Inserts a new value move-constructed from x and returns 
-   //!   the iterator pointing to the newly inserted element. 
+   //! <b>Effects</b>: Inserts a new value move-constructed from x and returns
+   //!   the iterator pointing to the newly inserted element.
    //!
    //! <b>Complexity</b>: Logarithmic search time plus linear insertion
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(BOOST_RV_REF(value_type) x) 
+   iterator insert(BOOST_RV_REF(value_type) x)
    { return container_detail::force_copy<iterator>(m_flat_tree.insert_equal(boost::move(x))); }
 
-   //! <b>Effects</b>: Inserts a new value move-constructed from x and returns 
-   //!   the iterator pointing to the newly inserted element. 
+   //! <b>Effects</b>: Inserts a new value move-constructed from x and returns
+   //!   the iterator pointing to the newly inserted element.
    //!
    //! <b>Complexity</b>: Logarithmic search time plus linear insertion
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(BOOST_RV_REF(impl_value_type) x) 
+   iterator insert(BOOST_RV_REF(impl_value_type) x)
       { return container_detail::force_copy<iterator>(m_flat_tree.insert_equal(boost::move(x))); }
 
    //! <b>Effects</b>: Inserts a copy of x in the container.
@@ -1226,7 +1247,7 @@
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(const_iterator position, const value_type& x) 
+   iterator insert(const_iterator position, const value_type& x)
       { return container_detail::force_copy<iterator>
          (m_flat_tree.insert_equal(container_detail::force<impl_const_iterator>(position), container_detail::force<impl_value_type>(x))); }
 
@@ -1241,7 +1262,7 @@
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(const_iterator position, BOOST_RV_REF(value_type) x) 
+   iterator insert(const_iterator position, BOOST_RV_REF(value_type) x)
    {
       return container_detail::force_copy<iterator>
          (m_flat_tree.insert_equal(container_detail::force<impl_const_iterator>(position)
@@ -1259,7 +1280,7 @@
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(const_iterator position, BOOST_RV_REF(impl_value_type) x) 
+   iterator insert(const_iterator position, BOOST_RV_REF(impl_value_type) x)
    {
       return container_detail::force_copy<iterator>(
          m_flat_tree.insert_equal(container_detail::force<impl_const_iterator>(position), boost::move(x)));
@@ -1274,14 +1295,30 @@
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class InputIterator>
-   void insert(InputIterator first, InputIterator last) 
+   void insert(InputIterator first, InputIterator last)
       {  m_flat_tree.insert_equal(first, last); }
 
+   //! <b>Requires</b>: first, last are not iterators into *this.
+   //!
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate.
+   //!
+   //! <b>Effects</b>: inserts each element from the range [first,last) if and only
+   //!   if there is no element with key equivalent to the key of that element. This
+   //!   function is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Complexity</b>: At most N log(size()+N) (N is the distance from first to last)
+   //!   search time plus N*size() insertion time.
+   //!
+   //! <b>Note</b>: If an element is inserted it might invalidate elements.
+   template <class InputIterator>
+   void insert(ordered_range_t, InputIterator first, InputIterator last)
+      {  m_flat_tree.insert_equal(ordered_range, first, last); }
+
    #if defined(BOOST_CONTAINER_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
    //! <b>Effects</b>: Inserts an object of type T constructed with
    //!   std::forward<Args>(args)... and returns the iterator pointing to the
-   //!   newly inserted element. 
+   //!   newly inserted element.
    //!
    //! <b>Complexity</b>: Logarithmic search time plus linear insertion
    //!   to the elements with bigger keys than x.
@@ -1333,14 +1370,14 @@
    //! <b>Effects</b>: Erases the element pointed to by position.
    //!
    //! <b>Returns</b>: Returns an iterator pointing to the element immediately
-   //!   following q prior to the element being erased. If no such element exists, 
+   //!   following q prior to the element being erased. If no such element exists,
    //!   returns end().
    //!
    //! <b>Complexity</b>: Linear to the elements with keys bigger than position
    //!
    //! <b>Note</b>: Invalidates elements with keys
    //!   not less than the erased element.
-   iterator erase(const_iterator position) 
+   iterator erase(const_iterator position)
       { return container_detail::force_copy<iterator>(m_flat_tree.erase(container_detail::force<impl_const_iterator>(position))); }
 
    //! <b>Effects</b>: Erases all elements in the container with key equivalent to x.
@@ -1349,7 +1386,7 @@
    //!
    //! <b>Complexity</b>: Logarithmic search time plus erasure time
    //!   linear to the elements with bigger keys.
-   size_type erase(const key_type& x) 
+   size_type erase(const key_type& x)
       { return m_flat_tree.erase(x); }
 
    //! <b>Effects</b>: Erases all the elements in the range [first, last).
@@ -1369,7 +1406,7 @@
    //! <b>Postcondition</b>: size() == 0.
    //!
    //! <b>Complexity</b>: linear in size().
-   void clear() 
+   void clear()
       { m_flat_tree.clear(); }
 
    //! <b>Effects</b>: Tries to deallocate the excess of memory created
@@ -1392,75 +1429,75 @@
    //!   equivalent to x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   const_iterator find(const key_type& x) const 
+   const_iterator find(const key_type& x) const
       { return container_detail::force<const_iterator>(m_flat_tree.find(x)); }
 
    //! <b>Returns</b>: The number of elements with key equivalent to x.
    //!
    //! <b>Complexity</b>: log(size())+count(k)
-   size_type count(const key_type& x) const 
+   size_type count(const key_type& x) const
       { return m_flat_tree.count(x); }
 
    //! <b>Returns</b>: An iterator pointing to the first element with key not less
    //!   than k, or a.end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic
-   iterator lower_bound(const key_type& x) 
+   iterator lower_bound(const key_type& x)
       {return container_detail::force_copy<iterator>(m_flat_tree.lower_bound(x)); }
 
    //! <b>Returns</b>: A const iterator pointing to the first element with key
    //!   not less than k, or a.end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic
-   const_iterator lower_bound(const key_type& x) const 
+   const_iterator lower_bound(const key_type& x) const
       {  return container_detail::force<const_iterator>(m_flat_tree.lower_bound(x));  }
 
    //! <b>Returns</b>: An iterator pointing to the first element with key not less
    //!   than x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic
-   iterator upper_bound(const key_type& x) 
+   iterator upper_bound(const key_type& x)
       {return container_detail::force_copy<iterator>(m_flat_tree.upper_bound(x)); }
 
    //! <b>Returns</b>: A const iterator pointing to the first element with key
    //!   not less than x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic
-   const_iterator upper_bound(const key_type& x) const 
+   const_iterator upper_bound(const key_type& x) const
       {  return container_detail::force<const_iterator>(m_flat_tree.upper_bound(x)); }
 
    //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
    //!
    //! <b>Complexity</b>: Logarithmic
-   std::pair<iterator,iterator> equal_range(const key_type& x) 
+   std::pair<iterator,iterator> equal_range(const key_type& x)
       {  return container_detail::force<std::pair<iterator,iterator> >(m_flat_tree.equal_range(x));   }
 
    //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
    //!
    //! <b>Complexity</b>: Logarithmic
-   std::pair<const_iterator,const_iterator> 
-      equal_range(const key_type& x) const 
+   std::pair<const_iterator,const_iterator>
+      equal_range(const key_type& x) const
       {  return container_detail::force<std::pair<const_iterator,const_iterator> >(m_flat_tree.equal_range(x));   }
 
    //! <b>Effects</b>: Number of elements for which memory has been allocated.
    //!   capacity() is always greater than or equal to size().
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   size_type capacity() const           
+   size_type capacity() const          
       { return m_flat_tree.capacity(); }
 
    //! <b>Effects</b>: If n is less than or equal to capacity(), this call has no
    //!   effect. Otherwise, it is a request for allocation of additional memory.
    //!   If the request is successful, then capacity() is greater than or equal to
    //!   n; otherwise, capacity() is unchanged. In either case, size() is unchanged.
-   //! 
+   //!
    //! <b>Throws</b>: If memory allocation allocation throws or T's copy constructor throws.
    //!
    //! <b>Note</b>: If capacity() is less than "count", iterators and references to
    //!   to values might be invalidated.
-   void reserve(size_type count)       
+   void reserve(size_type count)      
       { m_flat_tree.reserve(count);   }
 
    /// @cond
@@ -1475,37 +1512,37 @@
 };
 
 template <class Key, class T, class Pred, class A>
-inline bool operator==(const flat_multimap<Key,T,Pred,A>& x, 
-                       const flat_multimap<Key,T,Pred,A>& y) 
+inline bool operator==(const flat_multimap<Key,T,Pred,A>& x,
+                       const flat_multimap<Key,T,Pred,A>& y)
    {  return x.m_flat_tree == y.m_flat_tree;  }
 
 template <class Key, class T, class Pred, class A>
-inline bool operator<(const flat_multimap<Key,T,Pred,A>& x, 
-                      const flat_multimap<Key,T,Pred,A>& y) 
+inline bool operator<(const flat_multimap<Key,T,Pred,A>& x,
+                      const flat_multimap<Key,T,Pred,A>& y)
    {  return x.m_flat_tree < y.m_flat_tree;   }
 
 template <class Key, class T, class Pred, class A>
-inline bool operator!=(const flat_multimap<Key,T,Pred,A>& x, 
-                       const flat_multimap<Key,T,Pred,A>& y) 
+inline bool operator!=(const flat_multimap<Key,T,Pred,A>& x,
+                       const flat_multimap<Key,T,Pred,A>& y)
    {  return !(x == y);  }
 
 template <class Key, class T, class Pred, class A>
-inline bool operator>(const flat_multimap<Key,T,Pred,A>& x, 
-                      const flat_multimap<Key,T,Pred,A>& y) 
+inline bool operator>(const flat_multimap<Key,T,Pred,A>& x,
+                      const flat_multimap<Key,T,Pred,A>& y)
    {  return y < x;  }
 
 template <class Key, class T, class Pred, class A>
-inline bool operator<=(const flat_multimap<Key,T,Pred,A>& x, 
-                       const flat_multimap<Key,T,Pred,A>& y) 
+inline bool operator<=(const flat_multimap<Key,T,Pred,A>& x,
+                       const flat_multimap<Key,T,Pred,A>& y)
    {  return !(y < x);  }
 
 template <class Key, class T, class Pred, class A>
-inline bool operator>=(const flat_multimap<Key,T,Pred,A>& x, 
-                       const flat_multimap<Key,T,Pred,A>& y) 
+inline bool operator>=(const flat_multimap<Key,T,Pred,A>& x,
+                       const flat_multimap<Key,T,Pred,A>& y)
    {  return !(x < y);  }
 
 template <class Key, class T, class Pred, class A>
-inline void swap(flat_multimap<Key,T,Pred,A>& x, flat_multimap<Key,T,Pred,A>& y) 
+inline void swap(flat_multimap<Key,T,Pred,A>& x, flat_multimap<Key,T,Pred,A>& y)
    {  x.swap(y);  }
 
 }}
@@ -1522,7 +1559,7 @@
    static const bool value = has_trivial_destructor<A>::value && has_trivial_destructor<C>::value;
 };
 */
-}  //namespace boost { 
+}  //namespace boost {
 
 /// @endcond
 

Modified: branches/release/boost/container/flat_set.hpp
==============================================================================
--- branches/release/boost/container/flat_set.hpp	(original)
+++ branches/release/boost/container/flat_set.hpp	2012-05-24 12:36:39 EDT (Thu, 24 May 2012)
@@ -45,31 +45,31 @@
 class flat_set;
 
 template <class T, class Pred, class A>
-inline bool operator==(const flat_set<T,Pred,A>& x, 
+inline bool operator==(const flat_set<T,Pred,A>& x,
                        const flat_set<T,Pred,A>& y);
 
 template <class T, class Pred, class A>
-inline bool operator<(const flat_set<T,Pred,A>& x, 
+inline bool operator<(const flat_set<T,Pred,A>& x,
                       const flat_set<T,Pred,A>& y);
 /// @endcond
 
-//! flat_set is a Sorted Associative Container that stores objects of type Key. 
-//! flat_set is a Simple Associative Container, meaning that its value type, 
-//! as well as its key type, is Key. It is also a Unique Associative Container, 
-//! meaning that no two elements are the same. 
-//! 
+//! flat_set is a Sorted Associative Container that stores objects of type Key.
+//! flat_set is a Simple Associative Container, meaning that its value type,
+//! as well as its key type, is Key. It is also a Unique Associative Container,
+//! meaning that no two elements are the same.
+//!
 //! flat_set is similar to std::set but it's implemented like an ordered vector.
 //! This means that inserting a new element into a flat_set invalidates
 //! previous iterators and references
 //!
-//! Erasing an element of a flat_set invalidates iterators and references 
+//! Erasing an element of a flat_set invalidates iterators and references
 //! pointing to elements that come after (their keys are bigger) the erased element.
 #ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
 template <class T, class Pred = std::less<T>, class A = std::allocator<T> >
 #else
 template <class T, class Pred, class A>
 #endif
-class flat_set 
+class flat_set
 {
    /// @cond
    private:
@@ -101,7 +101,7 @@
    typedef typename tree_t::stored_allocator_type  stored_allocator_type;
 
    //! <b>Effects</b>: Default constructs an empty flat_set.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    explicit flat_set()
       : m_flat_tree()
@@ -109,58 +109,60 @@
 
    //! <b>Effects</b>: Constructs an empty flat_set using the specified
    //! comparison object and allocator.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    explicit flat_set(const Pred& comp,
                      const allocator_type& a = allocator_type())
       : m_flat_tree(comp, a)
    {}
 
-   //! <b>Effects</b>: Constructs an empty set using the specified comparison object and 
+   //! <b>Effects</b>: Constructs an empty set using the specified comparison object and
    //! allocator, and inserts elements from the range [first ,last ).
-   //! 
-   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using 
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
    //! comp and otherwise N logN, where N is last - first.
    template <class InputIterator>
-   flat_set(InputIterator first, InputIterator last, 
+   flat_set(InputIterator first, InputIterator last,
             const Pred& comp = Pred(),
             const allocator_type& a = allocator_type())
-      : m_flat_tree(comp, a) 
+      : m_flat_tree(comp, a)
       { m_flat_tree.insert_unique(first, last); }
 
-   //! <b>Effects</b>: Constructs an empty flat_set using the specified comparison object and 
+   //! <b>Effects</b>: Constructs an empty flat_set using the specified comparison object and
    //! allocator, and inserts elements from the ordered unique range [first ,last). This function
    //! is more efficient than the normal range creation for ordered ranges.
    //!
    //! <b>Requires</b>: [first ,last) must be ordered according to the predicate and must be
    //! unique values.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
    template <class InputIterator>
-   flat_set(ordered_unique_range_t, InputIterator first, InputIterator last, 
+   flat_set(ordered_unique_range_t, InputIterator first, InputIterator last,
             const Pred& comp = Pred(),
             const allocator_type& a = allocator_type())
-      : m_flat_tree(ordered_range, first, last, comp, a) 
+      : m_flat_tree(ordered_range, first, last, comp, a)
    {}
 
    //! <b>Effects</b>: Copy constructs a set.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear in x.size().
-   flat_set(const flat_set& x) 
+   flat_set(const flat_set& x)
       : m_flat_tree(x.m_flat_tree)
    {}
 
    //! <b>Effects</b>: Move constructs a set. Constructs *this using x's resources.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   //! 
+   //!
    //! <b>Postcondition</b>: x is emptied.
-   flat_set(BOOST_RV_REF(flat_set) mx) 
+   flat_set(BOOST_RV_REF(flat_set) mx)
       : m_flat_tree(boost::move(mx.m_flat_tree))
    {}
 
    //! <b>Effects</b>: Copy constructs a set using the specified allocator.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear in x.size().
    flat_set(const flat_set& x, const allocator_type &a)
       : m_flat_tree(x.m_flat_tree, a)
@@ -168,175 +170,175 @@
 
    //! <b>Effects</b>: Move constructs a set using the specified allocator.
    //!                 Constructs *this using x's resources.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant if a == mx.get_allocator(), linear otherwise
-   flat_set(BOOST_RV_REF(flat_set) mx, const allocator_type &a) 
+   flat_set(BOOST_RV_REF(flat_set) mx, const allocator_type &a)
       : m_flat_tree(boost::move(mx.m_flat_tree), a)
    {}
 
    //! <b>Effects</b>: Makes *this a copy of x.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear in x.size().
    flat_set& operator=(BOOST_COPY_ASSIGN_REF(flat_set) x)
       {  m_flat_tree = x.m_flat_tree;   return *this;  }
 
    //! <b>Effects</b>: Makes *this a copy of the previous value of xx.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear in x.size().
    flat_set& operator=(BOOST_RV_REF(flat_set) mx)
    {  m_flat_tree = boost::move(mx.m_flat_tree);   return *this;  }
 
    //! <b>Effects</b>: Returns the comparison object out
    //!   of which a was constructed.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   key_compare key_comp() const 
+   key_compare key_comp() const
       { return m_flat_tree.key_comp(); }
 
    //! <b>Effects</b>: Returns an object of value_compare constructed out
    //!   of the comparison object.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   value_compare value_comp() const 
+   value_compare value_comp() const
       { return m_flat_tree.key_comp(); }
 
    //! <b>Effects</b>: Returns a copy of the Allocator that
    //!   was passed to the object's constructor.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   allocator_type get_allocator() const 
+   allocator_type get_allocator() const
       { return m_flat_tree.get_allocator(); }
 
-   const stored_allocator_type &get_stored_allocator() const 
+   const stored_allocator_type &get_stored_allocator() const
    {  return m_flat_tree.get_stored_allocator(); }
 
    stored_allocator_type &get_stored_allocator()
    {  return m_flat_tree.get_stored_allocator(); }
 
    //! <b>Effects</b>: Returns an iterator to the first element contained in the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   iterator begin() 
+   iterator begin()
       { return m_flat_tree.begin(); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_iterator begin() const 
+   const_iterator begin() const
       { return m_flat_tree.begin(); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_iterator cbegin() const 
+   const_iterator cbegin() const
       { return m_flat_tree.cbegin(); }
 
    //! <b>Effects</b>: Returns an iterator to the end of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   iterator end() 
+   iterator end()
       { return m_flat_tree.end(); }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_iterator end() const 
+   const_iterator end() const
       { return m_flat_tree.end(); }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_iterator cend() const 
+   const_iterator cend() const
       { return m_flat_tree.cend(); }
 
-   //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning 
-   //! of the reversed container. 
-   //! 
+   //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   reverse_iterator rbegin() 
-      { return m_flat_tree.rbegin(); } 
+   reverse_iterator rbegin()
+      { return m_flat_tree.rbegin(); }
 
-   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning 
-   //! of the reversed container. 
-   //! 
+   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator rbegin() const 
-      { return m_flat_tree.rbegin(); } 
+   const_reverse_iterator rbegin() const
+      { return m_flat_tree.rbegin(); }
 
-   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning 
-   //! of the reversed container. 
-   //! 
+   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator crbegin() const 
-      { return m_flat_tree.crbegin(); } 
+   const_reverse_iterator crbegin() const
+      { return m_flat_tree.crbegin(); }
 
    //! <b>Effects</b>: Returns a reverse_iterator pointing to the end
-   //! of the reversed container. 
-   //! 
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    reverse_iterator rend()
       { return m_flat_tree.rend(); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
-   //! of the reversed container. 
-   //! 
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator rend() const 
+   const_reverse_iterator rend() const
       { return m_flat_tree.rend(); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
-   //! of the reversed container. 
-   //! 
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator crend() const 
+   const_reverse_iterator crend() const
       { return m_flat_tree.crend(); }
 
    //! <b>Effects</b>: Returns true if the container contains no elements.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   bool empty() const 
+   bool empty() const
       { return m_flat_tree.empty(); }
 
    //! <b>Effects</b>: Returns the number of the elements contained in the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   size_type size() const 
+   size_type size() const
       { return m_flat_tree.size(); }
 
    //! <b>Effects</b>: Returns the largest possible size of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   size_type max_size() const 
+   size_type max_size() const
       { return m_flat_tree.max_size(); }
 
    //! <b>Effects</b>: Swaps the contents of *this and x.
@@ -347,10 +349,10 @@
    void swap(flat_set& x)
    { m_flat_tree.swap(x.m_flat_tree); }
 
-   //! <b>Effects</b>: Inserts x if and only if there is no element in the container 
+   //! <b>Effects</b>: Inserts x if and only if there is no element in the container
    //!   with key equivalent to the key of x.
    //!
-   //! <b>Returns</b>: The bool component of the returned pair is true if and only 
+   //! <b>Returns</b>: The bool component of the returned pair is true if and only
    //!   if the insertion takes place, and the iterator component of the pair
    //!   points to the element with key equivalent to the key of x.
    //!
@@ -358,7 +360,7 @@
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   std::pair<iterator, bool> insert(insert_const_ref_type x) 
+   std::pair<iterator, bool> insert(insert_const_ref_type x)
    {  return priv_insert(x); }
 
    #if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -373,7 +375,7 @@
    //! <b>Effects</b>: Inserts a new value_type move constructed from the pair if and
    //! only if there is no element in the container with key equivalent to the key of x.
    //!
-   //! <b>Returns</b>: The bool component of the returned pair is true if and only 
+   //! <b>Returns</b>: The bool component of the returned pair is true if and only
    //!   if the insertion takes place, and the iterator component of the pair
    //!   points to the element with key equivalent to the key of x.
    //!
@@ -381,10 +383,10 @@
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   std::pair<iterator,bool> insert(BOOST_RV_REF(value_type) x) 
+   std::pair<iterator,bool> insert(BOOST_RV_REF(value_type) x)
    {  return m_flat_tree.insert_unique(boost::move(x));  }
 
-   //! <b>Effects</b>: Inserts a copy of x in the container if and only if there is 
+   //! <b>Effects</b>: Inserts a copy of x in the container if and only if there is
    //!   no element in the container with key equivalent to the key of x.
    //!   p is a hint pointing to where the insert should start to search.
    //!
@@ -395,7 +397,7 @@
    //!   right before p) plus insertion linear to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(const_iterator p, insert_const_ref_type x) 
+   iterator insert(const_iterator p, insert_const_ref_type x)
    {  return priv_insert(p, x); }
 
    #if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -416,12 +418,12 @@
    //!   right before p) plus insertion linear to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(const_iterator position, BOOST_RV_REF(value_type) x) 
+   iterator insert(const_iterator position, BOOST_RV_REF(value_type) x)
    {  return m_flat_tree.insert_unique(position, boost::move(x)); }
 
    //! <b>Requires</b>: first, last are not iterators into *this.
    //!
-   //! <b>Effects</b>: inserts each element from the range [first,last) if and only 
+   //! <b>Effects</b>: inserts each element from the range [first,last) if and only
    //!   if there is no element with key equivalent to the key of that element.
    //!
    //! <b>Complexity</b>: At most N log(size()+N) (N is the distance from first to last)
@@ -429,16 +431,31 @@
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class InputIterator>
-   void insert(InputIterator first, InputIterator last) 
+   void insert(InputIterator first, InputIterator last)
       {  m_flat_tree.insert_unique(first, last);  }
 
+   //! <b>Requires</b>: first, last are not iterators into *this and
+   //! must be ordered according to the predicate and must be
+   //! unique values.
+   //!
+   //! <b>Effects</b>: inserts each element from the range [first,last) .This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Complexity</b>: At most N log(size()+N) (N is the distance from first to last)
+   //!   search time plus N*size() insertion time.
+   //!
+   //! <b>Note</b>: Non-standard extension. If an element is inserted it might invalidate elements.
+   template <class InputIterator>
+   void insert(ordered_unique_range_t, InputIterator first, InputIterator last)
+      {  m_flat_tree.insert_unique(ordered_unique_range, first, last);  }
+
    #if defined(BOOST_CONTAINER_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
    //! <b>Effects</b>: Inserts an object x of type T constructed with
-   //!   std::forward<Args>(args)... if and only if there is no element in the container 
+   //!   std::forward<Args>(args)... if and only if there is no element in the container
    //!   with key equivalent to the key of x.
    //!
-   //! <b>Returns</b>: The bool component of the returned pair is true if and only 
+   //! <b>Returns</b>: The bool component of the returned pair is true if and only
    //!   if the insertion takes place, and the iterator component of the pair
    //!   points to the element with key equivalent to the key of x.
    //!
@@ -451,7 +468,7 @@
    {  return m_flat_tree.emplace_unique(boost::forward<Args>(args)...); }
 
    //! <b>Effects</b>: Inserts an object of type T constructed with
-   //!   std::forward<Args>(args)... in the container if and only if there is 
+   //!   std::forward<Args>(args)... in the container if and only if there is
    //!   no element in the container with key equivalent to the key of x.
    //!   p is a hint pointing to where the insert should start to search.
    //!
@@ -487,14 +504,14 @@
    //! <b>Effects</b>: Erases the element pointed to by position.
    //!
    //! <b>Returns</b>: Returns an iterator pointing to the element immediately
-   //!   following q prior to the element being erased. If no such element exists, 
+   //!   following q prior to the element being erased. If no such element exists,
    //!   returns end().
    //!
    //! <b>Complexity</b>: Linear to the elements with keys bigger than position
    //!
    //! <b>Note</b>: Invalidates elements with keys
    //!   not less than the erased element.
-   iterator erase(const_iterator position) 
+   iterator erase(const_iterator position)
       {  return m_flat_tree.erase(position); }
 
    //! <b>Effects</b>: Erases all elements in the container with key equivalent to x.
@@ -503,7 +520,7 @@
    //!
    //! <b>Complexity</b>: Logarithmic search time plus erasure time
    //!   linear to the elements with bigger keys.
-   size_type erase(const key_type& x) 
+   size_type erase(const key_type& x)
       {  return m_flat_tree.erase(x); }
 
    //! <b>Effects</b>: Erases all the elements in the range [first, last).
@@ -514,7 +531,7 @@
    //!
    //! <b>Complexity</b>: Logarithmic search time plus erasure time
    //!   linear to the elements with bigger keys.
-   iterator erase(const_iterator first, const_iterator last) 
+   iterator erase(const_iterator first, const_iterator last)
       {  return m_flat_tree.erase(first, last);  }
 
    //! <b>Effects</b>: erase(a.begin(),a.end()).
@@ -522,7 +539,7 @@
    //! <b>Postcondition</b>: size() == 0.
    //!
    //! <b>Complexity</b>: linear in size().
-   void clear() 
+   void clear()
       { m_flat_tree.clear(); }
 
    //! <b>Effects</b>: Tries to deallocate the excess of memory created
@@ -538,34 +555,34 @@
    //!   equivalent to x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   iterator find(const key_type& x) 
+   iterator find(const key_type& x)
       { return m_flat_tree.find(x); }
 
    //! <b>Returns</b>: A const_iterator pointing to an element with the key
    //!   equivalent to x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic.s
-   const_iterator find(const key_type& x) const 
+   const_iterator find(const key_type& x) const
       { return m_flat_tree.find(x); }
 
    //! <b>Returns</b>: The number of elements with key equivalent to x.
    //!
    //! <b>Complexity</b>: log(size())+count(k)
-   size_type count(const key_type& x) const 
+   size_type count(const key_type& x) const
       {  return m_flat_tree.find(x) == m_flat_tree.end() ? 0 : 1;  }
 
    //! <b>Returns</b>: An iterator pointing to the first element with key not less
    //!   than k, or a.end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic
-   iterator lower_bound(const key_type& x) 
+   iterator lower_bound(const key_type& x)
       {  return m_flat_tree.lower_bound(x); }
 
    //! <b>Returns</b>: A const iterator pointing to the first element with key not
    //!   less than k, or a.end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic
-   const_iterator lower_bound(const key_type& x) const 
+   const_iterator lower_bound(const key_type& x) const
       {  return m_flat_tree.lower_bound(x); }
 
    //! <b>Returns</b>: An iterator pointing to the first element with key not less
@@ -579,42 +596,42 @@
    //!   less than x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic
-   const_iterator upper_bound(const key_type& x) const 
+   const_iterator upper_bound(const key_type& x) const
       {  return m_flat_tree.upper_bound(x);    }
 
    //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
    //!
    //! <b>Complexity</b>: Logarithmic
-   std::pair<const_iterator, const_iterator> 
-      equal_range(const key_type& x) const 
+   std::pair<const_iterator, const_iterator>
+      equal_range(const key_type& x) const
       {  return m_flat_tree.equal_range(x); }
 
    //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
    //!
    //! <b>Complexity</b>: Logarithmic
-   std::pair<iterator,iterator> 
-      equal_range(const key_type& x) 
+   std::pair<iterator,iterator>
+      equal_range(const key_type& x)
       {  return m_flat_tree.equal_range(x); }
 
    //! <b>Effects</b>: Number of elements for which memory has been allocated.
    //!   capacity() is always greater than or equal to size().
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   size_type capacity() const           
+   size_type capacity() const          
       { return m_flat_tree.capacity(); }
 
    //! <b>Effects</b>: If n is less than or equal to capacity(), this call has no
    //!   effect. Otherwise, it is a request for allocation of additional memory.
    //!   If the request is successful, then capacity() is greater than or equal to
    //!   n; otherwise, capacity() is unchanged. In either case, size() is unchanged.
-   //! 
+   //!
    //! <b>Throws</b>: If memory allocation allocation throws or T's copy constructor throws.
    //!
    //! <b>Note</b>: If capacity() is less than "count", iterators and references to
    //!   to values might be invalidated.
-   void reserve(size_type count)       
+   void reserve(size_type count)      
       { m_flat_tree.reserve(count);   }
 
    /// @cond
@@ -625,46 +642,46 @@
    friend bool operator< (const flat_set<K1,C1,A1>&, const flat_set<K1,C1,A1>&);
 
    private:
-   std::pair<iterator, bool> priv_insert(const T &x) 
+   std::pair<iterator, bool> priv_insert(const T &x)
    {  return m_flat_tree.insert_unique(x);  }
 
-   iterator priv_insert(const_iterator p, const T &x) 
+   iterator priv_insert(const_iterator p, const T &x)
    {  return m_flat_tree.insert_unique(p, x); }
    /// @endcond
 };
 
 template <class T, class Pred, class A>
-inline bool operator==(const flat_set<T,Pred,A>& x, 
-                       const flat_set<T,Pred,A>& y) 
+inline bool operator==(const flat_set<T,Pred,A>& x,
+                       const flat_set<T,Pred,A>& y)
    {  return x.m_flat_tree == y.m_flat_tree;  }
 
 template <class T, class Pred, class A>
-inline bool operator<(const flat_set<T,Pred,A>& x, 
-                      const flat_set<T,Pred,A>& y) 
+inline bool operator<(const flat_set<T,Pred,A>& x,
+                      const flat_set<T,Pred,A>& y)
    {  return x.m_flat_tree < y.m_flat_tree;   }
 
 template <class T, class Pred, class A>
-inline bool operator!=(const flat_set<T,Pred,A>& x, 
-                       const flat_set<T,Pred,A>& y) 
+inline bool operator!=(const flat_set<T,Pred,A>& x,
+                       const flat_set<T,Pred,A>& y)
    {  return !(x == y);   }
 
 template <class T, class Pred, class A>
-inline bool operator>(const flat_set<T,Pred,A>& x, 
-                      const flat_set<T,Pred,A>& y) 
+inline bool operator>(const flat_set<T,Pred,A>& x,
+                      const flat_set<T,Pred,A>& y)
    {  return y < x; }
 
 template <class T, class Pred, class A>
-inline bool operator<=(const flat_set<T,Pred,A>& x, 
-                       const flat_set<T,Pred,A>& y) 
+inline bool operator<=(const flat_set<T,Pred,A>& x,
+                       const flat_set<T,Pred,A>& y)
    {  return !(y < x); }
 
 template <class T, class Pred, class A>
-inline bool operator>=(const flat_set<T,Pred,A>& x, 
-                       const flat_set<T,Pred,A>& y) 
+inline bool operator>=(const flat_set<T,Pred,A>& x,
+                       const flat_set<T,Pred,A>& y)
    {  return !(x < y);  }
 
 template <class T, class Pred, class A>
-inline void swap(flat_set<T,Pred,A>& x, flat_set<T,Pred,A>& y) 
+inline void swap(flat_set<T,Pred,A>& x, flat_set<T,Pred,A>& y)
    {  x.swap(y);  }
 
 /// @cond
@@ -691,31 +708,31 @@
 class flat_multiset;
 
 template <class T, class Pred, class A>
-inline bool operator==(const flat_multiset<T,Pred,A>& x, 
+inline bool operator==(const flat_multiset<T,Pred,A>& x,
                        const flat_multiset<T,Pred,A>& y);
 
 template <class T, class Pred, class A>
-inline bool operator<(const flat_multiset<T,Pred,A>& x, 
+inline bool operator<(const flat_multiset<T,Pred,A>& x,
                       const flat_multiset<T,Pred,A>& y);
 /// @endcond
 
-//! flat_multiset is a Sorted Associative Container that stores objects of type Key. 
-//! flat_multiset is a Simple Associative Container, meaning that its value type, 
+//! flat_multiset is a Sorted Associative Container that stores objects of type Key.
+//! flat_multiset is a Simple Associative Container, meaning that its value type,
 //! as well as its key type, is Key.
 //! flat_Multiset can store multiple copies of the same key value.
-//! 
+//!
 //! flat_multiset is similar to std::multiset but it's implemented like an ordered vector.
 //! This means that inserting a new element into a flat_multiset invalidates
 //! previous iterators and references
 //!
-//! Erasing an element of a flat_multiset invalidates iterators and references 
+//! Erasing an element of a flat_multiset invalidates iterators and references
 //! pointing to elements that come after (their keys are equal or bigger) the erased element.
 #ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
 template <class T, class Pred = std::less<T>, class A = std::allocator<T> >
 #else
 template <class T, class Pred, class A>
 #endif
-class flat_multiset 
+class flat_multiset
 {
    /// @cond
    private:
@@ -746,7 +763,7 @@
    typedef typename tree_t::stored_allocator_type  stored_allocator_type;
 
    //! <b>Effects</b>: Default constructs an empty flat_multiset.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    explicit flat_multiset()
       : m_flat_tree()
@@ -760,41 +777,43 @@
    flat_multiset(InputIterator first, InputIterator last,
                  const Pred& comp        = Pred(),
                  const allocator_type& a = allocator_type())
-      : m_flat_tree(comp, a) 
+      : m_flat_tree(comp, a)
       { m_flat_tree.insert_equal(first, last); }
 
-   //! <b>Effects</b>: Constructs an empty flat_multiset using the specified comparison object and 
+   //! <b>Effects</b>: Constructs an empty flat_multiset using the specified comparison object and
    //! allocator, and inserts elements from the ordered range [first ,last ). This function
    //! is more efficient than the normal range creation for ordered ranges.
    //!
    //! <b>Requires</b>: [first ,last) must be ordered according to the predicate.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
    template <class InputIterator>
    flat_multiset(ordered_range_t, InputIterator first, InputIterator last,
                  const Pred& comp        = Pred(),
                  const allocator_type& a = allocator_type())
-      : m_flat_tree(ordered_range, first, last, comp, a) 
+      : m_flat_tree(ordered_range, first, last, comp, a)
    {}
 
    //! <b>Effects</b>: Copy constructs a flat_multiset.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear in x.size().
-   flat_multiset(const flat_multiset& x) 
+   flat_multiset(const flat_multiset& x)
       : m_flat_tree(x.m_flat_tree)
    {}
 
    //! <b>Effects</b>: Move constructs a flat_multiset. Constructs *this using x's resources.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   //! 
+   //!
    //! <b>Postcondition</b>: x is emptied.
-   flat_multiset(BOOST_RV_REF(flat_multiset) mx) 
+   flat_multiset(BOOST_RV_REF(flat_multiset) mx)
       : m_flat_tree(boost::move(mx.m_flat_tree))
    {}
 
    //! <b>Effects</b>: Copy constructs a flat_multiset using the specified allocator.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear in x.size().
    flat_multiset(const flat_multiset& x, const allocator_type &a)
       : m_flat_tree(x.m_flat_tree, a)
@@ -802,175 +821,175 @@
 
    //! <b>Effects</b>: Move constructs a flat_multiset using the specified allocator.
    //!                 Constructs *this using x's resources.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant if a == mx.get_allocator(), linear otherwise
-   flat_multiset(BOOST_RV_REF(flat_multiset) mx, const allocator_type &a) 
+   flat_multiset(BOOST_RV_REF(flat_multiset) mx, const allocator_type &a)
       : m_flat_tree(boost::move(mx.m_flat_tree), a)
    {}
 
    //! <b>Effects</b>: Makes *this a copy of x.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear in x.size().
-   flat_multiset& operator=(BOOST_COPY_ASSIGN_REF(flat_multiset) x) 
+   flat_multiset& operator=(BOOST_COPY_ASSIGN_REF(flat_multiset) x)
       {  m_flat_tree = x.m_flat_tree;   return *this;  }
 
    //! <b>Effects</b>: Makes *this a copy of x.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear in x.size().
-   flat_multiset& operator=(BOOST_RV_REF(flat_multiset) mx) 
+   flat_multiset& operator=(BOOST_RV_REF(flat_multiset) mx)
    {  m_flat_tree = boost::move(mx.m_flat_tree);   return *this;  }
 
    //! <b>Effects</b>: Returns the comparison object out
    //!   of which a was constructed.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   key_compare key_comp() const 
+   key_compare key_comp() const
       { return m_flat_tree.key_comp(); }
 
    //! <b>Effects</b>: Returns an object of value_compare constructed out
    //!   of the comparison object.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   value_compare value_comp() const 
+   value_compare value_comp() const
       { return m_flat_tree.key_comp(); }
 
    //! <b>Effects</b>: Returns a copy of the Allocator that
    //!   was passed to the object's constructor.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   allocator_type get_allocator() const 
+   allocator_type get_allocator() const
    { return m_flat_tree.get_allocator(); }
 
-   const stored_allocator_type &get_stored_allocator() const 
+   const stored_allocator_type &get_stored_allocator() const
    { return m_flat_tree.get_stored_allocator(); }
 
    stored_allocator_type &get_stored_allocator()
    { return m_flat_tree.get_stored_allocator(); }
 
    //! <b>Effects</b>: Returns an iterator to the first element contained in the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   iterator begin() 
+   iterator begin()
       { return m_flat_tree.begin(); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_iterator begin() const 
+   const_iterator begin() const
       { return m_flat_tree.begin(); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_iterator cbegin() const 
+   const_iterator cbegin() const
       { return m_flat_tree.cbegin(); }
 
    //! <b>Effects</b>: Returns an iterator to the end of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   iterator end() 
+   iterator end()
       { return m_flat_tree.end(); }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_iterator end() const 
+   const_iterator end() const
       { return m_flat_tree.end(); }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_iterator cend() const 
+   const_iterator cend() const
       { return m_flat_tree.cend(); }
 
-   //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning 
-   //! of the reversed container. 
-   //! 
+   //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   reverse_iterator rbegin() 
-      { return m_flat_tree.rbegin(); } 
+   reverse_iterator rbegin()
+      { return m_flat_tree.rbegin(); }
 
-   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning 
-   //! of the reversed container. 
-   //! 
+   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator rbegin() const 
-      { return m_flat_tree.rbegin(); } 
+   const_reverse_iterator rbegin() const
+      { return m_flat_tree.rbegin(); }
 
-   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning 
-   //! of the reversed container. 
-   //! 
+   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator crbegin() const 
-      { return m_flat_tree.crbegin(); } 
+   const_reverse_iterator crbegin() const
+      { return m_flat_tree.crbegin(); }
 
    //! <b>Effects</b>: Returns a reverse_iterator pointing to the end
-   //! of the reversed container. 
-   //! 
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    reverse_iterator rend()
       { return m_flat_tree.rend(); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
-   //! of the reversed container. 
-   //! 
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator rend() const 
+   const_reverse_iterator rend() const
       { return m_flat_tree.rend(); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
-   //! of the reversed container. 
-   //! 
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator crend() const 
+   const_reverse_iterator crend() const
       { return m_flat_tree.crend(); }
 
    //! <b>Effects</b>: Returns true if the container contains no elements.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   bool empty() const 
+   bool empty() const
       { return m_flat_tree.empty(); }
 
    //! <b>Effects</b>: Returns the number of the elements contained in the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   size_type size() const 
+   size_type size() const
       { return m_flat_tree.size(); }
 
    //! <b>Effects</b>: Returns the largest possible size of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   size_type max_size() const 
+   size_type max_size() const
       { return m_flat_tree.max_size(); }
 
    //! <b>Effects</b>: Swaps the contents of *this and x.
@@ -982,13 +1001,13 @@
    { m_flat_tree.swap(x.m_flat_tree); }
 
    //! <b>Effects</b>: Inserts x and returns the iterator pointing to the
-   //!   newly inserted element. 
+   //!   newly inserted element.
    //!
    //! <b>Complexity</b>: Logarithmic search time plus linear insertion
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(insert_const_ref_type x) 
+   iterator insert(insert_const_ref_type x)
    {  return priv_insert(x); }
 
    #if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -1001,13 +1020,13 @@
    #endif
 
    //! <b>Effects</b>: Inserts a new value_type move constructed from x
-   //!   and returns the iterator pointing to the newly inserted element. 
+   //!   and returns the iterator pointing to the newly inserted element.
    //!
    //! <b>Complexity</b>: Logarithmic search time plus linear insertion
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(BOOST_RV_REF(value_type) x) 
+   iterator insert(BOOST_RV_REF(value_type) x)
    {  return m_flat_tree.insert_equal(boost::move(x));   }
 
    //! <b>Effects</b>: Inserts a copy of x in the container.
@@ -1020,7 +1039,7 @@
    //!   right before p) plus insertion linear to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(const_iterator p, insert_const_ref_type x) 
+   iterator insert(const_iterator p, insert_const_ref_type x)
    {  return priv_insert(p, x); }
 
    #if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -1043,7 +1062,7 @@
    //!   right before p) plus insertion linear to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(const_iterator position, BOOST_RV_REF(value_type) x) 
+   iterator insert(const_iterator position, BOOST_RV_REF(value_type) x)
    {  return m_flat_tree.insert_equal(position, boost::move(x));  }
 
    //! <b>Requires</b>: first, last are not iterators into *this.
@@ -1055,14 +1074,28 @@
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class InputIterator>
-   void insert(InputIterator first, InputIterator last) 
+   void insert(InputIterator first, InputIterator last)
       {  m_flat_tree.insert_equal(first, last);  }
 
+   //! <b>Requires</b>: first, last are not iterators into *this and
+   //! must be ordered according to the predicate.
+   //!
+   //! <b>Effects</b>: inserts each element from the range [first,last) .This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Complexity</b>: At most N log(size()+N) (N is the distance from first to last)
+   //!   search time plus N*size() insertion time.
+   //!
+   //! <b>Note</b>: Non-standard extension. If an element is inserted it might invalidate elements.
+   template <class InputIterator>
+   void insert(ordered_range_t, InputIterator first, InputIterator last)
+      {  m_flat_tree.insert_equal(ordered_range, first, last);  }
+
    #if defined(BOOST_CONTAINER_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
    //! <b>Effects</b>: Inserts an object of type T constructed with
    //!   std::forward<Args>(args)... and returns the iterator pointing to the
-   //!   newly inserted element. 
+   //!   newly inserted element.
    //!
    //! <b>Complexity</b>: Logarithmic search time plus linear insertion
    //!   to the elements with bigger keys than x.
@@ -1108,14 +1141,14 @@
    //! <b>Effects</b>: Erases the element pointed to by position.
    //!
    //! <b>Returns</b>: Returns an iterator pointing to the element immediately
-   //!   following q prior to the element being erased. If no such element exists, 
+   //!   following q prior to the element being erased. If no such element exists,
    //!   returns end().
    //!
    //! <b>Complexity</b>: Linear to the elements with keys bigger than position
    //!
    //! <b>Note</b>: Invalidates elements with keys
    //!   not less than the erased element.
-   iterator erase(const_iterator position) 
+   iterator erase(const_iterator position)
       {  return m_flat_tree.erase(position); }
 
    //! <b>Effects</b>: Erases all elements in the container with key equivalent to x.
@@ -1124,7 +1157,7 @@
    //!
    //! <b>Complexity</b>: Logarithmic search time plus erasure time
    //!   linear to the elements with bigger keys.
-   size_type erase(const key_type& x) 
+   size_type erase(const key_type& x)
       {  return m_flat_tree.erase(x); }
 
    //! <b>Effects</b>: Erases all the elements in the range [first, last).
@@ -1135,7 +1168,7 @@
    //!
    //! <b>Complexity</b>: Logarithmic search time plus erasure time
    //!   linear to the elements with bigger keys.
-   iterator erase(const_iterator first, const_iterator last) 
+   iterator erase(const_iterator first, const_iterator last)
       {  return m_flat_tree.erase(first, last);  }
 
    //! <b>Effects</b>: erase(a.begin(),a.end()).
@@ -1143,7 +1176,7 @@
    //! <b>Postcondition</b>: size() == 0.
    //!
    //! <b>Complexity</b>: linear in size().
-   void clear() 
+   void clear()
       { m_flat_tree.clear(); }
 
    //! <b>Effects</b>: Tries to deallocate the excess of memory created
@@ -1159,34 +1192,34 @@
    //!   equivalent to x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   iterator find(const key_type& x) 
+   iterator find(const key_type& x)
       { return m_flat_tree.find(x); }
 
    //! <b>Returns</b>: A const_iterator pointing to an element with the key
    //!   equivalent to x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic.s
-   const_iterator find(const key_type& x) const 
+   const_iterator find(const key_type& x) const
       { return m_flat_tree.find(x); }
 
    //! <b>Returns</b>: The number of elements with key equivalent to x.
    //!
    //! <b>Complexity</b>: log(size())+count(k)
-   size_type count(const key_type& x) const 
+   size_type count(const key_type& x) const
       { return m_flat_tree.count(x); }
 
    //! <b>Returns</b>: An iterator pointing to the first element with key not less
    //!   than k, or a.end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic
-   iterator lower_bound(const key_type& x) 
+   iterator lower_bound(const key_type& x)
       {  return m_flat_tree.lower_bound(x); }
 
    //! <b>Returns</b>: A const iterator pointing to the first element with key not
    //!   less than k, or a.end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic
-   const_iterator lower_bound(const key_type& x) const 
+   const_iterator lower_bound(const key_type& x) const
       {  return m_flat_tree.lower_bound(x); }
 
    //! <b>Returns</b>: An iterator pointing to the first element with key not less
@@ -1200,42 +1233,42 @@
    //!   less than x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic
-   const_iterator upper_bound(const key_type& x) const 
+   const_iterator upper_bound(const key_type& x) const
       {  return m_flat_tree.upper_bound(x);    }
 
    //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
    //!
    //! <b>Complexity</b>: Logarithmic
-   std::pair<const_iterator, const_iterator> 
-      equal_range(const key_type& x) const 
+   std::pair<const_iterator, const_iterator>
+      equal_range(const key_type& x) const
       {  return m_flat_tree.equal_range(x); }
 
    //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
    //!
    //! <b>Complexity</b>: Logarithmic
-   std::pair<iterator,iterator> 
-      equal_range(const key_type& x) 
+   std::pair<iterator,iterator>
+      equal_range(const key_type& x)
       {  return m_flat_tree.equal_range(x); }
 
    //! <b>Effects</b>: Number of elements for which memory has been allocated.
    //!   capacity() is always greater than or equal to size().
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   size_type capacity() const           
+   size_type capacity() const          
       { return m_flat_tree.capacity(); }
 
    //! <b>Effects</b>: If n is less than or equal to capacity(), this call has no
    //!   effect. Otherwise, it is a request for allocation of additional memory.
    //!   If the request is successful, then capacity() is greater than or equal to
    //!   n; otherwise, capacity() is unchanged. In either case, size() is unchanged.
-   //! 
+   //!
    //! <b>Throws</b>: If memory allocation allocation throws or T's copy constructor throws.
    //!
    //! <b>Note</b>: If capacity() is less than "count", iterators and references to
    //!   to values might be invalidated.
-   void reserve(size_type count)       
+   void reserve(size_type count)      
       { m_flat_tree.reserve(count);   }
 
    /// @cond
@@ -1246,46 +1279,46 @@
    friend bool operator< (const flat_multiset<K1,C1,A1>&,
                           const flat_multiset<K1,C1,A1>&);
    private:
-   iterator priv_insert(const T &x) 
+   iterator priv_insert(const T &x)
    {  return m_flat_tree.insert_equal(x);  }
 
-   iterator priv_insert(const_iterator p, const T &x) 
+   iterator priv_insert(const_iterator p, const T &x)
    {  return m_flat_tree.insert_equal(p, x); }
    /// @endcond
 };
 
 template <class T, class Pred, class A>
-inline bool operator==(const flat_multiset<T,Pred,A>& x, 
-                       const flat_multiset<T,Pred,A>& y) 
+inline bool operator==(const flat_multiset<T,Pred,A>& x,
+                       const flat_multiset<T,Pred,A>& y)
    {  return x.m_flat_tree == y.m_flat_tree;  }
 
 template <class T, class Pred, class A>
-inline bool operator<(const flat_multiset<T,Pred,A>& x, 
-                      const flat_multiset<T,Pred,A>& y) 
+inline bool operator<(const flat_multiset<T,Pred,A>& x,
+                      const flat_multiset<T,Pred,A>& y)
    {  return x.m_flat_tree < y.m_flat_tree;   }
 
 template <class T, class Pred, class A>
-inline bool operator!=(const flat_multiset<T,Pred,A>& x, 
-                       const flat_multiset<T,Pred,A>& y) 
+inline bool operator!=(const flat_multiset<T,Pred,A>& x,
+                       const flat_multiset<T,Pred,A>& y)
    {  return !(x == y);  }
 
 template <class T, class Pred, class A>
-inline bool operator>(const flat_multiset<T,Pred,A>& x, 
-                      const flat_multiset<T,Pred,A>& y) 
+inline bool operator>(const flat_multiset<T,Pred,A>& x,
+                      const flat_multiset<T,Pred,A>& y)
    {  return y < x;  }
 
 template <class T, class Pred, class A>
-inline bool operator<=(const flat_multiset<T,Pred,A>& x, 
-                       const flat_multiset<T,Pred,A>& y) 
+inline bool operator<=(const flat_multiset<T,Pred,A>& x,
+                       const flat_multiset<T,Pred,A>& y)
    {  return !(y < x);  }
 
 template <class T, class Pred, class A>
-inline bool operator>=(const flat_multiset<T,Pred,A>& x, 
-                       const flat_multiset<T,Pred,A>& y) 
+inline bool operator>=(const flat_multiset<T,Pred,A>& x,
+                       const flat_multiset<T,Pred,A>& y)
 {  return !(x < y);  }
 
 template <class T, class Pred, class A>
-inline void swap(flat_multiset<T,Pred,A>& x, flat_multiset<T,Pred,A>& y) 
+inline void swap(flat_multiset<T,Pred,A>& x, flat_multiset<T,Pred,A>& y)
    {  x.swap(y);  }
 
 /// @cond

Modified: branches/release/boost/container/list.hpp
==============================================================================
--- branches/release/boost/container/list.hpp	(original)
+++ branches/release/boost/container/list.hpp	2012-05-24 12:36:39 EDT (Thu, 24 May 2012)
@@ -32,7 +32,7 @@
 #if defined(BOOST_CONTAINER_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 #else
 //Preprocessor library to emulate perfect forwarding
-#include <boost/container/detail/preprocessor.hpp> 
+#include <boost/container/detail/preprocessor.hpp>
 #endif
 
 #include <stdexcept>
@@ -98,26 +98,26 @@
 /// @endcond
 
 //! A list is a doubly linked list. That is, it is a Sequence that supports both
-//! forward and backward traversal, and (amortized) constant time insertion and 
-//! removal of elements at the beginning or the end, or in the middle. Lists have 
-//! the important property that insertion and splicing do not invalidate iterators 
-//! to list elements, and that even removal invalidates only the iterators that point 
-//! to the elements that are removed. The ordering of iterators may be changed 
-//! (that is, list<T>::iterator might have a different predecessor or successor 
-//! after a list operation than it did before), but the iterators themselves will 
-//! not be invalidated or made to point to different elements unless that invalidation 
+//! forward and backward traversal, and (amortized) constant time insertion and
+//! removal of elements at the beginning or the end, or in the middle. Lists have
+//! the important property that insertion and splicing do not invalidate iterators
+//! to list elements, and that even removal invalidates only the iterators that point
+//! to the elements that are removed. The ordering of iterators may be changed
+//! (that is, list<T>::iterator might have a different predecessor or successor
+//! after a list operation than it did before), but the iterators themselves will
+//! not be invalidated or made to point to different elements unless that invalidation
 //! or mutation is explicit.
 #ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
 template <class T, class A = std::allocator<T> >
 #else
 template <class T, class A>
 #endif
-class list 
+class list
    : protected container_detail::node_alloc_holder
       <A, typename container_detail::intrusive_list_type<A>::type>
 {
    /// @cond
-   typedef typename 
+   typedef typename
       container_detail::intrusive_list_type<A>::type Icont;
    typedef list <T, A>                                ThisType;
    typedef container_detail::node_alloc_holder<A, Icont>        AllocHolder;
@@ -192,11 +192,11 @@
    /// @endcond
 
    public:
-   //! Const iterator used to iterate through a list. 
+   //! Const iterator used to iterate through a list.
    class const_iterator
       /// @cond
-      : public std::iterator<std::bidirectional_iterator_tag, 
-                                 value_type,         list_difference_type, 
+      : public std::iterator<std::bidirectional_iterator_tag,
+                                 value_type,         list_difference_type,
                                  list_const_pointer, list_const_reference>
    {
 
@@ -220,17 +220,17 @@
       {}
 
       //Pointer like operators
-      const_reference operator*()  const 
+      const_reference operator*()  const
       { return  m_it->m_data;  }
 
-      const_pointer   operator->() const 
+      const_pointer   operator->() const
       { return  const_pointer(&m_it->m_data); }
 
       //Increment / Decrement
-      const_iterator& operator++()       
+      const_iterator& operator++()      
       { prot_incr();  return *this; }
 
-      const_iterator operator++(int)      
+      const_iterator operator++(int)     
       { typename Icont::iterator tmp = m_it; ++*this; return const_iterator(tmp);  }
 
       const_iterator& operator--()
@@ -259,7 +259,7 @@
       explicit iterator(typename Icont::iterator it)
          :  const_iterator(it)
       {}
-   
+  
       typename Icont::iterator get()
       {  return this->m_it;   }
 
@@ -276,12 +276,12 @@
       pointer   operator->() const {  return  pointer(&this->m_it->m_data);  }
 
       //Increment / Decrement
-      iterator& operator++()  
+      iterator& operator++() 
          { this->prot_incr(); return *this;  }
 
       iterator operator++(int)
          { typename Icont::iterator tmp = this->m_it; ++*this; return iterator(tmp); }
-      
+     
       iterator& operator--()
          {  this->prot_decr(); return *this;  }
 
@@ -290,24 +290,24 @@
    };
    /// @endcond
 
-   //! Iterator used to iterate backwards through a list. 
+   //! Iterator used to iterate backwards through a list.
    typedef std::reverse_iterator<iterator>        reverse_iterator;
-   //! Const iterator used to iterate backwards through a list. 
+   //! Const iterator used to iterate backwards through a list.
    typedef std::reverse_iterator<const_iterator>  const_reverse_iterator;
 
    //! <b>Effects</b>: Default constructs a list.
-   //! 
+   //!
    //! <b>Throws</b>: If allocator_type's default constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   list() 
+   list()
       : AllocHolder()
    {}
 
    //! <b>Effects</b>: Constructs a list taking the allocator as parameter.
-   //! 
+   //!
    //! <b>Throws</b>: If allocator_type's copy constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    explicit list(const allocator_type &a)
       : AllocHolder(a)
@@ -318,7 +318,7 @@
    //!
    //! <b>Throws</b>: If allocator_type's default constructor or copy constructor
    //!   throws or T's default or copy constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear to n.
    explicit list(size_type n)
       : AllocHolder(A())
@@ -329,7 +329,7 @@
    //!
    //! <b>Throws</b>: If allocator_type's default constructor or copy constructor
    //!   throws or T's default or copy constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear to n.
    list(size_type n, const T& value, const A& a = A())
       : AllocHolder(a)
@@ -338,18 +338,18 @@
    //! <b>Effects</b>: Copy constructs a list.
    //!
    //! <b>Postcondition</b>: x == *this.
-   //! 
+   //!
    //! <b>Throws</b>: If allocator_type's default constructor or copy constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear to the elements x contains.
-   list(const list& x) 
+   list(const list& x)
       : AllocHolder(x)
    {  this->insert(this->cbegin(), x.begin(), x.end());   }
 
    //! <b>Effects</b>: Move constructor. Moves mx's resources to *this.
    //!
    //! <b>Throws</b>: If allocator_type's copy constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    list(BOOST_RV_REF(list) x)
       : AllocHolder(boost::move(static_cast<AllocHolder&>(x)))
@@ -358,11 +358,11 @@
    //! <b>Effects</b>: Copy constructs a list using the specified allocator.
    //!
    //! <b>Postcondition</b>: x == *this.
-   //! 
+   //!
    //! <b>Throws</b>: If allocator_type's default constructor or copy constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear to the elements x contains.
-   list(const list& x, const allocator_type &a) 
+   list(const list& x, const allocator_type &a)
       : AllocHolder(a)
    {  this->insert(this->cbegin(), x.begin(), x.end());   }
 
@@ -370,7 +370,7 @@
    //!                 Moves mx's resources to *this.
    //!
    //! <b>Throws</b>: If allocation or value_type's copy constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant if a == x.get_allocator(), linear otherwise.
    list(BOOST_RV_REF(list) x, const allocator_type &a)
       : AllocHolder(a)
@@ -405,14 +405,14 @@
    {} //AllocHolder clears the list
 
    //! <b>Effects</b>: Returns a copy of the internal allocator.
-   //! 
+   //!
    //! <b>Throws</b>: If allocator's copy constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    allocator_type get_allocator() const
    {  return allocator_type(this->node_alloc()); }
 
-   const stored_allocator_type &get_stored_allocator() const 
+   const stored_allocator_type &get_stored_allocator() const
    {  return this->node_alloc(); }
 
    stored_allocator_type &get_stored_allocator()
@@ -427,129 +427,129 @@
    {  AllocHolder::clear(alloc_version());  }
 
    //! <b>Effects</b>: Returns an iterator to the first element contained in the list.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    iterator begin()
    { return iterator(this->icont().begin()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the list.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_iterator begin() const
    {  return this->cbegin();   }
 
    //! <b>Effects</b>: Returns an iterator to the end of the list.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    iterator end()
    {  return iterator(this->icont().end());  }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the list.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_iterator end() const
    {  return this->cend();  }
 
-   //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning 
-   //! of the reversed list. 
-   //! 
+   //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning
+   //! of the reversed list.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    reverse_iterator rbegin()
    {  return reverse_iterator(end());  }
 
-   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning 
-   //! of the reversed list. 
-   //! 
+   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
+   //! of the reversed list.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_reverse_iterator rbegin() const
    {  return this->crbegin();  }
 
    //! <b>Effects</b>: Returns a reverse_iterator pointing to the end
-   //! of the reversed list. 
-   //! 
+   //! of the reversed list.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    reverse_iterator rend()
    {  return reverse_iterator(begin());   }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
-   //! of the reversed list. 
-   //! 
+   //! of the reversed list.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_reverse_iterator rend() const
    {  return this->crend();   }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the list.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_iterator cbegin() const
    {  return const_iterator(this->non_const_icont().begin());   }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the list.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_iterator cend() const
    {  return const_iterator(this->non_const_icont().end());  }
 
-   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning 
-   //! of the reversed list. 
-   //! 
+   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
+   //! of the reversed list.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_reverse_iterator crbegin() const
    {  return const_reverse_iterator(this->cend());  }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
-   //! of the reversed list. 
-   //! 
+   //! of the reversed list.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_reverse_iterator crend() const
    {  return const_reverse_iterator(this->cbegin());   }
 
    //! <b>Effects</b>: Returns true if the list contains no elements.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   bool empty() const 
+   bool empty() const
    {  return !this->size();  }
 
    //! <b>Effects</b>: Returns the number of the elements contained in the list.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   size_type size() const 
+   size_type size() const
    {   return this->icont().size();   }
 
    //! <b>Effects</b>: Returns the largest possible size of the list.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   size_type max_size() const 
+   size_type max_size() const
    {  return AllocHolder::max_size();  }
 
    #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -597,7 +597,7 @@
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Amortized constant time.
-   void pop_front()              
+   void pop_front()             
    {  this->erase(this->cbegin());      }
 
    //! <b>Effects</b>: Removes the last element from the list.
@@ -605,51 +605,51 @@
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Amortized constant time.
-   void pop_back()               
+   void pop_back()              
    {  const_iterator tmp = this->cend(); this->erase(--tmp);  }
 
    //! <b>Requires</b>: !empty()
    //!
-   //! <b>Effects</b>: Returns a reference to the first element 
+   //! <b>Effects</b>: Returns a reference to the first element
    //!   from the beginning of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   reference front()             
+   reference front()            
    { return *this->begin(); }
 
    //! <b>Requires</b>: !empty()
    //!
-   //! <b>Effects</b>: Returns a const reference to the first element 
+   //! <b>Effects</b>: Returns a const reference to the first element
    //!   from the beginning of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reference front() const 
+   const_reference front() const
    { return *this->begin(); }
 
    //! <b>Requires</b>: !empty()
    //!
-   //! <b>Effects</b>: Returns a reference to the first element 
+   //! <b>Effects</b>: Returns a reference to the first element
    //!   from the beginning of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   reference back()              
+   reference back()             
    { return *(--this->end()); }
 
    //! <b>Requires</b>: !empty()
    //!
-   //! <b>Effects</b>: Returns a const reference to the first element 
+   //! <b>Effects</b>: Returns a const reference to the first element
    //!   from the beginning of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reference back()  const 
+   const_reference back()  const
    { return *(--this->end()); }
 
    //! <b>Effects</b>: Inserts or erases elements at the end such that
@@ -662,7 +662,7 @@
    {
       const_iterator iend = this->cend();
       size_type len = this->size();
-      
+     
       if(len > new_size){
          size_type to_erase = len - new_size;
          while(to_erase--){
@@ -685,7 +685,7 @@
    {
       const_iterator iend = this->end();
       size_type len = this->size();
-      
+     
       if(len > new_size){
          size_type to_erase = len - new_size;
          const_iterator ifirst;
@@ -719,8 +719,8 @@
 
    //! <b>Effects</b>: Makes *this contain the same elements as x.
    //!
-   //! <b>Postcondition</b>: this->size() == x.size(). *this contains a copy 
-   //! of each of x's elements. 
+   //! <b>Postcondition</b>: this->size() == x.size(). *this contains a copy
+   //! of each of x's elements.
    //!
    //! <b>Throws</b>: If memory allocation throws or T's copy constructor throws.
    //!
@@ -791,7 +791,7 @@
    //!
    //! <b>Complexity</b>: Linear to std::distance [first, last).
    template <class InpIt>
-   void insert(const_iterator p, InpIt first, InpIt last) 
+   void insert(const_iterator p, InpIt first, InpIt last)
    {
       const bool aux_boolean = container_detail::is_convertible<InpIt, size_type>::value;
       typedef container_detail::bool_<aux_boolean> Result;
@@ -900,7 +900,7 @@
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Amortized constant time.
-   iterator erase(const_iterator p) 
+   iterator erase(const_iterator p)
    {  return iterator(this->icont().erase_and_dispose(p.get(), Destroyer(this->node_alloc()))); }
 
    //! <b>Requires</b>: first and last must be valid iterator to elements in *this.
@@ -918,7 +918,7 @@
    //! <b>Throws</b>: If memory allocation throws or T's copy constructor throws.
    //!
    //! <b>Complexity</b>: Linear to n.
-   void assign(size_type n, const T& val) 
+   void assign(size_type n, const T& val)
    {  this->priv_fill_assign(n, val);  }
 
    //! <b>Effects</b>: Assigns the the range [first, last) to *this.
@@ -928,7 +928,7 @@
    //!
    //! <b>Complexity</b>: Linear to n.
    template <class InpIt>
-   void assign(InpIt first, InpIt last) 
+   void assign(InpIt first, InpIt last)
    {
       const bool aux_boolean = container_detail::is_convertible<InpIt, size_type>::value;
       typedef container_detail::bool_<aux_boolean> Result;
@@ -945,7 +945,7 @@
    //!   are not equal.
    //!
    //! <b>Complexity</b>: Constant.
-   //! 
+   //!
    //! <b>Note</b>: 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, ThisType& x) BOOST_CONTAINER_NOEXCEPT
@@ -956,16 +956,16 @@
 
    //! <b>Requires</b>: p must point to an element contained
    //!   by this list. i must point to an element contained in list x.
-   //! 
-   //! <b>Effects</b>: Transfers the value pointed by i, from list x to this list, 
+   //!
+   //! <b>Effects</b>: Transfers the value pointed by i, from list x to this list,
    //!   before the the element pointed by p. No destructors or copy constructors are called.
-   //!   If p == i or p == ++i, this function is a null operation. 
-   //! 
+   //!   If p == i or p == ++i, this function is a null operation.
+   //!
    //! <b>Throws</b>: std::runtime_error if this' allocator and x's allocator
    //!   are not equal.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   //! 
+   //!
    //! <b>Note</b>: 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, ThisType &x, const_iterator i) BOOST_CONTAINER_NOEXCEPT
@@ -976,15 +976,15 @@
 
    //! <b>Requires</b>: p must point to an element contained
    //!   by this list. first and last must point to elements contained in list x.
-   //! 
-   //! <b>Effects</b>: Transfers the range pointed by first and last from list x to this list, 
+   //!
+   //! <b>Effects</b>: Transfers the range pointed by first and last from list x to this list,
    //!   before the the element pointed by p. No destructors or copy constructors are called.
-   //! 
+   //!
    //! <b>Throws</b>: std::runtime_error if this' allocator and x's allocator
    //!   are not equal.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear to the number of elements transferred.
-   //! 
+   //!
    //! <b>Note</b>: 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, ThisType &x, const_iterator first, const_iterator last) BOOST_CONTAINER_NOEXCEPT
@@ -996,15 +996,15 @@
    //! <b>Requires</b>: p must point to an element contained
    //!   by this list. first and last must point to elements contained in list x.
    //!   n == std::distance(first, last)
-   //! 
-   //! <b>Effects</b>: Transfers the range pointed by first and last from list x to this list, 
+   //!
+   //! <b>Effects</b>: Transfers the range pointed by first and last from list x to this list,
    //!   before the the element pointed by p. No destructors or copy constructors are called.
-   //! 
+   //!
    //! <b>Throws</b>: std::runtime_error if this' allocator and x's allocator
    //!   are not equal.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   //! 
+   //!
    //! <b>Note</b>: 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, ThisType &x, const_iterator first, const_iterator last, size_type n) BOOST_CONTAINER_NOEXCEPT
@@ -1013,22 +1013,22 @@
       this->icont().splice(p.get(), x.icont(), first.get(), last.get(), n);
    }
 
-   //! <b>Effects</b>: Reverses the order of elements in the list. 
-   //! 
+   //! <b>Effects</b>: Reverses the order of elements in the list.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: This function is linear time.
-   //! 
+   //!
    //! <b>Note</b>: Iterators and references are not invalidated
    void reverse()
-   {  this->icont().reverse(); }    
+   {  this->icont().reverse(); }   
 
    //! <b>Effects</b>: Removes all the elements that compare equal to value.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear time. It performs exactly size() comparisons for equality.
-   //! 
+   //!
    //! <b>Note</b>: The relative order of elements that are not removed is unchanged,
    //!   and iterators to elements that are not removed remain valid.
    void remove(const T& value)
@@ -1036,11 +1036,11 @@
 
    //! <b>Effects</b>: Removes all the elements for which a specified
    //!   predicate is satisfied.
-   //! 
+   //!
    //! <b>Throws</b>: If pred throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear time. It performs exactly size() calls to the predicate.
-   //! 
+   //!
    //! <b>Note</b>: The relative order of elements that are not removed is unchanged,
    //!   and iterators to elements that are not removed remain valid.
    template <class Pred>
@@ -1050,25 +1050,25 @@
       this->icont().remove_and_dispose_if(Predicate(pred), Destroyer(this->node_alloc()));
    }
 
-   //! <b>Effects</b>: Removes adjacent duplicate elements or adjacent 
+   //! <b>Effects</b>: Removes adjacent duplicate elements or adjacent
    //!   elements that are equal from the list.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear time (size()-1 comparisons calls to pred()).
-   //! 
+   //!
    //! <b>Note</b>: 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(value_equal());  }
 
-   //! <b>Effects</b>: Removes adjacent duplicate elements or adjacent 
+   //! <b>Effects</b>: Removes adjacent duplicate elements or adjacent
    //!   elements that satisfy some binary predicate from the list.
-   //! 
+   //!
    //! <b>Throws</b>: If pred throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear time (size()-1 comparisons equality comparisons).
-   //! 
+   //!
    //! <b>Note</b>: The relative order of elements that are not removed is unchanged,
    //!   and iterators to elements that are not removed remain valid.
    template <class BinaryPredicate>
@@ -1078,15 +1078,15 @@
       this->icont().unique_and_dispose(Predicate(binary_pred), Destroyer(this->node_alloc()));
    }
 
-   //! <b>Requires</b>: The lists x and *this must be distinct. 
+   //! <b>Requires</b>: The lists x and *this must be distinct.
    //!
    //! <b>Effects</b>: 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.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: This function is linear time: it performs at most
    //!   size() + x.size() - 1 comparisons.
    void merge(list<T, A>& x)
@@ -1094,17 +1094,17 @@
 
    //! <b>Requires</b>: 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.
+   //!
    //! <b>Effects</b>: 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.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: This function is linear time: it performs at most
    //!   size() + x.size() - 1 comparisons.
-   //! 
+   //!
    //! <b>Note</b>: Iterators and references to *this are not invalidated.
    template <class StrictWeakOrdering>
    void merge(list &x, StrictWeakOrdering comp)
@@ -1118,25 +1118,25 @@
       }
    }
 
-   //! <b>Effects</b>: This function sorts the list *this according to std::less<value_type>. 
+   //! <b>Effects</b>: 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.
    //!
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Notes</b>: Iterators and references are not invalidated.
-   //!   
+   //!  
    //! <b>Complexity</b>: The number of comparisons is approximately N log N, where N
    //!   is the list's size.
    void sort()
    {  this->sort(value_less());  }
 
-   //! <b>Effects</b>: This function sorts the list *this according to std::less<value_type>. 
+   //! <b>Effects</b>: 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.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Notes</b>: Iterators and references are not invalidated.
-   //! 
+   //!
    //! <b>Complexity</b>: The number of comparisons is approximately N log N, where N
    //!   is the list's size.
    template <class StrictWeakOrdering>
@@ -1151,25 +1151,25 @@
    /// @cond
    private:
 
-   iterator priv_insert(const_iterator p, const T &x) 
+   iterator priv_insert(const_iterator p, const T &x)
    {
       NodePtr tmp = AllocHolder::create_node(x);
       return iterator(this->icont().insert(p.get(), *tmp));
    }
 
-   iterator priv_insert(const_iterator p, BOOST_RV_REF(T) x) 
+   iterator priv_insert(const_iterator p, BOOST_RV_REF(T) x)
    {
       NodePtr tmp = AllocHolder::create_node(boost::move(x));
       return iterator(this->icont().insert(p.get(), *tmp));
    }
 
-   void priv_push_back (const T &x)   
+   void priv_push_back (const T &x)  
    {  this->insert(this->cend(), x);    }
 
    void priv_push_back (BOOST_RV_REF(T) x)
    {  this->insert(this->cend(), boost::move(x));    }
 
-   void priv_push_front (const T &x)   
+   void priv_push_front (const T &x)  
    {  this->insert(this->cbegin(), x);  }
 
    void priv_push_front (BOOST_RV_REF(T) x)
@@ -1251,10 +1251,10 @@
    {  this->priv_create_and_insert_nodes(p, first, last);   }
 
    template<class Integer>
-   void priv_insert_dispatch(const_iterator p, Integer n, Integer x, container_detail::true_) 
+   void priv_insert_dispatch(const_iterator p, Integer n, Integer x, container_detail::true_)
    {  this->insert(p, (size_type)n, x);  }
 
-   void priv_fill_assign(size_type n, const T& val) 
+   void priv_fill_assign(size_type n, const T& val)
    {
       iterator i = this->begin(), iend = this->end();
 
@@ -1328,25 +1328,25 @@
 }
 
 template <class T, class A>
-inline bool operator!=(const list<T,A>& x, const list<T,A>& y) 
+inline bool operator!=(const list<T,A>& x, const list<T,A>& y)
 {
   return !(x == y);
 }
 
 template <class T, class A>
-inline bool operator>(const list<T,A>& x, const list<T,A>& y) 
+inline bool operator>(const list<T,A>& x, const list<T,A>& y)
 {
   return y < x;
 }
 
 template <class T, class A>
-inline bool operator<=(const list<T,A>& x, const list<T,A>& y) 
+inline bool operator<=(const list<T,A>& x, const list<T,A>& y)
 {
   return !(y < x);
 }
 
 template <class T, class A>
-inline bool operator>=(const list<T,A>& x, const list<T,A>& y) 
+inline bool operator>=(const list<T,A>& x, const list<T,A>& y)
 {
   return !(x < y);
 }

Modified: branches/release/boost/container/map.hpp
==============================================================================
--- branches/release/boost/container/map.hpp	(original)
+++ branches/release/boost/container/map.hpp	2012-05-24 12:36:39 EDT (Thu, 24 May 2012)
@@ -47,20 +47,20 @@
 /// @cond
 // Forward declarations of operators == and <, needed for friend declarations.
 template <class Key, class T, class Pred, class A>
-inline bool operator==(const map<Key,T,Pred,A>& x, 
+inline bool operator==(const map<Key,T,Pred,A>& x,
                        const map<Key,T,Pred,A>& y);
 
 template <class Key, class T, class Pred, class A>
-inline bool operator<(const map<Key,T,Pred,A>& x, 
+inline bool operator<(const map<Key,T,Pred,A>& x,
                       const map<Key,T,Pred,A>& y);
 /// @endcond
 
-//! A map is a kind of associative container that supports unique keys (contains at 
-//! most one of each key value) and provides for fast retrieval of values of another 
+//! A map is a kind of associative container that supports unique keys (contains at
+//! most one of each key value) and provides for fast retrieval of values of another
 //! type T based on the keys. The map class supports bidirectional iterators.
-//! 
-//! A map satisfies all of the requirements of a container and of a reversible 
-//! container and of an associative container. For a 
+//!
+//! A map satisfies all of the requirements of a container and of a reversible
+//! container and of an associative container. For a
 //! map<Key,T> the key_type is Key and the value_type is std::pair<const Key,T>.
 //!
 //! Pred is the ordering function for Keys (e.g. <i>std::less<Key></i>).
@@ -72,15 +72,15 @@
 #else
 template <class Key, class T, class Pred, class A>
 #endif
-class map 
+class map
 {
    /// @cond
    private:
    BOOST_COPYABLE_AND_MOVABLE(map)
-   typedef container_detail::rbtree<Key, 
-                           std::pair<const Key, T>, 
-                           container_detail::select1st< std::pair<const Key, T> >, 
-                           Pred, 
+   typedef container_detail::rbtree<Key,
+                           std::pair<const Key, T>,
+                           container_detail::select1st< std::pair<const Key, T> >,
+                           Pred,
                            A> tree_t;
    tree_t m_tree;  // red-black tree representing map
 
@@ -112,7 +112,7 @@
    /// @cond
    class value_compare_impl
       :  public Pred,
-         public std::binary_function<value_type, value_type, bool> 
+         public std::binary_function<value_type, value_type, bool>
    {
       friend class map<Key,T,Pred,A>;
     protected :
@@ -126,7 +126,7 @@
    typedef value_compare_impl             value_compare;
 
    //! <b>Effects</b>: Default constructs an empty map.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    map()
       : m_tree()
@@ -135,9 +135,9 @@
       BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename A::value_type>::value));
    }
 
-   //! <b>Effects</b>: Constructs an empty map using the specified comparison object 
+   //! <b>Effects</b>: Constructs an empty map using the specified comparison object
    //! and allocator.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    explicit map(const Pred& comp,
                 const allocator_type& a = allocator_type())
@@ -147,41 +147,41 @@
       BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename A::value_type>::value));
    }
 
-   //! <b>Effects</b>: Constructs an empty map using the specified comparison object and 
+   //! <b>Effects</b>: Constructs an empty map using the specified comparison object and
    //! allocator, and inserts elements from the range [first ,last ).
-   //! 
-   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using 
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
    //! comp and otherwise N logN, where N is last - first.
    template <class InputIterator>
    map(InputIterator first, InputIterator last, const Pred& comp = Pred(),
          const allocator_type& a = allocator_type())
-      : m_tree(first, last, comp, a, true) 
+      : m_tree(first, last, comp, a, true)
    {
       //Allocator type must be std::pair<CONST Key, T>
       BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename A::value_type>::value));
    }
 
-   //! <b>Effects</b>: Constructs an empty map using the specified comparison object and 
+   //! <b>Effects</b>: Constructs an empty map using the specified comparison object and
    //! allocator, and inserts elements from the ordered unique range [first ,last). This function
    //! is more efficient than the normal range creation for ordered ranges.
    //!
    //! <b>Requires</b>: [first ,last) must be ordered according to the predicate and must be
    //! unique values.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear in N.
    template <class InputIterator>
    map( ordered_unique_range_t, InputIterator first, InputIterator last
       , const Pred& comp = Pred(), const allocator_type& a = allocator_type())
-      : m_tree(ordered_range, first, last, comp, a) 
+      : m_tree(ordered_range, first, last, comp, a)
    {
       //Allocator type must be std::pair<CONST Key, T>
       BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename A::value_type>::value));
    }
 
    //! <b>Effects</b>: Copy constructs a map.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear in x.size().
-   map(const map& x) 
+   map(const map& x)
       : m_tree(x.m_tree)
    {
       //Allocator type must be std::pair<CONST Key, T>
@@ -189,11 +189,11 @@
    }
 
    //! <b>Effects</b>: Move constructs a map. Constructs *this using x's resources.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   //! 
+   //!
    //! <b>Postcondition</b>: x is emptied.
-   map(BOOST_RV_REF(map) x) 
+   map(BOOST_RV_REF(map) x)
       : m_tree(boost::move(x.m_tree))
    {
       //Allocator type must be std::pair<CONST Key, T>
@@ -201,9 +201,9 @@
    }
 
    //! <b>Effects</b>: Copy constructs a map using the specified allocator.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear in x.size().
-   map(const map& x, const allocator_type &a) 
+   map(const map& x, const allocator_type &a)
       : m_tree(x.m_tree, a)
    {
       //Allocator type must be std::pair<CONST Key, T>
@@ -214,9 +214,9 @@
    //!                 Constructs *this using x's resources.
    //!
    //! <b>Complexity</b>: Constant if x == x.get_allocator(), linear otherwise.
-   //! 
+   //!
    //! <b>Postcondition</b>: x is emptied.
-   map(BOOST_RV_REF(map) x, const allocator_type &a) 
+   map(BOOST_RV_REF(map) x, const allocator_type &a)
       : m_tree(boost::move(x.m_tree), a)
    {
       //Allocator type must be std::pair<CONST Key, T>
@@ -224,184 +224,184 @@
    }
 
    //! <b>Effects</b>: Makes *this a copy of x.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear in x.size().
    map& operator=(BOOST_COPY_ASSIGN_REF(map) x)
    {  m_tree = x.m_tree;   return *this;  }
 
    //! <b>Effects</b>: this->swap(x.get()).
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    map& operator=(BOOST_RV_REF(map) x)
    {  m_tree = boost::move(x.m_tree);   return *this;  }
 
    //! <b>Effects</b>: Returns the comparison object out
    //!   of which a was constructed.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   key_compare key_comp() const 
+   key_compare key_comp() const
    { return m_tree.key_comp(); }
 
    //! <b>Effects</b>: Returns an object of value_compare constructed out
    //!   of the comparison object.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   value_compare value_comp() const 
+   value_compare value_comp() const
    { return value_compare(m_tree.key_comp()); }
 
    //! <b>Effects</b>: Returns a copy of the Allocator that
    //!   was passed to the object's constructor.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   allocator_type get_allocator() const 
+   allocator_type get_allocator() const
    { return m_tree.get_allocator(); }
 
-   const stored_allocator_type &get_stored_allocator() const 
+   const stored_allocator_type &get_stored_allocator() const
    { return m_tree.get_stored_allocator(); }
 
    stored_allocator_type &get_stored_allocator()
    { return m_tree.get_stored_allocator(); }
 
    //! <b>Effects</b>: Returns an iterator to the first element contained in the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   iterator begin() 
+   iterator begin()
    { return m_tree.begin(); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_iterator begin() const 
+   const_iterator begin() const
    { return this->cbegin(); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_iterator cbegin() const 
+   const_iterator cbegin() const
    { return m_tree.begin(); }
 
    //! <b>Effects</b>: Returns an iterator to the end of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   iterator end() 
+   iterator end()
    { return m_tree.end(); }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_iterator end() const 
+   const_iterator end() const
    { return this->cend(); }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_iterator cend() const 
+   const_iterator cend() const
    { return m_tree.end(); }
 
-   //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning 
-   //! of the reversed container. 
-   //! 
+   //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   reverse_iterator rbegin() 
+   reverse_iterator rbegin()
    { return m_tree.rbegin(); }
 
-   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning 
-   //! of the reversed container. 
-   //! 
+   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator rbegin() const 
+   const_reverse_iterator rbegin() const
    { return this->crbegin(); }
 
-   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning 
-   //! of the reversed container. 
-   //! 
+   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator crbegin() const 
+   const_reverse_iterator crbegin() const
    { return m_tree.rbegin(); }
 
    //! <b>Effects</b>: Returns a reverse_iterator pointing to the end
-   //! of the reversed container. 
-   //! 
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   reverse_iterator rend() 
+   reverse_iterator rend()
    { return m_tree.rend(); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
-   //! of the reversed container. 
-   //! 
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator rend() const 
+   const_reverse_iterator rend() const
    { return this->crend(); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
-   //! of the reversed container. 
-   //! 
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator crend() const 
+   const_reverse_iterator crend() const
    { return m_tree.rend(); }
 
    //! <b>Effects</b>: Returns true if the container contains no elements.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   bool empty() const 
+   bool empty() const
    { return m_tree.empty(); }
 
    //! <b>Effects</b>: Returns the number of the elements contained in the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   size_type size() const 
+   size_type size() const
    { return m_tree.size(); }
 
    //! <b>Effects</b>: Returns the largest possible size of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   size_type max_size() const 
+   size_type max_size() const
    { return m_tree.max_size(); }
 
    #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-   //! Effects: If there is no key equivalent to x in the map, inserts 
+   //! Effects: If there is no key equivalent to x in the map, inserts
    //! value_type(x, T()) into the map.
-   //! 
+   //!
    //! Returns: A reference to the mapped_type corresponding to x in *this.
-   //! 
+   //!
    //! Complexity: Logarithmic.
    mapped_type& operator[](const key_type &k);
 
-   //! Effects: If there is no key equivalent to x in the map, inserts 
+   //! Effects: If there is no key equivalent to x in the map, inserts
    //! value_type(boost::move(x), T()) into the map (the key is move-constructed)
-   //! 
+   //!
    //! Returns: A reference to the mapped_type corresponding to x in *this.
-   //! 
+   //!
    //! Complexity: Logarithmic.
    mapped_type& operator[](key_type &&k);
    #else
@@ -440,62 +440,62 @@
    void swap(map& x)
    { m_tree.swap(x.m_tree); }
 
-   //! <b>Effects</b>: Inserts x if and only if there is no element in the container 
+   //! <b>Effects</b>: Inserts x if and only if there is no element in the container
    //!   with key equivalent to the key of x.
    //!
-   //! <b>Returns</b>: The bool component of the returned pair is true if and only 
+   //! <b>Returns</b>: The bool component of the returned pair is true if and only
    //!   if the insertion takes place, and the iterator component of the pair
    //!   points to the element with key equivalent to the key of x.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   std::pair<iterator,bool> insert(const value_type& x) 
+   std::pair<iterator,bool> insert(const value_type& x)
    { return m_tree.insert_unique(x); }
 
-   //! <b>Effects</b>: Inserts a new value_type created from the pair if and only if 
+   //! <b>Effects</b>: Inserts a new value_type created from the pair if and only if
    //! there is no element in the container  with key equivalent to the key of x.
    //!
-   //! <b>Returns</b>: The bool component of the returned pair is true if and only 
+   //! <b>Returns</b>: The bool component of the returned pair is true if and only
    //!   if the insertion takes place, and the iterator component of the pair
    //!   points to the element with key equivalent to the key of x.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   std::pair<iterator,bool> insert(const nonconst_value_type& x) 
+   std::pair<iterator,bool> insert(const nonconst_value_type& x)
    { return m_tree.insert_unique(x); }
 
    //! <b>Effects</b>: Inserts a new value_type move constructed from the pair if and
    //! only if there is no element in the container with key equivalent to the key of x.
    //!
-   //! <b>Returns</b>: The bool component of the returned pair is true if and only 
+   //! <b>Returns</b>: The bool component of the returned pair is true if and only
    //!   if the insertion takes place, and the iterator component of the pair
    //!   points to the element with key equivalent to the key of x.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   std::pair<iterator,bool> insert(BOOST_RV_REF(nonconst_value_type) x) 
+   std::pair<iterator,bool> insert(BOOST_RV_REF(nonconst_value_type) x)
    { return m_tree.insert_unique(boost::move(x)); }
 
    //! <b>Effects</b>: Inserts a new value_type move constructed from the pair if and
    //! only if there is no element in the container with key equivalent to the key of x.
    //!
-   //! <b>Returns</b>: The bool component of the returned pair is true if and only 
+   //! <b>Returns</b>: The bool component of the returned pair is true if and only
    //!   if the insertion takes place, and the iterator component of the pair
    //!   points to the element with key equivalent to the key of x.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   std::pair<iterator,bool> insert(BOOST_RV_REF(nonconst_impl_value_type) x) 
+   std::pair<iterator,bool> insert(BOOST_RV_REF(nonconst_impl_value_type) x)
    { return m_tree.insert_unique(boost::move(x)); }
 
-   //! <b>Effects</b>: Move constructs a new value from x if and only if there is 
+   //! <b>Effects</b>: Move constructs a new value from x if and only if there is
    //!   no element in the container with key equivalent to the key of x.
    //!
-   //! <b>Returns</b>: The bool component of the returned pair is true if and only 
+   //! <b>Returns</b>: The bool component of the returned pair is true if and only
    //!   if the insertion takes place, and the iterator component of the pair
    //!   points to the element with key equivalent to the key of x.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   std::pair<iterator,bool> insert(BOOST_RV_REF(value_type) x) 
+   std::pair<iterator,bool> insert(BOOST_RV_REF(value_type) x)
    { return m_tree.insert_unique(boost::move(x)); }
 
-   //! <b>Effects</b>: Inserts a copy of x in the container if and only if there is 
+   //! <b>Effects</b>: Inserts a copy of x in the container if and only if there is
    //!   no element in the container with key equivalent to the key of x.
    //!   p is a hint pointing to where the insert should start to search.
    //!
@@ -507,7 +507,7 @@
    iterator insert(iterator position, const value_type& x)
    { return m_tree.insert_unique(position, x); }
 
-   //! <b>Effects</b>: Move constructs a new value from x if and only if there is 
+   //! <b>Effects</b>: Move constructs a new value from x if and only if there is
    //!   no element in the container with key equivalent to the key of x.
    //!   p is a hint pointing to where the insert should start to search.
    //!
@@ -519,7 +519,7 @@
    iterator insert(iterator position, BOOST_RV_REF(nonconst_value_type) x)
    { return m_tree.insert_unique(position, boost::move(x)); }
 
-   //! <b>Effects</b>: Move constructs a new value from x if and only if there is 
+   //! <b>Effects</b>: Move constructs a new value from x if and only if there is
    //!   no element in the container with key equivalent to the key of x.
    //!   p is a hint pointing to where the insert should start to search.
    //!
@@ -551,22 +551,22 @@
 
    //! <b>Requires</b>: first, last are not iterators into *this.
    //!
-   //! <b>Effects</b>: inserts each element from the range [first,last) if and only 
+   //! <b>Effects</b>: inserts each element from the range [first,last) if and only
    //!   if there is no element with key equivalent to the key of that element.
    //!
    //! <b>Complexity</b>: At most N log(size()+N) (N is the distance from first to last)
    template <class InputIterator>
-   void insert(InputIterator first, InputIterator last) 
+   void insert(InputIterator first, InputIterator last)
    {  m_tree.insert_unique(first, last);  }
 
    #if defined(BOOST_CONTAINER_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
    //! <b>Effects</b>: Inserts an object x of type T constructed with
-   //!   std::forward<Args>(args)... in the container if and only if there is 
+   //!   std::forward<Args>(args)... in the container if and only if there is
    //!   no element in the container with an equivalent key.
    //!   p is a hint pointing to where the insert should start to search.
    //!
-   //! <b>Returns</b>: The bool component of the returned pair is true if and only 
+   //! <b>Returns</b>: The bool component of the returned pair is true if and only
    //!   if the insertion takes place, and the iterator component of the pair
    //!   points to the element with key equivalent to the key of x.
    //!
@@ -577,7 +577,7 @@
    {  return m_tree.emplace_unique(boost::forward<Args>(args)...); }
 
    //! <b>Effects</b>: Inserts an object of type T constructed with
-   //!   std::forward<Args>(args)... in the container if and only if there is 
+   //!   std::forward<Args>(args)... in the container if and only if there is
    //!   no element in the container with an equivalent key.
    //!   p is a hint pointing to where the insert should start to search.
    //!
@@ -611,11 +611,11 @@
    //! <b>Effects</b>: Erases the element pointed to by position.
    //!
    //! <b>Returns</b>: Returns an iterator pointing to the element immediately
-   //!   following q prior to the element being erased. If no such element exists, 
+   //!   following q prior to the element being erased. If no such element exists,
    //!   returns end().
    //!
    //! <b>Complexity</b>: Amortized constant time
-   iterator erase(const_iterator position) 
+   iterator erase(const_iterator position)
    { return m_tree.erase(position); }
 
    //! <b>Effects</b>: Erases all elements in the container with key equivalent to x.
@@ -623,7 +623,7 @@
    //! <b>Returns</b>: Returns the number of erased elements.
    //!
    //! <b>Complexity</b>: log(size()) + count(k)
-   size_type erase(const key_type& x) 
+   size_type erase(const key_type& x)
    { return m_tree.erase(x); }
 
    //! <b>Effects</b>: Erases all the elements in the range [first, last).
@@ -639,67 +639,67 @@
    //! <b>Postcondition</b>: size() == 0.
    //!
    //! <b>Complexity</b>: linear in size().
-   void clear() 
+   void clear()
    { m_tree.clear(); }
 
    //! <b>Returns</b>: An iterator pointing to an element with the key
    //!   equivalent to x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   iterator find(const key_type& x) 
+   iterator find(const key_type& x)
    { return m_tree.find(x); }
 
    //! <b>Returns</b>: A const_iterator pointing to an element with the key
    //!   equivalent to x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   const_iterator find(const key_type& x) const 
+   const_iterator find(const key_type& x) const
    { return m_tree.find(x); }
 
    //! <b>Returns</b>: The number of elements with key equivalent to x.
    //!
    //! <b>Complexity</b>: log(size())+count(k)
-   size_type count(const key_type& x) const 
+   size_type count(const key_type& x) const
    {  return m_tree.find(x) == m_tree.end() ? 0 : 1;  }
 
    //! <b>Returns</b>: An iterator pointing to the first element with key not less
    //!   than k, or a.end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic
-   iterator lower_bound(const key_type& x) 
+   iterator lower_bound(const key_type& x)
    {  return m_tree.lower_bound(x); }
 
    //! <b>Returns</b>: A const iterator pointing to the first element with key not
    //!   less than k, or a.end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic
-   const_iterator lower_bound(const key_type& x) const 
+   const_iterator lower_bound(const key_type& x) const
    {  return m_tree.lower_bound(x); }
 
    //! <b>Returns</b>: An iterator pointing to the first element with key not less
    //!   than x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic
-   iterator upper_bound(const key_type& x) 
+   iterator upper_bound(const key_type& x)
    {  return m_tree.upper_bound(x); }
 
    //! <b>Returns</b>: A const iterator pointing to the first element with key not
    //!   less than x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic
-   const_iterator upper_bound(const key_type& x) const 
+   const_iterator upper_bound(const key_type& x) const
    {  return m_tree.upper_bound(x); }
 
    //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
    //!
    //! <b>Complexity</b>: Logarithmic
-   std::pair<iterator,iterator> equal_range(const key_type& x) 
+   std::pair<iterator,iterator> equal_range(const key_type& x)
    {  return m_tree.equal_range(x); }
 
    //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
    //!
    //! <b>Complexity</b>: Logarithmic
-   std::pair<const_iterator,const_iterator> equal_range(const key_type& x) const 
+   std::pair<const_iterator,const_iterator> equal_range(const key_type& x) const
    {  return m_tree.equal_range(x); }
 
    /// @cond
@@ -723,7 +723,7 @@
       return (*i).second;
    }
 
-   mapped_type& priv_subscript(BOOST_RV_REF(key_type) mk) 
+   mapped_type& priv_subscript(BOOST_RV_REF(key_type) mk)
    {
       key_type &k = mk;
       //we can optimize this
@@ -741,37 +741,37 @@
 };
 
 template <class Key, class T, class Pred, class A>
-inline bool operator==(const map<Key,T,Pred,A>& x, 
-                       const map<Key,T,Pred,A>& y) 
+inline bool operator==(const map<Key,T,Pred,A>& x,
+                       const map<Key,T,Pred,A>& y)
    {  return x.m_tree == y.m_tree;  }
 
 template <class Key, class T, class Pred, class A>
-inline bool operator<(const map<Key,T,Pred,A>& x, 
-                      const map<Key,T,Pred,A>& y) 
+inline bool operator<(const map<Key,T,Pred,A>& x,
+                      const map<Key,T,Pred,A>& y)
    {  return x.m_tree < y.m_tree;   }
 
 template <class Key, class T, class Pred, class A>
-inline bool operator!=(const map<Key,T,Pred,A>& x, 
-                       const map<Key,T,Pred,A>& y) 
+inline bool operator!=(const map<Key,T,Pred,A>& x,
+                       const map<Key,T,Pred,A>& y)
    {  return !(x == y); }
 
 template <class Key, class T, class Pred, class A>
-inline bool operator>(const map<Key,T,Pred,A>& x, 
-                      const map<Key,T,Pred,A>& y) 
+inline bool operator>(const map<Key,T,Pred,A>& x,
+                      const map<Key,T,Pred,A>& y)
    {  return y < x;  }
 
 template <class Key, class T, class Pred, class A>
-inline bool operator<=(const map<Key,T,Pred,A>& x, 
-                       const map<Key,T,Pred,A>& y) 
+inline bool operator<=(const map<Key,T,Pred,A>& x,
+                       const map<Key,T,Pred,A>& y)
    {  return !(y < x);  }
 
 template <class Key, class T, class Pred, class A>
-inline bool operator>=(const map<Key,T,Pred,A>& x, 
-                       const map<Key,T,Pred,A>& y) 
+inline bool operator>=(const map<Key,T,Pred,A>& x,
+                       const map<Key,T,Pred,A>& y)
    {  return !(x < y);  }
 
 template <class Key, class T, class Pred, class A>
-inline void swap(map<Key,T,Pred,A>& x, map<Key,T,Pred,A>& y) 
+inline void swap(map<Key,T,Pred,A>& x, map<Key,T,Pred,A>& y)
    {  x.swap(y);  }
 
 /// @cond
@@ -779,11 +779,11 @@
 // Forward declaration of operators < and ==, needed for friend declaration.
 
 template <class Key, class T, class Pred, class A>
-inline bool operator==(const multimap<Key,T,Pred,A>& x, 
+inline bool operator==(const multimap<Key,T,Pred,A>& x,
                        const multimap<Key,T,Pred,A>& y);
 
 template <class Key, class T, class Pred, class A>
-inline bool operator<(const multimap<Key,T,Pred,A>& x, 
+inline bool operator<(const multimap<Key,T,Pred,A>& x,
                       const multimap<Key,T,Pred,A>& y);
 
 }  //namespace container {
@@ -800,14 +800,14 @@
 
 /// @endcond
 
-//! A multimap is a kind of associative container that supports equivalent keys 
-//! (possibly containing multiple copies of the same key value) and provides for 
+//! A multimap is a kind of associative container that supports equivalent keys
+//! (possibly containing multiple copies of the same key value) and provides for
 //! fast retrieval of values of another type T based on the keys. The multimap class
 //! supports bidirectional iterators.
-//! 
-//! A multimap satisfies all of the requirements of a container and of a reversible 
-//! container and of an associative container. For a 
-//! map<Key,T> the key_type is Key and the value_type is std::pair<const Key,T>. 
+//!
+//! A multimap satisfies all of the requirements of a container and of a reversible
+//! container and of an associative container. For a
+//! map<Key,T> the key_type is Key and the value_type is std::pair<const Key,T>.
 //!
 //! Pred is the ordering function for Keys (e.g. <i>std::less<Key></i>).
 //!
@@ -818,15 +818,15 @@
 #else
 template <class Key, class T, class Pred, class A>
 #endif
-class multimap 
+class multimap
 {
    /// @cond
    private:
    BOOST_COPYABLE_AND_MOVABLE(multimap)
-   typedef container_detail::rbtree<Key, 
-                           std::pair<const Key, T>, 
-                           container_detail::select1st< std::pair<const Key, T> >, 
-                           Pred, 
+   typedef container_detail::rbtree<Key,
+                           std::pair<const Key, T>,
+                           container_detail::select1st< std::pair<const Key, T> >,
+                           Pred,
                            A> tree_t;
    tree_t m_tree;  // red-black tree representing map
    typedef typename container_detail::
@@ -859,7 +859,7 @@
    /// @cond
    class value_compare_impl
       :  public Pred,
-         public std::binary_function<value_type, value_type, bool> 
+         public std::binary_function<value_type, value_type, bool>
    {
       friend class multimap<Key,T,Pred,A>;
     protected :
@@ -873,7 +873,7 @@
    typedef value_compare_impl                      value_compare;
 
    //! <b>Effects</b>: Default constructs an empty multimap.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    multimap()
       : m_tree()
@@ -884,7 +884,7 @@
 
    //! <b>Effects</b>: Constructs an empty multimap using the specified comparison
    //!   object and allocator.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    explicit multimap(const Pred& comp, const allocator_type& a = allocator_type())
       : m_tree(comp, a)
@@ -895,36 +895,36 @@
 
    //! <b>Effects</b>: Constructs an empty multimap using the specified comparison object
    //!   and allocator, and inserts elements from the range [first ,last ).
-   //! 
-   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using 
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
    //! comp and otherwise N logN, where N is last - first.
    template <class InputIterator>
    multimap(InputIterator first, InputIterator last,
             const Pred& comp = Pred(),
             const allocator_type& a = allocator_type())
-      : m_tree(first, last, comp, a, false) 
+      : m_tree(first, last, comp, a, false)
    {
       //Allocator type must be std::pair<CONST Key, T>
       BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename A::value_type>::value));
    }
 
-   //! <b>Effects</b>: Constructs an empty multimap using the specified comparison object and 
+   //! <b>Effects</b>: Constructs an empty multimap using the specified comparison object and
    //! allocator, and inserts elements from the ordered range [first ,last). This function
    //! is more efficient than the normal range creation for ordered ranges.
    //!
    //! <b>Requires</b>: [first ,last) must be ordered according to the predicate.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear in N.
    template <class InputIterator>
    multimap(ordered_range_t ordered_range, InputIterator first, InputIterator last, const Pred& comp = Pred(),
          const allocator_type& a = allocator_type())
-      : m_tree(ordered_range, first, last, comp, a) 
+      : m_tree(ordered_range, first, last, comp, a)
    {}
 
    //! <b>Effects</b>: Copy constructs a multimap.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear in x.size().
-   multimap(const multimap& x) 
+   multimap(const multimap& x)
       : m_tree(x.m_tree)
    {
       //Allocator type must be std::pair<CONST Key, T>
@@ -932,11 +932,11 @@
    }
 
    //! <b>Effects</b>: Move constructs a multimap. Constructs *this using x's resources.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   //! 
+   //!
    //! <b>Postcondition</b>: x is emptied.
-   multimap(BOOST_RV_REF(multimap) x) 
+   multimap(BOOST_RV_REF(multimap) x)
       : m_tree(boost::move(x.m_tree))
    {
       //Allocator type must be std::pair<CONST Key, T>
@@ -944,9 +944,9 @@
    }
 
    //! <b>Effects</b>: Copy constructs a multimap.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear in x.size().
-   multimap(const multimap& x, const allocator_type &a) 
+   multimap(const multimap& x, const allocator_type &a)
       : m_tree(x.m_tree, a)
    {
       //Allocator type must be std::pair<CONST Key, T>
@@ -956,7 +956,7 @@
    //! <b>Effects</b>: Move constructs a multimap using the specified allocator.
    //!                 Constructs *this using x's resources.
    //! <b>Complexity</b>: Constant if a == x.get_allocator(), linear otherwise.
-   //! 
+   //!
    //! <b>Postcondition</b>: x is emptied.
    multimap(BOOST_RV_REF(multimap) x, const allocator_type &a)
       : m_tree(boost::move(x.m_tree), a)
@@ -966,168 +966,168 @@
    }
 
    //! <b>Effects</b>: Makes *this a copy of x.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear in x.size().
-   multimap& operator=(BOOST_COPY_ASSIGN_REF(multimap) x) 
+   multimap& operator=(BOOST_COPY_ASSIGN_REF(multimap) x)
    {  m_tree = x.m_tree;   return *this;  }
 
    //! <b>Effects</b>: this->swap(x.get()).
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   multimap& operator=(BOOST_RV_REF(multimap) x) 
+   multimap& operator=(BOOST_RV_REF(multimap) x)
    {  m_tree = boost::move(x.m_tree);   return *this;  }
 
    //! <b>Effects</b>: Returns the comparison object out
    //!   of which a was constructed.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   key_compare key_comp() const 
+   key_compare key_comp() const
    { return m_tree.key_comp(); }
 
    //! <b>Effects</b>: Returns an object of value_compare constructed out
    //!   of the comparison object.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   value_compare value_comp() const 
+   value_compare value_comp() const
    { return value_compare(m_tree.key_comp()); }
 
    //! <b>Effects</b>: Returns a copy of the Allocator that
    //!   was passed to the object's constructor.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   allocator_type get_allocator() const 
+   allocator_type get_allocator() const
    { return m_tree.get_allocator(); }
 
-   const stored_allocator_type &get_stored_allocator() const 
+   const stored_allocator_type &get_stored_allocator() const
    { return m_tree.get_stored_allocator(); }
 
    stored_allocator_type &get_stored_allocator()
    { return m_tree.get_stored_allocator(); }
 
    //! <b>Effects</b>: Returns an iterator to the first element contained in the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   iterator begin() 
+   iterator begin()
    { return m_tree.begin(); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_iterator begin() const 
+   const_iterator begin() const
    { return this->cbegin(); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_iterator cbegin() const 
+   const_iterator cbegin() const
    { return m_tree.begin(); }
 
    //! <b>Effects</b>: Returns an iterator to the end of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   iterator end() 
+   iterator end()
    { return m_tree.end(); }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_iterator end() const 
+   const_iterator end() const
    { return this->cend(); }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_iterator cend() const 
+   const_iterator cend() const
    { return m_tree.end(); }
 
-   //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning 
-   //! of the reversed container. 
-   //! 
+   //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   reverse_iterator rbegin() 
+   reverse_iterator rbegin()
    { return m_tree.rbegin(); }
 
-   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning 
-   //! of the reversed container. 
-   //! 
+   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator rbegin() const 
+   const_reverse_iterator rbegin() const
    { return this->crbegin(); }
 
-   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning 
-   //! of the reversed container. 
-   //! 
+   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator crbegin() const 
+   const_reverse_iterator crbegin() const
    { return m_tree.rbegin(); }
 
    //! <b>Effects</b>: Returns a reverse_iterator pointing to the end
-   //! of the reversed container. 
-   //! 
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   reverse_iterator rend() 
+   reverse_iterator rend()
    { return m_tree.rend(); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
-   //! of the reversed container. 
-   //! 
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator rend() const 
+   const_reverse_iterator rend() const
    { return this->crend(); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
-   //! of the reversed container. 
-   //! 
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator crend() const 
+   const_reverse_iterator crend() const
    { return m_tree.rend(); }
 
    //! <b>Effects</b>: Returns true if the container contains no elements.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   bool empty() const 
+   bool empty() const
    { return m_tree.empty(); }
 
    //! <b>Effects</b>: Returns the number of the elements contained in the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   size_type size() const 
+   size_type size() const
    { return m_tree.size(); }
 
    //! <b>Effects</b>: Returns the largest possible size of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   size_type max_size() const 
+   size_type max_size() const
    { return m_tree.max_size(); }
 
    //! <b>Effects</b>: Swaps the contents of *this and x.
@@ -1139,31 +1139,31 @@
    { m_tree.swap(x.m_tree); }
 
    //! <b>Effects</b>: Inserts x and returns the iterator pointing to the
-   //!   newly inserted element. 
+   //!   newly inserted element.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   iterator insert(const value_type& x) 
+   iterator insert(const value_type& x)
    { return m_tree.insert_equal(x); }
 
-   //! <b>Effects</b>: Inserts a new value constructed from x and returns 
-   //!   the iterator pointing to the newly inserted element. 
+   //! <b>Effects</b>: Inserts a new value constructed from x and returns
+   //!   the iterator pointing to the newly inserted element.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   iterator insert(const nonconst_value_type& x) 
+   iterator insert(const nonconst_value_type& x)
    { return m_tree.insert_equal(x); }
 
-   //! <b>Effects</b>: Inserts a new value move-constructed from x and returns 
-   //!   the iterator pointing to the newly inserted element. 
+   //! <b>Effects</b>: Inserts a new value move-constructed from x and returns
+   //!   the iterator pointing to the newly inserted element.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   iterator insert(BOOST_RV_REF(nonconst_value_type) x) 
+   iterator insert(BOOST_RV_REF(nonconst_value_type) x)
    { return m_tree.insert_equal(boost::move(x)); }
 
-   //! <b>Effects</b>: Inserts a new value move-constructed from x and returns 
-   //!   the iterator pointing to the newly inserted element. 
+   //! <b>Effects</b>: Inserts a new value move-constructed from x and returns
+   //!   the iterator pointing to the newly inserted element.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   iterator insert(BOOST_RV_REF(nonconst_impl_value_type) x) 
+   iterator insert(BOOST_RV_REF(nonconst_impl_value_type) x)
    { return m_tree.insert_equal(boost::move(x)); }
 
    //! <b>Effects</b>: Inserts a copy of x in the container.
@@ -1216,7 +1216,7 @@
    //!
    //! <b>Complexity</b>: At most N log(size()+N) (N is the distance from first to last)
    template <class InputIterator>
-   void insert(InputIterator first, InputIterator last) 
+   void insert(InputIterator first, InputIterator last)
    {  m_tree.insert_equal(first, last); }
 
    #if defined(BOOST_CONTAINER_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -1268,11 +1268,11 @@
    //! <b>Effects</b>: Erases the element pointed to by position.
    //!
    //! <b>Returns</b>: Returns an iterator pointing to the element immediately
-   //!   following q prior to the element being erased. If no such element exists, 
+   //!   following q prior to the element being erased. If no such element exists,
    //!   returns end().
    //!
    //! <b>Complexity</b>: Amortized constant time
-   iterator erase(const_iterator position) 
+   iterator erase(const_iterator position)
    { return m_tree.erase(position); }
 
    //! <b>Effects</b>: Erases all elements in the container with key equivalent to x.
@@ -1280,7 +1280,7 @@
    //! <b>Returns</b>: Returns the number of erased elements.
    //!
    //! <b>Complexity</b>: log(size()) + count(k)
-   size_type erase(const key_type& x) 
+   size_type erase(const key_type& x)
    { return m_tree.erase(x); }
 
    //! <b>Effects</b>: Erases all the elements in the range [first, last).
@@ -1296,68 +1296,68 @@
    //! <b>Postcondition</b>: size() == 0.
    //!
    //! <b>Complexity</b>: linear in size().
-   void clear() 
+   void clear()
    { m_tree.clear(); }
 
    //! <b>Returns</b>: An iterator pointing to an element with the key
    //!   equivalent to x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   iterator find(const key_type& x) 
+   iterator find(const key_type& x)
    { return m_tree.find(x); }
 
    //! <b>Returns</b>: A const iterator pointing to an element with the key
    //!   equivalent to x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   const_iterator find(const key_type& x) const 
+   const_iterator find(const key_type& x) const
    { return m_tree.find(x); }
 
    //! <b>Returns</b>: The number of elements with key equivalent to x.
    //!
    //! <b>Complexity</b>: log(size())+count(k)
-   size_type count(const key_type& x) const 
+   size_type count(const key_type& x) const
    { return m_tree.count(x); }
 
    //! <b>Returns</b>: An iterator pointing to the first element with key not less
    //!   than k, or a.end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic
-   iterator lower_bound(const key_type& x) 
+   iterator lower_bound(const key_type& x)
    {return m_tree.lower_bound(x); }
 
    //! <b>Returns</b>: A const iterator pointing to the first element with key not
    //!   less than k, or a.end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic
-   const_iterator lower_bound(const key_type& x) const 
+   const_iterator lower_bound(const key_type& x) const
    {  return m_tree.lower_bound(x);  }
 
    //! <b>Returns</b>: An iterator pointing to the first element with key not less
    //!   than x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic
-   iterator upper_bound(const key_type& x) 
+   iterator upper_bound(const key_type& x)
    {  return m_tree.upper_bound(x); }
 
    //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
    //!
    //! <b>Complexity</b>: Logarithmic
-   std::pair<iterator,iterator> equal_range(const key_type& x) 
+   std::pair<iterator,iterator> equal_range(const key_type& x)
    {  return m_tree.equal_range(x);   }
 
    //! <b>Returns</b>: A const iterator pointing to the first element with key not
    //!   less than x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic
-   const_iterator upper_bound(const key_type& x) const 
+   const_iterator upper_bound(const key_type& x) const
    {  return m_tree.upper_bound(x); }
 
    //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
    //!
    //! <b>Complexity</b>: Logarithmic
-   std::pair<const_iterator,const_iterator> 
-      equal_range(const key_type& x) const 
+   std::pair<const_iterator,const_iterator>
+      equal_range(const key_type& x) const
    {  return m_tree.equal_range(x);   }
 
    /// @cond
@@ -1372,37 +1372,37 @@
 };
 
 template <class Key, class T, class Pred, class A>
-inline bool operator==(const multimap<Key,T,Pred,A>& x, 
-                       const multimap<Key,T,Pred,A>& y) 
+inline bool operator==(const multimap<Key,T,Pred,A>& x,
+                       const multimap<Key,T,Pred,A>& y)
 {  return x.m_tree == y.m_tree;  }
 
 template <class Key, class T, class Pred, class A>
-inline bool operator<(const multimap<Key,T,Pred,A>& x, 
-                      const multimap<Key,T,Pred,A>& y) 
+inline bool operator<(const multimap<Key,T,Pred,A>& x,
+                      const multimap<Key,T,Pred,A>& y)
 {  return x.m_tree < y.m_tree;   }
 
 template <class Key, class T, class Pred, class A>
-inline bool operator!=(const multimap<Key,T,Pred,A>& x, 
-                       const multimap<Key,T,Pred,A>& y) 
+inline bool operator!=(const multimap<Key,T,Pred,A>& x,
+                       const multimap<Key,T,Pred,A>& y)
 {  return !(x == y);  }
 
 template <class Key, class T, class Pred, class A>
-inline bool operator>(const multimap<Key,T,Pred,A>& x, 
-                      const multimap<Key,T,Pred,A>& y) 
+inline bool operator>(const multimap<Key,T,Pred,A>& x,
+                      const multimap<Key,T,Pred,A>& y)
 {  return y < x;  }
 
 template <class Key, class T, class Pred, class A>
-inline bool operator<=(const multimap<Key,T,Pred,A>& x, 
-                       const multimap<Key,T,Pred,A>& y) 
+inline bool operator<=(const multimap<Key,T,Pred,A>& x,
+                       const multimap<Key,T,Pred,A>& y)
 {  return !(y < x);  }
 
 template <class Key, class T, class Pred, class A>
-inline bool operator>=(const multimap<Key,T,Pred,A>& x, 
-                       const multimap<Key,T,Pred,A>& y) 
+inline bool operator>=(const multimap<Key,T,Pred,A>& x,
+                       const multimap<Key,T,Pred,A>& y)
 {  return !(x < y);  }
 
 template <class Key, class T, class Pred, class A>
-inline void swap(multimap<Key,T,Pred,A>& x, multimap<Key,T,Pred,A>& y) 
+inline void swap(multimap<Key,T,Pred,A>& x, multimap<Key,T,Pred,A>& y)
 {  x.swap(y);  }
 
 /// @cond

Modified: branches/release/boost/container/scoped_allocator.hpp
==============================================================================
--- branches/release/boost/container/scoped_allocator.hpp	(original)
+++ branches/release/boost/container/scoped_allocator.hpp	2012-05-24 12:36:39 EDT (Thu, 24 May 2012)
@@ -75,36 +75,36 @@
 //!
 static const allocator_arg_t allocator_arg = allocator_arg_t();
 
-//! <b>Remark</b>: if a specialization is derived from true_type, indicates that T may be constructed 
-//! with an allocator as its last constructor argument.  Ideally, all constructors of T (including the 
-//! copy and move constructors) should have a variant that accepts a final argument of 
-//! allocator_type. 
+//! <b>Remark</b>: if a specialization is derived from true_type, indicates that T may be constructed
+//! with an allocator as its last constructor argument.  Ideally, all constructors of T (including the
+//! copy and move constructors) should have a variant that accepts a final argument of
+//! allocator_type.
 //!
-//! <b>Requires</b>: if a specialization is derived from true_type, T must have a nested type, 
-//! allocator_type and at least one constructor for which allocator_type is the last 
-//! parameter.  If not all constructors of T can be called with a final allocator_type argument, 
-//! and if T is used in a context where a container must call such a constructor, then the program is 
-//! ill-formed. 
+//! <b>Requires</b>: if a specialization is derived from true_type, T must have a nested type,
+//! allocator_type and at least one constructor for which allocator_type is the last
+//! parameter.  If not all constructors of T can be called with a final allocator_type argument,
+//! and if T is used in a context where a container must call such a constructor, then the program is
+//! ill-formed.
 //!
-//! [Example: 
-//!  template <class T, class A = allocator<T> >   
-//!  class Z { 
-//!    public: 
-//!      typedef A allocator_type; 
+//! [Example:
+//!  template <class T, class A = allocator<T> >  
+//!  class Z {
+//!    public:
+//!      typedef A allocator_type;
 //!
-//!    // Default constructor with optional allocator suffix 
-//!    Z(const allocator_type& a = allocator_type()); 
+//!    // Default constructor with optional allocator suffix
+//!    Z(const allocator_type& a = allocator_type());
 //!
-//!    // Copy constructor and allocator-extended copy constructor 
-//!    Z(const Z& zz); 
-//!    Z(const Z& zz, const allocator_type& a); 
-//! }; 
+//!    // Copy constructor and allocator-extended copy constructor
+//!    Z(const Z& zz);
+//!    Z(const Z& zz, const allocator_type& a);
+//! };
 //!
-//! // Specialize trait for class template Z 
-//! template <class T, class A = allocator<T> > 
-//! struct constructible_with_allocator_suffix<Z<T,A> >  
+//! // Specialize trait for class template Z
+//! template <class T, class A = allocator<T> >
+//! struct constructible_with_allocator_suffix<Z<T,A> > 
 //!      : ::boost::true_type { };
-//! -- end example] 
+//! -- end example]
 //!
 //! <b>Note</b>: This trait is a workaround inspired by "N2554: The Scoped Allocator Model (Rev 2)"
 //! (Pablo Halpern, 2008-02-29) to backport the scoped allocator model to C++03, as
@@ -117,44 +117,44 @@
 template <class T>
 struct constructible_with_allocator_suffix
    : ::boost::false_type
-{}; 
+{};
 
-//! <b>Remark</b>: if a specialization is derived from true_type, indicates that T may be constructed 
-//! with allocator_arg and T::allocator_type as its first two constructor arguments.  
-//! Ideally, all constructors of T (including the copy and move constructors) should have a variant 
+//! <b>Remark</b>: if a specialization is derived from true_type, indicates that T may be constructed
+//! with allocator_arg and T::allocator_type as its first two constructor arguments. 
+//! Ideally, all constructors of T (including the copy and move constructors) should have a variant
 //! that accepts these two initial arguments.
 //!
-//! <b>Requires</b>: if a specialization is derived from true_type, T must have a nested type, 
-//! allocator_type and at least one constructor for which allocator_arg_t is the first 
-//! parameter and allocator_type is the second parameter.  If not all constructors of T can be 
-//! called with these initial arguments, and if T is used in a context where a container must call such 
+//! <b>Requires</b>: if a specialization is derived from true_type, T must have a nested type,
+//! allocator_type and at least one constructor for which allocator_arg_t is the first
+//! parameter and allocator_type is the second parameter.  If not all constructors of T can be
+//! called with these initial arguments, and if T is used in a context where a container must call such
 //! a constructor, then the program is ill-formed.
 //!
-//! [Example: 
-//! template <class T, class A = allocator<T> > 
-//! class Y { 
-//!    public: 
-//!       typedef A allocator_type; 
-//!  
-//!       // Default constructor with and allocator-extended default constructor 
-//!       Y(); 
-//!       Y(allocator_arg_t, const allocator_type& a); 
-//!  
-//!       // Copy constructor and allocator-extended copy constructor 
-//!       Y(const Y& yy); 
-//!       Y(allocator_arg_t, const allocator_type& a, const Y& yy); 
-//!  
-//!       // Variadic constructor and allocator-extended variadic constructor 
-//!       template<class ...Args> Y(Args&& args...); 
-//!       template<class ...Args>  
-//!       Y(allocator_arg_t, const allocator_type& a, Args&&... args); 
-//! }; 
-//!  
-//! // Specialize trait for class template Y 
-//! template <class T, class A = allocator<T> > 
-//! struct constructible_with_allocator_prefix<Y<T,A> >  
-//!       : ::boost::true_type { }; 
-//!  
+//! [Example:
+//! template <class T, class A = allocator<T> >
+//! class Y {
+//!    public:
+//!       typedef A allocator_type;
+//! 
+//!       // Default constructor with and allocator-extended default constructor
+//!       Y();
+//!       Y(allocator_arg_t, const allocator_type& a);
+//! 
+//!       // Copy constructor and allocator-extended copy constructor
+//!       Y(const Y& yy);
+//!       Y(allocator_arg_t, const allocator_type& a, const Y& yy);
+//! 
+//!       // Variadic constructor and allocator-extended variadic constructor
+//!       template<class ...Args> Y(Args&& args...);
+//!       template<class ...Args> 
+//!       Y(allocator_arg_t, const allocator_type& a, Args&&... args);
+//! };
+//! 
+//! // Specialize trait for class template Y
+//! template <class T, class A = allocator<T> >
+//! struct constructible_with_allocator_prefix<Y<T,A> > 
+//!       : ::boost::true_type { };
+//! 
 //! -- end example]
 //!
 //! <b>Note</b>: This trait is a workaround inspired by "N2554: The Scoped Allocator Model (Rev 2)"
@@ -166,7 +166,7 @@
 //! (when BOOST_NO_SFINAE_EXPR is NOT defined), this trait is ignored and C++11 rules will be used
 //! to detect if a type should be constructed with suffix or prefix allocator arguments.
 template <class T>
-struct constructible_with_allocator_prefix 
+struct constructible_with_allocator_prefix
     : ::boost::false_type
 {};
 
@@ -201,12 +201,12 @@
 
 ///@endcond
 
-//! <b>Remark</b>: Automatically detects if T has a nested allocator_type that is convertible from 
-//! Alloc. Meets the BinaryTypeTrait requirements ([meta.rqmts] 20.4.1). A program may 
+//! <b>Remark</b>: Automatically detects if T has a nested allocator_type that is convertible from
+//! Alloc. Meets the BinaryTypeTrait requirements ([meta.rqmts] 20.4.1). A program may
 //! specialize this type to derive from true_type for a T of user-defined type if T does not
-//! have a nested allocator_type but is nonetheless constructible using the specified Alloc. 
+//! have a nested allocator_type but is nonetheless constructible using the specified Alloc.
 //!
-//! <b>Result</b>: derived from true_type if Convertible<Alloc,T::allocator_type> and 
+//! <b>Result</b>: derived from true_type if Convertible<Alloc,T::allocator_type> and
 //! derived from false_type otherwise.
 template <typename T, typename Alloc>
 struct uses_allocator
@@ -340,7 +340,7 @@
    //!
 
    //Generate N+1 template parameters so that we can specialize N
-   template<class T 
+   template<class T
             BOOST_PP_ENUM_TRAILING( BOOST_PP_ADD(BOOST_CONTAINER_MAX_IS_CONSTRUCTIBLE_PARAMETERS, 1)
                                  , BOOST_CONTAINER_PP_TEMPLATE_PARAM_WITH_DEFAULT
                                  , void)
@@ -379,7 +379,7 @@
    #include BOOST_PP_LOCAL_ITERATE()
 
    //Finally just inherit from the implementation to define he trait
-   template< class T 
+   template< class T
            BOOST_PP_ENUM_TRAILING( BOOST_CONTAINER_MAX_IS_CONSTRUCTIBLE_PARAMETERS
                                  , BOOST_CONTAINER_PP_TEMPLATE_PARAM_WITH_DEFAULT
                                  , void)
@@ -388,14 +388,14 @@
       : boost::integral_constant
          < bool
          , is_constructible_impl
-            < T 
+            < T
             BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_CONTAINER_MAX_IS_CONSTRUCTIBLE_PARAMETERS, P)
             , void>::value
          >
    {};
 
    //Finally just inherit from the implementation to define he trait
-   template <class T 
+   template <class T
             ,class InnerAlloc
             BOOST_PP_ENUM_TRAILING( BOOST_PP_SUB(BOOST_CONTAINER_MAX_IS_CONSTRUCTIBLE_PARAMETERS, 2)
                                  , BOOST_CONTAINER_PP_TEMPLATE_PARAM_WITH_DEFAULT
@@ -408,7 +408,7 @@
          >
    {};
 /*
-   template <class T 
+   template <class T
             ,class InnerAlloc
             BOOST_PP_ENUM_TRAILING( BOOST_PP_SUB(BOOST_CONTAINER_MAX_IS_CONSTRUCTIBLE_PARAMETERS, 1)
                                  , BOOST_CONTAINER_PP_TEMPLATE_PARAM_WITH_DEFAULT
@@ -443,7 +443,7 @@
 
    #else    // #if !defined(BOOST_NO_VARIADIC_TEMPLATES)
 
-   template < class T 
+   template < class T
             , class InnerAlloc
             BOOST_PP_ENUM_TRAILING( BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS
                                   , BOOST_CONTAINER_PP_TEMPLATE_PARAM_WITH_DEFAULT
@@ -453,7 +453,7 @@
       : constructible_with_allocator_prefix<T>
    {};
 /*
-   template < class T 
+   template < class T
             , class InnerAlloc
             BOOST_PP_ENUM_TRAILING( BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS
                                   , BOOST_CONTAINER_PP_TEMPLATE_PARAM_WITH_DEFAULT
@@ -954,7 +954,7 @@
    scoped_allocator_adaptor_base(internal_type_t, BOOST_FWD_REF(OuterA2) outerAlloc, const inner_allocator_type &)
       : outer_allocator_type(::boost::forward<OuterA2>(outerAlloc))
       {}
-  
+ 
    public:
    scoped_allocator_adaptor_base &operator=(BOOST_COPY_ASSIGN_REF(scoped_allocator_adaptor_base) other)
    {
@@ -991,36 +991,36 @@
    #if !defined(BOOST_CONTAINER_UNIMPLEMENTED_PACK_EXPANSION_TO_FIXED_LIST)
 
    //! This class is a C++03-compatible implementation of std::scoped_allocator_adaptor.
-   //! The class template scoped_allocator_adaptor is an allocator template that specifies 
-   //! the memory resource (the outer allocator) to be used by a container (as any other 
-   //! allocator does) and also specifies an inner allocator resource to be passed to 
+   //! The class template scoped_allocator_adaptor is an allocator template that specifies
+   //! the memory resource (the outer allocator) to be used by a container (as any other
+   //! allocator does) and also specifies an inner allocator resource to be passed to
    //! the constructor of every element within the container.
    //!
-   //! This adaptor is 
-   //! instantiated with one outer and zero or more inner allocator types. If 
-   //! instantiated with only one allocator type, the inner allocator becomes the 
-   //! scoped_allocator_adaptor itself, thus using the same allocator resource for the 
-   //! container and every element within the container and, if the elements themselves 
-   //! are containers, each of their elements recursively. If instantiated with more than 
+   //! This adaptor is
+   //! instantiated with one outer and zero or more inner allocator types. If
+   //! instantiated with only one allocator type, the inner allocator becomes the
+   //! scoped_allocator_adaptor itself, thus using the same allocator resource for the
+   //! container and every element within the container and, if the elements themselves
+   //! are containers, each of their elements recursively. If instantiated with more than
    //! one allocator, the first allocator is the outer allocator for use by the container,
-   //! the second allocator is passed to the constructors of the container's elements, 
-   //! and, if the elements themselves are containers, the third allocator is passed to 
-   //! the elements' elements, and so on. If containers are nested to a depth greater 
-   //! than the number of allocators, the last allocator is used repeatedly, as in the 
-   //! single-allocator case, for any remaining recursions. 
+   //! the second allocator is passed to the constructors of the container's elements,
+   //! and, if the elements themselves are containers, the third allocator is passed to
+   //! the elements' elements, and so on. If containers are nested to a depth greater
+   //! than the number of allocators, the last allocator is used repeatedly, as in the
+   //! single-allocator case, for any remaining recursions.
    //!
    //! [<b>Note</b>: The
-   //! scoped_allocator_adaptor is derived from the outer allocator type so it can be 
+   //! scoped_allocator_adaptor is derived from the outer allocator type so it can be
    //! substituted for the outer allocator type in most expressions. -end note]
    //!
-   //! In the construct member functions, `OUTERMOST(x)` is x if x does not have 
+   //! In the construct member functions, `OUTERMOST(x)` is x if x does not have
    //! an `outer_allocator()` member function and
    //! `OUTERMOST(x.outer_allocator())` otherwise; `OUTERMOST_ALLOC_TRAITS(x)` is
    //! `allocator_traits<decltype(OUTERMOST(x))>`.
    //!
    //! [<b>Note</b>: `OUTERMOST(x)` and
-   //! `OUTERMOST_ALLOC_TRAITS(x)` are recursive operations. It is incumbent upon 
-   //! the definition of `outer_allocator()` to ensure that the recursion terminates. 
+   //! `OUTERMOST_ALLOC_TRAITS(x)` are recursive operations. It is incumbent upon
+   //! the definition of `outer_allocator()` to ensure that the recursion terminates.
    //! It will terminate for all instantiations of scoped_allocator_adaptor. -end note]
    template <typename OuterAlloc, typename ...InnerAllocs>
    class scoped_allocator_adaptor
@@ -1120,7 +1120,7 @@
       : base_type(other.base())
       {}
 
-   //! <b>Effects</b>: move constructs each allocator within the adaptor with 
+   //! <b>Effects</b>: move constructs each allocator within the adaptor with
    //! the corresponding allocator from other.
    scoped_allocator_adaptor(BOOST_RV_REF(scoped_allocator_adaptor) other)
       : base_type(::boost::move(other.base()))
@@ -1131,7 +1131,7 @@
    //! <b>Requires</b>: OuterAlloc shall be constructible from OuterA2.
    //!
    //! <b>Effects</b>: initializes the OuterAlloc base class with boost::forward<OuterA2>(outerAlloc) and inner
-   //! with innerAllocs...(hence recursively initializing each allocator within the adaptor with the 
+   //! with innerAllocs...(hence recursively initializing each allocator within the adaptor with the
    //! corresponding allocator from the argument list).
    template <class OuterA2>
    scoped_allocator_adaptor(BOOST_FWD_REF(OuterA2) outerAlloc, const InnerAllocs & ...innerAllocs)
@@ -1169,7 +1169,7 @@
 
    //! <b>Requires</b>: OuterAlloc shall be constructible from OuterA2.
    //!
-   //! <b>Effects</b>: initializes each allocator within the adaptor with the corresponding allocator 
+   //! <b>Effects</b>: initializes each allocator within the adaptor with the corresponding allocator
    //! rvalue from other.
    template <class OuterA2>
    scoped_allocator_adaptor(BOOST_RV_REF_BEG scoped_allocator_adaptor<OuterA2
@@ -1221,7 +1221,7 @@
       return outer_traits_type::max_size(this->outer_allocator());
    }
 
-   //! <b>Effects</b>: 
+   //! <b>Effects</b>:
    //!   calls `OUTERMOST_ALLOC_TRAITS(*this)::destroy(OUTERMOST(*this), p)`.
    template <class T>
    void destroy(T* p)
@@ -1230,14 +1230,14 @@
          ::destroy(get_outermost_allocator(this->outer_allocator()), p);
    }
 
-   //! <b>Returns</b>: 
+   //! <b>Returns</b>:
    //! `allocator_traits<OuterAlloc>::allocate(outer_allocator(), n)`.
    pointer allocate(size_type n)
    {
       return outer_traits_type::allocate(this->outer_allocator(), n);
    }
 
-   //! <b>Returns</b>: 
+   //! <b>Returns</b>:
    //! `allocator_traits<OuterAlloc>::allocate(outer_allocator(), n, hint)`.
    pointer allocate(size_type n, const_void_pointer hint)
    {
@@ -1252,7 +1252,7 @@
    }
 
    //! <b>Returns</b>: A new scoped_allocator_adaptor object where each allocator
-   //! A in the adaptor is initialized from the result of calling 
+   //! A in the adaptor is initialized from the result of calling
    //! `allocator_traits<A>::select_on_container_copy_construction()` on
    //! the corresponding allocator in *this.
    scoped_allocator_adaptor select_on_container_copy_construction() const
@@ -1275,21 +1275,21 @@
    //! 1) If `uses_allocator<T, inner_allocator_type>::value` is false calls
    //!    `OUTERMOST_ALLOC_TRAITS(*this)::construct
    //!       (OUTERMOST(*this), p, std::forward<Args>(args)...)`.
-   //! 
-   //! 2) Otherwise, if `uses_allocator<T, inner_allocator_type>::value` is true and 
+   //!
+   //! 2) Otherwise, if `uses_allocator<T, inner_allocator_type>::value` is true and
    //!    `is_constructible<T, allocator_arg_t, inner_allocator_type, Args...>::value` is true, calls
    //!    `OUTERMOST_ALLOC_TRAITS(*this)::construct(OUTERMOST(*this), p, allocator_arg,
    //!    inner_allocator(), std::forward<Args>(args)...)`.
-   //! 
+   //!
    //! [<b>Note</b>: In compilers without advanced decltype SFINAE support, `is_constructible` can't
    //! be implemented so that condition will be replaced by
    //! constructible_with_allocator_prefix<T>::value. -end note]
    //!
-   //! 3) Otherwise, if uses_allocator<T, inner_allocator_type>::value is true and 
-   //!    `is_constructible<T, Args..., inner_allocator_type>::value` is true, calls 
-   //!    `OUTERMOST_ALLOC_TRAITS(*this)::construct(OUTERMOST(*this), p, 
+   //! 3) Otherwise, if uses_allocator<T, inner_allocator_type>::value is true and
+   //!    `is_constructible<T, Args..., inner_allocator_type>::value` is true, calls
+   //!    `OUTERMOST_ALLOC_TRAITS(*this)::construct(OUTERMOST(*this), p,
    //!    std::forward<Args>(args)..., inner_allocator())`.
-   //! 
+   //!
    //! [<b>Note</b>: In compilers without advanced decltype SFINAE support, `is_constructible` can't be
    //! implemented so that condition will be replaced by
    //! `constructible_with_allocator_suffix<T>::value`. -end note]
@@ -1352,7 +1352,7 @@
    template <class T1, class T2, class U, class V>
    void construct(container_detail::pair<T1, T2>* p, BOOST_FWD_REF(U) x, BOOST_FWD_REF(V) y)
    {  this->construct_pair(p, ::boost::forward<U>(x), ::boost::forward<V>(y));   }
-   
+  
    template <class T1, class T2, class U, class V>
    void construct(std::pair<T1, T2>* p, const std::pair<U, V>& x)
    {  this->construct_pair(p, x);   }
@@ -1361,7 +1361,7 @@
    void construct( container_detail::pair<T1, T2>* p
                  , const container_detail::pair<U, V>& x)
    {  this->construct_pair(p, x);   }
-   
+  
    template <class T1, class T2, class U, class V>
    void construct( std::pair<T1, T2>* p
                  , BOOST_RV_REF_BEG std::pair<U, V> BOOST_RV_REF_END x)
@@ -1461,7 +1461,7 @@
       #endif
    >& b)
 {
-   #if !defined(BOOST_NO_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)   
+   #if !defined(BOOST_NO_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)  
    const bool has_zero_inner = sizeof...(InnerAllocs) == 0u;
    #else
    const bool has_zero_inner =

Modified: branches/release/boost/container/set.hpp
==============================================================================
--- branches/release/boost/container/set.hpp	(original)
+++ branches/release/boost/container/set.hpp	2012-05-24 12:36:39 EDT (Thu, 24 May 2012)
@@ -42,32 +42,32 @@
 /// @cond
 // Forward declarations of operators < and ==, needed for friend declaration.
 template <class T, class Pred, class A>
-inline bool operator==(const set<T,Pred,A>& x, 
+inline bool operator==(const set<T,Pred,A>& x,
                        const set<T,Pred,A>& y);
 
 template <class T, class Pred, class A>
-inline bool operator<(const set<T,Pred,A>& x, 
+inline bool operator<(const set<T,Pred,A>& x,
                       const set<T,Pred,A>& y);
 /// @endcond
 
-//! A set is a kind of associative container that supports unique keys (contains at 
-//! most one of each key value) and provides for fast retrieval of the keys themselves. 
-//! Class set supports bidirectional iterators. 
-//! 
-//! A set satisfies all of the requirements of a container and of a reversible container 
-//! , and of an associative container. A set also provides most operations described in 
+//! A set is a kind of associative container that supports unique keys (contains at
+//! most one of each key value) and provides for fast retrieval of the keys themselves.
+//! Class set supports bidirectional iterators.
+//!
+//! A set satisfies all of the requirements of a container and of a reversible container
+//! , and of an associative container. A set also provides most operations described in
 //! for unique keys.
 #ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
 template <class T, class Pred = std::less<T>, class A = std::allocator<T> >
 #else
 template <class T, class Pred, class A>
 #endif
-class set 
+class set
 {
    /// @cond
    private:
    BOOST_COPYABLE_AND_MOVABLE(set)
-   typedef container_detail::rbtree<T, T, 
+   typedef container_detail::rbtree<T, T,
                      container_detail::identity<T>, Pred, A> tree_t;
    tree_t m_tree;  // red-black tree representing set
    typedef typename container_detail::
@@ -95,66 +95,66 @@
    typedef typename tree_t::stored_allocator_type  stored_allocator_type;
 
    //! <b>Effects</b>: Default constructs an empty set.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    set()
       : m_tree()
    {}
 
-   //! <b>Effects</b>: Constructs an empty set using the specified comparison object 
+   //! <b>Effects</b>: Constructs an empty set using the specified comparison object
    //! and allocator.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    explicit set(const Pred& comp,
                 const allocator_type& a = allocator_type())
       : m_tree(comp, a)
    {}
 
-   //! <b>Effects</b>: Constructs an empty set using the specified comparison object and 
+   //! <b>Effects</b>: Constructs an empty set using the specified comparison object and
    //! allocator, and inserts elements from the range [first ,last ).
-   //! 
-   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using 
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
    //! comp and otherwise N logN, where N is last - first.
    template <class InputIterator>
    set(InputIterator first, InputIterator last, const Pred& comp = Pred(),
          const allocator_type& a = allocator_type())
-      : m_tree(first, last, comp, a, true) 
+      : m_tree(first, last, comp, a, true)
    {}
 
-   //! <b>Effects</b>: Constructs an empty set using the specified comparison object and 
+   //! <b>Effects</b>: Constructs an empty set using the specified comparison object and
    //! allocator, and inserts elements from the ordered unique range [first ,last). This function
    //! is more efficient than the normal range creation for ordered ranges.
    //!
    //! <b>Requires</b>: [first ,last) must be ordered according to the predicate and must be
    //! unique values.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear in N.
    template <class InputIterator>
    set( ordered_unique_range_t, InputIterator first, InputIterator last
       , const Pred& comp = Pred(), const allocator_type& a = allocator_type())
-      : m_tree(ordered_range, first, last, comp, a) 
+      : m_tree(ordered_range, first, last, comp, a)
    {}
 
    //! <b>Effects</b>: Copy constructs a set.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear in x.size().
-   set(const set& x) 
+   set(const set& x)
       : m_tree(x.m_tree)
    {}
 
    //! <b>Effects</b>: Move constructs a set. Constructs *this using x's resources.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   //! 
+   //!
    //! <b>Postcondition</b>: x is emptied.
-   set(BOOST_RV_REF(set) x) 
+   set(BOOST_RV_REF(set) x)
       : m_tree(boost::move(x.m_tree))
    {}
 
    //! <b>Effects</b>: Copy constructs a set using the specified allocator.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear in x.size().
-   set(const set& x, const allocator_type &a) 
+   set(const set& x, const allocator_type &a)
       : m_tree(x.m_tree, a)
    {}
 
@@ -162,7 +162,7 @@
    //!                 Constructs *this using x's resources.
    //!
    //! <b>Complexity</b>: Constant if a == x.get_allocator(), linear otherwise.
-   set(BOOST_RV_REF(set) x, const allocator_type &a) 
+   set(BOOST_RV_REF(set) x, const allocator_type &a)
       : m_tree(boost::move(x.m_tree), a)
    {}
 
@@ -173,162 +173,162 @@
    {  m_tree = x.m_tree;   return *this;  }
 
    //! <b>Effects</b>: this->swap(x.get()).
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    set& operator=(BOOST_RV_REF(set) x)
    {  m_tree = boost::move(x.m_tree);   return *this;  }
 
    //! <b>Effects</b>: Returns the comparison object out
    //!   of which a was constructed.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   key_compare key_comp() const 
+   key_compare key_comp() const
    { return m_tree.key_comp(); }
 
    //! <b>Effects</b>: Returns an object of value_compare constructed out
    //!   of the comparison object.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   value_compare value_comp() const 
+   value_compare value_comp() const
    { return m_tree.key_comp(); }
 
    //! <b>Effects</b>: Returns a copy of the Allocator that
    //!   was passed to the object's constructor.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   allocator_type get_allocator() const 
+   allocator_type get_allocator() const
    { return m_tree.get_allocator(); }
 
-   const stored_allocator_type &get_stored_allocator() const 
+   const stored_allocator_type &get_stored_allocator() const
    { return m_tree.get_stored_allocator(); }
 
    stored_allocator_type &get_stored_allocator()
    { return m_tree.get_stored_allocator(); }
 
    //! <b>Effects</b>: Returns an iterator to the first element contained in the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant
-   iterator begin() 
+   iterator begin()
    { return m_tree.begin(); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_iterator begin() const 
+   const_iterator begin() const
    { return m_tree.begin(); }
 
    //! <b>Effects</b>: Returns an iterator to the end of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   iterator end() 
+   iterator end()
    { return m_tree.end(); }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_iterator end() const 
+   const_iterator end() const
    { return m_tree.end(); }
 
-   //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning 
-   //! of the reversed container. 
-   //! 
+   //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   reverse_iterator rbegin() 
-   { return m_tree.rbegin(); } 
+   reverse_iterator rbegin()
+   { return m_tree.rbegin(); }
 
-   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning 
-   //! of the reversed container. 
-   //! 
+   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator rbegin() const 
-   { return m_tree.rbegin(); } 
+   const_reverse_iterator rbegin() const
+   { return m_tree.rbegin(); }
 
    //! <b>Effects</b>: Returns a reverse_iterator pointing to the end
-   //! of the reversed container. 
-   //! 
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   reverse_iterator rend() 
+   reverse_iterator rend()
    { return m_tree.rend(); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
-   //! of the reversed container. 
-   //! 
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator rend() const 
+   const_reverse_iterator rend() const
    { return m_tree.rend(); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_iterator cbegin() const 
+   const_iterator cbegin() const
    { return m_tree.cbegin(); }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_iterator cend() const 
+   const_iterator cend() const
    { return m_tree.cend(); }
 
-   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning 
-   //! of the reversed container. 
-   //! 
+   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator crbegin() const 
-   { return m_tree.crbegin(); } 
+   const_reverse_iterator crbegin() const
+   { return m_tree.crbegin(); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
-   //! of the reversed container. 
-   //! 
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator crend() const 
+   const_reverse_iterator crend() const
    { return m_tree.crend(); }
 
    //! <b>Effects</b>: Returns true if the container contains no elements.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   bool empty() const 
+   bool empty() const
    { return m_tree.empty(); }
 
    //! <b>Effects</b>: Returns the number of the elements contained in the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   size_type size() const 
+   size_type size() const
    { return m_tree.size(); }
 
    //! <b>Effects</b>: Returns the largest possible size of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   size_type max_size() const 
+   size_type max_size() const
    { return m_tree.max_size(); }
 
    //! <b>Effects</b>: Swaps the contents of *this and x.
@@ -339,15 +339,15 @@
    void swap(set& x)
    { m_tree.swap(x.m_tree); }
 
-   //! <b>Effects</b>: Inserts x if and only if there is no element in the container 
+   //! <b>Effects</b>: Inserts x if and only if there is no element in the container
    //!   with key equivalent to the key of x.
    //!
-   //! <b>Returns</b>: The bool component of the returned pair is true if and only 
+   //! <b>Returns</b>: The bool component of the returned pair is true if and only
    //!   if the insertion takes place, and the iterator component of the pair
    //!   points to the element with key equivalent to the key of x.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   std::pair<iterator,bool> insert(insert_const_ref_type x) 
+   std::pair<iterator,bool> insert(insert_const_ref_type x)
    {  return priv_insert(x); }
 
    #if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -360,18 +360,18 @@
    {  return priv_insert(u); }
    #endif
 
-   //! <b>Effects</b>: Move constructs a new value from x if and only if there is 
+   //! <b>Effects</b>: Move constructs a new value from x if and only if there is
    //!   no element in the container with key equivalent to the key of x.
    //!
-   //! <b>Returns</b>: The bool component of the returned pair is true if and only 
+   //! <b>Returns</b>: The bool component of the returned pair is true if and only
    //!   if the insertion takes place, and the iterator component of the pair
    //!   points to the element with key equivalent to the key of x.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   std::pair<iterator,bool> insert(BOOST_RV_REF(value_type) x) 
+   std::pair<iterator,bool> insert(BOOST_RV_REF(value_type) x)
    {  return m_tree.insert_unique(boost::move(x));  }
 
-   //! <b>Effects</b>: Inserts a copy of x in the container if and only if there is 
+   //! <b>Effects</b>: Inserts a copy of x in the container if and only if there is
    //!   no element in the container with key equivalent to the key of x.
    //!   p is a hint pointing to where the insert should start to search.
    //!
@@ -380,7 +380,7 @@
    //!
    //! <b>Complexity</b>: Logarithmic in general, but amortized constant if t
    //!   is inserted right before p.
-   iterator insert(const_iterator p, insert_const_ref_type x) 
+   iterator insert(const_iterator p, insert_const_ref_type x)
    {  return priv_insert(p, x); }
 
    #if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -399,28 +399,28 @@
    //! <b>Returns</b>: An iterator pointing to the element with key equivalent to the key of x.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   iterator insert(const_iterator p, BOOST_RV_REF(value_type) x) 
+   iterator insert(const_iterator p, BOOST_RV_REF(value_type) x)
    {  return m_tree.insert_unique(p, boost::move(x)); }
 
    //! <b>Requires</b>: first, last are not iterators into *this.
    //!
-   //! <b>Effects</b>: inserts each element from the range [first,last) if and only 
+   //! <b>Effects</b>: inserts each element from the range [first,last) if and only
    //!   if there is no element with key equivalent to the key of that element.
    //!
    //! <b>Complexity</b>: At most N log(size()+N) (N is the distance from first to last)
    template <class InputIterator>
-   void insert(InputIterator first, InputIterator last) 
+   void insert(InputIterator first, InputIterator last)
    {  m_tree.insert_unique(first, last);  }
 
    #if defined(BOOST_CONTAINER_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
    //! <b>Effects</b>:  Inserts an object x of type T constructed with
-   //!   std::forward<Args>(args)... if and only if there is 
+   //!   std::forward<Args>(args)... if and only if there is
    //!   no element in the container with equivalent value.
    //!   and returns the iterator pointing to the
    //!   newly inserted element.
    //!
-   //! <b>Returns</b>: The bool component of the returned pair is true if and only 
+   //! <b>Returns</b>: The bool component of the returned pair is true if and only
    //!   if the insertion takes place, and the iterator component of the pair
    //!   points to the element with key equivalent to the key of x.
    //!
@@ -433,7 +433,7 @@
    {  return m_tree.emplace_unique(boost::forward<Args>(args)...); }
 
    //! <b>Effects</b>:  Inserts an object of type T constructed with
-   //!   std::forward<Args>(args)... if and only if there is 
+   //!   std::forward<Args>(args)... if and only if there is
    //!   no element in the container with equivalent value.
    //!   p is a hint pointing to where the insert
    //!   should start to search.
@@ -466,11 +466,11 @@
    //! <b>Effects</b>: Erases the element pointed to by p.
    //!
    //! <b>Returns</b>: Returns an iterator pointing to the element immediately
-   //!   following q prior to the element being erased. If no such element exists, 
+   //!   following q prior to the element being erased. If no such element exists,
    //!   returns end().
    //!
    //! <b>Complexity</b>: Amortized constant time
-   iterator erase(const_iterator p) 
+   iterator erase(const_iterator p)
    {  return m_tree.erase(p); }
 
    //! <b>Effects</b>: Erases all elements in the container with key equivalent to x.
@@ -478,7 +478,7 @@
    //! <b>Returns</b>: Returns the number of erased elements.
    //!
    //! <b>Complexity</b>: log(size()) + count(k)
-   size_type erase(const key_type& x) 
+   size_type erase(const key_type& x)
    {  return m_tree.erase(x); }
 
    //! <b>Effects</b>: Erases all the elements in the range [first, last).
@@ -486,7 +486,7 @@
    //! <b>Returns</b>: Returns last.
    //!
    //! <b>Complexity</b>: log(size())+N where N is the distance from first to last.
-   iterator erase(const_iterator first, const_iterator last) 
+   iterator erase(const_iterator first, const_iterator last)
    {  return m_tree.erase(first, last);  }
 
    //! <b>Effects</b>: erase(a.begin(),a.end()).
@@ -494,41 +494,41 @@
    //! <b>Postcondition</b>: size() == 0.
    //!
    //! <b>Complexity</b>: linear in size().
-   void clear() 
+   void clear()
    { m_tree.clear(); }
 
    //! <b>Returns</b>: An iterator pointing to an element with the key
    //!   equivalent to x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   iterator find(const key_type& x) 
+   iterator find(const key_type& x)
    { return m_tree.find(x); }
 
    //! <b>Returns</b>: A const_iterator pointing to an element with the key
    //!   equivalent to x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   const_iterator find(const key_type& x) const 
+   const_iterator find(const key_type& x) const
    { return m_tree.find(x); }
 
    //! <b>Returns</b>: The number of elements with key equivalent to x.
    //!
    //! <b>Complexity</b>: log(size())+count(k)
-   size_type count(const key_type& x) const 
+   size_type count(const key_type& x) const
    {  return m_tree.find(x) == m_tree.end() ? 0 : 1;  }
 
    //! <b>Returns</b>: An iterator pointing to the first element with key not less
    //!   than k, or a.end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic
-   iterator lower_bound(const key_type& x) 
+   iterator lower_bound(const key_type& x)
    {  return m_tree.lower_bound(x); }
 
    //! <b>Returns</b>: A const iterator pointing to the first element with key not
    //!   less than k, or a.end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic
-   const_iterator lower_bound(const key_type& x) const 
+   const_iterator lower_bound(const key_type& x) const
    {  return m_tree.lower_bound(x); }
 
    //! <b>Returns</b>: An iterator pointing to the first element with key not less
@@ -542,21 +542,21 @@
    //!   less than x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic
-   const_iterator upper_bound(const key_type& x) const 
+   const_iterator upper_bound(const key_type& x) const
    {  return m_tree.upper_bound(x);    }
 
    //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
    //!
    //! <b>Complexity</b>: Logarithmic
-   std::pair<iterator,iterator> 
-      equal_range(const key_type& x) 
+   std::pair<iterator,iterator>
+      equal_range(const key_type& x)
    {  return m_tree.equal_range(x); }
 
    //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
    //!
    //! <b>Complexity</b>: Logarithmic
-   std::pair<const_iterator, const_iterator> 
-      equal_range(const key_type& x) const 
+   std::pair<const_iterator, const_iterator>
+      equal_range(const key_type& x) const
    {  return m_tree.equal_range(x); }
 
    /// @cond
@@ -567,47 +567,47 @@
    friend bool operator< (const set<K1,C1,A1>&, const set<K1,C1,A1>&);
 
    private:
-   std::pair<iterator, bool> priv_insert(const T &x) 
+   std::pair<iterator, bool> priv_insert(const T &x)
    {  return m_tree.insert_unique(x);  }
 
-   iterator priv_insert(const_iterator p, const T &x) 
+   iterator priv_insert(const_iterator p, const T &x)
    {  return m_tree.insert_unique(p, x); }
 
    /// @endcond
 };
 
 template <class T, class Pred, class A>
-inline bool operator==(const set<T,Pred,A>& x, 
-                       const set<T,Pred,A>& y) 
+inline bool operator==(const set<T,Pred,A>& x,
+                       const set<T,Pred,A>& y)
 {  return x.m_tree == y.m_tree;  }
 
 template <class T, class Pred, class A>
-inline bool operator<(const set<T,Pred,A>& x, 
-                      const set<T,Pred,A>& y) 
+inline bool operator<(const set<T,Pred,A>& x,
+                      const set<T,Pred,A>& y)
 {  return x.m_tree < y.m_tree;   }
 
 template <class T, class Pred, class A>
-inline bool operator!=(const set<T,Pred,A>& x, 
-                       const set<T,Pred,A>& y) 
+inline bool operator!=(const set<T,Pred,A>& x,
+                       const set<T,Pred,A>& y)
 {  return !(x == y);   }
 
 template <class T, class Pred, class A>
-inline bool operator>(const set<T,Pred,A>& x, 
-                      const set<T,Pred,A>& y) 
+inline bool operator>(const set<T,Pred,A>& x,
+                      const set<T,Pred,A>& y)
 {  return y < x; }
 
 template <class T, class Pred, class A>
-inline bool operator<=(const set<T,Pred,A>& x, 
-                       const set<T,Pred,A>& y) 
+inline bool operator<=(const set<T,Pred,A>& x,
+                       const set<T,Pred,A>& y)
 {  return !(y < x); }
 
 template <class T, class Pred, class A>
-inline bool operator>=(const set<T,Pred,A>& x, 
-                       const set<T,Pred,A>& y) 
+inline bool operator>=(const set<T,Pred,A>& x,
+                       const set<T,Pred,A>& y)
 {  return !(x < y);  }
 
 template <class T, class Pred, class A>
-inline void swap(set<T,Pred,A>& x, set<T,Pred,A>& y) 
+inline void swap(set<T,Pred,A>& x, set<T,Pred,A>& y)
 {  x.swap(y);  }
 
 /// @cond
@@ -627,32 +627,32 @@
 // Forward declaration of operators < and ==, needed for friend declaration.
 
 template <class T, class Pred, class A>
-inline bool operator==(const multiset<T,Pred,A>& x, 
+inline bool operator==(const multiset<T,Pred,A>& x,
                        const multiset<T,Pred,A>& y);
 
 template <class T, class Pred, class A>
-inline bool operator<(const multiset<T,Pred,A>& x, 
+inline bool operator<(const multiset<T,Pred,A>& x,
                       const multiset<T,Pred,A>& y);
 /// @endcond
 
-//! A multiset is a kind of associative container that supports equivalent keys 
-//! (possibly contains multiple copies of the same key value) and provides for 
+//! A multiset is a kind of associative container that supports equivalent keys
+//! (possibly contains multiple copies of the same key value) and provides for
 //! fast retrieval of the keys themselves. Class multiset supports bidirectional iterators.
-//! 
-//! A multiset satisfies all of the requirements of a container and of a reversible 
-//! container, and of an associative container). multiset also provides most operations 
+//!
+//! A multiset satisfies all of the requirements of a container and of a reversible
+//! container, and of an associative container). multiset also provides most operations
 //! described for duplicate keys.
 #ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
 template <class T, class Pred = std::less<T>, class A = std::allocator<T> >
 #else
 template <class T, class Pred, class A>
 #endif
-class multiset 
+class multiset
 {
    /// @cond
    private:
    BOOST_COPYABLE_AND_MOVABLE(multiset)
-   typedef container_detail::rbtree<T, T, 
+   typedef container_detail::rbtree<T, T,
                      container_detail::identity<T>, Pred, A> tree_t;
    tree_t m_tree;  // red-black tree representing multiset
    typedef typename container_detail::
@@ -681,7 +681,7 @@
 
    //! <b>Effects</b>: Constructs an empty multiset using the specified comparison
    //!   object and allocator.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    multiset()
       : m_tree()
@@ -689,7 +689,7 @@
 
    //! <b>Effects</b>: Constructs an empty multiset using the specified comparison
    //!   object and allocator.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    explicit multiset(const Pred& comp,
                      const allocator_type& a = allocator_type())
@@ -698,226 +698,226 @@
 
    //! <b>Effects</b>: Constructs an empty multiset using the specified comparison object
    //!   and allocator, and inserts elements from the range [first ,last ).
-   //! 
-   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using 
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
    //! comp and otherwise N logN, where N is last - first.
    template <class InputIterator>
    multiset(InputIterator first, InputIterator last,
             const Pred& comp = Pred(),
             const allocator_type& a = allocator_type())
-      : m_tree(first, last, comp, a, false) 
+      : m_tree(first, last, comp, a, false)
    {}
 
-   //! <b>Effects</b>: Constructs an empty multiset using the specified comparison object and 
+   //! <b>Effects</b>: Constructs an empty multiset using the specified comparison object and
    //! allocator, and inserts elements from the ordered range [first ,last ). This function
    //! is more efficient than the normal range creation for ordered ranges.
    //!
    //! <b>Requires</b>: [first ,last) must be ordered according to the predicate.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear in N.
    template <class InputIterator>
    multiset( ordered_range_t ordered_range, InputIterator first, InputIterator last
            , const Pred& comp = Pred()
            , const allocator_type& a = allocator_type())
-      : m_tree(ordered_range, first, last, comp, a) 
+      : m_tree(ordered_range, first, last, comp, a)
    {}
 
    //! <b>Effects</b>: Copy constructs a multiset.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear in x.size().
-   multiset(const multiset& x) 
+   multiset(const multiset& x)
       : m_tree(x.m_tree)
    {}
 
    //! <b>Effects</b>: Move constructs a multiset. Constructs *this using x's resources.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   //! 
+   //!
    //! <b>Postcondition</b>: x is emptied.
-   multiset(BOOST_RV_REF(multiset) x) 
+   multiset(BOOST_RV_REF(multiset) x)
       : m_tree(boost::move(x.m_tree))
    {}
 
    //! <b>Effects</b>: Copy constructs a multiset using the specified allocator.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear in x.size().
-   multiset(const multiset& x, const allocator_type &a) 
+   multiset(const multiset& x, const allocator_type &a)
       : m_tree(x.m_tree, a)
    {}
 
    //! <b>Effects</b>: Move constructs a multiset using the specified allocator.
    //!                 Constructs *this using x's resources.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant if a == x.get_allocator(), linear otherwise.
-   //! 
+   //!
    //! <b>Postcondition</b>: x is emptied.
-   multiset(BOOST_RV_REF(multiset) x, const allocator_type &a) 
+   multiset(BOOST_RV_REF(multiset) x, const allocator_type &a)
       : m_tree(boost::move(x.m_tree), a)
    {}
 
    //! <b>Effects</b>: Makes *this a copy of x.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear in x.size().
-   multiset& operator=(BOOST_COPY_ASSIGN_REF(multiset) x) 
+   multiset& operator=(BOOST_COPY_ASSIGN_REF(multiset) x)
    {  m_tree = x.m_tree;   return *this;  }
 
    //! <b>Effects</b>: this->swap(x.get()).
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   multiset& operator=(BOOST_RV_REF(multiset) x) 
+   multiset& operator=(BOOST_RV_REF(multiset) x)
    {  m_tree = boost::move(x.m_tree);   return *this;  }
 
    //! <b>Effects</b>: Returns the comparison object out
    //!   of which a was constructed.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   key_compare key_comp() const 
+   key_compare key_comp() const
    { return m_tree.key_comp(); }
 
    //! <b>Effects</b>: Returns an object of value_compare constructed out
    //!   of the comparison object.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   value_compare value_comp() const 
+   value_compare value_comp() const
    { return m_tree.key_comp(); }
 
    //! <b>Effects</b>: Returns a copy of the Allocator that
    //!   was passed to the object's constructor.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   allocator_type get_allocator() const 
+   allocator_type get_allocator() const
    { return m_tree.get_allocator(); }
 
-   const stored_allocator_type &get_stored_allocator() const 
+   const stored_allocator_type &get_stored_allocator() const
    { return m_tree.get_stored_allocator(); }
 
    stored_allocator_type &get_stored_allocator()
    { return m_tree.get_stored_allocator(); }
 
    //! <b>Effects</b>: Returns an iterator to the first element contained in the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   iterator begin() 
+   iterator begin()
    { return m_tree.begin(); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_iterator begin() const 
+   const_iterator begin() const
    { return m_tree.begin(); }
 
    //! <b>Effects</b>: Returns an iterator to the end of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   iterator end() 
+   iterator end()
    { return m_tree.end(); }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_iterator end() const 
+   const_iterator end() const
    { return m_tree.end(); }
 
-   //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning 
-   //! of the reversed container. 
-   //! 
+   //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   reverse_iterator rbegin() 
-   { return m_tree.rbegin(); } 
+   reverse_iterator rbegin()
+   { return m_tree.rbegin(); }
 
-   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning 
-   //! of the reversed container. 
-   //! 
+   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator rbegin() const 
-   { return m_tree.rbegin(); } 
+   const_reverse_iterator rbegin() const
+   { return m_tree.rbegin(); }
 
    //! <b>Effects</b>: Returns a reverse_iterator pointing to the end
-   //! of the reversed container. 
-   //! 
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   reverse_iterator rend() 
+   reverse_iterator rend()
    { return m_tree.rend(); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
-   //! of the reversed container. 
-   //! 
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator rend() const 
+   const_reverse_iterator rend() const
    { return m_tree.rend(); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_iterator cbegin() const 
+   const_iterator cbegin() const
    { return m_tree.cbegin(); }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_iterator cend() const 
+   const_iterator cend() const
    { return m_tree.cend(); }
 
-   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning 
-   //! of the reversed container. 
-   //! 
+   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator crbegin() const 
-   { return m_tree.crbegin(); } 
+   const_reverse_iterator crbegin() const
+   { return m_tree.crbegin(); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
-   //! of the reversed container. 
-   //! 
+   //! of the reversed container.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator crend() const 
+   const_reverse_iterator crend() const
    { return m_tree.crend(); }
 
    //! <b>Effects</b>: Returns true if the container contains no elements.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   bool empty() const 
+   bool empty() const
    { return m_tree.empty(); }
 
    //! <b>Effects</b>: Returns the number of the elements contained in the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   size_type size() const 
+   size_type size() const
    { return m_tree.size(); }
 
    //! <b>Effects</b>: Returns the largest possible size of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   size_type max_size() const 
+   size_type max_size() const
    { return m_tree.max_size(); }
 
    //! <b>Effects</b>: Swaps the contents of *this and x.
@@ -929,10 +929,10 @@
    { m_tree.swap(x.m_tree); }
 
    //! <b>Effects</b>: Inserts x and returns the iterator pointing to the
-   //!   newly inserted element. 
+   //!   newly inserted element.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   iterator insert(insert_const_ref_type x) 
+   iterator insert(insert_const_ref_type x)
    {  return priv_insert(x); }
 
    #if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -952,7 +952,7 @@
    //!
    //! <b>Complexity</b>: Logarithmic in general, but amortized constant if t
    //!   is inserted right before p.
-   iterator insert(BOOST_RV_REF(value_type) x) 
+   iterator insert(BOOST_RV_REF(value_type) x)
    {  return m_tree.insert_equal(boost::move(x));  }
 
    //! <b>Effects</b>: Inserts a copy of x in the container.
@@ -963,7 +963,7 @@
    //!
    //! <b>Complexity</b>: Logarithmic in general, but amortized constant if t
    //!   is inserted right before p.
-   iterator insert(const_iterator p, insert_const_ref_type x) 
+   iterator insert(const_iterator p, insert_const_ref_type x)
    {  return priv_insert(p, x); }
 
    #if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -984,7 +984,7 @@
    //!
    //! <b>Complexity</b>: Logarithmic in general, but amortized constant if t
    //!   is inserted right before p.
-   iterator insert(const_iterator p, BOOST_RV_REF(value_type) x) 
+   iterator insert(const_iterator p, BOOST_RV_REF(value_type) x)
    {  return m_tree.insert_equal(p, boost::move(x));  }
 
    //! <b>Requires</b>: first, last are not iterators into *this.
@@ -993,14 +993,14 @@
    //!
    //! <b>Complexity</b>: At most N log(size()+N) (N is the distance from first to last)
    template <class InputIterator>
-   void insert(InputIterator first, InputIterator last) 
+   void insert(InputIterator first, InputIterator last)
    {  m_tree.insert_equal(first, last);  }
 
    #if defined(BOOST_CONTAINER_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
    //! <b>Effects</b>: Inserts an object of type T constructed with
    //!   std::forward<Args>(args)... and returns the iterator pointing to the
-   //!   newly inserted element. 
+   //!   newly inserted element.
    //!
    //! <b>Complexity</b>: Logarithmic.
    template <class... Args>
@@ -1040,11 +1040,11 @@
    //! <b>Effects</b>: Erases the element pointed to by p.
    //!
    //! <b>Returns</b>: Returns an iterator pointing to the element immediately
-   //!   following q prior to the element being erased. If no such element exists, 
+   //!   following q prior to the element being erased. If no such element exists,
    //!   returns end().
    //!
    //! <b>Complexity</b>: Amortized constant time
-   iterator erase(const_iterator p) 
+   iterator erase(const_iterator p)
    {  return m_tree.erase(p); }
 
    //! <b>Effects</b>: Erases all elements in the container with key equivalent to x.
@@ -1052,7 +1052,7 @@
    //! <b>Returns</b>: Returns the number of erased elements.
    //!
    //! <b>Complexity</b>: log(size()) + count(k)
-   size_type erase(const key_type& x) 
+   size_type erase(const key_type& x)
    {  return m_tree.erase(x); }
 
    //! <b>Effects</b>: Erases all the elements in the range [first, last).
@@ -1068,41 +1068,41 @@
    //! <b>Postcondition</b>: size() == 0.
    //!
    //! <b>Complexity</b>: linear in size().
-   void clear() 
+   void clear()
    { m_tree.clear(); }
 
    //! <b>Returns</b>: An iterator pointing to an element with the key
    //!   equivalent to x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   iterator find(const key_type& x) 
+   iterator find(const key_type& x)
    { return m_tree.find(x); }
 
    //! <b>Returns</b>: A const iterator pointing to an element with the key
    //!   equivalent to x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   const_iterator find(const key_type& x) const 
+   const_iterator find(const key_type& x) const
    { return m_tree.find(x); }
 
    //! <b>Returns</b>: The number of elements with key equivalent to x.
    //!
    //! <b>Complexity</b>: log(size())+count(k)
-   size_type count(const key_type& x) const 
+   size_type count(const key_type& x) const
    {  return m_tree.count(x);  }
 
    //! <b>Returns</b>: An iterator pointing to the first element with key not less
    //!   than k, or a.end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic
-   iterator lower_bound(const key_type& x) 
+   iterator lower_bound(const key_type& x)
    {  return m_tree.lower_bound(x); }
 
    //! <b>Returns</b>: A const iterator pointing to the first element with key not
    //!   less than k, or a.end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic
-   const_iterator lower_bound(const key_type& x) const 
+   const_iterator lower_bound(const key_type& x) const
    {  return m_tree.lower_bound(x); }
 
    //! <b>Returns</b>: An iterator pointing to the first element with key not less
@@ -1116,21 +1116,21 @@
    //!   less than x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic
-   const_iterator upper_bound(const key_type& x) const 
+   const_iterator upper_bound(const key_type& x) const
    {  return m_tree.upper_bound(x);    }
 
    //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
    //!
    //! <b>Complexity</b>: Logarithmic
-   std::pair<iterator,iterator> 
-      equal_range(const key_type& x) 
+   std::pair<iterator,iterator>
+      equal_range(const key_type& x)
    {  return m_tree.equal_range(x); }
 
    //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
    //!
    //! <b>Complexity</b>: Logarithmic
-   std::pair<const_iterator, const_iterator> 
-      equal_range(const key_type& x) const 
+   std::pair<const_iterator, const_iterator>
+      equal_range(const key_type& x) const
    {  return m_tree.equal_range(x); }
 
    /// @cond
@@ -1141,47 +1141,47 @@
    friend bool operator< (const multiset<K1,C1,A1>&,
                           const multiset<K1,C1,A1>&);
    private:
-   iterator priv_insert(const T &x) 
+   iterator priv_insert(const T &x)
    {  return m_tree.insert_equal(x);  }
 
-   iterator priv_insert(const_iterator p, const T &x) 
+   iterator priv_insert(const_iterator p, const T &x)
    {  return m_tree.insert_equal(p, x); }
 
    /// @endcond
 };
 
 template <class T, class Pred, class A>
-inline bool operator==(const multiset<T,Pred,A>& x, 
-                       const multiset<T,Pred,A>& y) 
+inline bool operator==(const multiset<T,Pred,A>& x,
+                       const multiset<T,Pred,A>& y)
 {  return x.m_tree == y.m_tree;  }
 
 template <class T, class Pred, class A>
-inline bool operator<(const multiset<T,Pred,A>& x, 
-                      const multiset<T,Pred,A>& y) 
+inline bool operator<(const multiset<T,Pred,A>& x,
+                      const multiset<T,Pred,A>& y)
 {  return x.m_tree < y.m_tree;   }
 
 template <class T, class Pred, class A>
-inline bool operator!=(const multiset<T,Pred,A>& x, 
-                       const multiset<T,Pred,A>& y) 
+inline bool operator!=(const multiset<T,Pred,A>& x,
+                       const multiset<T,Pred,A>& y)
 {  return !(x == y);  }
 
 template <class T, class Pred, class A>
-inline bool operator>(const multiset<T,Pred,A>& x, 
-                      const multiset<T,Pred,A>& y) 
+inline bool operator>(const multiset<T,Pred,A>& x,
+                      const multiset<T,Pred,A>& y)
 {  return y < x;  }
 
 template <class T, class Pred, class A>
-inline bool operator<=(const multiset<T,Pred,A>& x, 
-                       const multiset<T,Pred,A>& y) 
+inline bool operator<=(const multiset<T,Pred,A>& x,
+                       const multiset<T,Pred,A>& y)
 {  return !(y < x);  }
 
 template <class T, class Pred, class A>
-inline bool operator>=(const multiset<T,Pred,A>& x, 
-                       const multiset<T,Pred,A>& y) 
+inline bool operator>=(const multiset<T,Pred,A>& x,
+                       const multiset<T,Pred,A>& y)
 {  return !(x < y);  }
 
 template <class T, class Pred, class A>
-inline void swap(multiset<T,Pred,A>& x, multiset<T,Pred,A>& y) 
+inline void swap(multiset<T,Pred,A>& x, multiset<T,Pred,A>& y)
 {  x.swap(y);  }
 
 /// @cond

Modified: branches/release/boost/container/slist.hpp
==============================================================================
--- branches/release/boost/container/slist.hpp	(original)
+++ branches/release/boost/container/slist.hpp	2012-05-24 12:36:39 EDT (Thu, 24 May 2012)
@@ -32,7 +32,7 @@
 #if defined(BOOST_CONTAINER_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 //Preprocessor library to emulate perfect forwarding
 #else
-#include <boost/container/detail/preprocessor.hpp> 
+#include <boost/container/detail/preprocessor.hpp>
 #endif
 
 #include <stdexcept>
@@ -99,51 +99,51 @@
 
 /// @endcond
 
-//! An slist is a singly linked list: a list where each element is linked to the next 
-//! element, but not to the previous element. That is, it is a Sequence that 
-//! supports forward but not backward traversal, and (amortized) constant time 
-//! insertion and removal of elements. Slists, like lists, have the important 
-//! property that insertion and splicing do not invalidate iterators to list elements, 
-//! and that even removal invalidates only the iterators that point to the elements 
-//! that are removed. The ordering of iterators may be changed (that is, 
-//! slist<T>::iterator might have a different predecessor or successor after a list 
-//! operation than it did before), but the iterators themselves will not be invalidated 
+//! An slist is a singly linked list: a list where each element is linked to the next
+//! element, but not to the previous element. That is, it is a Sequence that
+//! supports forward but not backward traversal, and (amortized) constant time
+//! insertion and removal of elements. Slists, like lists, have the important
+//! property that insertion and splicing do not invalidate iterators to list elements,
+//! and that even removal invalidates only the iterators that point to the elements
+//! that are removed. The ordering of iterators may be changed (that is,
+//! slist<T>::iterator might have a different predecessor or successor after a list
+//! operation than it did before), but the iterators themselves will not be invalidated
 //! or made to point to different elements unless that invalidation or mutation is explicit.
 //!
-//! The main difference between slist and list is that list's iterators are bidirectional 
-//! iterators, while slist's iterators are forward iterators. This means that slist is 
-//! less versatile than list; frequently, however, bidirectional iterators are 
-//! unnecessary. You should usually use slist unless you actually need the extra 
-//! functionality of list, because singly linked lists are smaller and faster than double 
-//! linked lists. 
-//! 
-//! Important performance note: like every other Sequence, slist defines the member 
-//! functions insert and erase. Using these member functions carelessly, however, can 
-//! result in disastrously slow programs. The problem is that insert's first argument is 
-//! an iterator p, and that it inserts the new element(s) before p. This means that 
-//! insert must find the iterator just before p; this is a constant-time operation 
-//! for list, since list has bidirectional iterators, but for slist it must find that 
-//! iterator by traversing the list from the beginning up to p. In other words: 
+//! The main difference between slist and list is that list's iterators are bidirectional
+//! iterators, while slist's iterators are forward iterators. This means that slist is
+//! less versatile than list; frequently, however, bidirectional iterators are
+//! unnecessary. You should usually use slist unless you actually need the extra
+//! functionality of list, because singly linked lists are smaller and faster than double
+//! linked lists.
+//!
+//! Important performance note: like every other Sequence, slist defines the member
+//! functions insert and erase. Using these member functions carelessly, however, can
+//! result in disastrously slow programs. The problem is that insert's first argument is
+//! an iterator p, and that it inserts the new element(s) before p. This means that
+//! insert must find the iterator just before p; this is a constant-time operation
+//! for list, since list has bidirectional iterators, but for slist it must find that
+//! iterator by traversing the list from the beginning up to p. In other words:
 //! insert and erase are slow operations anywhere but near the beginning of the slist.
-//! 
-//! Slist provides the member functions insert_after and erase_after, which are constant 
-//! time operations: you should always use insert_after and erase_after whenever 
-//! possible. If you find that insert_after and erase_after aren't adequate for your 
-//! needs, and that you often need to use insert and erase in the middle of the list, 
+//!
+//! Slist provides the member functions insert_after and erase_after, which are constant
+//! time operations: you should always use insert_after and erase_after whenever
+//! possible. If you find that insert_after and erase_after aren't adequate for your
+//! needs, and that you often need to use insert and erase in the middle of the list,
 //! then you should probably use list instead of slist.
 #ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
 template <class T, class A = std::allocator<T> >
 #else
 template <class T, class A>
 #endif
-class slist 
+class slist
    : protected container_detail::node_alloc_holder
       <A, typename container_detail::intrusive_slist_type<A>::type>
 {
    /// @cond
    typedef typename container_detail::
       move_const_ref_type<T>::type                    insert_const_ref_type;
-   typedef typename 
+   typedef typename
       container_detail::intrusive_slist_type<A>::type           Icont;
    typedef container_detail::node_alloc_holder<A, Icont>        AllocHolder;
    typedef typename AllocHolder::NodePtr              NodePtr;
@@ -218,11 +218,11 @@
 
    public:
 
-   //! Const iterator used to iterate through a list. 
+   //! Const iterator used to iterate through a list.
    class const_iterator
       /// @cond
-      : public std::iterator<std::forward_iterator_tag, 
-                                 value_type,         list_difference_type, 
+      : public std::iterator<std::forward_iterator_tag,
+                                 value_type,         list_difference_type,
                                  list_const_pointer, list_const_reference>
    {
 
@@ -245,17 +245,17 @@
       {}
 
       //Pointer like operators
-      const_reference operator*() const 
+      const_reference operator*() const
       { return m_it->m_data;  }
 
-      const_pointer   operator->() const 
+      const_pointer   operator->() const
       { return  const_pointer(&m_it->m_data); }
 
       //Increment / Decrement
-      const_iterator& operator++()       
+      const_iterator& operator++()      
       { prot_incr();  return *this; }
 
-      const_iterator operator++(int)      
+      const_iterator operator++(int)     
       { typename Icont::iterator tmp = m_it; ++*this; return const_iterator(tmp);  }
 
       //Comparison operators
@@ -278,7 +278,7 @@
       explicit iterator(typename Icont::iterator it)
          :  const_iterator(it)
       {}
-   
+  
       typename Icont::iterator get()
       {  return this->m_it;   }
 
@@ -295,7 +295,7 @@
       pointer   operator->() const {  return  pointer(&this->m_it->m_data);  }
 
       //Increment / Decrement
-      iterator& operator++()  
+      iterator& operator++() 
          { this->prot_incr(); return *this;  }
 
       iterator operator++(int)
@@ -306,18 +306,18 @@
 
    public:
    //! <b>Effects</b>: Constructs a list taking the allocator as parameter.
-   //! 
+   //!
    //! <b>Throws</b>: If allocator_type's copy constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    slist()
       :  AllocHolder()
    {}
 
    //! <b>Effects</b>: Constructs a list taking the allocator as parameter.
-   //! 
+   //!
    //! <b>Throws</b>: If allocator_type's copy constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    explicit slist(const allocator_type& a)
       :  AllocHolder(a)
@@ -332,7 +332,7 @@
    //!
    //! <b>Throws</b>: If allocator_type's default constructor or copy constructor
    //!   throws or T's default or copy constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear to n.
    explicit slist(size_type n, const value_type& x, const allocator_type& a = allocator_type())
       :  AllocHolder(a)
@@ -347,25 +347,25 @@
    //! <b>Complexity</b>: Linear to the range [first, last).
    template <class InpIt>
    slist(InpIt first, InpIt last,
-         const allocator_type& a =  allocator_type()) 
+         const allocator_type& a =  allocator_type())
       : AllocHolder(a)
    { this->insert_after(this->before_begin(), first, last); }
 
    //! <b>Effects</b>: Copy constructs a list.
    //!
    //! <b>Postcondition</b>: x == *this.
-   //! 
+   //!
    //! <b>Throws</b>: If allocator_type's default constructor or copy constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear to the elements x contains.
-   slist(const slist& x) 
+   slist(const slist& x)
       : AllocHolder(x)
    { this->insert_after(this->before_begin(), x.begin(), x.end()); }
 
    //! <b>Effects</b>: Move constructor. Moves mx's resources to *this.
    //!
    //! <b>Throws</b>: If allocator_type's copy constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    slist(BOOST_RV_REF(slist) x)
       : AllocHolder(boost::move(static_cast<AllocHolder&>(x)))
@@ -374,11 +374,11 @@
    //! <b>Effects</b>: Copy constructs a list using the specified allocator.
    //!
    //! <b>Postcondition</b>: x == *this.
-   //! 
+   //!
    //! <b>Throws</b>: If allocator_type's default constructor or copy constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear to the elements x contains.
-   slist(const slist& x, const allocator_type &a) 
+   slist(const slist& x, const allocator_type &a)
       : AllocHolder(a)
    { this->insert_after(this->before_begin(), x.begin(), x.end()); }
 
@@ -386,7 +386,7 @@
    //!                 Moves x's resources to *this.
    //!
    //! <b>Throws</b>: If allocation or value_type's copy constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant if a == x.get_allocator(), linear otherwise.
    slist(BOOST_RV_REF(slist) x, const allocator_type &a)
       : AllocHolder(a)
@@ -401,8 +401,8 @@
 
    //! <b>Effects</b>: Makes *this contain the same elements as x.
    //!
-   //! <b>Postcondition</b>: this->size() == x.size(). *this contains a copy 
-   //! of each of x's elements. 
+   //! <b>Postcondition</b>: this->size() == x.size(). *this contains a copy
+   //! of each of x's elements.
    //!
    //! <b>Throws</b>: If memory allocation throws or T's copy constructor throws.
    //!
@@ -425,8 +425,8 @@
 
    //! <b>Effects</b>: Makes *this contain the same elements as x.
    //!
-   //! <b>Postcondition</b>: this->size() == x.size(). *this contains a copy 
-   //! of each of x's elements. 
+   //! <b>Postcondition</b>: this->size() == x.size(). *this contains a copy
+   //! of each of x's elements.
    //!
    //! <b>Throws</b>: If memory allocation throws or T's copy constructor throws.
    //!
@@ -460,18 +460,18 @@
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Linear to the number of elements.
-   ~slist() 
+   ~slist()
    {} //AllocHolder clears the slist
 
    //! <b>Effects</b>: Returns a copy of the internal allocator.
-   //! 
+   //!
    //! <b>Throws</b>: If allocator's copy constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    allocator_type get_allocator() const
    {  return allocator_type(this->node_alloc()); }
 
-   const stored_allocator_type &get_stored_allocator() const 
+   const stored_allocator_type &get_stored_allocator() const
    {  return this->node_alloc(); }
 
    stored_allocator_type &get_stored_allocator()
@@ -494,7 +494,7 @@
    //!
    //! <b>Complexity</b>: Linear to n.
    template <class InpIt>
-   void assign(InpIt first, InpIt last) 
+   void assign(InpIt first, InpIt last)
    {
       const bool aux_boolean = container_detail::is_convertible<InpIt, size_type>::value;
       typedef container_detail::bool_<aux_boolean> Result;
@@ -502,33 +502,33 @@
    }
 
    //! <b>Effects</b>: Returns an iterator to the first element contained in the list.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   iterator begin() 
+   iterator begin()
    { return iterator(this->icont().begin()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the list.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_iterator begin() const 
+   const_iterator begin() const
    {  return this->cbegin();   }
 
    //! <b>Effects</b>: Returns an iterator to the end of the list.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    iterator end()
    { return iterator(this->icont().end()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the list.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_iterator end() const
    {  return this->cend();   }
@@ -536,71 +536,71 @@
    //! <b>Effects</b>: Returns a non-dereferenceable iterator that,
    //! when incremented, yields begin().  This iterator may be used
    //! as the argument toinsert_after, erase_after, etc.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   iterator before_begin() 
+   iterator before_begin()
    {  return iterator(end());  }
 
-   //! <b>Effects</b>: Returns a non-dereferenceable const_iterator 
+   //! <b>Effects</b>: Returns a non-dereferenceable const_iterator
    //! that, when incremented, yields begin().  This iterator may be used
    //! as the argument toinsert_after, erase_after, etc.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_iterator before_begin() const
    {  return this->cbefore_begin();  }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the list.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_iterator cbegin() const 
+   const_iterator cbegin() const
    {  return const_iterator(this->non_const_icont().begin());   }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the list.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_iterator cend() const
    {  return const_iterator(this->non_const_icont().end());   }
 
-   //! <b>Effects</b>: Returns a non-dereferenceable const_iterator 
+   //! <b>Effects</b>: Returns a non-dereferenceable const_iterator
    //! that, when incremented, yields begin().  This iterator may be used
    //! as the argument toinsert_after, erase_after, etc.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_iterator cbefore_begin() const
    {  return const_iterator(end());  }
 
    //! <b>Effects</b>: Returns the number of the elements contained in the list.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   size_type size() const 
+   size_type size() const
    {  return this->icont().size(); }
 
    //! <b>Effects</b>: Returns the largest possible size of the list.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   size_type max_size() const 
+   size_type max_size() const
    {  return AllocHolder::max_size();  }
 
    //! <b>Effects</b>: Returns true if the list contains no elements.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   bool empty() const 
+   bool empty() const
    {  return !this->size();   }
 
    //! <b>Effects</b>: Swaps the contents of *this and x.
@@ -613,24 +613,24 @@
 
    //! <b>Requires</b>: !empty()
    //!
-   //! <b>Effects</b>: Returns a reference to the first element 
+   //! <b>Effects</b>: Returns a reference to the first element
    //!   from the beginning of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   reference front() 
+   reference front()
    {  return *this->begin();  }
 
    //! <b>Requires</b>: !empty()
    //!
-   //! <b>Effects</b>: Returns a const reference to the first element 
+   //! <b>Effects</b>: Returns a const reference to the first element
    //!   from the beginning of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reference front() const 
+   const_reference front() const
    {  return *this->begin();  }
 
    //! <b>Effects</b>: Inserts a copy of t in the beginning of the list.
@@ -668,24 +668,24 @@
    void pop_front()
    {  this->icont().pop_front_and_dispose(Destroyer(this->node_alloc()));      }
 
-   //! <b>Returns</b>: The iterator to the element before i in the sequence. 
-   //!   Returns the end-iterator, if either i is the begin-iterator or the 
-   //!   sequence is empty. 
-   //! 
-   //! <b>Throws</b>: Nothing.
-   //! 
-   //! <b>Complexity</b>: Linear to the number of elements before i. 
-   iterator previous(iterator p) 
+   //! <b>Returns</b>: The iterator to the element before i in the sequence.
+   //!   Returns the end-iterator, if either i is the begin-iterator or the
+   //!   sequence is empty.
+   //!
+   //! <b>Throws</b>: Nothing.
+   //!
+   //! <b>Complexity</b>: Linear to the number of elements before i.
+   iterator previous(iterator p)
    {  return iterator(this->icont().previous(p.get())); }
 
-   //! <b>Returns</b>: The const_iterator to the element before i in the sequence. 
-   //!   Returns the end-const_iterator, if either i is the begin-const_iterator or 
-   //!   the sequence is empty. 
-   //! 
-   //! <b>Throws</b>: Nothing.
-   //! 
-   //! <b>Complexity</b>: Linear to the number of elements before i. 
-   const_iterator previous(const_iterator p) 
+   //! <b>Returns</b>: The const_iterator to the element before i in the sequence.
+   //!   Returns the end-const_iterator, if either i is the begin-const_iterator or
+   //!   the sequence is empty.
+   //!
+   //! <b>Throws</b>: Nothing.
+   //!
+   //! <b>Complexity</b>: Linear to the number of elements before i.
+   const_iterator previous(const_iterator p)
    {  return const_iterator(this->icont().previous(p.get())); }
 
    //! <b>Requires</b>: p must be a valid iterator of *this.
@@ -694,14 +694,14 @@
    //!    by prev_p.
    //!
    //! <b>Returns</b>: An iterator to the inserted element.
-   //! 
+   //!
    //! <b>Throws</b>: If memory allocation throws or T's copy constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Amortized constant time.
    //!
    //! <b>Note</b>: Does not affect the validity of iterators and references of
    //!   previous values.
-   iterator insert_after(const_iterator prev_pos, insert_const_ref_type x) 
+   iterator insert_after(const_iterator prev_pos, insert_const_ref_type x)
    {  return this->priv_insert_after(prev_pos, x); }
 
    #if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -720,14 +720,14 @@
    //!    p pointed by prev_pos.
    //!
    //! <b>Returns</b>: An iterator to the inserted element.
-   //! 
+   //!
    //! <b>Throws</b>: If memory allocation throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Amortized constant time.
    //!
    //! <b>Note</b>: Does not affect the validity of iterators and references of
    //!   previous values.
-   iterator insert_after(const_iterator prev_pos, BOOST_RV_REF(value_type) x) 
+   iterator insert_after(const_iterator prev_pos, BOOST_RV_REF(value_type) x)
    {  return iterator(this->icont().insert_after(prev_pos.get(), *this->create_node(boost::move(x)))); }
 
    //! <b>Requires</b>: prev_pos must be a valid iterator of *this.
@@ -744,19 +744,19 @@
    {  this->priv_create_and_insert_nodes(prev_pos, n, x); }
 
    //! <b>Requires</b>: prev_pos must be a valid iterator of *this.
-   //! 
-   //! <b>Effects</b>: Inserts the range pointed by [first, last) 
+   //!
+   //! <b>Effects</b>: Inserts the range pointed by [first, last)
    //!   after the p prev_pos.
-   //! 
+   //!
    //! <b>Throws</b>: If memory allocation throws, T's constructor from a
    //!   dereferenced InpIt throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear to the number of elements inserted.
-   //! 
+   //!
    //! <b>Note</b>: Does not affect the validity of iterators and references of
    //!   previous values.
    template <class InIter>
-   void insert_after(const_iterator prev_pos, InIter first, InIter last) 
+   void insert_after(const_iterator prev_pos, InIter first, InIter last)
    {
       const bool aux_boolean = container_detail::is_convertible<InIter, size_type>::value;
       typedef container_detail::bool_<aux_boolean> Result;
@@ -770,7 +770,7 @@
    //! <b>Throws</b>: If memory allocation throws or x's copy constructor throws.
    //!
    //! <b>Complexity</b>: Linear to the elements before p.
-   iterator insert(const_iterator position, insert_const_ref_type x) 
+   iterator insert(const_iterator position, insert_const_ref_type x)
    {  return this->priv_insert(position, x); }
 
    #if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -790,7 +790,7 @@
    //! <b>Throws</b>: If memory allocation throws.
    //!
    //! <b>Complexity</b>: Linear to the elements before p.
-   iterator insert(const_iterator p, BOOST_RV_REF(value_type) x) 
+   iterator insert(const_iterator p, BOOST_RV_REF(value_type) x)
    {  return this->insert_after(previous(p), boost::move(x)); }
 
    //! <b>Requires</b>: p must be a valid iterator of *this.
@@ -800,9 +800,9 @@
    //! <b>Throws</b>: If memory allocation throws or T's copy constructor throws.
    //!
    //! <b>Complexity</b>: Linear to n plus linear to the elements before p.
-   void insert(const_iterator p, size_type n, const value_type& x) 
+   void insert(const_iterator p, size_type n, const value_type& x)
    {  return this->insert_after(previous(p), n, x); }
-      
+     
    //! <b>Requires</b>: p must be a valid iterator of *this.
    //!
    //! <b>Effects</b>: Insert a copy of the [first, last) range before p.
@@ -813,7 +813,7 @@
    //! <b>Complexity</b>: Linear to std::distance [first, last) plus
    //!    linear to the elements before p.
    template <class InIter>
-   void insert(const_iterator p, InIter first, InIter last) 
+   void insert(const_iterator p, InIter first, InIter last)
    {  return this->insert_after(previous(p), first, last); }
 
    #if defined(BOOST_CONTAINER_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -892,11 +892,11 @@
    //!
    //! <b>Returns</b>: the first element remaining beyond the removed elements,
    //!   or end() if no such element exists.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   //! 
+   //!
    //! <b>Note</b>: Does not invalidate iterators or references to non erased elements.
    iterator erase_after(const_iterator prev_pos)
    {
@@ -904,17 +904,17 @@
    }
 
    //! <b>Effects</b>: Erases the range (before_first, last) from
-   //!   the list. 
+   //!   the list.
    //!
    //! <b>Returns</b>: the first element remaining beyond the removed elements,
    //!   or end() if no such element exists.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear to the number of erased elements.
-   //! 
+   //!
    //! <b>Note</b>: Does not invalidate iterators or references to non erased elements.
-   iterator erase_after(const_iterator before_first, const_iterator last) 
+   iterator erase_after(const_iterator before_first, const_iterator last)
    {
       return iterator(this->icont().erase_after_and_dispose(before_first.get(), last.get(), Destroyer(this->node_alloc())));
    }
@@ -926,7 +926,7 @@
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Linear to the number of elements before p.
-   iterator erase(const_iterator p) 
+   iterator erase(const_iterator p)
    {  return iterator(this->erase_after(previous(p))); }
 
    //! <b>Requires</b>: first and last must be valid iterator to elements in *this.
@@ -953,7 +953,7 @@
          --new_size;
          cur = cur_next;
       }
-      if (cur_next != end_n) 
+      if (cur_next != end_n)
          this->erase_after(const_iterator(cur), const_iterator(end_n));
       else
          this->insert_after(const_iterator(cur), new_size, x);
@@ -970,7 +970,7 @@
       typename Icont::iterator end_n(this->icont().end()), cur(this->icont().before_begin()), cur_next;
       size_type len = this->size();
       size_type left = new_size;
-      
+     
       while (++(cur_next = cur) != end_n && left > 0){
          --left;
          cur = cur_next;
@@ -988,7 +988,7 @@
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the list.
-   void clear() 
+   void clear()
    {  this->icont().clear_and_dispose(Destroyer(this->node_alloc()));  }
 
    //! <b>Requires</b>: p must point to an element contained
@@ -1001,7 +1001,7 @@
    //!   are not equal.
    //!
    //! <b>Complexity</b>: Linear to the elements in x.
-   //! 
+   //!
    //! <b>Note</b>: 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& x)
@@ -1016,16 +1016,16 @@
 
    //! <b>Requires</b>: prev_pos must be a valid iterator of this.
    //!   i must point to an element contained in list x.
-   //! 
-   //! <b>Effects</b>: Transfers the value pointed by i, from list x to this list, 
+   //!
+   //! <b>Effects</b>: Transfers the value pointed by i, from list x to this list,
    //!   after the element pointed by prev_pos.
-   //!   If prev_pos == prev or prev_pos == ++prev, this function is a null operation. 
-   //! 
+   //!   If prev_pos == prev or prev_pos == ++prev, this function is a null operation.
+   //!
    //! <b>Throws</b>: std::runtime_error if this' allocator and x's allocator
    //!   are not equal.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   //! 
+   //!
    //! <b>Note</b>: 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& x, const_iterator prev)
@@ -1041,18 +1041,18 @@
    //! <b>Requires</b>: prev_pos must be a valid iterator of this.
    //!   before_first and before_last must be valid iterators of x.
    //!   prev_pos must not be contained in [before_first, before_last) range.
-   //! 
+   //!
    //! <b>Effects</b>: Transfers the range [before_first + 1, before_last + 1)
    //!   from list x to this list, after the element pointed by prev_pos.
-   //! 
+   //!
    //! <b>Throws</b>: std::runtime_error if this' allocator and x's allocator
    //!   are not equal.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear to the number of transferred elements.
-   //! 
+   //!
    //! <b>Note</b>: 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& x, 
+   void splice_after(const_iterator prev_pos,      slist& x,
       const_iterator before_first,  const_iterator before_last)
    {
       if((NodeAlloc&)*this == (NodeAlloc&)x){
@@ -1068,18 +1068,18 @@
    //!   before_first and before_last must be valid iterators of x.
    //!   prev_pos must not be contained in [before_first, before_last) range.
    //!   n == std::distance(before_first, before_last)
-   //! 
+   //!
    //! <b>Effects</b>: Transfers the range [before_first + 1, before_last + 1)
    //!   from list x to this list, after the element pointed by prev_pos.
-   //! 
+   //!
    //! <b>Throws</b>: std::runtime_error if this' allocator and x's allocator
    //!   are not equal.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   //! 
+   //!
    //! <b>Note</b>: 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& x, 
+   void splice_after(const_iterator prev_pos,      slist& x,
                      const_iterator before_first,  const_iterator before_last,
                      size_type n)
    {
@@ -1102,24 +1102,24 @@
    //!   are not equal.
    //!
    //! <b>Complexity</b>: Linear in distance(begin(), p), and linear in x.size().
-   //! 
+   //!
    //! <b>Note</b>: 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, ThisType& x) 
+   void splice(const_iterator p, ThisType& x)
    {  this->splice_after(this->previous(p), x);  }
 
    //! <b>Requires</b>: p must point to an element contained
    //!   by this list. i must point to an element contained in list x.
-   //! 
-   //! <b>Effects</b>: Transfers the value pointed by i, from list x to this list, 
+   //!
+   //! <b>Effects</b>: Transfers the value pointed by i, from list x to this list,
    //!   before the the element pointed by p. No destructors or copy constructors are called.
-   //!   If p == i or p == ++i, this function is a null operation. 
-   //! 
+   //!   If p == i or p == ++i, this function is a null operation.
+   //!
    //! <b>Throws</b>: std::runtime_error if this' allocator and x's allocator
    //!   are not equal.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear in distance(begin(), p), and in distance(x.begin(), i).
-   //! 
+   //!
    //! <b>Note</b>: 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, slist& x, const_iterator i)
@@ -1127,37 +1127,37 @@
 
    //! <b>Requires</b>: p must point to an element contained
    //!   by this list. first and last must point to elements contained in list x.
-   //! 
-   //! <b>Effects</b>: Transfers the range pointed by first and last from list x to this list, 
+   //!
+   //! <b>Effects</b>: Transfers the range pointed by first and last from list x to this list,
    //!   before the the element pointed by p. No destructors or copy constructors are called.
-   //! 
+   //!
    //! <b>Throws</b>: std::runtime_error if this' allocator and x's allocator
    //!   are not equal.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear in distance(begin(), p), in distance(x.begin(), first),
    //!   and in distance(first, last).
-   //! 
+   //!
    //! <b>Note</b>: 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, slist& x, const_iterator first, const_iterator last)
    {  this->splice_after(previous(p), x, previous(first), previous(last));  }
 
-   //! <b>Effects</b>: Reverses the order of elements in the list. 
-   //! 
+   //! <b>Effects</b>: Reverses the order of elements in the list.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: This function is linear time.
-   //! 
+   //!
    //! <b>Note</b>: Iterators and references are not invalidated
-   void reverse() 
+   void reverse()
    {  this->icont().reverse();  }
 
    //! <b>Effects</b>: Removes all the elements that compare equal to value.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear time. It performs exactly size() comparisons for equality.
-   //! 
+   //!
    //! <b>Note</b>: The relative order of elements that are not removed is unchanged,
    //!   and iterators to elements that are not removed remain valid.
    void remove(const T& value)
@@ -1165,57 +1165,57 @@
 
    //! <b>Effects</b>: Removes all the elements for which a specified
    //!   predicate is satisfied.
-   //! 
+   //!
    //! <b>Throws</b>: If pred throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear time. It performs exactly size() calls to the predicate.
-   //! 
+   //!
    //! <b>Note</b>: The relative order of elements that are not removed is unchanged,
    //!   and iterators to elements that are not removed remain valid.
-   template <class Pred> 
+   template <class Pred>
    void remove_if(Pred pred)
    {
       typedef ValueCompareToNodeCompare<Pred> Predicate;
       this->icont().remove_and_dispose_if(Predicate(pred), Destroyer(this->node_alloc()));
    }
 
-   //! <b>Effects</b>: Removes adjacent duplicate elements or adjacent 
+   //! <b>Effects</b>: Removes adjacent duplicate elements or adjacent
    //!   elements that are equal from the list.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear time (size()-1 comparisons calls to pred()).
-   //! 
+   //!
    //! <b>Note</b>: 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(value_equal());  }
 
-   //! <b>Effects</b>: Removes adjacent duplicate elements or adjacent 
+   //! <b>Effects</b>: Removes adjacent duplicate elements or adjacent
    //!   elements that satisfy some binary predicate from the list.
-   //! 
+   //!
    //! <b>Throws</b>: If pred throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear time (size()-1 comparisons equality comparisons).
-   //! 
+   //!
    //! <b>Note</b>: The relative order of elements that are not removed is unchanged,
    //!   and iterators to elements that are not removed remain valid.
-   template <class Pred> 
+   template <class Pred>
    void unique(Pred pred)
    {
       typedef ValueCompareToNodeCompare<Pred> Predicate;
       this->icont().unique_and_dispose(Predicate(pred), Destroyer(this->node_alloc()));
    }
 
-   //! <b>Requires</b>: The lists x and *this must be distinct. 
+   //! <b>Requires</b>: The lists x and *this must be distinct.
    //!
    //! <b>Effects</b>: 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.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: This function is linear time: it performs at most
    //!   size() + x.size() - 1 comparisons.
    void merge(slist & x)
@@ -1223,17 +1223,17 @@
 
    //! <b>Requires</b>: 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.
+   //!
    //! <b>Effects</b>: 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.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: This function is linear time: it performs at most
    //!   size() + x.size() - 1 comparisons.
-   //! 
+   //!
    //! <b>Note</b>: Iterators and references to *this are not invalidated.
    template <class StrictWeakOrdering>
    void merge(slist& x, StrictWeakOrdering comp)
@@ -1247,28 +1247,28 @@
       }
    }
 
-   //! <b>Effects</b>: This function sorts the list *this according to std::less<value_type>. 
+   //! <b>Effects</b>: 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.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Notes</b>: Iterators and references are not invalidated.
-   //! 
+   //!
    //! <b>Complexity</b>: The number of comparisons is approximately N log N, where N
    //!   is the list's size.
    void sort()
    {  this->sort(value_less());  }
 
-   //! <b>Effects</b>: This function sorts the list *this according to std::less<value_type>. 
+   //! <b>Effects</b>: 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.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Notes</b>: Iterators and references are not invalidated.
-   //! 
+   //!
    //! <b>Complexity</b>: The number of comparisons is approximately N log N, where N
    //!   is the list's size.
-   template <class StrictWeakOrdering> 
+   template <class StrictWeakOrdering>
    void sort(StrictWeakOrdering comp)
    {
       // nothing if the slist has length 0 or 1.
@@ -1279,10 +1279,10 @@
 
    /// @cond
    private:
-   iterator priv_insert(const_iterator p, const value_type& x) 
+   iterator priv_insert(const_iterator p, const value_type& x)
    {  return this->insert_after(previous(p), x); }
 
-   iterator priv_insert_after(const_iterator prev_pos, const value_type& x) 
+   iterator priv_insert_after(const_iterator prev_pos, const value_type& x)
    {  return iterator(this->icont().insert_after(prev_pos.get(), *this->create_node(x))); }
 
    void priv_push_front(const value_type &x)
@@ -1362,10 +1362,10 @@
    {  this->priv_create_and_insert_nodes(prev, first, last);   }
 
    template<class Integer>
-   void priv_insert_dispatch(const_iterator prev, Integer n, Integer x, container_detail::true_) 
+   void priv_insert_dispatch(const_iterator prev, Integer n, Integer x, container_detail::true_)
    {  this->priv_create_and_insert_nodes(prev, (size_type)n, x);  }
 
-   void priv_fill_assign(size_type n, const T& val) 
+   void priv_fill_assign(size_type n, const T& val)
    {
       iterator end_n(this->end());
       iterator prev(this->before_begin());
@@ -1404,11 +1404,11 @@
    }
 
    template <class Int>
-   void priv_insert_after_range_dispatch(const_iterator prev_pos, Int n, Int x, container_detail::true_) 
+   void priv_insert_after_range_dispatch(const_iterator prev_pos, Int n, Int x, container_detail::true_)
    {  this->priv_create_and_insert_nodes(prev_pos, (size_type)n, x);  }
 
    template <class InIter>
-   void priv_insert_after_range_dispatch(const_iterator prev_pos, InIter first, InIter last, container_detail::false_) 
+   void priv_insert_after_range_dispatch(const_iterator prev_pos, InIter first, InIter last, container_detail::false_)
    {  this->priv_create_and_insert_nodes(prev_pos, first, last); }
 
    //Functors for member algorithm defaults
@@ -1438,7 +1438,7 @@
 };
 
 template <class T, class A>
-inline bool 
+inline bool
 operator==(const slist<T,A>& x, const slist<T,A>& y)
 {
    if(x.size() != y.size()){
@@ -1465,27 +1465,27 @@
 }
 
 template <class T, class A>
-inline bool 
-operator!=(const slist<T,A>& sL1, const slist<T,A>& sL2) 
+inline bool
+operator!=(const slist<T,A>& sL1, const slist<T,A>& sL2)
    {  return !(sL1 == sL2);   }
 
 template <class T, class A>
-inline bool 
-operator>(const slist<T,A>& sL1, const slist<T,A>& sL2) 
+inline bool
+operator>(const slist<T,A>& sL1, const slist<T,A>& sL2)
    {  return sL2 < sL1; }
 
 template <class T, class A>
-inline bool 
+inline bool
 operator<=(const slist<T,A>& sL1, const slist<T,A>& sL2)
    {  return !(sL2 < sL1); }
 
 template <class T, class A>
-inline bool 
+inline bool
 operator>=(const slist<T,A>& sL1, const slist<T,A>& sL2)
    {  return !(sL1 < sL2); }
 
 template <class T, class A>
-inline void swap(slist<T,A>& x, slist<T,A>& y) 
+inline void swap(slist<T,A>& x, slist<T,A>& y)
    {  x.swap(y);  }
 
 }}
@@ -1513,12 +1513,12 @@
 
 ///@cond
 
-//Ummm, I don't like to define things in namespace std, but 
+//Ummm, I don't like to define things in namespace std, but
 //there is no other way
 namespace std {
 
 template <class T, class A>
-class insert_iterator<boost::container::slist<T, A> > 
+class insert_iterator<boost::container::slist<T, A> >
 {
  protected:
    typedef boost::container::slist<T, A> Container;
@@ -1532,14 +1532,14 @@
    typedef void                pointer;
    typedef void                reference;
 
-   insert_iterator(Container& x, 
-                   typename Container::iterator i, 
-                   bool is_previous = false) 
+   insert_iterator(Container& x,
+                   typename Container::iterator i,
+                   bool is_previous = false)
       : container(&x), iter(is_previous ? i : x.previous(i)){ }
 
-   insert_iterator<Container>& 
-      operator=(const typename Container::value_type& value) 
-   { 
+   insert_iterator<Container>&
+      operator=(const typename Container::value_type& value)
+   {
       iter = container->insert_after(iter, value);
       return *this;
    }

Modified: branches/release/boost/container/stable_vector.hpp
==============================================================================
--- branches/release/boost/container/stable_vector.hpp	(original)
+++ branches/release/boost/container/stable_vector.hpp	2012-05-24 12:36:39 EDT (Thu, 24 May 2012)
@@ -93,7 +93,7 @@
    {
       if(do_clear_){
          c_.clear();
-         c_.clear_pool();  
+         c_.clear_pool(); 
       }
    }
 
@@ -172,7 +172,7 @@
    iterator(const iterator<T, T&, typename boost::intrusive::pointer_traits<Pointer>::template rebind_pointer<T>::type>& x)
       : pn(x.pn)
    {}
-   
+  
    private:
    static node_type_ptr_t node_ptr_cast(const void_ptr &p)
    {
@@ -208,7 +208,7 @@
    pointer   operator->() const {  return  pointer(&this->dereference());  }
 
    //Increment / Decrement
-   iterator& operator++()  
+   iterator& operator++() 
    {  this->increment(); return *this;  }
 
    iterator operator++(int)
@@ -328,11 +328,11 @@
 //! stability.
 //!
 //! More details taken the author's blog:
-//! (<a href="http://bannalia.blogspot.com/2008/09/introducing-stablevector.html" > 
+//! (<a href="http://bannalia.blogspot.com/2008/09/introducing-stablevector.html" >
 //! Introducing stable_vector</a>)
 //!
 //! We present stable_vector, a fully STL-compliant stable container that provides
-//! most of the features of std::vector except element contiguity. 
+//! most of the features of std::vector except element contiguity.
 //!
 //! General properties: stable_vector satisfies all the requirements of a container,
 //! a reversible container and a sequence and provides all the optional operations
@@ -398,7 +398,7 @@
       integral_constant<unsigned, 1>                  allocator_v1;
    typedef ::boost::container::container_detail::
       integral_constant<unsigned, 2>                  allocator_v2;
-   typedef ::boost::container::container_detail::integral_constant 
+   typedef ::boost::container::container_detail::integral_constant
       <unsigned, boost::container::container_detail::
       version<A>::value>                              alloc_version;
    typedef typename allocator_traits_type::
@@ -481,9 +481,9 @@
    public:
 
    //! <b>Effects</b>: Default constructs a stable_vector.
-   //! 
+   //!
    //! <b>Throws</b>: If allocator_type's default constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    stable_vector()
       : internal_data(), impl()
@@ -492,9 +492,9 @@
    }
 
    //! <b>Effects</b>: Constructs a stable_vector taking the allocator as parameter.
-   //! 
+   //!
    //! <b>Throws</b>: If allocator_type's copy constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    explicit stable_vector(const allocator_type& al)
       : internal_data(al),impl(al)
@@ -507,7 +507,7 @@
    //!
    //! <b>Throws</b>: If allocator_type's default constructor or copy constructor
    //!   throws or T's default or copy constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear to n.
    explicit stable_vector(size_type n)
       : internal_data(),impl()
@@ -523,7 +523,7 @@
    //!
    //! <b>Throws</b>: If allocator_type's default constructor or copy constructor
    //!   throws or T's default or copy constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear to n.
    stable_vector(size_type n, const T& t, const allocator_type& al = allocator_type())
       : internal_data(al),impl(al)
@@ -554,7 +554,7 @@
    //! <b>Effects</b>: Copy constructs a stable_vector.
    //!
    //! <b>Postcondition</b>: x == *this.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear to the elements x contains.
    stable_vector(const stable_vector& x)
       : internal_data(allocator_traits<node_allocator_type>::
@@ -571,7 +571,7 @@
    //! <b>Effects</b>: Move constructor. Moves mx's resources to *this.
    //!
    //! <b>Throws</b>: If allocator_type's copy constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    stable_vector(BOOST_RV_REF(stable_vector) x)
       : internal_data(boost::move(x.node_alloc())), impl(boost::move(x.impl))
@@ -582,7 +582,7 @@
    //! <b>Effects</b>: Copy constructs a stable_vector using the specified allocator.
    //!
    //! <b>Postcondition</b>: x == *this.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear to the elements x contains.
    stable_vector(const stable_vector& x, const allocator_type &a)
       : internal_data(a), impl(a)
@@ -597,7 +597,7 @@
    //!                 Moves mx's resources to *this.
    //!
    //! <b>Throws</b>: If allocator_type's copy constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant if a == x.get_allocator(), linear otherwise
    stable_vector(BOOST_RV_REF(stable_vector) x, const allocator_type &a)
       : internal_data(a), impl(a)
@@ -622,13 +622,13 @@
    ~stable_vector()
    {
       this->clear();
-      clear_pool();  
+      clear_pool(); 
    }
 
    //! <b>Effects</b>: Makes *this contain the same elements as x.
    //!
-   //! <b>Postcondition</b>: this->size() == x.size(). *this contains a copy 
-   //! of each of x's elements. 
+   //! <b>Postcondition</b>: this->size() == x.size(). *this contains a copy
+   //! of each of x's elements.
    //!
    //! <b>Throws</b>: If memory allocation throws or T's copy constructor throws.
    //!
@@ -711,146 +711,146 @@
    }
 
    //! <b>Effects</b>: Returns a copy of the internal allocator.
-   //! 
+   //!
    //! <b>Throws</b>: If allocator's copy constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    allocator_type get_allocator()const  {return this->node_alloc();}
 
    //! <b>Effects</b>: Returns a reference to the internal allocator.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   //! 
+   //!
    //! <b>Note</b>: Non-standard extension.
    const stored_allocator_type &get_stored_allocator() const BOOST_CONTAINER_NOEXCEPT
    {  return node_alloc(); }
 
    //! <b>Effects</b>: Returns a reference to the internal allocator.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   //! 
+   //!
    //! <b>Note</b>: Non-standard extension.
    stored_allocator_type &get_stored_allocator() BOOST_CONTAINER_NOEXCEPT
    {  return node_alloc(); }
 
 
    //! <b>Effects</b>: Returns an iterator to the first element contained in the stable_vector.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    iterator  begin()
    {   return (impl.empty()) ? end(): iterator(node_ptr_cast(impl.front())) ;   }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the stable_vector.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_iterator  begin()const
    {   return (impl.empty()) ? cend() : const_iterator(node_ptr_cast(impl.front())) ;   }
 
    //! <b>Effects</b>: Returns an iterator to the end of the stable_vector.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    iterator        end()                {return iterator(get_end_node());}
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the stable_vector.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_iterator  end()const           {return const_iterator(get_end_node());}
 
-   //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning 
-   //! of the reversed stable_vector. 
-   //! 
+   //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning
+   //! of the reversed stable_vector.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    reverse_iterator       rbegin()      {return reverse_iterator(this->end());}
 
-   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning 
-   //! of the reversed stable_vector. 
-   //! 
+   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
+   //! of the reversed stable_vector.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_reverse_iterator rbegin()const {return const_reverse_iterator(this->end());}
 
    //! <b>Effects</b>: Returns a reverse_iterator pointing to the end
-   //! of the reversed stable_vector. 
-   //! 
+   //! of the reversed stable_vector.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    reverse_iterator       rend()        {return reverse_iterator(this->begin());}
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
-   //! of the reversed stable_vector. 
-   //! 
+   //! of the reversed stable_vector.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_reverse_iterator rend()const   {return const_reverse_iterator(this->begin());}
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the stable_vector.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_iterator         cbegin()const {return this->begin();}
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the stable_vector.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_iterator         cend()const   {return this->end();}
 
-   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning 
-   //! of the reversed stable_vector. 
-   //! 
+   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
+   //! of the reversed stable_vector.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_reverse_iterator crbegin()const{return this->rbegin();}
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
-   //! of the reversed stable_vector. 
-   //! 
+   //! of the reversed stable_vector.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_reverse_iterator crend()const  {return this->rend();}
 
    //! <b>Effects</b>: Returns the number of the elements contained in the stable_vector.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    size_type size() const
    {  return impl.empty() ? 0 : (impl.size() - ExtraPointers);   }
 
    //! <b>Effects</b>: Returns the largest possible size of the stable_vector.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    size_type max_size() const
    {  return impl.max_size() - ExtraPointers;  }
 
    //! <b>Effects</b>: Number of elements for which memory has been allocated.
    //!   capacity() is always greater than or equal to size().
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    size_type capacity() const
    {
@@ -865,9 +865,9 @@
    }
 
    //! <b>Effects</b>: Returns true if the stable_vector contains no elements.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    bool empty() const
    {  return impl.empty() || impl.size() == ExtraPointers;  }
@@ -907,7 +907,7 @@
    //!   effect. Otherwise, it is a request for allocation of additional memory.
    //!   If the request is successful, then capacity() is greater than or equal to
    //!   n; otherwise, capacity() is unchanged. In either case, size() is unchanged.
-   //! 
+   //!
    //! <b>Throws</b>: If memory allocation allocation throws.
    void reserve(size_type n)
    {
@@ -915,7 +915,7 @@
       if(n > this->max_size())
          throw std::bad_alloc();
 
-      size_type size = this->size();   
+      size_type size = this->size();  
       size_type old_capacity = this->capacity();
       if(n > old_capacity){
          this->initialize_end_node(n);
@@ -935,31 +935,31 @@
 
    //! <b>Requires</b>: size() > n.
    //!
-   //! <b>Effects</b>: Returns a reference to the nth element 
+   //! <b>Effects</b>: Returns a reference to the nth element
    //!   from the beginning of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    reference operator[](size_type n){return value(impl[n]);}
 
    //! <b>Requires</b>: size() > n.
    //!
-   //! <b>Effects</b>: Returns a const reference to the nth element 
+   //! <b>Effects</b>: Returns a const reference to the nth element
    //!   from the beginning of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_reference operator[](size_type n)const{return value(impl[n]);}
 
    //! <b>Requires</b>: size() > n.
    //!
-   //! <b>Effects</b>: Returns a reference to the nth element 
+   //! <b>Effects</b>: Returns a reference to the nth element
    //!   from the beginning of the container.
-   //! 
+   //!
    //! <b>Throws</b>: std::range_error if n >= size()
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    reference at(size_type n)
    {
@@ -970,11 +970,11 @@
 
    //! <b>Requires</b>: size() > n.
    //!
-   //! <b>Effects</b>: Returns a const reference to the nth element 
+   //! <b>Effects</b>: Returns a const reference to the nth element
    //!   from the beginning of the container.
-   //! 
+   //!
    //! <b>Throws</b>: std::range_error if n >= size()
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_reference at(size_type n)const
    {
@@ -987,9 +987,9 @@
    //!
    //! <b>Effects</b>: Returns a reference to the first
    //!   element of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    reference front()
    {  return value(impl.front());   }
@@ -998,9 +998,9 @@
    //!
    //! <b>Effects</b>: Returns a const reference to the first
    //!   element of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_reference front()const
    {  return value(impl.front());   }
@@ -1009,9 +1009,9 @@
    //!
    //! <b>Effects</b>: Returns a reference to the last
    //!   element of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    reference back()
    {  return value(*(&impl.back() - ExtraPointers)); }
@@ -1020,9 +1020,9 @@
    //!
    //! <b>Effects</b>: Returns a const reference to the last
    //!   element of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_reference back()const
    {  return value(*(&impl.back() - ExtraPointers)); }
@@ -1033,7 +1033,7 @@
    //!   T's copy constructor throws.
    //!
    //! <b>Complexity</b>: Amortized constant time.
-   void push_back(insert_const_ref_type x) 
+   void push_back(insert_const_ref_type x)
    {  return priv_push_back(x);  }
 
    #if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -1051,7 +1051,7 @@
    //! <b>Throws</b>: If memory allocation throws.
    //!
    //! <b>Complexity</b>: Amortized constant time.
-   void push_back(BOOST_RV_REF(T) t) 
+   void push_back(BOOST_RV_REF(T) t)
    {  this->insert(end(), boost::move(t));  }
 
    //! <b>Effects</b>: Removes the last element from the stable_vector.
@@ -1070,7 +1070,7 @@
    //!
    //! <b>Complexity</b>: If position is end(), amortized constant time
    //!   Linear time otherwise.
-   iterator insert(const_iterator position, insert_const_ref_type x) 
+   iterator insert(const_iterator position, insert_const_ref_type x)
    {  return this->priv_insert(position, x); }
 
    #if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -1090,7 +1090,7 @@
    //!
    //! <b>Complexity</b>: If position is end(), amortized constant time
    //!   Linear time otherwise.
-   iterator insert(const_iterator position, BOOST_RV_REF(T) x) 
+   iterator insert(const_iterator position, BOOST_RV_REF(T) x)
    {
       typedef repeat_iterator<T, difference_type>           repeat_it;
       typedef boost::move_iterator<repeat_it> repeat_move_it;
@@ -1210,7 +1210,7 @@
    //!
    //! <b>Throws</b>: Nothing.
    //!
-   //! <b>Complexity</b>: Linear to the elements between pos and the 
+   //! <b>Complexity</b>: Linear to the elements between pos and the
    //!   last element. Constant if pos is the last element.
    iterator erase(const_iterator position)
    {
@@ -1581,7 +1581,7 @@
    {
       for(; first!=last; ++first){
          this->insert(position, *first);
-      }    
+      }   
    }
 
    template <class InputIterator>
@@ -1692,7 +1692,7 @@
          return false;
       }
       for(const_impl_iterator it = impl.begin(), it_end = get_last_align(); it != it_end; ++it){
-         if(const_void_ptr(node_ptr_cast(*it)->up) != 
+         if(const_void_ptr(node_ptr_cast(*it)->up) !=
                const_void_ptr(const_void_ptr_ptr(&*it)))
             return false;
       }

Modified: branches/release/boost/container/string.hpp
==============================================================================
--- branches/release/boost/container/string.hpp	(original)
+++ branches/release/boost/container/string.hpp	2012-05-24 12:36:39 EDT (Thu, 24 May 2012)
@@ -50,8 +50,8 @@
 
 #include <functional>
 #include <string>
-#include <stdexcept>      
-#include <utility>  
+#include <stdexcept>     
+#include <utility> 
 #include <iterator>
 #include <memory>
 #include <algorithm>
@@ -78,14 +78,14 @@
 /// @cond
 namespace container_detail {
 // ------------------------------------------------------------
-// Class basic_string_base.  
+// Class basic_string_base. 
 
 // basic_string_base is a helper class that makes it it easier to write
 // an exception-safe version of basic_string.  The constructor allocates,
 // but does not initialize, a block of memory.  The destructor
 // deallocates, but does not destroy elements within, a block of
-// memory.  The destructor assumes that the memory either is the internal buffer, 
-// or else points to a block of memory that was allocated using _String_base's 
+// memory.  The destructor assumes that the memory either is the internal buffer,
+// or else points to a block of memory that was allocated using _String_base's
 // allocator and whose size is this->m_storage.
 template <class A>
 class basic_string_base
@@ -111,22 +111,22 @@
 
    basic_string_base(const allocator_type& a, size_type n)
       : members_(a)
-   {  
-      this->init(); 
+   { 
+      this->init();
       this->allocate_initial_block(n);
    }
 
    basic_string_base(BOOST_RV_REF(basic_string_base) b)
       :  members_(boost::move(b.alloc()))
-   {  
+   { 
       this->init();
-      this->swap_data(b); 
+      this->swap_data(b);
    }
 
-   ~basic_string_base() 
-   {  
+   ~basic_string_base()
+   { 
       if(!this->is_short()){
-         this->deallocate_block(); 
+         this->deallocate_block();
          allocator_traits_type::destroy
             ( this->alloc()
             , static_cast<long_t*>(static_cast<void*>(&this->members_.m_repr.r))
@@ -136,7 +136,7 @@
 
    private:
 
-   //This is the structure controlling a long string 
+   //This is the structure controlling a long string
    struct long_t
    {
       size_type      is_short  : 1;
@@ -175,8 +175,8 @@
 
    //This type has the same alignment and size as long_t but it's POD
    //so, unlike long_t, it can be placed in a union
-   
-   typedef typename boost::aligned_storage< sizeof(long_t), 
+  
+   typedef typename boost::aligned_storage< sizeof(long_t),
        container_detail::alignment_of<long_t>::value>::type   long_raw_t;
 
    protected:
@@ -187,13 +187,13 @@
       container_detail::ct_rounded_size<sizeof(short_header),  AlignmentOfValueType>::value;
    static const size_type  ZeroCostInternalBufferChars =
       (sizeof(long_t) - ShortDataOffset)/sizeof(value_type);
-   static const size_type  UnalignedFinalInternalBufferChars = 
+   static const size_type  UnalignedFinalInternalBufferChars =
       (ZeroCostInternalBufferChars > MinInternalBufferChars) ?
                 ZeroCostInternalBufferChars : MinInternalBufferChars;
 
    struct short_t
    {
-      short_header   h; 
+      short_header   h;
       value_type     data[UnalignedFinalInternalBufferChars];
    };
 
@@ -241,7 +241,7 @@
    {  return static_cast<bool>(this->members_.m_repr.s.h.is_short != 0);  }
 
    void is_short(bool yes)
-   {  
+   { 
       if(yes && !this->is_short()){
          allocator_traits_type::destroy
             ( this->alloc()
@@ -273,7 +273,7 @@
 
    std::pair<pointer, bool>
       allocation_command(allocation_type command,
-                         size_type limit_size, 
+                         size_type limit_size,
                          size_type preferred_size,
                          size_type &received_size, pointer reuse = 0)
    {
@@ -287,7 +287,7 @@
 
    std::pair<pointer, bool>
       allocation_command(allocation_type command,
-                         size_type limit_size, 
+                         size_type limit_size,
                          size_type preferred_size,
                          size_type &received_size,
                          const pointer &reuse,
@@ -303,21 +303,21 @@
 
    std::pair<pointer, bool>
       allocation_command(allocation_type command,
-                         size_type limit_size, 
+                         size_type limit_size,
                          size_type preferred_size,
                          size_type &received_size,
                          pointer reuse,
                          allocator_v2)
    {
-      return this->alloc().allocation_command(command, limit_size, preferred_size, 
+      return this->alloc().allocation_command(command, limit_size, preferred_size,
                                               received_size, reuse);
    }
 
    size_type next_capacity(size_type additional_objects) const
    {  return get_next_capacity(allocator_traits_type::max_size(this->alloc()), this->priv_storage(), additional_objects);  }
 
-   void deallocate(pointer p, size_type n) 
-   {  
+   void deallocate(pointer p, size_type n)
+   { 
       if (p && (n > InternalBufferChars))
          this->alloc().deallocate(p, n);
    }
@@ -365,9 +365,9 @@
          throw_length_error();
    }
 
-   void deallocate_block() 
+   void deallocate_block()
    {  this->deallocate(this->priv_addr(), this->priv_storage());  }
-      
+     
    size_type max_size() const
    {  return allocator_traits_type::max_size(this->alloc()) - 1; }
 
@@ -404,13 +404,13 @@
    {  return this->members_.m_repr.long_repr().storage;  }
 
    void priv_storage(size_type storage)
-   {  
+   { 
       if(!this->is_short())
          this->priv_long_storage(storage);
    }
 
    void priv_long_storage(size_type storage)
-   {  
+   { 
       this->members_.m_repr.long_repr().storage = storage;
    }
 
@@ -424,7 +424,7 @@
    {  return this->members_.m_repr.long_repr().length;  }
 
    void priv_size(size_type sz)
-   {  
+   { 
       if(this->is_short())
          this->priv_short_size(sz);
       else
@@ -432,12 +432,12 @@
    }
 
    void priv_short_size(size_type sz)
-   {  
+   { 
       this->members_.m_repr.s.h.length = (unsigned char)sz;
    }
 
    void priv_long_size(size_type sz)
-   {  
+   { 
       this->members_.m_repr.long_repr().length = static_cast<typename allocator_traits_type::size_type>(sz);
    }
 
@@ -470,41 +470,41 @@
 
 /// @endcond
 
-//! The basic_string class represents a Sequence of characters. It contains all the 
-//! usual operations of a Sequence, and, additionally, it contains standard string 
+//! The basic_string class represents a Sequence of characters. It contains all the
+//! usual operations of a Sequence, and, additionally, it contains standard string
 //! operations such as search and concatenation.
 //!
-//! The basic_string class is parameterized by character type, and by that type's 
+//! The basic_string class is parameterized by character type, and by that type's
 //! Character Traits.
-//! 
-//! This class has performance characteristics very much like vector<>, meaning, 
+//!
+//! This class has performance characteristics very much like vector<>, meaning,
 //! for example, that it does not perform reference-count or copy-on-write, and that
-//! concatenation of two strings is an O(N) operation. 
-//! 
-//! Some of basic_string's member functions use an unusual method of specifying positions 
-//! and ranges. In addition to the conventional method using iterators, many of 
-//! basic_string's member functions use a single value pos of type size_type to represent a 
-//! position (in which case the position is begin() + pos, and many of basic_string's 
-//! member functions use two values, pos and n, to represent a range. In that case pos is 
-//! the beginning of the range and n is its size. That is, the range is 
-//! [begin() + pos, begin() + pos + n). 
-//! 
-//! Note that the C++ standard does not specify the complexity of basic_string operations. 
-//! In this implementation, basic_string has performance characteristics very similar to 
-//! those of vector: access to a single character is O(1), while copy and concatenation 
+//! concatenation of two strings is an O(N) operation.
+//!
+//! Some of basic_string's member functions use an unusual method of specifying positions
+//! and ranges. In addition to the conventional method using iterators, many of
+//! basic_string's member functions use a single value pos of type size_type to represent a
+//! position (in which case the position is begin() + pos, and many of basic_string's
+//! member functions use two values, pos and n, to represent a range. In that case pos is
+//! the beginning of the range and n is its size. That is, the range is
+//! [begin() + pos, begin() + pos + n).
+//!
+//! Note that the C++ standard does not specify the complexity of basic_string operations.
+//! In this implementation, basic_string has performance characteristics very similar to
+//! those of vector: access to a single character is O(1), while copy and concatenation
 //! are O(N).
-//! 
-//! In this implementation, begin(), 
+//!
+//! In this implementation, begin(),
 //! end(), rbegin(), rend(), operator[], c_str(), and data() do not invalidate iterators.
 //! In this implementation, iterators are only invalidated by member functions that
-//! explicitly change the string's contents. 
+//! explicitly change the string's contents.
 #ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
 template <class CharT, class Traits = std::char_traits<CharT>, class A = std::allocator<CharT> >
 #else
 template <class CharT, class Traits, class A>
 #endif
 class basic_string
-   :  private container_detail::basic_string_base<A> 
+   :  private container_detail::basic_string_base<A>
 {
    /// @cond
    private:
@@ -535,12 +535,12 @@
       const Pointer m_first;
       const Pointer m_last;
 
-      Not_within_traits(Pointer f, Pointer l) 
+      Not_within_traits(Pointer f, Pointer l)
          : m_first(f), m_last(l) {}
 
-      bool operator()(const typename Tr::char_type& x) const 
+      bool operator()(const typename Tr::char_type& x) const
       {
-         return std::find_if(m_first, m_last, 
+         return std::find_if(m_first, m_last,
                         std::bind1st(Eq_traits<Tr>(), x)) == m_last;
       }
    };
@@ -558,11 +558,11 @@
    typedef Traits                                  traits_type;
    //! Pointer to CharT
    typedef typename allocator_traits_type::pointer pointer;
-   //! Const pointer to CharT 
+   //! Const pointer to CharT
    typedef typename allocator_traits_type::const_pointer               const_pointer;
-   //! Reference to CharT 
+   //! Reference to CharT
    typedef typename allocator_traits_type::reference                   reference;
-   //! Const reference to CharT 
+   //! Const reference to CharT
    typedef typename allocator_traits_type::const_reference             const_reference;
    //! An unsigned integral type
    typedef typename allocator_traits_type::size_type                   size_type;
@@ -576,7 +576,7 @@
    typedef std::reverse_iterator<iterator>       reverse_iterator;
    //! Const iterator used to iterate backwards through a string
    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-   //! The largest possible value of type size_type. That is, size_type(-1). 
+   //! The largest possible value of type size_type. That is, size_type(-1).
    static const size_type npos;
 
    /// @cond
@@ -602,7 +602,7 @@
    /// @endcond
 
    //! <b>Effects</b>: Default constructs a basic_string.
-   //! 
+   //!
    //! <b>Throws</b>: If allocator_type's default constructor throws.
    basic_string()
       : base_t()
@@ -610,7 +610,7 @@
 
 
    //! <b>Effects</b>: Constructs a basic_string taking the allocator as parameter.
-   //! 
+   //!
    //! <b>Throws</b>: If allocator_type's copy constructor throws.
    explicit basic_string(const allocator_type& a)
       : base_t(a)
@@ -619,27 +619,27 @@
    //! <b>Effects</b>: Copy constructs a basic_string.
    //!
    //! <b>Postcondition</b>: x == *this.
-   //! 
+   //!
    //! <b>Throws</b>: If allocator_type's default constructor throws.
-   basic_string(const basic_string& s) 
+   basic_string(const basic_string& s)
       :  base_t(allocator_traits_type::select_on_container_copy_construction(s.alloc()))
    { this->priv_range_initialize(s.begin(), s.end()); }
 
    //! <b>Effects</b>: Move constructor. Moves s's resources to *this.
    //!
    //! <b>Throws</b>: If allocator_type's copy constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   basic_string(BOOST_RV_REF(basic_string) s) 
+   basic_string(BOOST_RV_REF(basic_string) s)
       : base_t(boost::move((base_t&)s))
    {}
 
    //! <b>Effects</b>: Copy constructs a basic_string using the specified allocator.
    //!
    //! <b>Postcondition</b>: x == *this.
-   //! 
+   //!
    //! <b>Throws</b>: If allocation throws.
-   basic_string(const basic_string& s, const allocator_type &a) 
+   basic_string(const basic_string& s, const allocator_type &a)
       :  base_t(a)
    { this->priv_range_initialize(s.begin(), s.end()); }
 
@@ -647,9 +647,9 @@
    //!                 Moves s's resources to *this.
    //!
    //! <b>Throws</b>: If allocation throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant if a == s.get_allocator(), linear otherwise.
-   basic_string(BOOST_RV_REF(basic_string) s, const allocator_type &a) 
+   basic_string(BOOST_RV_REF(basic_string) s, const allocator_type &a)
       : base_t(a)
    {
       if(a == this->alloc()){
@@ -661,10 +661,10 @@
    }
 
    //! <b>Effects</b>: Constructs a basic_string taking the allocator as parameter,
-   //!   and is initialized by a specific number of characters of the s string. 
+   //!   and is initialized by a specific number of characters of the s string.
    basic_string(const basic_string& s, size_type pos, size_type n = npos,
-               const allocator_type& a = allocator_type()) 
-      : base_t(a) 
+               const allocator_type& a = allocator_type())
+      : base_t(a)
    {
       if (pos > s.size())
          this->throw_out_of_range();
@@ -676,15 +676,15 @@
    //! <b>Effects</b>: Constructs a basic_string taking the allocator as parameter,
    //!   and is initialized by a specific number of characters of the s c-string.
    basic_string(const CharT* s, size_type n,
-               const allocator_type& a = allocator_type()) 
-      : base_t(a) 
+               const allocator_type& a = allocator_type())
+      : base_t(a)
    { this->priv_range_initialize(s, s + n); }
 
    //! <b>Effects</b>: Constructs a basic_string taking the allocator as parameter,
    //!   and is initialized by the null-terminated s c-string.
    basic_string(const CharT* s,
                 const allocator_type& a = allocator_type())
-      : base_t(a) 
+      : base_t(a)
    { this->priv_range_initialize(s, s + Traits::length(s)); }
 
    //! <b>Effects</b>: Constructs a basic_string taking the allocator as parameter,
@@ -692,7 +692,7 @@
    basic_string(size_type n, CharT c,
                 const allocator_type& a = allocator_type())
       : base_t(a)
-   {  
+   { 
       this->priv_range_initialize(cvalue_iterator(c, n),
                                   cvalue_iterator());
    }
@@ -715,13 +715,13 @@
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   ~basic_string() 
+   ~basic_string()
    {}
-      
+     
    //! <b>Effects</b>: Copy constructs a string.
    //!
    //! <b>Postcondition</b>: x == *this.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear to the elements x contains.
    basic_string& operator=(BOOST_COPY_ASSIGN_REF(basic_string) x)
    {
@@ -747,7 +747,7 @@
    //! <b>Effects</b>: Move constructor. Moves mx's resources to *this.
    //!
    //! <b>Throws</b>: If allocator_type's copy constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    basic_string& operator=(BOOST_RV_REF(basic_string) x)
    {
@@ -773,7 +773,7 @@
    }
 
    //! <b>Effects</b>: Assignment from a null-terminated c-string.
-   basic_string& operator=(const CharT* s) 
+   basic_string& operator=(const CharT* s)
    { return this->assign(s, s + Traits::length(s)); }
 
    //! <b>Effects</b>: Assignment from character.
@@ -781,155 +781,155 @@
    { return this->assign(static_cast<size_type>(1), c); }
 
    //! <b>Effects</b>: Returns an iterator to the first element contained in the vector.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    iterator begin()
    { return this->priv_addr(); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the vector.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_iterator begin() const
    { return this->priv_addr(); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the vector.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_iterator cbegin() const
    { return this->priv_addr(); }
 
    //! <b>Effects</b>: Returns an iterator to the end of the vector.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    iterator end()
    { return this->priv_addr() + this->priv_size(); }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the vector.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_iterator end() const 
-   { return this->priv_addr() + this->priv_size(); }  
+   const_iterator end() const
+   { return this->priv_addr() + this->priv_size(); } 
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the vector.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_iterator cend() const 
-   { return this->priv_addr() + this->priv_size(); }  
+   const_iterator cend() const
+   { return this->priv_addr() + this->priv_size(); } 
 
-   //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning 
-   //! of the reversed vector. 
-   //! 
+   //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning
+   //! of the reversed vector.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   reverse_iterator rbegin()             
+   reverse_iterator rbegin()            
    { return reverse_iterator(this->priv_addr() + this->priv_size()); }
 
-   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning 
-   //! of the reversed vector. 
-   //! 
+   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
+   //! of the reversed vector.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator rbegin() const 
+   const_reverse_iterator rbegin() const
    { return this->crbegin(); }
 
-   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning 
-   //! of the reversed vector. 
-   //! 
+   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
+   //! of the reversed vector.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator crbegin() const 
+   const_reverse_iterator crbegin() const
    { return const_reverse_iterator(this->priv_addr() + this->priv_size()); }
 
    //! <b>Effects</b>: Returns a reverse_iterator pointing to the end
-   //! of the reversed vector. 
-   //! 
+   //! of the reversed vector.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   reverse_iterator rend()               
+   reverse_iterator rend()              
    { return reverse_iterator(this->priv_addr()); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
-   //! of the reversed vector. 
-   //! 
+   //! of the reversed vector.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator rend()   const 
+   const_reverse_iterator rend()   const
    { return this->crend(); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
-   //! of the reversed vector. 
-   //! 
+   //! of the reversed vector.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator crend()   const 
+   const_reverse_iterator crend()   const
    { return const_reverse_iterator(this->priv_addr()); }
 
    //! <b>Effects</b>: Returns a copy of the internal allocator.
-   //! 
+   //!
    //! <b>Throws</b>: If allocator's copy constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   allocator_type get_allocator() const 
+   allocator_type get_allocator() const
    { return this->alloc(); }
 
    //! <b>Effects</b>: Returns a reference to the internal allocator.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   //! 
+   //!
    //! <b>Note</b>: Non-standard extension.
    const stored_allocator_type &get_stored_allocator() const BOOST_CONTAINER_NOEXCEPT
    {  return this->alloc(); }
 
    //! <b>Effects</b>: Returns a reference to the internal allocator.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   //! 
+   //!
    //! <b>Note</b>: Non-standard extension.
    stored_allocator_type &get_stored_allocator() BOOST_CONTAINER_NOEXCEPT
    {  return this->alloc(); }
 
    //! <b>Effects</b>: Returns the number of the elements contained in the vector.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   size_type size() const    
+   size_type size() const   
    { return this->priv_size(); }
 
    //! <b>Effects</b>: Returns the number of the elements contained in the vector.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    size_type length() const
    { return this->size(); }
 
    //! <b>Effects</b>: Returns the largest possible size of the vector.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    size_type max_size() const
    { return base_t::max_size(); }
@@ -961,7 +961,7 @@
    //!   effect. Otherwise, it is a request for allocation of additional memory.
    //!   If the request is successful, then capacity() is greater than or equal to
    //!   n; otherwise, capacity() is unchanged. In either case, size() is unchanged.
-   //! 
+   //!
    //! <b>Throws</b>: If memory allocation allocation throws
    void reserve(size_type res_arg)
    {
@@ -988,9 +988,9 @@
 
    //! <b>Effects</b>: Number of elements for which memory has been allocated.
    //!   capacity() is always greater than or equal to size().
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    size_type capacity() const
    { return this->priv_capacity(); }
@@ -1040,42 +1040,42 @@
    }
 
    //! <b>Effects</b>: Returns true if the vector contains no elements.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    bool empty() const
    { return !this->priv_size(); }
 
    //! <b>Requires</b>: size() > n.
    //!
-   //! <b>Effects</b>: Returns a reference to the nth element 
+   //! <b>Effects</b>: Returns a reference to the nth element
    //!   from the beginning of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    reference operator[](size_type n)
       { return *(this->priv_addr() + n); }
 
    //! <b>Requires</b>: size() > n.
    //!
-   //! <b>Effects</b>: Returns a const reference to the nth element 
+   //! <b>Effects</b>: Returns a const reference to the nth element
    //!   from the beginning of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_reference operator[](size_type n) const
       { return *(this->priv_addr() + n); }
 
    //! <b>Requires</b>: size() > n.
    //!
-   //! <b>Effects</b>: Returns a reference to the nth element 
+   //! <b>Effects</b>: Returns a reference to the nth element
    //!   from the beginning of the container.
-   //! 
+   //!
    //! <b>Throws</b>: std::range_error if n >= size()
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    reference at(size_type n) {
       if (n >= size())
@@ -1085,11 +1085,11 @@
 
    //! <b>Requires</b>: size() > n.
    //!
-   //! <b>Effects</b>: Returns a const reference to the nth element 
+   //! <b>Effects</b>: Returns a const reference to the nth element
    //!   from the beginning of the container.
-   //! 
+   //!
    //! <b>Throws</b>: std::range_error if n >= size()
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_reference at(size_type n) const {
       if (n >= size())
@@ -1118,12 +1118,12 @@
    //! <b>Effects</b>: Calls append(str.data(), str.size()).
    //!
    //! <b>Returns</b>: *this
-   basic_string& append(const basic_string& s) 
+   basic_string& append(const basic_string& s)
    {  return this->append(s.begin(), s.end());  }
 
    //! <b>Requires</b>: pos <= str.size()
    //!
-   //! <b>Effects</b>: Determines the effective length rlen of the string to append 
+   //! <b>Effects</b>: Determines the effective length rlen of the string to append
    //! as the smaller of n and str.size() - pos and calls append(str.data() + pos, rlen).
    //!
    //! <b>Throws</b>: If memory allocation throws and out_of_range if pos > str.size()
@@ -1147,7 +1147,7 @@
    //! <b>Throws</b>: If memory allocation throws length_error if size() + n > max_size().
    //!
    //! <b>Returns</b>: *this
-   basic_string& append(const CharT* s, size_type n) 
+   basic_string& append(const CharT* s, size_type n)
    {  return this->append(s, s + n);  }
 
    //! <b>Requires</b>: s points to an array of at least traits::length(s) + 1 elements of CharT.
@@ -1155,7 +1155,7 @@
    //! <b>Effects</b>: Calls append(s, traits::length(s)).
    //!
    //! <b>Returns</b>: *this
-   basic_string& append(const CharT* s) 
+   basic_string& append(const CharT* s)
    {  return this->append(s, s + Traits::length(s));  }
 
    //! <b>Effects</b>: Equivalent to append(basic_string(n, c)).
@@ -1190,17 +1190,17 @@
    //! <b>Effects</b>: Equivalent to assign(str, 0, npos).
    //!
    //! <b>Returns</b>: *this
-   basic_string& assign(const basic_string& s) 
+   basic_string& assign(const basic_string& s)
    {  return this->operator=(s); }
 
    //! <b>Effects</b>: The function replaces the string controlled by *this
-   //!    with a string of length str.size() whose elements are a copy of the string 
+   //!    with a string of length str.size() whose elements are a copy of the string
    //!   controlled by str. Leaves str in a valid but unspecified state.
    //!
    //! <b>Throws</b>: Nothing
    //!
    //! <b>Returns</b>: *this
-   basic_string& assign(BOOST_RV_REF(basic_string) ms) 
+   basic_string& assign(BOOST_RV_REF(basic_string) ms)
    {  return this->swap_data(ms), *this;  }
 
    //! <b>Requires</b>: pos <= str.size()
@@ -1211,11 +1211,11 @@
    //! <b>Throws</b>: If memory allocation throws or out_of_range if pos > str.size().
    //!
    //! <b>Returns</b>: *this
-   basic_string& assign(const basic_string& s, 
+   basic_string& assign(const basic_string& s,
                         size_type pos, size_type n) {
       if (pos > s.size())
       this->throw_out_of_range();
-      return this->assign(s.begin() + pos, 
+      return this->assign(s.begin() + pos,
                           s.begin() + pos + container_detail::min_value(n, s.size() - pos));
    }
 
@@ -1225,7 +1225,7 @@
    //! length n whose elements are a copy of those pointed to by s.
    //!
    //! <b>Throws</b>: If memory allocation throws or length_error if n > max_size().
-   //!    
+   //!   
    //! <b>Returns</b>: *this
    basic_string& assign(const CharT* s, size_type n)
    {  return this->assign(s, s + n);   }
@@ -1248,7 +1248,7 @@
    //!
    //! <b>Returns</b>: *this
    template <class InputIter>
-   basic_string& assign(InputIter first, InputIter last) 
+   basic_string& assign(InputIter first, InputIter last)
    {
       //Dispatch depending on integer/iterator
       const bool aux_boolean = container_detail::is_convertible<InputIter, size_type>::value;
@@ -1263,7 +1263,7 @@
    //! <b>Throws</b>: If memory allocation throws or out_of_range if pos > size().
    //!
    //! <b>Returns</b>: *this
-   basic_string& insert(size_type pos, const basic_string& s) 
+   basic_string& insert(size_type pos, const basic_string& s)
    {
       if (pos > size())
          this->throw_out_of_range();
@@ -1282,7 +1282,7 @@
    //!
    //! <b>Returns</b>: *this
    basic_string& insert(size_type pos1, const basic_string& s,
-                        size_type pos2, size_type n) 
+                        size_type pos2, size_type n)
    {
       if (pos1 > this->size() || pos2 > s.size())
          this->throw_out_of_range();
@@ -1306,7 +1306,7 @@
    //!   length_error if size() + n > max_size().
    //!
    //! <b>Returns</b>: *this
-   basic_string& insert(size_type pos, const CharT* s, size_type n) 
+   basic_string& insert(size_type pos, const CharT* s, size_type n)
    {
       if (pos > this->size())
          this->throw_out_of_range();
@@ -1324,7 +1324,7 @@
    //!   length_error if size() > max_size() - Traits::length(s)
    //!
    //! <b>Returns</b>: *this
-   basic_string& insert(size_type pos, const CharT* s) 
+   basic_string& insert(size_type pos, const CharT* s)
    {
       if (pos > size())
          this->throw_out_of_range();
@@ -1341,7 +1341,7 @@
    //!   length_error if size() > max_size() - n
    //!
    //! <b>Returns</b>: *this
-   basic_string& insert(size_type pos, size_type n, CharT c) 
+   basic_string& insert(size_type pos, size_type n, CharT c)
    {
       if (pos > this->size())
          this->throw_out_of_range();
@@ -1356,7 +1356,7 @@
    //! <b>Effects</b>: inserts a copy of c before the character referred to by p.
    //!
    //! <b>Returns</b>: An iterator which refers to the copy of the inserted character.
-   iterator insert(const_iterator p, CharT c) 
+   iterator insert(const_iterator p, CharT c)
    {
       size_type new_offset = p - this->priv_addr() + 1;
       this->insert(p, cvalue_iterator(c, 1), cvalue_iterator());
@@ -1382,7 +1382,7 @@
    //! <b>Returns</b>: An iterator which refers to the copy of the first
    //!   inserted character, or p if first == last.
    template <class InputIter>
-   void insert(const_iterator p, InputIter first, InputIter last) 
+   void insert(const_iterator p, InputIter first, InputIter last)
    {
       //Dispatch depending on integer/iterator
       const bool aux_boolean = container_detail::is_convertible<InputIter, size_type>::value;
@@ -1401,13 +1401,13 @@
    //! <b>Throws</b>: out_of_range if pos > size().
    //!
    //! <b>Returns</b>: *this
-   basic_string& erase(size_type pos = 0, size_type n = npos) 
+   basic_string& erase(size_type pos = 0, size_type n = npos)
    {
       if (pos > size())
          this->throw_out_of_range();
       erase(this->priv_addr() + pos, this->priv_addr() + pos + container_detail::min_value(n, size() - pos));
       return *this;
-   }  
+   } 
 
    //! <b>Effects</b>: Removes the character referred to by p.
    //!
@@ -1415,12 +1415,12 @@
    //!
    //! <b>Returns</b>: An iterator which points to the element immediately following p prior to the element being
    //!    erased. If no such element exists, end() is returned.
-   iterator erase(const_iterator p) 
+   iterator erase(const_iterator p)
    {
       // The move includes the terminating null.
       CharT *ptr = const_cast<CharT*>(container_detail::to_raw_pointer(p));
       Traits::move(ptr,
-                   container_detail::to_raw_pointer(p + 1), 
+                   container_detail::to_raw_pointer(p + 1),
                    this->priv_size() - (p - this->priv_addr()));
       this->priv_size(this->priv_size()-1);
       return iterator(ptr);
@@ -1440,7 +1440,7 @@
       if (first != last) { // The move includes the terminating null.
          size_type num_erased = last - first;
          Traits::move(f,
-                      container_detail::to_raw_pointer(last), 
+                      container_detail::to_raw_pointer(last),
                       (this->priv_size() + 1)-(last - this->priv_addr()));
          size_type new_length = this->priv_size() - num_erased;
          this->priv_size(new_length);
@@ -1466,14 +1466,14 @@
    //! <b>Throws</b>: if memory allocation throws or out_of_range if pos1 > size().
    //!
    //! <b>Returns</b>: *this
-   basic_string& replace(size_type pos1, size_type n1, const basic_string& str) 
+   basic_string& replace(size_type pos1, size_type n1, const basic_string& str)
    {
       if (pos1 > size())
          this->throw_out_of_range();
       const size_type len = container_detail::min_value(n1, size() - pos1);
       if (this->size() - len >= this->max_size() - str.size())
          this->throw_length_error();
-      return this->replace(this->priv_addr() + pos1, this->priv_addr() + pos1 + len, 
+      return this->replace(this->priv_addr() + pos1, this->priv_addr() + pos1 + len,
                            str.begin(), str.end());
    }
 
@@ -1487,7 +1487,7 @@
    //!
    //! <b>Returns</b>: *this
    basic_string& replace(size_type pos1, size_type n1,
-                         const basic_string& str, size_type pos2, size_type n2) 
+                         const basic_string& str, size_type pos2, size_type n2)
    {
       if (pos1 > size() || pos2 > str.size())
          this->throw_out_of_range();
@@ -1501,20 +1501,20 @@
 
    //! <b>Requires</b>: pos1 <= size() and s points to an array of at least n2 elements of CharT.
    //!
-   //! <b>Effects</b>: Determines the effective length xlen of the string to be removed as the 
-   //!   smaller of n1 and size() - pos1. If size() - xlen >= max_size() - n2 throws length_error. 
-   //!   Otherwise, the function replaces the string controlled by *this with a string of 
-   //!   length size() - xlen + n2 whose first pos1 elements are a copy of the initial elements 
-   //!   of the original string controlled by *this, whose next n2 elements are a copy of the 
-   //!   initial n2 elements of s, and whose remaining elements are a copy of the elements of 
+   //! <b>Effects</b>: Determines the effective length xlen of the string to be removed as the
+   //!   smaller of n1 and size() - pos1. If size() - xlen >= max_size() - n2 throws length_error.
+   //!   Otherwise, the function replaces the string controlled by *this with a string of
+   //!   length size() - xlen + n2 whose first pos1 elements are a copy of the initial elements
+   //!   of the original string controlled by *this, whose next n2 elements are a copy of the
+   //!   initial n2 elements of s, and whose remaining elements are a copy of the elements of
    //!   the original string controlled by *this beginning at position pos + xlen.
    //!
-   //! <b>Throws</b>: if memory allocation throws, out_of_range if pos1 > size() or length_error 
+   //! <b>Throws</b>: if memory allocation throws, out_of_range if pos1 > size() or length_error
    //!   if the length of the  resulting string would exceed max_size()
    //!
    //! <b>Returns</b>: *this
    basic_string& replace(size_type pos1, size_type n1,
-                        const CharT* s, size_type n2) 
+                        const CharT* s, size_type n2)
    {
       if (pos1 > size())
          this->throw_out_of_range();
@@ -1535,11 +1535,11 @@
    //! remaining elements are a copy of the elements of the original string controlled by *this
    //! beginning at position pos + xlen.
    //!
-   //! <b>Throws</b>: if memory allocation throws, out_of_range if pos1 > size() or length_error 
+   //! <b>Throws</b>: if memory allocation throws, out_of_range if pos1 > size() or length_error
    //!   if the length of the resulting string would exceed max_size()
    //!
    //! <b>Returns</b>: *this
-   basic_string& replace(size_type pos, size_type n1, const CharT* s) 
+   basic_string& replace(size_type pos, size_type n1, const CharT* s)
    {
       if (pos > size())
          this->throw_out_of_range();
@@ -1555,11 +1555,11 @@
    //!
    //! <b>Effects</b>: Equivalent to replace(pos1, n1, basic_string(n2, c)).
    //!
-   //! <b>Throws</b>: if memory allocation throws, out_of_range if pos1 > size() or length_error 
+   //! <b>Throws</b>: if memory allocation throws, out_of_range if pos1 > size() or length_error
    //!   if the length of the  resulting string would exceed max_size()
    //!
    //! <b>Returns</b>: *this
-   basic_string& replace(size_type pos1, size_type n1, size_type n2, CharT c) 
+   basic_string& replace(size_type pos1, size_type n1, size_type n2, CharT c)
    {
       if (pos1 > size())
          this->throw_out_of_range();
@@ -1576,10 +1576,10 @@
    //! <b>Throws</b>: if memory allocation throws
    //!
    //! <b>Returns</b>: *this
-   basic_string& replace(const_iterator i1, const_iterator i2, const basic_string& str) 
+   basic_string& replace(const_iterator i1, const_iterator i2, const basic_string& str)
    { return this->replace(i1, i2, str.begin(), str.end()); }
 
-   //! <b>Requires</b>: [begin(),i1) and [i1,i2) are valid ranges and 
+   //! <b>Requires</b>: [begin(),i1) and [i1,i2) are valid ranges and
    //!   s points to an array of at least n elements
    //!
    //! <b>Effects</b>: Calls replace(i1 - begin(), i2 - i1, s, n).
@@ -1587,7 +1587,7 @@
    //! <b>Throws</b>: if memory allocation throws
    //!
    //! <b>Returns</b>: *this
-   basic_string& replace(const_iterator i1, const_iterator i2, const CharT* s, size_type n) 
+   basic_string& replace(const_iterator i1, const_iterator i2, const CharT* s, size_type n)
    { return this->replace(i1, i2, s, s + n); }
 
    //! <b>Requires</b>: [begin(),i1) and [i1,i2) are valid ranges and s points to an
@@ -1598,7 +1598,7 @@
    //! <b>Throws</b>: if memory allocation throws
    //!
    //! <b>Returns</b>: *this
-   basic_string& replace(const_iterator i1, const_iterator i2, const CharT* s) 
+   basic_string& replace(const_iterator i1, const_iterator i2, const CharT* s)
    {  return this->replace(i1, i2, s, s + Traits::length(s));   }
 
    //! <b>Requires</b>: [begin(),i1) and [i1,i2) are valid ranges.
@@ -1630,7 +1630,7 @@
    //!
    //! <b>Returns</b>: *this
    template <class InputIter>
-   basic_string& replace(const_iterator i1, const_iterator i2, InputIter j1, InputIter j2) 
+   basic_string& replace(const_iterator i1, const_iterator i2, InputIter j1, InputIter j2)
    {
       //Dispatch depending on integer/iterator
       const bool aux_boolean = container_detail::is_convertible<InputIter, size_type>::value;
@@ -1642,14 +1642,14 @@
    //!
    //! <b>Effects</b>: Determines the effective length rlen of the string to copy as the
    //!   smaller of n and size() - pos. s shall designate an array of at least rlen elements.
-   //!   The function then replaces the string designated by s with a string of length rlen 
+   //!   The function then replaces the string designated by s with a string of length rlen
    //!   whose elements are a copy of the string controlled by *this beginning at position pos.
    //!   The function does not append a null object to the string designated by s.
    //!
    //! <b>Throws</b>: if memory allocation throws, out_of_range if pos > size().
    //!
    //! <b>Returns</b>: rlen
-   size_type copy(CharT* s, size_type n, size_type pos = 0) const 
+   size_type copy(CharT* s, size_type n, size_type pos = 0) const
    {
       if (pos > size())
          this->throw_out_of_range();
@@ -1658,7 +1658,7 @@
       return len;
    }
 
-   //! <b>Effects</b>: *this contains the same sequence of characters that was in s, 
+   //! <b>Effects</b>: *this contains the same sequence of characters that was in s,
    //!   s contains the same sequence of characters that was in *this.
    //!
    //! <b>Throws</b>: Nothing
@@ -1674,7 +1674,7 @@
    //! <b>Returns</b>: A pointer p such that p + i == &operator[](i) for each i in [0,size()].
    //!
    //! <b>Complexity</b>: constant time.
-   const CharT* c_str() const 
+   const CharT* c_str() const
    {  return container_detail::to_raw_pointer(this->priv_addr()); }
 
    //! <b>Requires</b>: The program shall not alter any of the values stored in the character array.
@@ -1682,17 +1682,17 @@
    //! <b>Returns</b>: A pointer p such that p + i == &operator[](i) for each i in [0,size()].
    //!
    //! <b>Complexity</b>: constant time.
-   const CharT* data()  const 
+   const CharT* data()  const
    {  return container_detail::to_raw_pointer(this->priv_addr()); }
 
-   //! <b>Effects</b>: Determines the lowest position xpos, if possible, such that both 
+   //! <b>Effects</b>: Determines the lowest position xpos, if possible, such that both
    //!   of the following conditions obtain: 19 pos <= xpos and xpos + str.size() <= size();
    //!   2) traits::eq(at(xpos+I), str.at(I)) for all elements I of the string controlled by str.
    //!
    //! <b>Throws</b>: Nothing
    //!
    //! <b>Returns</b>: xpos if the function can determine such a value for xpos. Otherwise, returns npos.
-   size_type find(const basic_string& s, size_type pos = 0) const 
+   size_type find(const basic_string& s, size_type pos = 0) const
    { return find(s.c_str(), pos, s.size()); }
 
    //! <b>Requires</b>: s points to an array of at least n elements of CharT.
@@ -1707,7 +1707,7 @@
       else {
          pointer finish = this->priv_addr() + this->priv_size();
          const const_iterator result =
-            std::search(container_detail::to_raw_pointer(this->priv_addr() + pos), 
+            std::search(container_detail::to_raw_pointer(this->priv_addr() + pos),
                    container_detail::to_raw_pointer(finish),
                    s, s + n, Eq_traits<Traits>());
          return result != finish ? result - begin() : npos;
@@ -1719,7 +1719,7 @@
    //! <b>Throws</b>: Nothing
    //!
    //! <b>Returns</b>: find(basic_string(s), pos).
-   size_type find(const CharT* s, size_type pos = 0) const 
+   size_type find(const CharT* s, size_type pos = 0) const
    { return find(s, pos, Traits::length(s)); }
 
    //! <b>Throws</b>: Nothing
@@ -1738,7 +1738,7 @@
       }
    }
 
-   //! <b>Effects</b>: Determines the highest position xpos, if possible, such 
+   //! <b>Effects</b>: Determines the highest position xpos, if possible, such
    //!   that both of the following conditions obtain:
    //!   a) xpos <= pos and xpos + str.size() <= size();
    //!   b) traits::eq(at(xpos+I), str.at(I)) for all elements I of the string controlled by str.
@@ -1746,7 +1746,7 @@
    //! <b>Throws</b>: Nothing
    //!
    //! <b>Returns</b>: xpos if the function can determine such a value for xpos. Otherwise, returns npos.
-   size_type rfind(const basic_string& str, size_type pos = npos) const 
+   size_type rfind(const basic_string& str, size_type pos = npos) const
       { return rfind(str.c_str(), pos, str.size()); }
 
    //! <b>Requires</b>: s points to an array of at least n elements of CharT.
@@ -1771,13 +1771,13 @@
       }
    }
 
-   //! <b>Requires</b>: pos <= size() and s points to an array of at least 
+   //! <b>Requires</b>: pos <= size() and s points to an array of at least
    //!   traits::length(s) + 1 elements of CharT.
    //!
    //! <b>Throws</b>: Nothing
    //!
    //! <b>Returns</b>: rfind(basic_string(s), pos).
-   size_type rfind(const CharT* s, size_type pos = npos) const 
+   size_type rfind(const CharT* s, size_type pos = npos) const
       { return rfind(s, pos, Traits::length(s)); }
 
    //! <b>Throws</b>: Nothing
@@ -1805,7 +1805,7 @@
    //! <b>Throws</b>: Nothing
    //!
    //! <b>Returns</b>: xpos if the function can determine such a value for xpos. Otherwise, returns npos.
-   size_type find_first_of(const basic_string& s, size_type pos = 0) const 
+   size_type find_first_of(const basic_string& s, size_type pos = 0) const
       { return find_first_of(s.c_str(), pos, s.size()); }
 
    //! <b>Requires</b>: s points to an array of at least n elements of CharT.
@@ -1831,7 +1831,7 @@
    //! <b>Throws</b>: Nothing
    //!
    //! <b>Returns</b>: find_first_of(basic_string(s), pos).
-   size_type find_first_of(const CharT* s, size_type pos = 0) const 
+   size_type find_first_of(const CharT* s, size_type pos = 0) const
       { return find_first_of(s, pos, Traits::length(s)); }
 
    //! <b>Requires</b>: s points to an array of at least traits::length(s) + 1 elements of CharT.
@@ -1839,10 +1839,10 @@
    //! <b>Throws</b>: Nothing
    //!
    //! <b>Returns</b>: find_first_of(basic_string<CharT,traits,Allocator>(1,c), pos).
-   size_type find_first_of(CharT c, size_type pos = 0) const 
+   size_type find_first_of(CharT c, size_type pos = 0) const
     { return find(c, pos); }
 
-   //! <b>Effects</b>: Determines the highest position xpos, if possible, such that both of 
+   //! <b>Effects</b>: Determines the highest position xpos, if possible, such that both of
    //!   the following conditions obtain: a) xpos <= pos and xpos < size(); b)
    //!   traits::eq(at(xpos), str.at(I)) for some element I of the string controlled by str.
    //!
@@ -1878,16 +1878,16 @@
    //! <b>Throws</b>: Nothing
    //!
    //! <b>Returns</b>: find_last_of(basic_string<CharT,traits,Allocator>(1,c),pos).
-   size_type find_last_of(const CharT* s, size_type pos = npos) const 
+   size_type find_last_of(const CharT* s, size_type pos = npos) const
       { return find_last_of(s, pos, Traits::length(s)); }
 
    //! <b>Throws</b>: Nothing
    //!
    //! <b>Returns</b>: find_last_of(basic_string(s), pos).
-   size_type find_last_of(CharT c, size_type pos = npos) const 
+   size_type find_last_of(CharT c, size_type pos = npos) const
       {  return rfind(c, pos);   }
 
-   //! <b>Effects</b>: Determines the lowest position xpos, if possible, such that 
+   //! <b>Effects</b>: Determines the lowest position xpos, if possible, such that
    //!   both of the following conditions obtain:
    //!   a) pos <= xpos and xpos < size(); b) traits::eq(at(xpos), str.at(I)) for no
    //!   element I of the string controlled by str.
@@ -1895,7 +1895,7 @@
    //! <b>Throws</b>: Nothing
    //!
    //! <b>Returns</b>: xpos if the function can determine such a value for xpos. Otherwise, returns npos.
-   size_type find_first_not_of(const basic_string& str, size_type pos = 0) const 
+   size_type find_first_not_of(const basic_string& str, size_type pos = 0) const
       { return find_first_not_of(str.c_str(), pos, str.size()); }
 
    //! <b>Requires</b>: s points to an array of at least traits::length(s) + 1 elements of CharT.
@@ -1920,7 +1920,7 @@
    //! <b>Throws</b>: Nothing
    //!
    //! <b>Returns</b>: find_first_not_of(basic_string(s), pos).
-   size_type find_first_not_of(const CharT* s, size_type pos = 0) const 
+   size_type find_first_not_of(const CharT* s, size_type pos = 0) const
       { return find_first_not_of(s, pos, Traits::length(s)); }
 
    //! <b>Throws</b>: Nothing
@@ -1940,7 +1940,7 @@
    }
 
    //! <b>Effects</b>: Determines the highest position xpos, if possible, such that
-   //!   both of the following conditions obtain: a) xpos <= pos and xpos < size(); 
+   //!   both of the following conditions obtain: a) xpos <= pos and xpos < size();
    //!   b) traits::eq(at(xpos), str.at(I)) for no element I of the string controlled by str.
    //!
    //! <b>Throws</b>: Nothing
@@ -2003,11 +2003,11 @@
    //! <b>Throws</b>: If memory allocation throws or out_of_range if pos > size().
    //!
    //! <b>Returns</b>: basic_string<CharT,traits,Allocator>(data()+pos,rlen).
-   basic_string substr(size_type pos = 0, size_type n = npos) const 
+   basic_string substr(size_type pos = 0, size_type n = npos) const
    {
       if (pos > size())
          this->throw_out_of_range();
-      return basic_string(this->priv_addr() + pos, 
+      return basic_string(this->priv_addr() + pos,
                           this->priv_addr() + pos + container_detail::min_value(n, size() - pos), this->alloc());
    }
 
@@ -2020,7 +2020,7 @@
    //! <b>Returns</b>: The nonzero result if the result of the comparison is nonzero.
    //!   Otherwise, returns a value < 0 if size() < str.size(), a 0 value if size() == str.size(),
    //!   and value > 0 if size() > str.size()
-   int compare(const basic_string& str) const 
+   int compare(const basic_string& str) const
    { return s_compare(this->priv_addr(), this->priv_addr() + this->priv_size(), str.priv_addr(), str.priv_addr() + str.priv_size()); }
 
    //! <b>Requires</b>: pos1 <= size()
@@ -2031,16 +2031,16 @@
    //! <b>Throws</b>: out_of_range if pos1 > size()
    //!
    //! <b>Returns</b>:basic_string(*this,pos1,n1).compare(str).
-   int compare(size_type pos1, size_type n1, const basic_string& str) const 
+   int compare(size_type pos1, size_type n1, const basic_string& str) const
    {
       if (pos1 > size())
          this->throw_out_of_range();
-      return s_compare(this->priv_addr() + pos1, 
+      return s_compare(this->priv_addr() + pos1,
                         this->priv_addr() + pos1 + container_detail::min_value(n1, size() - pos1),
                         str.priv_addr(), str.priv_addr() + str.priv_size());
    }
 
-   //! <b>Requires</b>: pos1 <= size() and pos2 <= str.size() 
+   //! <b>Requires</b>: pos1 <= size() and pos2 <= str.size()
    //!
    //! <b>Effects</b>: Determines the effective length rlen of the string to copy as
    //!   the smaller of
@@ -2048,20 +2048,20 @@
    //! <b>Throws</b>: out_of_range if pos1 > size() or pos2 > str.size()
    //!
    //! <b>Returns</b>: basic_string(*this, pos1, n1).compare(basic_string(str, pos2, n2)).
-   int compare(size_type pos1, size_type n1, 
+   int compare(size_type pos1, size_type n1,
                const basic_string& str, size_type pos2, size_type n2) const {
       if (pos1 > size() || pos2 > str.size())
          this->throw_out_of_range();
-      return s_compare(this->priv_addr() + pos1, 
+      return s_compare(this->priv_addr() + pos1,
                         this->priv_addr() + pos1 + container_detail::min_value(n1, size() - pos1),
-                        str.priv_addr() + pos2, 
+                        str.priv_addr() + pos2,
                         str.priv_addr() + pos2 + container_detail::min_value(n2, size() - pos2));
    }
 
    //! <b>Throws</b>: Nothing
    //!
    //! <b>Returns</b>: compare(basic_string(s)).
-   int compare(const CharT* s) const 
+   int compare(const CharT* s) const
    {  return s_compare(this->priv_addr(), this->priv_addr() + this->priv_size(), s, s + Traits::length(s));   }
 
 
@@ -2071,11 +2071,11 @@
    //!
    //! <b>Returns</b>: basic_string(*this, pos, n1).compare(basic_string(s, n2)).
    int compare(size_type pos1, size_type n1,
-               const CharT* s, size_type n2) const 
+               const CharT* s, size_type n2) const
    {
       if (pos1 > size())
          this->throw_out_of_range();
-      return s_compare(this->priv_addr() + pos1, 
+      return s_compare(this->priv_addr() + pos1,
                         this->priv_addr() + pos1 + container_detail::min_value(n1, size() - pos1),
                         s, s + n2);
    }
@@ -2085,18 +2085,18 @@
    //! <b>Throws</b>: out_of_range if pos1 > size()
    //!
    //! <b>Returns</b>: basic_string(*this, pos, n1).compare(basic_string(s, n2)).
-   int compare(size_type pos1, size_type n1, const CharT* s) const 
+   int compare(size_type pos1, size_type n1, const CharT* s) const
    {  return this->compare(pos1, n1, s, Traits::length(s)); }
 
    /// @cond
    private:
    static int s_compare(const_pointer f1, const_pointer l1,
-                        const_pointer f2, const_pointer l2) 
+                        const_pointer f2, const_pointer l2)
    {
       const difference_type n1 = l1 - f1;
       const difference_type n2 = l2 - f2;
-      const int cmp = Traits::compare(container_detail::to_raw_pointer(f1), 
-                                      container_detail::to_raw_pointer(f2), 
+      const int cmp = Traits::compare(container_detail::to_raw_pointer(f1),
+                                      container_detail::to_raw_pointer(f2),
                                       container_detail::min_value(n1, n2));
       return cmp != 0 ? cmp : (n1 < n2 ? -1 : (n1 > n2 ? 1 : 0));
    }
@@ -2131,7 +2131,7 @@
 
    template<class AllocVersion>
    void priv_shrink_to_fit_dynamic_buffer
-      ( AllocVersion 
+      ( AllocVersion
       , typename container_detail::enable_if<container_detail::is_same<AllocVersion, allocator_v2> >::type* = 0)
    {
       size_type received_size;
@@ -2151,7 +2151,7 @@
 
    // Helper functions used by constructors.  It is a severe error for
    // any of them to be called anywhere except from within constructors.
-   void priv_terminate_string() 
+   void priv_terminate_string()
    {  this->priv_construct_null(this->priv_addr() + this->priv_size());  }
 
    template <class InputIter>
@@ -2164,7 +2164,7 @@
    }
 
    template <class ForwardIter>
-   void priv_range_initialize(ForwardIter f, ForwardIter l, 
+   void priv_range_initialize(ForwardIter f, ForwardIter l,
                               std::forward_iterator_tag)
    {
       difference_type n = std::distance(f, l);
@@ -2193,7 +2193,7 @@
    template <class InputIter>
    void priv_initialize_dispatch(InputIter f, InputIter l, container_detail::false_)
    {  this->priv_range_initialize(f, l);  }
- 
+
    template<class FwdIt, class Count> inline
    void priv_uninitialized_fill_n(FwdIt first, Count count, const CharT val)
    {
@@ -2241,7 +2241,7 @@
    }
 
    template <class Integer>
-   basic_string& priv_assign_dispatch(Integer n, Integer x, container_detail::true_) 
+   basic_string& priv_assign_dispatch(Integer n, Integer x, container_detail::true_)
    {  return this->assign((size_type) n, (CharT) x);   }
 
    template <class InputIter>
@@ -2272,7 +2272,7 @@
    }
 
    template <class ForwardIter>
-   void priv_insert(const_iterator position, ForwardIter first, 
+   void priv_insert(const_iterator position, ForwardIter first,
                     ForwardIter last,  std::forward_iterator_tag)
    {
       if (first != last) {
@@ -2286,13 +2286,13 @@
 
          //Check if we have enough capacity
          if (remaining >= n){
-            enough_capacity = true;            
+            enough_capacity = true;           
          }
          else {
             //Otherwise expand current buffer or allocate new storage
             new_cap  = this->next_capacity(n);
             allocation_ret = this->allocation_command
-                  (allocate_new | expand_fwd | expand_bwd, old_size + n + 1, 
+                  (allocate_new | expand_fwd | expand_bwd, old_size + n + 1,
                      new_cap, new_cap, old_start);
 
             //Check forward expansion
@@ -2353,7 +2353,7 @@
                this->priv_long_storage(new_cap);
             }
             else{
-               //value_type is POD, so backwards expansion is much easier 
+               //value_type is POD, so backwards expansion is much easier
                //than with vector<T>
                value_type *oldbuf = container_detail::to_raw_pointer(old_start);
                value_type *newbuf = container_detail::to_raw_pointer(new_start);
@@ -2377,12 +2377,12 @@
 
    template <class Integer>
    void priv_insert_dispatch(const_iterator p, Integer n, Integer x,
-                           container_detail::true_) 
+                           container_detail::true_)
    {  insert(p, (size_type) n, (CharT) x);   }
 
    template <class InputIter>
    void priv_insert_dispatch(const_iterator p, InputIter first, InputIter last,
-                           container_detail::false_) 
+                           container_detail::false_)
    {
       typedef typename std::iterator_traits<InputIter>::iterator_category Category;
       priv_insert(p, first, last, Category());
@@ -2395,19 +2395,19 @@
          Traits::assign(*result, *first);
    }
 
-   void priv_copy(const CharT* first, const CharT* last, CharT* result) 
+   void priv_copy(const CharT* first, const CharT* last, CharT* result)
    {  Traits::copy(result, first, last - first);  }
 
    template <class Integer>
    basic_string& priv_replace_dispatch(const_iterator first, const_iterator last,
                                        Integer n, Integer x,
-                                       container_detail::true_) 
+                                       container_detail::true_)
    {  return this->replace(first, last, (size_type) n, (CharT) x);   }
 
    template <class InputIter>
    basic_string& priv_replace_dispatch(const_iterator first, const_iterator last,
                                        InputIter f, InputIter l,
-                                       container_detail::false_) 
+                                       container_detail::false_)
    {
       typedef typename std::iterator_traits<InputIter>::iterator_category Category;
       return this->priv_replace(first, last, f, l, Category());
@@ -2430,7 +2430,7 @@
 
    template <class ForwardIter>
    basic_string& priv_replace(const_iterator first, const_iterator last,
-                              ForwardIter f, ForwardIter l, 
+                              ForwardIter f, ForwardIter l,
                               std::forward_iterator_tag)
    {
       difference_type n = std::distance(f, l);
@@ -2468,9 +2468,9 @@
 
 /// @cond
 
-template <class CharT, class Traits, class A> 
-const typename basic_string<CharT,Traits,A>::size_type 
-basic_string<CharT,Traits,A>::npos 
+template <class CharT, class Traits, class A>
+const typename basic_string<CharT,Traits,A>::size_type
+basic_string<CharT,Traits,A>::npos
   = (typename basic_string<CharT,Traits,A>::size_type) -1;
 
 /// @endcond
@@ -2526,7 +2526,7 @@
 
 template <class CharT, class Traits, class A>
 inline basic_string<CharT,Traits,A>
-operator+(const CharT* s, const basic_string<CharT,Traits,A>& y) 
+operator+(const CharT* s, const basic_string<CharT,Traits,A>& y)
 {
    typedef basic_string<CharT, Traits, A> str_t;
    typedef typename str_t::reserve_t reserve_t;
@@ -2549,7 +2549,7 @@
 
 template <class CharT, class Traits, class A>
 inline basic_string<CharT,Traits,A>
-operator+(CharT c, const basic_string<CharT,Traits,A>& y) 
+operator+(CharT c, const basic_string<CharT,Traits,A>& y)
 {
    typedef basic_string<CharT,Traits,A> str_t;
    typedef typename str_t::reserve_t reserve_t;
@@ -2571,7 +2571,7 @@
 
 template <class CharT, class Traits, class A>
 inline basic_string<CharT,Traits,A>
-operator+(const basic_string<CharT,Traits,A>& x, const CharT* s) 
+operator+(const basic_string<CharT,Traits,A>& x, const CharT* s)
 {
    typedef basic_string<CharT,Traits,A> str_t;
    typedef typename str_t::reserve_t reserve_t;
@@ -2594,7 +2594,7 @@
 
 template <class CharT, class Traits, class A>
 inline basic_string<CharT,Traits,A>
-operator+(const basic_string<CharT,Traits,A>& x, const CharT c) 
+operator+(const basic_string<CharT,Traits,A>& x, const CharT c)
 {
    typedef basic_string<CharT,Traits,A> str_t;
    typedef typename str_t::reserve_t reserve_t;
@@ -2619,7 +2619,7 @@
 template <class CharT, class Traits, class A>
 inline bool
 operator==(const basic_string<CharT,Traits,A>& x,
-           const basic_string<CharT,Traits,A>& y) 
+           const basic_string<CharT,Traits,A>& y)
 {
    return x.size() == y.size() &&
           Traits::compare(x.data(), y.data(), x.size()) == 0;
@@ -2627,7 +2627,7 @@
 
 template <class CharT, class Traits, class A>
 inline bool
-operator==(const CharT* s, const basic_string<CharT,Traits,A>& y) 
+operator==(const CharT* s, const basic_string<CharT,Traits,A>& y)
 {
    typename basic_string<CharT,Traits,A>::size_type n = Traits::length(s);
    return n == y.size() && Traits::compare(s, y.data(), n) == 0;
@@ -2635,7 +2635,7 @@
 
 template <class CharT, class Traits, class A>
 inline bool
-operator==(const basic_string<CharT,Traits,A>& x, const CharT* s) 
+operator==(const basic_string<CharT,Traits,A>& x, const CharT* s)
 {
    typename basic_string<CharT,Traits,A>::size_type n = Traits::length(s);
    return x.size() == n && Traits::compare(x.data(), s, n) == 0;
@@ -2644,17 +2644,17 @@
 template <class CharT, class Traits, class A>
 inline bool
 operator!=(const basic_string<CharT,Traits,A>& x,
-           const basic_string<CharT,Traits,A>& y) 
+           const basic_string<CharT,Traits,A>& y)
    {  return !(x == y);  }
 
 template <class CharT, class Traits, class A>
 inline bool
-operator!=(const CharT* s, const basic_string<CharT,Traits,A>& y) 
+operator!=(const CharT* s, const basic_string<CharT,Traits,A>& y)
    {  return !(s == y); }
 
 template <class CharT, class Traits, class A>
 inline bool
-operator!=(const basic_string<CharT,Traits,A>& x, const CharT* s) 
+operator!=(const basic_string<CharT,Traits,A>& x, const CharT* s)
    {  return !(x == s);   }
 
 
@@ -2662,7 +2662,7 @@
 
 template <class CharT, class Traits, class A>
 inline bool
-operator<(const basic_string<CharT,Traits,A>& x, const basic_string<CharT,Traits,A>& y) 
+operator<(const basic_string<CharT,Traits,A>& x, const basic_string<CharT,Traits,A>& y)
 {
    return x.compare(y) < 0;
 //   return basic_string<CharT,Traits,A>
@@ -2671,7 +2671,7 @@
 
 template <class CharT, class Traits, class A>
 inline bool
-operator<(const CharT* s, const basic_string<CharT,Traits,A>& y) 
+operator<(const CharT* s, const basic_string<CharT,Traits,A>& y)
 {
    return y.compare(s) > 0;
 //   basic_string<CharT,Traits,A>::size_type n = Traits::length(s);
@@ -2682,7 +2682,7 @@
 template <class CharT, class Traits, class A>
 inline bool
 operator<(const basic_string<CharT,Traits,A>& x,
-          const CharT* s) 
+          const CharT* s)
 {
    return x.compare(s) < 0;
 //   basic_string<CharT,Traits,A>::size_type n = Traits::length(s);
@@ -2705,7 +2705,7 @@
 
 template <class CharT, class Traits, class A>
 inline bool
-operator>(const basic_string<CharT,Traits,A>& x, const CharT* s) 
+operator>(const basic_string<CharT,Traits,A>& x, const CharT* s)
 {
    return s < x;
 }
@@ -2713,44 +2713,44 @@
 template <class CharT, class Traits, class A>
 inline bool
 operator<=(const basic_string<CharT,Traits,A>& x,
-           const basic_string<CharT,Traits,A>& y) 
+           const basic_string<CharT,Traits,A>& y)
 {
   return !(y < x);
 }
 
 template <class CharT, class Traits, class A>
 inline bool
-operator<=(const CharT* s, const basic_string<CharT,Traits,A>& y) 
+operator<=(const CharT* s, const basic_string<CharT,Traits,A>& y)
    {  return !(y < s);  }
 
 template <class CharT, class Traits, class A>
 inline bool
-operator<=(const basic_string<CharT,Traits,A>& x, const CharT* s) 
+operator<=(const basic_string<CharT,Traits,A>& x, const CharT* s)
    {  return !(s < x);  }
 
 template <class CharT, class Traits, class A>
 inline bool
 operator>=(const basic_string<CharT,Traits,A>& x,
-           const basic_string<CharT,Traits,A>& y) 
+           const basic_string<CharT,Traits,A>& y)
    {  return !(x < y);  }
 
 template <class CharT, class Traits, class A>
 inline bool
-operator>=(const CharT* s, const basic_string<CharT,Traits,A>& y) 
+operator>=(const CharT* s, const basic_string<CharT,Traits,A>& y)
    {  return !(s < y);  }
 
 template <class CharT, class Traits, class A>
 inline bool
-operator>=(const basic_string<CharT,Traits,A>& x, const CharT* s) 
+operator>=(const basic_string<CharT,Traits,A>& x, const CharT* s)
    {  return !(x < s);  }
 
 // Swap.
 template <class CharT, class Traits, class A>
-inline void swap(basic_string<CharT,Traits,A>& x, basic_string<CharT,Traits,A>& y) 
+inline void swap(basic_string<CharT,Traits,A>& x, basic_string<CharT,Traits,A>& y)
 {  x.swap(y);  }
 
 /// @cond
-// I/O.  
+// I/O. 
 namespace container_detail {
 
 template <class CharT, class Traits>
@@ -2788,11 +2788,11 @@
 
       if (w != 0 && n < w)
          pad_len = w - n;
-       
+      
       if (!left)
-         ok = container_detail::string_fill(os, buf, pad_len);    
+         ok = container_detail::string_fill(os, buf, pad_len);   
 
-      ok = ok && 
+      ok = ok &&
             buf->sputn(s.data(), std::streamsize(n)) == std::streamsize(n);
 
       if (left)
@@ -2807,7 +2807,7 @@
 
 
 template <class CharT, class Traits, class A>
-std::basic_istream<CharT, Traits>& 
+std::basic_istream<CharT, Traits>&
 operator>>(std::basic_istream<CharT, Traits>& is, basic_string<CharT,Traits,A>& s)
 {
    typename std::basic_istream<CharT, Traits>::sentry sentry(is);
@@ -2842,7 +2842,7 @@
                s.push_back(c);
          }
       }
-      
+     
       // If we have read no characters, then set failbit.
       if (s.size() == 0)
          is.setstate(std::ios_base::failbit);
@@ -2853,8 +2853,8 @@
    return is;
 }
 
-template <class CharT, class Traits, class A>    
-std::basic_istream<CharT, Traits>& 
+template <class CharT, class Traits, class A>   
+std::basic_istream<CharT, Traits>&
 getline(std::istream& is, basic_string<CharT,Traits,A>& s,CharT delim)
 {
    typename basic_string<CharT,Traits,A>::size_type nread = 0;
@@ -2872,7 +2872,7 @@
          else {
             ++nread;
             CharT c = Traits::to_char_type(c1);
-            if (!Traits::eq(c, delim)) 
+            if (!Traits::eq(c, delim))
                s.push_back(c);
             else
                break;              // Character is extracted but not appended.
@@ -2885,8 +2885,8 @@
    return is;
 }
 
-template <class CharT, class Traits, class A>    
-inline std::basic_istream<CharT, Traits>& 
+template <class CharT, class Traits, class A>   
+inline std::basic_istream<CharT, Traits>&
 getline(std::basic_istream<CharT, Traits>& is, basic_string<CharT,Traits,A>& s)
 {
    return getline(is, s, '\n');

Modified: branches/release/boost/container/vector.hpp
==============================================================================
--- branches/release/boost/container/vector.hpp	(original)
+++ branches/release/boost/container/vector.hpp	2012-05-24 12:36:39 EDT (Thu, 24 May 2012)
@@ -55,7 +55,7 @@
 
 namespace container_detail {
 
-//! Const vector_iterator used to iterate through a vector. 
+//! Const vector_iterator used to iterate through a vector.
 template <class Pointer>
 class vector_const_iterator
 {
@@ -82,20 +82,20 @@
    vector_const_iterator() : m_ptr(0){}
 
    //Pointer like operators
-   reference operator*()   const  
+   reference operator*()   const 
    {  return *m_ptr;  }
 
-   const value_type * operator->()  const  
+   const value_type * operator->()  const 
    {  return  container_detail::to_raw_pointer(m_ptr);  }
 
    reference operator[](difference_type off) const
    {  return m_ptr[off];   }
 
    //Increment / Decrement
-   vector_const_iterator& operator++()       
+   vector_const_iterator& operator++()      
    { ++m_ptr;  return *this; }
 
-   vector_const_iterator operator++(int)      
+   vector_const_iterator operator++(int)     
    {  Pointer tmp = m_ptr; ++*this; return vector_const_iterator(tmp);  }
 
    vector_const_iterator& operator--()
@@ -165,22 +165,22 @@
    {}
 
    //Pointer like operators
-   reference operator*()  const  
+   reference operator*()  const 
    {  return *this->m_ptr;  }
 
-   value_type* operator->() const  
+   value_type* operator->() const 
    {  return  container_detail::to_raw_pointer(this->m_ptr);  }
 
-   reference operator[](difference_type off) const 
+   reference operator[](difference_type off) const
    {  return this->m_ptr[off];   }
 
    //Increment / Decrement
-   vector_iterator& operator++()  
+   vector_iterator& operator++() 
    {  ++this->m_ptr; return *this;  }
 
    vector_iterator operator++(int)
    {  pointer tmp = this->m_ptr; ++*this; return vector_iterator(tmp);  }
-   
+  
    vector_iterator& operator--()
    {  --this->m_ptr; return *this;  }
 
@@ -249,7 +249,7 @@
 
 //!This struct deallocates and allocated memory
 template <class A>
-struct vector_alloc_holder 
+struct vector_alloc_holder
 {
    typedef boost::container::allocator_traits<A>         allocator_traits_type;
    typedef typename allocator_traits_type::pointer       pointer;
@@ -282,7 +282,7 @@
       boost::container::container_detail::version<A>::value> alloc_version;
    std::pair<pointer, bool>
       allocation_command(allocation_type command,
-                         size_type limit_size, 
+                         size_type limit_size,
                          size_type preferred_size,
                          size_type &received_size, const pointer &reuse = 0)
    {
@@ -292,7 +292,7 @@
 
    std::pair<pointer, bool>
       allocation_command(allocation_type command,
-                         size_type limit_size, 
+                         size_type limit_size,
                          size_type preferred_size,
                          size_type &received_size,
                          const pointer &reuse,
@@ -308,7 +308,7 @@
 
    std::pair<pointer, bool>
       allocation_command(allocation_type command,
-                         size_type limit_size, 
+                         size_type limit_size,
                          size_type preferred_size,
                          size_type &received_size,
                          const pointer &reuse,
@@ -394,9 +394,9 @@
 /// @endcond
 
 //! \class vector
-//! A vector is a sequence that supports random access to elements, constant 
-//! time insertion and removal of elements at the end, and linear time insertion 
-//! and removal of elements at the beginning or in the middle. The number of 
+//! A vector is a sequence that supports random access to elements, constant
+//! time insertion and removal of elements at the end, and linear time insertion
+//! and removal of elements at the beginning or in the middle. The number of
 //! elements in a vector may vary dynamically; memory management is automatic.
 //! boost::container::vector is similar to std::vector but it's compatible
 //! with shared memory and memory mapped files.
@@ -434,11 +434,11 @@
    //! The random access const_iterator
    typedef container_detail::vector_const_iterator<pointer>  const_iterator;
 
-   //! Iterator used to iterate backwards through a vector. 
-   typedef std::reverse_iterator<iterator>   
+   //! Iterator used to iterate backwards through a vector.
+   typedef std::reverse_iterator<iterator>  
       reverse_iterator;
-   //! Const iterator used to iterate backwards through a vector. 
-   typedef std::reverse_iterator<const_iterator>                 
+   //! Const iterator used to iterate backwards through a vector.
+   typedef std::reverse_iterator<const_iterator>                
       const_reverse_iterator;
    //! The stored allocator type
    typedef allocator_type                          stored_allocator_type;
@@ -461,9 +461,9 @@
    public:
 
    //! <b>Effects</b>: Constructs a vector taking the allocator as parameter.
-   //! 
+   //!
    //! <b>Throws</b>: If allocator_type's default constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    vector()
       BOOST_CONTAINER_NOEXCEPT_IF(::boost::has_nothrow_default_constructor<A>::value)
@@ -471,9 +471,9 @@
    {}
 
    //! <b>Effects</b>: Constructs a vector taking the allocator as parameter.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    explicit vector(const A& a) BOOST_CONTAINER_NOEXCEPT
       : base_t(a)
@@ -484,7 +484,7 @@
    //!
    //! <b>Throws</b>: If allocator_type's default constructor or allocation
    //!   throws or T's default constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear to n.
    explicit vector(size_type n)
       :  base_t()
@@ -511,21 +511,21 @@
    //!
    //! <b>Throws</b>: If allocator_type's default constructor or allocation
    //!   throws or T's copy constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear to n.
-   vector(size_type n, const T& value, const allocator_type& a = allocator_type()) 
+   vector(size_type n, const T& value, const allocator_type& a = allocator_type())
       :  base_t(a)
    {  this->insert(this->cend(), n, value); }
 
    //! <b>Effects</b>: Copy constructs a vector.
    //!
    //! <b>Postcondition</b>: x == *this.
-   //! 
+   //!
    //! <b>Throws</b>: If allocator_type's default constructor or allocation
    //!   throws or T's copy constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear to the elements x contains.
-   vector(const vector &x) 
+   vector(const vector &x)
       :  base_t(allocator_traits_type::select_on_container_copy_construction(x.alloc()))
    {
       this->assign( container_detail::to_raw_pointer(x.members_.m_start)
@@ -535,7 +535,7 @@
    //! <b>Effects</b>: Move constructor. Moves mx's resources to *this.
    //!
    //! <b>Throws</b>: Nothing
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    vector(BOOST_RV_REF(vector) mx) BOOST_CONTAINER_NOEXCEPT
       :  base_t(boost::move(mx.alloc()))
@@ -544,12 +544,12 @@
    //! <b>Effects</b>: Copy constructs a vector using the specified allocator.
    //!
    //! <b>Postcondition</b>: x == *this.
-   //! 
+   //!
    //! <b>Throws</b>: If allocation
    //!   throws or T's copy constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Linear to the elements x contains.
-   vector(const vector &x, const allocator_type &a) 
+   vector(const vector &x, const allocator_type &a)
       :  base_t(a)
    {
       this->assign( container_detail::to_raw_pointer(x.members_.m_start)
@@ -561,7 +561,7 @@
    //!                 Otherwise copies values from x to *this.
    //!
    //! <b>Throws</b>: If allocation or T's copy constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant if a == mx.get_allocator(), linear otherwise.
    vector(BOOST_RV_REF(vector) mx, const allocator_type &a)
       :  base_t(a)
@@ -597,103 +597,103 @@
    {} //vector_alloc_holder clears the data
 
    //! <b>Effects</b>: Returns an iterator to the first element contained in the vector.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    iterator begin() BOOST_CONTAINER_NOEXCEPT
    { return iterator(this->members_.m_start); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the vector.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_iterator begin() const BOOST_CONTAINER_NOEXCEPT
    { return const_iterator(this->members_.m_start); }
 
    //! <b>Effects</b>: Returns an iterator to the end of the vector.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    iterator end() BOOST_CONTAINER_NOEXCEPT
    { return iterator(this->members_.m_start + this->members_.m_size); }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the vector.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_iterator end() const BOOST_CONTAINER_NOEXCEPT
    { return this->cend(); }
 
-   //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning 
-   //! of the reversed vector. 
-   //! 
+   //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning
+   //! of the reversed vector.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    reverse_iterator rbegin() BOOST_CONTAINER_NOEXCEPT
    { return reverse_iterator(this->end());      }
 
-   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning 
-   //! of the reversed vector. 
-   //! 
+   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
+   //! of the reversed vector.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_reverse_iterator rbegin() const BOOST_CONTAINER_NOEXCEPT
    { return this->crbegin(); }
 
    //! <b>Effects</b>: Returns a reverse_iterator pointing to the end
-   //! of the reversed vector. 
-   //! 
+   //! of the reversed vector.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    reverse_iterator rend() BOOST_CONTAINER_NOEXCEPT
    { return reverse_iterator(this->begin());       }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
-   //! of the reversed vector. 
-   //! 
+   //! of the reversed vector.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_reverse_iterator rend() const BOOST_CONTAINER_NOEXCEPT
    { return this->crend(); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the vector.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_iterator cbegin() const BOOST_CONTAINER_NOEXCEPT
    { return const_iterator(this->members_.m_start); }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the vector.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_iterator cend() const BOOST_CONTAINER_NOEXCEPT
    { return const_iterator(this->members_.m_start + this->members_.m_size); }
 
-   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning 
-   //! of the reversed vector. 
-   //! 
+   //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
+   //! of the reversed vector.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_reverse_iterator crbegin() const BOOST_CONTAINER_NOEXCEPT
    { return const_reverse_iterator(this->end());}
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
-   //! of the reversed vector. 
-   //! 
+   //! of the reversed vector.
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_reverse_iterator crend() const BOOST_CONTAINER_NOEXCEPT
    { return const_reverse_iterator(this->begin()); }
@@ -702,9 +702,9 @@
    //!
    //! <b>Effects</b>: Returns a reference to the first
    //!   element of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    reference         front() BOOST_CONTAINER_NOEXCEPT
    { return *this->members_.m_start; }
@@ -713,9 +713,9 @@
    //!
    //! <b>Effects</b>: Returns a const reference to the first
    //!   element of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_reference   front() const BOOST_CONTAINER_NOEXCEPT
    { return *this->members_.m_start; }
@@ -724,9 +724,9 @@
    //!
    //! <b>Effects</b>: Returns a reference to the last
    //!   element of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    reference         back() BOOST_CONTAINER_NOEXCEPT
    { return this->members_.m_start[this->members_.m_size - 1]; }
@@ -735,132 +735,132 @@
    //!
    //! <b>Effects</b>: Returns a const reference to the last
    //!   element of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_reference   back()  const BOOST_CONTAINER_NOEXCEPT
    { return this->members_.m_start[this->members_.m_size - 1]; }
 
    //! <b>Returns</b>: A pointer such that [data(),data() + size()) is a valid range.
    //!   For a non-empty vector, data() == &front().
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    pointer data() BOOST_CONTAINER_NOEXCEPT
    { return this->members_.m_start; }
 
    //! <b>Returns</b>: A pointer such that [data(),data() + size()) is a valid range.
    //!   For a non-empty vector, data() == &front().
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_pointer data()  const BOOST_CONTAINER_NOEXCEPT
    { return this->members_.m_start; }
 
    //! <b>Effects</b>: Returns the number of the elements contained in the vector.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    size_type size() const BOOST_CONTAINER_NOEXCEPT
    { return this->members_.m_size; }
 
    //! <b>Effects</b>: Returns the largest possible size of the vector.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    size_type max_size() const BOOST_CONTAINER_NOEXCEPT
    { return allocator_traits_type::max_size(this->alloc()); }
 
    //! <b>Effects</b>: Number of elements for which memory has been allocated.
    //!   capacity() is always greater than or equal to size().
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    size_type capacity() const BOOST_CONTAINER_NOEXCEPT
    { return this->members_.m_capacity; }
 
    //! <b>Effects</b>: Returns true if the vector contains no elements.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    bool empty() const BOOST_CONTAINER_NOEXCEPT
    { return !this->members_.m_size; }
 
    //! <b>Requires</b>: size() > n.
    //!
-   //! <b>Effects</b>: Returns a reference to the nth element 
+   //! <b>Effects</b>: Returns a reference to the nth element
    //!   from the beginning of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   reference operator[](size_type n)         
+   reference operator[](size_type n)        
    { return this->members_.m_start[n]; }
 
    //! <b>Requires</b>: size() > n.
    //!
-   //! <b>Effects</b>: Returns a const reference to the nth element 
+   //! <b>Effects</b>: Returns a const reference to the nth element
    //!   from the beginning of the container.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_reference operator[](size_type n) const BOOST_CONTAINER_NOEXCEPT
    { return this->members_.m_start[n]; }
 
    //! <b>Requires</b>: size() > n.
    //!
-   //! <b>Effects</b>: Returns a reference to the nth element 
+   //! <b>Effects</b>: Returns a reference to the nth element
    //!   from the beginning of the container.
-   //! 
+   //!
    //! <b>Throws</b>: std::range_error if n >= size()
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   reference at(size_type n) 
+   reference at(size_type n)
    { this->priv_check_range(n); return this->members_.m_start[n]; }
 
    //! <b>Requires</b>: size() > n.
    //!
-   //! <b>Effects</b>: Returns a const reference to the nth element 
+   //! <b>Effects</b>: Returns a const reference to the nth element
    //!   from the beginning of the container.
-   //! 
+   //!
    //! <b>Throws</b>: std::range_error if n >= size()
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    const_reference at(size_type n) const
    { this->priv_check_range(n); return this->members_.m_start[n]; }
 
    //! <b>Effects</b>: Returns a copy of the internal allocator.
-   //! 
+   //!
    //! <b>Throws</b>: If allocator's copy constructor throws.
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
    allocator_type get_allocator() const BOOST_CONTAINER_NOEXCEPT
    { return this->alloc();  }
 
    //! <b>Effects</b>: Returns a reference to the internal allocator.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   //! 
+   //!
    //! <b>Note</b>: Non-standard extension.
    const stored_allocator_type &get_stored_allocator() const BOOST_CONTAINER_NOEXCEPT
    {  return this->alloc(); }
 
    //! <b>Effects</b>: Returns a reference to the internal allocator.
-   //! 
+   //!
    //! <b>Throws</b>: Nothing
-   //! 
+   //!
    //! <b>Complexity</b>: Constant.
-   //! 
+   //!
    //! <b>Note</b>: Non-standard extension.
    stored_allocator_type &get_stored_allocator() BOOST_CONTAINER_NOEXCEPT
    {  return this->alloc(); }
@@ -869,7 +869,7 @@
    //!   effect. Otherwise, it is a request for allocation of additional memory.
    //!   If the request is successful, then capacity() is greater than or equal to
    //!   n; otherwise, capacity() is unchanged. In either case, size() is unchanged.
-   //! 
+   //!
    //! <b>Throws</b>: If memory allocation allocation throws or T's copy/move constructor throws.
    void reserve(size_type new_cap)
    {
@@ -928,8 +928,8 @@
 
    //! <b>Effects</b>: Makes *this contain the same elements as x.
    //!
-   //! <b>Postcondition</b>: this->size() == x.size(). *this contains a copy 
-   //! of each of x's elements. 
+   //! <b>Postcondition</b>: this->size() == x.size(). *this contains a copy
+   //! of each of x's elements.
    //!
    //! <b>Throws</b>: If memory allocation throws or T's copy/move constructor/assignment throws.
    //!
@@ -1002,7 +1002,7 @@
    //!
    //! <b>Complexity</b>: Linear to n.
    template <class InIt>
-   void assign(InIt first, InIt last) 
+   void assign(InIt first, InIt last)
    {
       //Dispatch depending on integer/iterator
       const bool aux_boolean = container_detail::is_convertible<InIt, size_type>::value;
@@ -1113,7 +1113,7 @@
    #include BOOST_PP_LOCAL_ITERATE()
 
    #endif   //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
-  
+ 
    //! <b>Effects</b>: Swaps the contents of *this and x.
    //!
    //! <b>Throws</b>: Nothing.
@@ -1184,7 +1184,7 @@
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant time.
-   void pop_back() 
+   void pop_back()
    {
       //Destroy last element
       --this->members_.m_size;
@@ -1195,9 +1195,9 @@
    //!
    //! <b>Throws</b>: Nothing.
    //!
-   //! <b>Complexity</b>: Linear to the elements between pos and the 
+   //! <b>Complexity</b>: Linear to the elements between pos and the
    //!   last element. Constant if pos is the last element.
-   iterator erase(const_iterator position) 
+   iterator erase(const_iterator position)
    {
       T *pos = container_detail::to_raw_pointer(position.get_ptr());
       T *beg = container_detail::to_raw_pointer(this->members_.m_start);
@@ -1214,7 +1214,7 @@
    //!
    //! <b>Complexity</b>: Linear to the distance between first and last
    //!   plus linear to the elements between pos and the last element.
-   iterator erase(const_iterator first, const_iterator last) 
+   iterator erase(const_iterator first, const_iterator last)
    {
       if (first != last){   // worth doing, copy down over hole
          T* end_pos = container_detail::to_raw_pointer(this->members_.m_start) + this->members_.m_size;
@@ -1236,7 +1236,7 @@
    //! <b>Throws</b>: If memory allocation throws, or T's copy constructor throws.
    //!
    //! <b>Complexity</b>: Linear to the difference between size() and new_size.
-   void resize(size_type new_size, const T& x) 
+   void resize(size_type new_size, const T& x)
    {
       pointer finish = this->members_.m_start + this->members_.m_size;
       if (new_size < size()){
@@ -1255,7 +1255,7 @@
    //! <b>Throws</b>: If memory allocation throws, or T's copy constructor throws.
    //!
    //! <b>Complexity</b>: Linear to the difference between size() and new_size.
-   void resize(size_type new_size) 
+   void resize(size_type new_size)
    {
       if (new_size < this->size()){
          //Destroy last elements
@@ -1288,8 +1288,23 @@
 
    /// @cond
 
+   //Absolutely experimental. This function might change, disappear or simply crash!
+   template<class BiDirPosConstIt, class BiDirValueIt>
+   void insert_ordered_at(size_type element_count, BiDirPosConstIt last_position_it, BiDirValueIt last_value_it)
+   {
+      const size_type *dummy = 0;
+      this->priv_insert_ordered_at(element_count, last_position_it, false, &dummy[0], last_value_it);
+   }
+
+   //Absolutely experimental. This function might change, disappear or simply crash!
+   template<class BiDirPosConstIt, class BiDirSkipConstIt, class BiDirValueIt>
+   void insert_ordered_at(size_type element_count, BiDirPosConstIt last_position_it, BiDirSkipConstIt last_skip_it, BiDirValueIt last_value_it)
+   {
+      this->priv_insert_ordered_at(element_count, last_position_it, true, last_skip_it, last_value_it);
+   }
+
    private:
-   iterator priv_insert(const_iterator position, const T &x) 
+   iterator priv_insert(const_iterator position, const T &x)
    {
       //Just call more general insert(pos, size, value) and return iterator
       size_type pos_n = position - cbegin();
@@ -1297,7 +1312,7 @@
       return iterator(this->members_.m_start + pos_n);
    }
 
-   iterator priv_insert(const_iterator position, BOOST_RV_REF(T) x) 
+   iterator priv_insert(const_iterator position, BOOST_RV_REF(T) x)
    {
       //Just call more general insert(pos, size, value) and return iterator
       size_type pos_n = position - cbegin();
@@ -1387,7 +1402,7 @@
    template <class FwdIt>
    void priv_range_insert(const_iterator pos, FwdIt first, FwdIt last, std::forward_iterator_tag)
    {
-      if(first != last){        
+      if(first != last){       
          const size_type n = std::distance(first, last);
          container_detail::advanced_insert_aux_proxy<A, FwdIt, T*> proxy(this->alloc(), first, last);
          priv_range_insert(pos.get_ptr(), n, proxy);
@@ -1428,7 +1443,7 @@
             this->members_.m_capacity  = real_cap;
          }
       }
-      
+     
       //If we had room or we have expanded forward
       if (same_buffer_start){
          #ifdef BOOST_CONTAINER_VECTOR_ALLOC_STATS
@@ -1463,10 +1478,10 @@
       }
    }
 
-   public:
    //Absolutely experimental. This function might change, disappear or simply crash!
-   template<class BiDirPosIt, class BiDirValueIt>
-   void insert_ordered_at(size_type element_count, BiDirPosIt last_position_it, BiDirValueIt last_value_it)
+   template<class BiDirPosConstIt, class BiDirSkipConstIt, class BiDirValueIt>
+   void priv_insert_ordered_at( size_type element_count, BiDirPosConstIt last_position_it
+                              , bool do_skip, BiDirSkipConstIt last_skip_it, BiDirValueIt last_value_it)
    {
       const size_type old_size_pos = this->size();
       this->reserve(old_size_pos + element_count);
@@ -1484,11 +1499,15 @@
       while(insertions_left){
          const size_type pos = static_cast<size_type>(*(--last_position_it));
          BOOST_ASSERT(pos <= old_size_pos);
-         //Shift the range after the insertion point, function will take care if the shift
-         //crosses the size() boundary, using copy/move or uninitialized copy/move if necessary.
-         size_type new_hole_size = insert_ordered_at_shift_range(pos, next_pos, this->size(), insertions_left);
+         //If needed shift the range after the insertion point and the previous insertion point.
+         //Function will take care if the shift crosses the size() boundary, using copy/move
+         //or uninitialized copy/move if necessary.
+         size_type new_hole_size = (pos != next_pos)
+            ? priv_insert_ordered_at_shift_range(pos, next_pos, this->size(), insertions_left)
+            : hole_size
+            ;
          if(new_hole_size > 0){
-            //The hole was reduced by insert_ordered_at_shift_range so expand exception rollback range backwards
+            //The hole was reduced by priv_insert_ordered_at_shift_range so expand exception rollback range backwards
             past_hole_values_destroyer.increment_size_backwards(next_pos - pos);
             //Insert the new value in the hole
             allocator_traits_type::construct(this->alloc(), begin_ptr + pos + insertions_left - 1, *(--last_value_it));
@@ -1505,13 +1524,19 @@
          }
          else{
             if(hole_size){
-               //Hole was just filled by insert_ordered_at_shift_range, disable exception rollback and change vector size
+               //Hole was just filled by priv_insert_ordered_at_shift_range, disable exception rollback and change vector size
                past_hole_values_destroyer.release();
                this->members_.m_size += element_count;
             }
             //Insert the new value in the already constructed range
             begin_ptr[pos + insertions_left - 1] = *(--last_value_it);
          }
+         if(do_skip){
+            size_type n = *(--last_skip_it);
+            while(n--){
+               --last_value_it;
+            }
+         }
          --insertions_left;
          hole_size = new_hole_size;
          next_pos = pos;
@@ -1531,7 +1556,7 @@
    //
    //Old situation:
    //       first_pos   last_pos         old_limit
-   //             |       |                  |  
+   //             |       |                  | 
    // ____________V_______V__________________V_____________
    //|   prefix   | range |     suffix       |raw_mem      ~
    //|____________|_______|__________________|_____________~
@@ -1540,20 +1565,20 @@
    // range is moved through move assignments
    //
    //       first_pos   last_pos         old_limit
-   //             |       |                  |  
+   //             |       |                  | 
    // ____________V_______V__________________V_____________
    //|   prefix'  |       |  | range |suffix'|raw_mem      ~
    //|________________+______|___^___|_______|_____________~
    //                 |          |
-   //                 |_>_>_>_>_>^                     
+   //                 |_>_>_>_>_>^                    
    //
    //
    //New situation in Case B (hole_size >= 0):
    // range is moved through uninitialized moves
    //
    //       first_pos   last_pos         old_limit
-   //             |       |                  |  
-   // ____________V_______V__________________V________________ 
+   //             |       |                  | 
+   // ____________V_______V__________________V________________
    //|    prefix' |       |                  | [hole] | range |
    //|_______________________________________|________|___^___|
    //                 |                                   |
@@ -1563,13 +1588,13 @@
    // range is moved through move assignments and uninitialized moves
    //
    //       first_pos   last_pos         old_limit
-   //             |       |                  |  
-   // ____________V_______V__________________V___ 
+   //             |       |                  | 
+   // ____________V_______V__________________V___
    //|   prefix'  |       |              | range |
    //|___________________________________|___^___|
    //                 |                      |
    //                 |_>_>_>_>_>_>_>_>_>_>_>^
-   size_type insert_ordered_at_shift_range(size_type first_pos, size_type last_pos, size_type limit_pos, size_type shift_count)
+   size_type priv_insert_ordered_at_shift_range(size_type first_pos, size_type last_pos, size_type limit_pos, size_type shift_count)
    {
       BOOST_ASSERT(first_pos <= last_pos);
       BOOST_ASSERT(last_pos <= limit_pos);
@@ -1597,7 +1622,7 @@
          ::boost::container::uninitialized_move_alloc
             (this->alloc(), boundary_ptr, begin_ptr + last_pos, limit_ptr);
          //The rest is move assigned
-         boost::move_backward(begin_ptr + first_pos, boundary_ptr, limit_ptr + shift_count);
+         boost::move_backward(begin_ptr + first_pos, boundary_ptr, limit_ptr);
       }
       return hole_size;
    }
@@ -1646,7 +1671,7 @@
       typename value_traits::ArrayDeallocator scoped_alloc(new_start, this->alloc(), new_cap);
       typename value_traits::ArrayDestructor constructed_values_destroyer(new_start, this->alloc(), 0u);
 
-      //Initialize with [begin(), pos) old buffer 
+      //Initialize with [begin(), pos) old buffer
       //the start of the new buffer
       T *old_buffer = container_detail::to_raw_pointer(this->members_.m_start);
       if(old_buffer){
@@ -1658,7 +1683,7 @@
       interf.uninitialized_copy_remaining_to(old_finish = new_finish);
       new_finish += n;
       constructed_values_destroyer.increment_size(new_finish - old_finish);
-      //Initialize from the rest of the old buffer, 
+      //Initialize from the rest of the old buffer,
       //starting from previous point
       if(old_buffer){
          new_finish = ::boost::container::uninitialized_move_alloc
@@ -1666,7 +1691,7 @@
          //Destroy and deallocate old elements
          //If there is allocated memory, destroy and deallocate
          if(!value_traits::trivial_dctr_after_move)
-            this->destroy_n(old_buffer, this->members_.m_size); 
+            this->destroy_n(old_buffer, this->members_.m_size);
          this->alloc().deallocate(this->members_.m_start, this->members_.m_capacity);
       }
       this->members_.m_start     = new_start;
@@ -1812,7 +1837,7 @@
             //|___________|_____|_________|_____________________|
             //
             //Copy the first part of old_begin to raw_mem
-            T *start_n = old_start + difference_type(s_before); 
+            T *start_n = old_start + difference_type(s_before);
             ::boost::container::uninitialized_move_alloc
                (this->alloc(), old_start, start_n, new_start);
             //The buffer is all constructed until old_end,
@@ -2021,7 +2046,7 @@
             this->members_.m_capacity  = real_cap;
          }
       }
-      
+     
       if(same_buffer_start){
          T *start = container_detail::to_raw_pointer(this->members_.m_start);
          if (this->size() >= n){
@@ -2050,7 +2075,7 @@
          scoped_alloc.release();
          //Destroy and deallocate old buffer
          if(this->members_.m_start != 0){
-            this->destroy_n(container_detail::to_raw_pointer(this->members_.m_start), this->members_.m_size); 
+            this->destroy_n(container_detail::to_raw_pointer(this->members_.m_start), this->members_.m_size);
             this->alloc().deallocate(this->members_.m_start, this->members_.m_capacity);
          }
          this->members_.m_start     = ret.first;
@@ -2068,7 +2093,7 @@
          this->members_.m_size  = 0;
          this->members_.m_start = ret.first;
          this->members_.m_capacity = real_cap;
-         
+        
          //Backup old buffer data
          size_type old_offset    = old_start - container_detail::to_raw_pointer(ret.first);
          size_type first_count   = container_detail::min_value(n, old_offset);
@@ -2079,7 +2104,7 @@
             (this->alloc(), first, mid, container_detail::to_raw_pointer(ret.first));
 
          if(old_offset > n){
-            //All old elements will be destroyed by "old_values_destroyer" 
+            //All old elements will be destroyed by "old_values_destroyer"
             this->members_.m_size = n;
          }
          else{
@@ -2094,7 +2119,7 @@
             std::advance(mid2, second_count);
             // iG std::copy(mid, mid2, old_start);
             std::copy(mid, mid2, old_start);
-            
+           
             //Check if we still have to append elements in the
             //uninitialized end
             if(second_count == old_size){
@@ -2107,7 +2132,7 @@
                   (old_start + second_count, old_size - second_count);
                this->members_.m_size = n;
             }
-            this->members_.m_size = n;                        
+            this->members_.m_size = n;                       
          }
       }
    }
@@ -2118,18 +2143,18 @@
 
    template <class InIt>
    void priv_assign_dispatch(InIt first, InIt last, container_detail::false_)
-   { 
+   {
       //Dispatch depending on integer/iterator
       typedef typename std::iterator_traits<InIt>::iterator_category ItCat;
-      this->priv_assign_aux(first, last, ItCat()); 
+      this->priv_assign_aux(first, last, ItCat());
    }
 
    template <class Integer>
-   void priv_insert_dispatch(const_iterator pos, Integer n, Integer val, container_detail::true_) 
+   void priv_insert_dispatch(const_iterator pos, Integer n, Integer val, container_detail::true_)
    {  this->insert(pos, (size_type)n, (T)val);  }
 
    template <class InIt>
-   void priv_insert_dispatch(const_iterator pos, InIt first, 
+   void priv_insert_dispatch(const_iterator pos, InIt first,
                              InIt last,      container_detail::false_)
    {
       //Dispatch depending on integer/iterator
@@ -2137,7 +2162,7 @@
       this->priv_range_insert(pos, first, last, ItCat());
    }
 
-   void priv_check_range(size_type n) const 
+   void priv_check_range(size_type n) const
    {
       //If n is out of range, throw an out_of_range exception
       if (n >= size())
@@ -2157,7 +2182,7 @@
 };
 
 template <class T, class A>
-inline bool 
+inline bool
 operator==(const vector<T, A>& x, const vector<T, A>& y)
 {
    //Check first size and each element if needed
@@ -2165,7 +2190,7 @@
 }
 
 template <class T, class A>
-inline bool 
+inline bool
 operator!=(const vector<T, A>& x, const vector<T, A>& y)
 {
    //Check first size and each element if needed
@@ -2173,7 +2198,7 @@
 }
 
 template <class T, class A>
-inline bool 
+inline bool
 operator<(const vector<T, A>& x, const vector<T, A>& y)
 {
    return std::lexicographical_compare(x.begin(), x.end(), y.begin(), y.end());