Index: boost/container/list.hpp
===================================================================
--- boost/container/list.hpp	(revision 75790)
+++ boost/container/list.hpp	(working copy)
@@ -692,7 +692,7 @@ class list 
    }
 
    //! <b>Effects</b>: Swaps the contents of *this and x.
-   //!   If this->allocator_type() != x.allocator_type()
+   //!   If this->get_allocator() != x.get_allocator()
    //!   allocators are also swapped.
    //!
    //! <b>Throws</b>: Nothing.
Index: boost/container/set.hpp
===================================================================
--- boost/container/set.hpp	(revision 75790)
+++ boost/container/set.hpp	(working copy)
@@ -310,7 +310,7 @@ class set 
    { return m_tree.max_size(); }
 
    //! <b>Effects</b>: Swaps the contents of *this and x.
-   //!   If this->allocator_type() != x.allocator_type() allocators are also swapped.
+   //!   If this->get_allocator() != x.get_allocator() allocators are also swapped.
    //!
    //! <b>Throws</b>: Nothing.
    //!
@@ -873,7 +873,7 @@ class multiset 
    { return m_tree.max_size(); }
 
    //! <b>Effects</b>: Swaps the contents of *this and x.
-   //!   If this->allocator_type() != x.allocator_type() allocators are also swapped.
+   //!   If this->get_allocator() != x.get_allocator() allocators are also swapped.
    //!
    //! <b>Throws</b>: Nothing.
    //!
Index: boost/container/stable_vector.hpp
===================================================================
--- boost/container/stable_vector.hpp	(revision 75790)
+++ boost/container/stable_vector.hpp	(working copy)
@@ -1148,7 +1148,7 @@ class stable_vector
    {   return priv_erase(first, last, alloc_version());  }
 
    //! <b>Effects</b>: Swaps the contents of *this and x.
-   //!   If this->allocator_type() != x.allocator_type()
+   //!   If this->get_allocator() != x.get_allocator()
    //!   allocators are also swapped.
    //!
    //! <b>Throws</b>: Nothing.
Index: boost/container/map.hpp
===================================================================
--- boost/container/map.hpp	(revision 75790)
+++ boost/container/map.hpp	(working copy)
@@ -381,7 +381,7 @@ class map 
    }
 
    //! <b>Effects</b>: Swaps the contents of *this and x.
-   //!   If this->allocator_type() != x.allocator_type() allocators are also swapped.
+   //!   If this->get_allocator() != x.get_allocator() allocators are also swapped.
    //!
    //! <b>Throws</b>: Nothing.
    //!
@@ -989,7 +989,7 @@ class multimap 
    { return m_tree.max_size(); }
 
    //! <b>Effects</b>: Swaps the contents of *this and x.
-   //!   If this->allocator_type() != x.allocator_type() allocators are also swapped.
+   //!   If this->get_allocator() != x.get_allocator() allocators are also swapped.
    //!
    //! <b>Throws</b>: Nothing.
    //!
Index: boost/container/slist.hpp
===================================================================
--- boost/container/slist.hpp	(revision 75790)
+++ boost/container/slist.hpp	(working copy)
@@ -563,7 +563,7 @@ class slist 
    {  return !this->size();   }
 
    //! <b>Effects</b>: Swaps the contents of *this and x.
-   //!   If this->allocator_type() != x.allocator_type()
+   //!   If this->get_allocator() != x.get_allocator()
    //!   allocators are also swapped.
    //!
    //! <b>Throws</b>: Nothing.
Index: boost/container/flat_set.hpp
===================================================================
--- boost/container/flat_set.hpp	(revision 75790)
+++ boost/container/flat_set.hpp	(working copy)
@@ -317,7 +317,7 @@ class flat_set 
       { return m_flat_tree.max_size(); }
 
    //! <b>Effects</b>: Swaps the contents of *this and x.
-   //!   If this->allocator_type() != x.allocator_type() allocators are also swapped.
+   //!   If this->get_allocator() != x.get_allocator() allocators are also swapped.
    //!
    //! <b>Throws</b>: Nothing.
    //!
@@ -335,7 +335,7 @@ class flat_set 
    //! <b>Complexity</b>: Logarithmic search time plus linear insertion
    //!   to the elements with bigger keys than x.
    //!
-   //! <b>Note</b>: If an element it's inserted it might invalidate elements.
+   //! <b>Note</b>: If an element is inserted it might invalidate elements.
    std::pair<iterator, bool> insert(insert_const_ref_type x) 
    {  return priv_insert(x); }
 
@@ -358,7 +358,7 @@ class flat_set 
    //! <b>Complexity</b>: Logarithmic search time plus linear insertion
    //!   to the elements with bigger keys than x.
    //!
-   //! <b>Note</b>: If an element it's inserted it might invalidate elements.
+   //! <b>Note</b>: If an element is inserted it might invalidate elements.
    std::pair<iterator,bool> insert(BOOST_RV_REF(value_type) x) 
    {  return m_flat_tree.insert_unique(boost::move(x));  }
 
@@ -372,7 +372,7 @@ class flat_set 
    //! <b>Complexity</b>: Logarithmic search time (constant if x is inserted
    //!   right before p) plus insertion linear to the elements with bigger keys than x.
    //!
-   //! <b>Note</b>: If an element it's inserted it might invalidate elements.
+   //! <b>Note</b>: If an element is inserted it might invalidate elements.
    iterator insert(const_iterator p, insert_const_ref_type x) 
    {  return priv_insert(p, x); }
 
@@ -393,7 +393,7 @@ class flat_set 
    //! <b>Complexity</b>: Logarithmic search time (constant if x is inserted
    //!   right before p) plus insertion linear to the elements with bigger keys than x.
    //!
-   //! <b>Note</b>: If an element it's inserted it might invalidate elements.
+   //! <b>Note</b>: If an element is inserted it might invalidate elements.
    iterator insert(const_iterator position, BOOST_RV_REF(value_type) x) 
    {  return m_flat_tree.insert_unique(position, boost::move(x)); }
 
@@ -405,7 +405,7 @@ class flat_set 
    //! <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 it's inserted it might invalidate elements.
+   //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class InputIterator>
    void insert(InputIterator first, InputIterator last) 
       {  m_flat_tree.insert_unique(first, last);  }
@@ -423,7 +423,7 @@ class flat_set 
    //! <b>Complexity</b>: Logarithmic search time plus linear insertion
    //!   to the elements with bigger keys than x.
    //!
-   //! <b>Note</b>: If an element it's inserted it might invalidate elements.
+   //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class... Args>
    iterator emplace(Args&&... args)
    {  return m_flat_tree.emplace_unique(boost::forward<Args>(args)...); }
@@ -439,7 +439,7 @@ class flat_set 
    //! <b>Complexity</b>: Logarithmic search time (constant if x is inserted
    //!   right before p) plus insertion linear to the elements with bigger keys than x.
    //!
-   //! <b>Note</b>: If an element it's inserted it might invalidate elements.
+   //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class... Args>
    iterator emplace_hint(const_iterator hint, Args&&... args)
    {  return m_flat_tree.emplace_hint_unique(hint, boost::forward<Args>(args)...); }
@@ -920,7 +920,7 @@ class flat_multiset 
       { return m_flat_tree.max_size(); }
 
    //! <b>Effects</b>: Swaps the contents of *this and x.
-   //!   If this->allocator_type() != x.allocator_type() allocators are also swapped.
+   //!   If this->get_allocator() != x.get_allocator() allocators are also swapped.
    //!
    //! <b>Throws</b>: Nothing.
    //!
@@ -934,7 +934,7 @@ class flat_multiset 
    //! <b>Complexity</b>: Logarithmic search time plus linear insertion
    //!   to the elements with bigger keys than x.
    //!
-   //! <b>Note</b>: If an element it's inserted it might invalidate elements.
+   //! <b>Note</b>: If an element is inserted it might invalidate elements.
    iterator insert(insert_const_ref_type x) 
    {  return priv_insert(x); }
 
@@ -953,7 +953,7 @@ class flat_multiset 
    //! <b>Complexity</b>: Logarithmic search time plus linear insertion
    //!   to the elements with bigger keys than x.
    //!
-   //! <b>Note</b>: If an element it's inserted it might invalidate elements.
+   //! <b>Note</b>: If an element is inserted it might invalidate elements.
    iterator insert(BOOST_RV_REF(value_type) x) 
    {  return m_flat_tree.insert_equal(boost::move(x));   }
 
@@ -966,7 +966,7 @@ class flat_multiset 
    //! <b>Complexity</b>: Logarithmic search time (constant if x is inserted
    //!   right before p) plus insertion linear to the elements with bigger keys than x.
    //!
-   //! <b>Note</b>: If an element it's inserted it might invalidate elements.
+   //! <b>Note</b>: If an element is inserted it might invalidate elements.
    iterator insert(const_iterator p, insert_const_ref_type x) 
    {  return priv_insert(p, x); }
 
@@ -988,7 +988,7 @@ class flat_multiset 
    //! <b>Complexity</b>: Logarithmic search time (constant if x is inserted
    //!   right before p) plus insertion linear to the elements with bigger keys than x.
    //!
-   //! <b>Note</b>: If an element it's inserted it might invalidate elements.
+   //! <b>Note</b>: If an element is inserted it might invalidate elements.
    iterator insert(const_iterator position, BOOST_RV_REF(value_type) x) 
    {  return m_flat_tree.insert_equal(position, boost::move(x));  }
 
@@ -999,7 +999,7 @@ class flat_multiset 
    //! <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 it's inserted it might invalidate elements.
+   //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class InputIterator>
    void insert(InputIterator first, InputIterator last) 
       {  m_flat_tree.insert_equal(first, last);  }
@@ -1013,7 +1013,7 @@ class flat_multiset 
    //! <b>Complexity</b>: Logarithmic search time plus linear insertion
    //!   to the elements with bigger keys than x.
    //!
-   //! <b>Note</b>: If an element it's inserted it might invalidate elements.
+   //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class... Args>
    iterator emplace(Args&&... args)
    {  return m_flat_tree.emplace_equal(boost::forward<Args>(args)...); }
@@ -1028,7 +1028,7 @@ class flat_multiset 
    //! <b>Complexity</b>: Logarithmic search time (constant if x is inserted
    //!   right before p) plus insertion linear to the elements with bigger keys than x.
    //!
-   //! <b>Note</b>: If an element it's inserted it might invalidate elements.
+   //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class... Args>
    iterator emplace_hint(const_iterator hint, Args&&... args)
    {  return m_flat_tree.emplace_hint_equal(hint, boost::forward<Args>(args)...); }
Index: boost/container/vector.hpp
===================================================================
--- boost/container/vector.hpp	(revision 75790)
+++ boost/container/vector.hpp	(working copy)
@@ -1053,7 +1053,7 @@ class vector : private containers_detail
    #endif   //#ifdef BOOST_CONTAINERS_PERFECT_FORWARDING
   
    //! <b>Effects</b>: Swaps the contents of *this and x.
-   //!   If this->allocator_type() != x.allocator_type()
+   //!   If this->get_allocator() != x.get_allocator()
    //!   allocators are also swapped.
    //!
    //! <b>Throws</b>: Nothing.
Index: boost/container/deque.hpp
===================================================================
--- boost/container/deque.hpp	(revision 75790)
+++ boost/container/deque.hpp	(working copy)
@@ -892,7 +892,7 @@ class deque : protected deque_base<T, A>
    }
 
    //! <b>Effects</b>: Swaps the contents of *this and x.
-   //!   If this->allocator_type() != x.allocator_type()
+   //!   If this->get_allocator() != x.get_allocator()
    //!   allocators are also swapped.
    //!
    //! <b>Throws</b>: Nothing.
Index: boost/container/flat_map.hpp
===================================================================
--- boost/container/flat_map.hpp	(revision 75790)
+++ boost/container/flat_map.hpp	(working copy)
@@ -428,7 +428,7 @@ class flat_map 
    }
 
    //! <b>Effects</b>: Swaps the contents of *this and x.
-   //!   If this->allocator_type() != x.allocator_type() allocators are also swapped.
+   //!   If this->get_allocator() != x.get_allocator() allocators are also swapped.
    //!
    //! <b>Throws</b>: Nothing.
    //!
@@ -446,7 +446,7 @@ class flat_map 
    //! <b>Complexity</b>: Logarithmic search time plus linear insertion
    //!   to the elements with bigger keys than x.
    //!
-   //! <b>Note</b>: If an element it's inserted it might invalidate elements.
+   //! <b>Note</b>: If an element is inserted it might invalidate elements.
    std::pair<iterator,bool> insert(const value_type& x) 
       { return force<std::pair<iterator,bool> >(
          m_flat_tree.insert_unique(force<impl_value_type>(x))); }
@@ -461,7 +461,7 @@ class flat_map 
    //! <b>Complexity</b>: Logarithmic search time plus linear insertion
    //!   to the elements with bigger keys than x.
    //!
-   //! <b>Note</b>: If an element it's inserted it might invalidate elements.
+   //! <b>Note</b>: If an element is inserted it might invalidate elements.
    std::pair<iterator,bool> insert(BOOST_RV_REF(value_type) x) 
    {  return force<std::pair<iterator,bool> >(
       m_flat_tree.insert_unique(boost::move(force<impl_value_type>(x)))); }
@@ -476,7 +476,7 @@ class flat_map 
    //! <b>Complexity</b>: Logarithmic search time plus linear insertion
    //!   to the elements with bigger keys than x.
    //!
-   //! <b>Note</b>: If an element it's inserted it might invalidate elements.
+   //! <b>Note</b>: If an element is inserted it might invalidate elements.
    std::pair<iterator,bool> insert(BOOST_RV_REF(impl_value_type) x) 
    {
       return force<std::pair<iterator,bool> >
@@ -493,7 +493,7 @@ class flat_map 
    //! <b>Complexity</b>: Logarithmic search time (constant if x is inserted
    //!   right before p) plus insertion linear to the elements with bigger keys than x.
    //!
-   //! <b>Note</b>: If an element it's inserted it might invalidate elements.
+   //! <b>Note</b>: If an element is inserted it might invalidate elements.
    iterator insert(const_iterator position, const value_type& x)
       { return force_copy<iterator>(
          m_flat_tree.insert_unique(force<impl_const_iterator>(position), force<impl_value_type>(x))); }
@@ -506,7 +506,7 @@ class flat_map 
    //! <b>Complexity</b>: Logarithmic search time (constant if x is inserted
    //!   right before p) plus insertion linear to the elements with bigger keys than x.
    //!
-   //! <b>Note</b>: If an element it's inserted it might invalidate elements.
+   //! <b>Note</b>: If an element is inserted it might invalidate elements.
    iterator insert(const_iterator position, BOOST_RV_REF(value_type) x)
       { return force_copy<iterator>(
          m_flat_tree.insert_unique(force<impl_const_iterator>(position), boost::move(force<impl_value_type>(x)))); }
@@ -519,7 +519,7 @@ class flat_map 
    //! <b>Complexity</b>: Logarithmic search time (constant if x is inserted
    //!   right before p) plus insertion linear to the elements with bigger keys than x.
    //!
-   //! <b>Note</b>: If an element it's inserted it might invalidate elements.
+   //! <b>Note</b>: If an element is inserted it might invalidate elements.
    iterator insert(const_iterator position, BOOST_RV_REF(impl_value_type) x)
    {
       return force_copy<iterator>(
@@ -534,7 +534,7 @@ class flat_map 
    //! <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 it's inserted it might invalidate elements.
+   //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class InputIterator>
    void insert(InputIterator first, InputIterator last) 
    {  m_flat_tree.insert_unique(first, last);  }
@@ -552,7 +552,7 @@ class flat_map 
    //! <b>Complexity</b>: Logarithmic search time plus linear insertion
    //!   to the elements with bigger keys than x.
    //!
-   //! <b>Note</b>: If an element it's inserted it might invalidate elements.
+   //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class... Args>
    iterator emplace(Args&&... args)
    {  return force_copy<iterator>(m_flat_tree.emplace_unique(boost::forward<Args>(args)...)); }
@@ -568,7 +568,7 @@ class flat_map 
    //! <b>Complexity</b>: Logarithmic search time (constant if x is inserted
    //!   right before p) plus insertion linear to the elements with bigger keys than x.
    //!
-   //! <b>Note</b>: If an element it's inserted it might invalidate elements.
+   //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class... Args>
    iterator emplace_hint(const_iterator hint, Args&&... args)
    {  return force_copy<iterator>(m_flat_tree.emplace_hint_unique(force<impl_const_iterator>(hint), boost::forward<Args>(args)...)); }
@@ -1082,7 +1082,7 @@ class flat_multimap 
       { return m_flat_tree.max_size(); }
 
    //! <b>Effects</b>: Swaps the contents of *this and x.
-   //!   If this->allocator_type() != x.allocator_type() allocators are also swapped.
+   //!   If this->get_allocator() != x.get_allocator() allocators are also swapped.
    //!
    //! <b>Throws</b>: Nothing.
    //!
@@ -1096,7 +1096,7 @@ class flat_multimap 
    //! <b>Complexity</b>: Logarithmic search time plus linear insertion
    //!   to the elements with bigger keys than x.
    //!
-   //! <b>Note</b>: If an element it's inserted it might invalidate elements.
+   //! <b>Note</b>: If an element is inserted it might invalidate elements.
    iterator insert(const value_type& x) 
       { return force_copy<iterator>(m_flat_tree.insert_equal(force<impl_value_type>(x))); }
 
@@ -1106,7 +1106,7 @@ class flat_multimap 
    //! <b>Complexity</b>: Logarithmic search time plus linear insertion
    //!   to the elements with bigger keys than x.
    //!
-   //! <b>Note</b>: If an element it's inserted it might invalidate elements.
+   //! <b>Note</b>: If an element is inserted it might invalidate elements.
    iterator insert(BOOST_RV_REF(value_type) x) 
    { return force_copy<iterator>(m_flat_tree.insert_equal(boost::move(x))); }
 
@@ -1116,7 +1116,7 @@ class flat_multimap 
    //! <b>Complexity</b>: Logarithmic search time plus linear insertion
    //!   to the elements with bigger keys than x.
    //!
-   //! <b>Note</b>: If an element it's inserted it might invalidate elements.
+   //! <b>Note</b>: If an element is inserted it might invalidate elements.
    iterator insert(BOOST_RV_REF(impl_value_type) x) 
       { return force_copy<iterator>(m_flat_tree.insert_equal(boost::move(x))); }
 
@@ -1130,7 +1130,7 @@ class flat_multimap 
    //!   is to be inserted before p) plus linear insertion
    //!   to the elements with bigger keys than x.
    //!
-   //! <b>Note</b>: If an element it's inserted it might invalidate elements.
+   //! <b>Note</b>: If an element is inserted it might invalidate elements.
    iterator insert(const_iterator position, const value_type& x) 
       { return force_copy<iterator>(m_flat_tree.insert_equal(force<impl_const_iterator>(position), force<impl_value_type>(x))); }
 
@@ -1144,7 +1144,7 @@ class flat_multimap 
    //!   is to be inserted before p) plus linear insertion
    //!   to the elements with bigger keys than x.
    //!
-   //! <b>Note</b>: If an element it's inserted it might invalidate elements.
+   //! <b>Note</b>: If an element is inserted it might invalidate elements.
    iterator insert(const_iterator position, BOOST_RV_REF(value_type) x) 
    {
       return force_copy<iterator>
@@ -1162,7 +1162,7 @@ class flat_multimap 
    //!   is to be inserted before p) plus linear insertion
    //!   to the elements with bigger keys than x.
    //!
-   //! <b>Note</b>: If an element it's inserted it might invalidate elements.
+   //! <b>Note</b>: If an element is inserted it might invalidate elements.
    iterator insert(const_iterator position, BOOST_RV_REF(impl_value_type) x) 
    {
       return force_copy<iterator>(
@@ -1176,7 +1176,7 @@ class flat_multimap 
    //! <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 it's inserted it might invalidate elements.
+   //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class InputIterator>
    void insert(InputIterator first, InputIterator last) 
       {  m_flat_tree.insert_equal(first, last); }
@@ -1190,7 +1190,7 @@ class flat_multimap 
    //! <b>Complexity</b>: Logarithmic search time plus linear insertion
    //!   to the elements with bigger keys than x.
    //!
-   //! <b>Note</b>: If an element it's inserted it might invalidate elements.
+   //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class... Args>
    iterator emplace(Args&&... args)
    {  return force_copy<iterator>(m_flat_tree.emplace_equal(boost::forward<Args>(args)...)); }
@@ -1206,7 +1206,7 @@ class flat_multimap 
    //!   is to be inserted before p) plus linear insertion
    //!   to the elements with bigger keys than x.
    //!
-   //! <b>Note</b>: If an element it's inserted it might invalidate elements.
+   //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class... Args>
    iterator emplace_hint(const_iterator hint, Args&&... args)
    {