passenger 5.3.3 → 5.3.4

data/src/cxx_supportlib/vendor-modified/boost/container/static_vector.hpp

@@ -33,7 +33,7 @@ namespace boost { namespace container {
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
-namespace container_detail {
+namespace dtl {
 
 template<class T, std::size_t N>
 class static_storage_allocator
@@ -51,17 +51,17 @@ class static_storage_allocator
    {  return *this;  }
 
    BOOST_CONTAINER_FORCEINLINE T* internal_storage() const BOOST_NOEXCEPT_OR_NOTHROW
-   {  return const_cast<T*>(static_cast<const T*>(static_cast<const void*>(&storage)));  }
+   {  return const_cast<T*>(static_cast<const T*>(static_cast<const void*>(storage.data)));  }
 
    BOOST_CONTAINER_FORCEINLINE T* internal_storage() BOOST_NOEXCEPT_OR_NOTHROW
-   {  return static_cast<T*>(static_cast<void*>(&storage));  }
+   {  return static_cast<T*>(static_cast<void*>(storage.data));  }
 
    static const std::size_t internal_capacity = N;
 
    std::size_t max_size() const
    {  return N;   }
 
-   typedef boost::container::container_detail::version_type<static_storage_allocator, 0>   version;
+   typedef boost::container::dtl::version_type<static_storage_allocator, 0>   version;
 
    BOOST_CONTAINER_FORCEINLINE friend bool operator==(const static_storage_allocator &, const static_storage_allocator &) BOOST_NOEXCEPT_OR_NOTHROW
    {  return false;  }
@@ -73,7 +73,7 @@ class static_storage_allocator
    typename aligned_storage<sizeof(T)*N, alignment_of<T>::value>::type storage;
 };
 
-}  //namespace container_detail {
+}  //namespace dtl {
 
 #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
@@ -103,16 +103,18 @@ class static_storage_allocator
 //!@tparam Capacity The maximum number of elements static_vector can store, fixed at compile time.
 template <typename Value, std::size_t Capacity>
 class static_vector
-    : public vector<Value, container_detail::static_storage_allocator<Value, Capacity> >
+    : public vector<Value, dtl::static_storage_allocator<Value, Capacity> >
 {
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
-   typedef vector<Value, container_detail::static_storage_allocator<Value, Capacity> > base_t;
+   typedef vector<Value, dtl::static_storage_allocator<Value, Capacity> > base_t;
 
    BOOST_COPYABLE_AND_MOVABLE(static_vector)
 
    template<class U, std::size_t OtherCapacity>
    friend class static_vector;
 
+   public:
+   typedef dtl::static_storage_allocator<Value, Capacity> allocator_type;
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
 public:
@@ -252,6 +254,19 @@ public:
         : base_t(other)
     {}
 
+    BOOST_CONTAINER_FORCEINLINE static_vector(static_vector const& other, const allocator_type &)
+       : base_t(other)
+    {}
+
+    BOOST_CONTAINER_FORCEINLINE static_vector(BOOST_RV_REF(static_vector) other,  const allocator_type &)
+       BOOST_NOEXCEPT_IF(boost::container::dtl::is_nothrow_move_constructible<value_type>::value)
+       : base_t(BOOST_MOVE_BASE(base_t, other))
+    {}
+
+    BOOST_CONTAINER_FORCEINLINE explicit static_vector(const allocator_type &)
+       : base_t()
+    {}
+
     //! @pre <tt>other.size() <= capacity()</tt>.
     //!
     //! @brief Constructs a copy of other static_vector.
@@ -279,7 +294,7 @@ public:
     //! @par Complexity
     //!   Linear O(N).
     BOOST_CONTAINER_FORCEINLINE static_vector(BOOST_RV_REF(static_vector) other)
-      BOOST_NOEXCEPT_IF(boost::container::container_detail::is_nothrow_move_constructible<value_type>::value)
+      BOOST_NOEXCEPT_IF(boost::container::dtl::is_nothrow_move_constructible<value_type>::value)
         : base_t(BOOST_MOVE_BASE(base_t, other))
     {}
 
@@ -1213,7 +1228,7 @@ inline void swap(static_vector<V, C1> & x, static_vector<V, C2> & y);
 
 template<typename V, std::size_t C1, std::size_t C2>
 inline void swap(static_vector<V, C1> & x, static_vector<V, C2> & y
-      , typename container_detail::enable_if_c< C1 != C2>::type * = 0)
+      , typename dtl::enable_if_c< C1 != C2>::type * = 0)
 {
    x.swap(y);
 }

data/src/cxx_supportlib/vendor-modified/boost/container/string.hpp

@@ -35,10 +35,11 @@
 #include <boost/container/detail/min_max.hpp>
 #include <boost/container/detail/mpl.hpp>
 #include <boost/container/detail/next_capacity.hpp>
-#include <boost/container/detail/to_raw_pointer.hpp>
+#include <boost/move/detail/to_raw_pointer.hpp>
 #include <boost/container/detail/version_type.hpp>
 #include <boost/container/detail/type_traits.hpp>
 #include <boost/container/detail/minimal_char_traits_header.hpp>
+#include <boost/container/detail/algorithm.hpp>
 
 #include <boost/intrusive/pointer_traits.hpp>
 
@@ -51,7 +52,6 @@
 #include <boost/functional/hash.hpp>
 
 #include <algorithm>
-#include <functional>   //bind2nd, etc.
 #include <iosfwd>
 #include <istream>
 #include <ostream>
@@ -70,7 +70,7 @@ namespace boost {
 namespace container {
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
-namespace container_detail {
+namespace dtl {
 // ------------------------------------------------------------
 // Class basic_string_base.
 
@@ -170,8 +170,8 @@ class basic_string_base
    //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 container_detail::aligned_storage
-      <sizeof(long_t), container_detail::alignment_of<long_t>::value>::type   long_raw_t;
+   typedef typename dtl::aligned_storage
+      <sizeof(long_t), dtl::alignment_of<long_t>::value>::type   long_raw_t;
 
    protected:
    static const size_type  MinInternalBufferChars = 8;
@@ -199,7 +199,7 @@ class basic_string_base
       {  return s;  }
 
       const long_t &long_repr() const
-      {  return *static_cast<const long_t*>(static_cast<const void*>(&r));  }
+      {  return *static_cast<const long_t*>(static_cast<const void*>(r.data));  }
 
       short_t &short_repr()
       {  return s;  }
@@ -274,8 +274,8 @@ class basic_string_base
 
    protected:
 
-   typedef container_detail::integral_constant<unsigned,
-      boost::container::container_detail::version<Allocator>::value> alloc_version;
+   typedef dtl::integral_constant<unsigned,
+      boost::container::dtl::version<Allocator>::value> alloc_version;
 
    pointer allocation_command(allocation_type command,
                          size_type limit_size,
@@ -286,16 +286,14 @@ class basic_string_base
          reuse = 0;
          command &= ~(expand_fwd | expand_bwd);
       }
-      return container_detail::allocator_version_traits<Allocator>::allocation_command
+      return dtl::allocator_version_traits<Allocator>::allocation_command
          (this->alloc(), command, limit_size, prefer_in_recvd_out_size, reuse);
    }
 
    size_type next_capacity(size_type additional_objects) const
    {
-      return next_capacity_calculator
-         <size_type, NextCapacityDouble /*NextCapacity60Percent*/>::
-            get( allocator_traits_type::max_size(this->alloc())
-               , this->priv_storage(), additional_objects );
+      return growth_factor_100()
+            ( this->priv_storage(), additional_objects, allocator_traits_type::max_size(this->alloc()));
    }
 
    void deallocate(pointer p, size_type n)
@@ -308,14 +306,14 @@ class basic_string_base
    {
       allocator_traits_type::construct
          ( this->alloc()
-         , container_detail::to_raw_pointer(p)
+         , boost::movelib::to_raw_pointer(p)
          , value
          );
    }
 
    void destroy(pointer p, size_type n)
    {
-      value_type *raw_p = container_detail::to_raw_pointer(p);
+      value_type *raw_p = boost::movelib::to_raw_pointer(p);
       for(; n--; ++raw_p){
          allocator_traits_type::destroy( this->alloc(), raw_p);
       }
@@ -325,7 +323,7 @@ class basic_string_base
    {
       allocator_traits_type::destroy
          ( this->alloc()
-         , container_detail::to_raw_pointer(p)
+         , boost::movelib::to_raw_pointer(p)
          );
    }
 
@@ -460,7 +458,7 @@ class basic_string_base
    }
 };
 
-}  //namespace container_detail {
+}  //namespace dtl {
 
 #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
@@ -502,13 +500,13 @@ template <class CharT, class Traits = std::char_traits<CharT>, class Allocator =
 template <class CharT, class Traits, class Allocator>
 #endif
 class basic_string
-   :  private container_detail::basic_string_base<Allocator>
+   :  private dtl::basic_string_base<Allocator>
 {
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    private:
    typedef allocator_traits<Allocator> allocator_traits_type;
    BOOST_COPYABLE_AND_MOVABLE(basic_string)
-   typedef container_detail::basic_string_base<Allocator> base_t;
+   typedef dtl::basic_string_base<Allocator> base_t;
    static const typename base_t::size_type InternalBufferChars = base_t::InternalBufferChars;
 
    protected:
@@ -541,8 +539,8 @@ class basic_string
 
       bool operator()(const typename Tr::char_type& x) const
       {
-         return std::find_if(m_first, m_last,
-                        std::bind1st(Eq_traits<Tr>(), x)) == m_last;
+         return boost::container::find_if(m_first, m_last,
+                        boost::container::bind1st(Eq_traits<Tr>(), x)) == m_last;
       }
    };
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
@@ -598,7 +596,7 @@ class basic_string
    //! <b>Effects</b>: Default constructs a basic_string.
    //!
    //! <b>Throws</b>: If allocator_type's default constructor throws.
-   basic_string() BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value)
+   basic_string() BOOST_NOEXCEPT_IF(dtl::is_nothrow_default_constructible<Allocator>::value)
       : base_t()
    { this->priv_terminate_string(); }
 
@@ -689,7 +687,7 @@ class basic_string
          throw_out_of_range("basic_string::basic_string out of range position");
       else
          this->assign
-            (s.begin() + pos, s.begin() + pos + container_detail::min_value(n, s.size() - pos));
+            (s.begin() + pos, s.begin() + pos + dtl::min_value(n, s.size() - pos));
    }
 
    //! <b>Effects</b>: Constructs a basic_string taking the allocator as parameter,
@@ -702,7 +700,7 @@ class basic_string
          throw_out_of_range("basic_string::basic_string out of range position");
       else
          this->assign
-            (s.begin() + pos, s.begin() + pos + container_detail::min_value(n, s.size() - pos));
+            (s.begin() + pos, s.begin() + pos + dtl::min_value(n, s.size() - pos));
    }
 
    //! <b>Effects</b>: Constructs a basic_string taking a default-constructed allocator,
@@ -827,7 +825,7 @@ class basic_string
       if (&x != this){
          allocator_type &this_alloc     = this->alloc();
          const allocator_type &x_alloc  = x.alloc();
-         container_detail::bool_<allocator_traits_type::
+         dtl::bool_<allocator_traits_type::
             propagate_on_container_copy_assignment::value> flag;
          if(flag && this_alloc != x_alloc){
             if(!this->is_short()){
@@ -837,7 +835,7 @@ class basic_string
                this->priv_short_size(0);
             }
          }
-         container_detail::assign_alloc(this->alloc(), x.alloc(), flag);
+         dtl::assign_alloc(this->alloc(), x.alloc(), flag);
          this->assign(x.begin(), x.end());
       }
       return *this;
@@ -861,7 +859,7 @@ class basic_string
       allocator_type &x_alloc    = x.alloc();
       const bool propagate_alloc = allocator_traits_type::
             propagate_on_container_move_assignment::value;
-      container_detail::bool_<propagate_alloc> flag;
+      dtl::bool_<propagate_alloc> flag;
       const bool allocators_equal = this_alloc == x_alloc; (void)allocators_equal;
       //Resources can be transferred if both allocators are
       //going to be equal after this function (either propagated or already equal)
@@ -869,7 +867,7 @@ class basic_string
          //Destroy objects but retain memory in case x reuses it in the future
          this->clear();
          //Move allocator if needed
-         container_detail::move_alloc(this_alloc, x_alloc, flag);
+         dtl::move_alloc(this_alloc, x_alloc, flag);
          //Nothrow swap
          this->swap_data(x);
       }
@@ -1158,8 +1156,8 @@ class basic_string
             size_type long_storage = this->priv_long_storage();
             size_type long_size    = this->priv_long_size();
             //Shrink from allocated buffer to the internal one, including trailing null
-            Traits::copy( container_detail::to_raw_pointer(this->priv_short_addr())
-                        , container_detail::to_raw_pointer(long_addr)
+            Traits::copy( boost::movelib::to_raw_pointer(this->priv_short_addr())
+                        , boost::movelib::to_raw_pointer(long_addr)
                         , long_size+1);
             this->is_short(true);
             this->alloc().deallocate(long_addr, long_storage);
@@ -1356,7 +1354,7 @@ class basic_string
       if (pos > s.size())
          throw_out_of_range("basic_string::append out of range position");
       return this->append(s.begin() + pos,
-                          s.begin() + pos + container_detail::min_value(n, s.size() - pos));
+                          s.begin() + pos + dtl::min_value(n, s.size() - pos));
    }
 
    //! <b>Requires</b>: s points to an array of at least n elements of CharT.
@@ -1457,7 +1455,7 @@ class basic_string
       if (pos > s.size())
          throw_out_of_range("basic_string::assign out of range position");
       return this->assign(s.begin() + pos,
-                          s.begin() + pos + container_detail::min_value(n, s.size() - pos));
+                          s.begin() + pos + dtl::min_value(n, s.size() - pos));
    }
 
    //! <b>Requires</b>: s points to an array of at least n elements of CharT.
@@ -1492,7 +1490,7 @@ class basic_string
     {
        size_type n = static_cast<size_type>(last - first);
        this->reserve(n);
-       CharT* ptr = container_detail::to_raw_pointer(this->priv_addr());
+       CharT* ptr = boost::movelib::to_raw_pointer(this->priv_addr());
        Traits::copy(ptr, first, n);
        this->priv_construct_null(ptr + n);
        this->priv_size(n);
@@ -1505,13 +1503,13 @@ class basic_string
    template <class InputIter>
    basic_string& assign(InputIter first, InputIter last
       #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-      , typename container_detail::disable_if_convertible<InputIter, size_type>::type * = 0
+      , typename dtl::disable_if_convertible<InputIter, size_type>::type * = 0
       #endif
       )
    {
       size_type cur = 0;
       const pointer addr = this->priv_addr();
-      CharT *ptr = container_detail::to_raw_pointer(addr);
+      CharT *ptr = boost::movelib::to_raw_pointer(addr);
       const size_type old_size = this->priv_size();
       while (first != last && cur != old_size) {
          Traits::assign(*ptr, *first);
@@ -1567,10 +1565,10 @@ class basic_string
       const size_type str_size = s.size();
       if (pos1 > sz || pos2 > str_size)
          throw_out_of_range("basic_string::insert out of range position");
-      size_type len = container_detail::min_value(n, str_size - pos2);
+      size_type len = dtl::min_value(n, str_size - pos2);
       if (sz > this->max_size() - len)
          throw_length_error("basic_string::insert max_size() exceeded");
-      const CharT *beg_ptr = container_detail::to_raw_pointer(s.begin()) + pos2;
+      const CharT *beg_ptr = boost::movelib::to_raw_pointer(s.begin()) + pos2;
       const CharT *end_ptr = beg_ptr + len;
       this->insert(this->priv_addr() + pos1, beg_ptr, end_ptr);
       return *this;
@@ -1666,10 +1664,10 @@ class basic_string
    template <class InputIter>
    iterator insert(const_iterator p, InputIter first, InputIter last
       #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-      , typename container_detail::disable_if_or
+      , typename dtl::disable_if_or
          < void
-         , container_detail::is_convertible<InputIter, size_type>
-         , container_detail::is_not_input_iterator<InputIter>
+         , dtl::is_convertible<InputIter, size_type>
+         , dtl::is_not_input_iterator<InputIter>
          >::type * = 0
       #endif
       )
@@ -1684,10 +1682,10 @@ class basic_string
    #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
    template <class ForwardIter>
    iterator insert(const_iterator p, ForwardIter first, ForwardIter last
-      , typename container_detail::disable_if_or
+      , typename dtl::disable_if_or
          < void
-         , container_detail::is_convertible<ForwardIter, size_type>
-         , container_detail::is_input_iterator<ForwardIter>
+         , dtl::is_convertible<ForwardIter, size_type>
+         , dtl::is_input_iterator<ForwardIter>
          >::type * = 0
       )
    {
@@ -1730,10 +1728,10 @@ class basic_string
                                        pointer_past_last, pointer_past_last);
 
                this->priv_size(old_size+n);
-               Traits::move(const_cast<CharT*>(container_detail::to_raw_pointer(p + n)),
-                           container_detail::to_raw_pointer(p),
+               Traits::move(const_cast<CharT*>(boost::movelib::to_raw_pointer(p + n)),
+                           boost::movelib::to_raw_pointer(p),
                            (elems_after - n) + 1);
-               this->priv_copy(first, last, const_cast<CharT*>(container_detail::to_raw_pointer(p)));
+               this->priv_copy(first, last, const_cast<CharT*>(boost::movelib::to_raw_pointer(p)));
             }
             else {
                ForwardIter mid = first;
@@ -1746,7 +1744,7 @@ class basic_string
                   (p, const_iterator(old_start + old_length + 1),
                   old_start + newer_size);
                this->priv_size(newer_size + elems_after);
-               this->priv_copy(first, mid, const_cast<CharT*>(container_detail::to_raw_pointer(p)));
+               this->priv_copy(first, mid, const_cast<CharT*>(boost::movelib::to_raw_pointer(p)));
             }
          }
          else{
@@ -1773,9 +1771,9 @@ class basic_string
             else{
                //value_type is POD, so backwards expansion is much easier
                //than with vector<T>
-               value_type * const oldbuf     = container_detail::to_raw_pointer(old_start);
-               value_type * const newbuf     = container_detail::to_raw_pointer(new_start);
-               const value_type *const pos   = container_detail::to_raw_pointer(p);
+               value_type * const oldbuf     = boost::movelib::to_raw_pointer(old_start);
+               value_type * const newbuf     = boost::movelib::to_raw_pointer(new_start);
+               const value_type *const pos   = boost::movelib::to_raw_pointer(p);
                const size_type before  = pos - oldbuf;
 
                //First move old data
@@ -1834,7 +1832,7 @@ class basic_string
       if (pos > this->size())
          throw_out_of_range("basic_string::erase out of range position");
       const pointer addr = this->priv_addr();
-      erase(addr + pos, addr + pos + container_detail::min_value(n, this->size() - pos));
+      erase(addr + pos, addr + pos + dtl::min_value(n, this->size() - pos));
       return *this;
    }
 
@@ -1847,10 +1845,10 @@ class basic_string
    iterator erase(const_iterator p) BOOST_NOEXCEPT_OR_NOTHROW
    {
       // The move includes the terminating null.
-      CharT * const ptr = const_cast<CharT*>(container_detail::to_raw_pointer(p));
+      CharT * const ptr = const_cast<CharT*>(boost::movelib::to_raw_pointer(p));
       const size_type old_size = this->priv_size();
       Traits::move(ptr,
-                   container_detail::to_raw_pointer(p + 1),
+                   boost::movelib::to_raw_pointer(p + 1),
                    old_size - (p - this->priv_addr()));
       this->priv_size(old_size-1);
       return iterator(ptr);
@@ -1866,12 +1864,12 @@ class basic_string
    //!   the other elements being erased. If no such element exists, end() is returned.
    iterator erase(const_iterator first, const_iterator last) BOOST_NOEXCEPT_OR_NOTHROW
    {
-      CharT * f = const_cast<CharT*>(container_detail::to_raw_pointer(first));
+      CharT * f = const_cast<CharT*>(boost::movelib::to_raw_pointer(first));
       if (first != last) { // The move includes the terminating null.
          const size_type num_erased = last - first;
          const size_type old_size = this->priv_size();
          Traits::move(f,
-                      container_detail::to_raw_pointer(last),
+                      boost::movelib::to_raw_pointer(last),
                       (old_size + 1)-(last - this->priv_addr()));
          const size_type new_length = old_size - num_erased;
          this->priv_size(new_length);
@@ -1903,7 +1901,7 @@ class basic_string
    {
       if (pos1 > this->size())
          throw_out_of_range("basic_string::replace out of range position");
-      const size_type len = container_detail::min_value(n1, this->size() - pos1);
+      const size_type len = dtl::min_value(n1, this->size() - pos1);
       if (this->size() - len >= this->max_size() - str.size())
          throw_length_error("basic_string::replace max_size() exceeded");
       const pointer addr = this->priv_addr();
@@ -1934,7 +1932,7 @@ class basic_string
    {
       if (pos2 > str.size())
          throw_out_of_range("basic_string::replace out of range position");
-      return this->replace(pos1, n1, str.data()+pos2, container_detail::min_value(n2, str.size() - pos2));
+      return this->replace(pos1, n1, str.data()+pos2, dtl::min_value(n2, str.size() - pos2));
    }
 
    //! <b>Throws</b>: out_of_range if pos1 > size() or pos2 > sv.size().
@@ -1949,7 +1947,7 @@ class basic_string
    {
       if (pos2 > sv.size())
          throw_out_of_range("basic_string::replace out of range position");
-      return this->replace(pos1, n1, sv.data()+pos2, container_detail::min_value(n2, sv.size() - pos2));
+      return this->replace(pos1, n1, sv.data()+pos2, dtl::min_value(n2, sv.size() - pos2));
    }
 
    //! <b>Requires</b>: pos1 <= size() and s points to an array of at least n2 elements of CharT.
@@ -1970,7 +1968,7 @@ class basic_string
    {
       if (pos1 > this->size())
          throw_out_of_range("basic_string::replace out of range position");
-      const size_type len = container_detail::min_value(n1, this->size() - pos1);
+      const size_type len = dtl::min_value(n1, this->size() - pos1);
       const size_type max_size = this->max_size();
       if (n2 > max_size || (this->size() - len) >= (max_size - n2))
          throw_length_error("basic_string::replace max_size() exceeded");
@@ -2009,7 +2007,7 @@ class basic_string
    {
       if (pos1 > this->size())
          throw_out_of_range("basic_string::replace out of range position");
-      const size_type len = container_detail::min_value(n1, this->size() - pos1);
+      const size_type len = dtl::min_value(n1, this->size() - pos1);
       if (n2 > this->max_size() || this->size() - len >= this->max_size() - n2)
          throw_length_error("basic_string::replace max_size() exceeded");
       const pointer addr    = this->priv_addr();
@@ -2059,11 +2057,11 @@ class basic_string
    {
       const size_type len = static_cast<size_type>(i2 - i1);
       if (len >= n) {
-         Traits::assign(const_cast<CharT*>(container_detail::to_raw_pointer(i1)), n, c);
+         Traits::assign(const_cast<CharT*>(boost::movelib::to_raw_pointer(i1)), n, c);
          erase(i1 + n, i2);
       }
       else {
-         Traits::assign(const_cast<CharT*>(container_detail::to_raw_pointer(i1)), len, c);
+         Traits::assign(const_cast<CharT*>(boost::movelib::to_raw_pointer(i1)), len, c);
          insert(i2, n - len, c);
       }
       return *this;
@@ -2079,16 +2077,16 @@ class basic_string
    template <class InputIter>
    basic_string& replace(const_iterator i1, const_iterator i2, InputIter j1, InputIter j2
       #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-      , typename container_detail::disable_if_or
+      , typename dtl::disable_if_or
          < void
-         , container_detail::is_convertible<InputIter, size_type>
-         , container_detail::is_input_iterator<InputIter>
+         , dtl::is_convertible<InputIter, size_type>
+         , dtl::is_input_iterator<InputIter>
          >::type * = 0
       #endif
       )
    {
       for ( ; i1 != i2 && j1 != j2; ++i1, ++j1){
-         Traits::assign(*const_cast<CharT*>(container_detail::to_raw_pointer(i1)), *j1);
+         Traits::assign(*const_cast<CharT*>(boost::movelib::to_raw_pointer(i1)), *j1);
       }
 
       if (j1 == j2)
@@ -2101,23 +2099,23 @@ class basic_string
    #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
    template <class ForwardIter>
    basic_string& replace(const_iterator i1, const_iterator i2, ForwardIter j1, ForwardIter j2
-      , typename container_detail::disable_if_or
+      , typename dtl::disable_if_or
          < void
-         , container_detail::is_convertible<ForwardIter, size_type>
-         , container_detail::is_not_input_iterator<ForwardIter>
+         , dtl::is_convertible<ForwardIter, size_type>
+         , dtl::is_not_input_iterator<ForwardIter>
          >::type * = 0
       )
    {
       difference_type n = boost::container::iterator_distance(j1, j2);
       const difference_type len = i2 - i1;
       if (len >= n) {
-         this->priv_copy(j1, j2, const_cast<CharT*>(container_detail::to_raw_pointer(i1)));
+         this->priv_copy(j1, j2, const_cast<CharT*>(boost::movelib::to_raw_pointer(i1)));
          this->erase(i1 + n, i2);
       }
       else {
          ForwardIter m = j1;
          boost::container::iterator_advance(m, len);
-         this->priv_copy(j1, m, const_cast<CharT*>(container_detail::to_raw_pointer(i1)));
+         this->priv_copy(j1, m, const_cast<CharT*>(boost::movelib::to_raw_pointer(i1)));
          this->insert(i2, m, j2);
       }
       return *this;
@@ -2128,7 +2126,7 @@ class basic_string
    //!
    //! <b>Effects</b>: Calls `replace(i1 - begin(), i2 - i1, sv).`.
    //!
-   //! <bReturns</b>: *this.
+   //! <b>Returns</b>: *this.
    template<template <class, class> class BasicStringView>
    basic_string& replace(const_iterator i1, const_iterator i2, BasicStringView<CharT, Traits> sv)
    {
@@ -2141,7 +2139,7 @@ class basic_string
    //!
    //! <b>Effects</b>: Calls replace(i1 - begin(), i2 - i1, il.begin(), il.size()).
    //!
-   //! <bReturns</b>: *this.
+   //! <b>Returns</b>: *this.
    basic_string& replace(const_iterator i1, const_iterator i2, std::initializer_list<CharT> il)
    {
       return this->replace( static_cast<size_type>(i1 - this->cbegin())
@@ -2165,8 +2163,8 @@ class basic_string
    {
       if (pos > this->size())
          throw_out_of_range("basic_string::copy out of range position");
-      const size_type len = container_detail::min_value(n, this->size() - pos);
-      Traits::copy(s, container_detail::to_raw_pointer(this->priv_addr() + pos), len);
+      const size_type len = dtl::min_value(n, this->size() - pos);
+      Traits::copy(s, boost::movelib::to_raw_pointer(this->priv_addr() + pos), len);
       return len;
    }
 
@@ -2179,8 +2177,8 @@ class basic_string
                                || allocator_traits_type::is_always_equal::value)
    {
       this->base_t::swap_data(x);
-      container_detail::bool_<allocator_traits_type::propagate_on_container_swap::value> flag;
-      container_detail::swap_alloc(this->alloc(), x.alloc(), flag);
+      dtl::bool_<allocator_traits_type::propagate_on_container_swap::value> flag;
+      dtl::swap_alloc(this->alloc(), x.alloc(), flag);
    }
 
    //////////////////////////////////////////////
@@ -2195,7 +2193,7 @@ class basic_string
    //!
    //! <b>Complexity</b>: constant time.
    const CharT* c_str() const BOOST_NOEXCEPT_OR_NOTHROW
-   {  return container_detail::to_raw_pointer(this->priv_addr()); }
+   {  return boost::movelib::to_raw_pointer(this->priv_addr()); }
 
    //! <b>Requires</b>: The program shall not alter any of the values stored in the character array.
    //!
@@ -2203,13 +2201,13 @@ class basic_string
    //!
    //! <b>Complexity</b>: constant time.
    const CharT* data()  const BOOST_NOEXCEPT_OR_NOTHROW
-   {  return container_detail::to_raw_pointer(this->priv_addr()); }
+   {  return boost::movelib::to_raw_pointer(this->priv_addr()); }
 
    //! <b>Returns</b>: A pointer p such that p + i == &operator[](i) for each i in [0,size()].
    //!
    //! <b>Complexity</b>: constant time.
    CharT* data()  BOOST_NOEXCEPT_OR_NOTHROW
-   {  return container_detail::to_raw_pointer(this->priv_addr()); }
+   {  return boost::movelib::to_raw_pointer(this->priv_addr()); }
 
    #ifndef BOOST_CONTAINER_TEMPLATED_CONVERSION_OPERATOR_BROKEN
    //! <b>Returns</b>: a string_view to the characters in the string.
@@ -2272,8 +2270,8 @@ class basic_string
          const pointer addr = this->priv_addr();
          pointer finish = addr + this->priv_size();
          const const_iterator result =
-            std::search(container_detail::to_raw_pointer(addr + pos),
-                   container_detail::to_raw_pointer(finish),
+            boost::container::search(boost::movelib::to_raw_pointer(addr + pos),
+                   boost::movelib::to_raw_pointer(finish),
                    s, s + n, Eq_traits<Traits>());
          return result != finish ? result - begin() : npos;
       }
@@ -2299,8 +2297,8 @@ class basic_string
          const pointer addr    = this->priv_addr();
          pointer finish = addr + sz;
          const const_iterator result =
-            std::find_if(addr + pos, finish,
-                  std::bind2nd(Eq_traits<Traits>(), c));
+            boost::container::find_if(addr + pos, finish,
+                  boost::container::bind2nd(Eq_traits<Traits>(), c));
          return result != finish ? result - begin() : npos;
       }
    }
@@ -2340,9 +2338,9 @@ class basic_string
       if (n > len)
          return npos;
       else if (n == 0)
-         return container_detail::min_value(len, pos);
+         return dtl::min_value(len, pos);
       else {
-         const const_iterator last = begin() + container_detail::min_value(len - n, pos) + n;
+         const const_iterator last = begin() + dtl::min_value(len - n, pos) + n;
          const const_iterator result = find_end(begin(), last,
                                                 s, s + n,
                                                 Eq_traits<Traits>());
@@ -2369,10 +2367,10 @@ class basic_string
       if (len < 1)
          return npos;
       else {
-         const const_iterator last = begin() + container_detail::min_value(len - 1, pos) + 1;
+         const const_iterator last = begin() + dtl::min_value(len - 1, pos) + 1;
          const_reverse_iterator rresult =
-            std::find_if(const_reverse_iterator(last), rend(),
-                  std::bind2nd(Eq_traits<Traits>(), c));
+            boost::container::find_if(const_reverse_iterator(last), rend(),
+                  boost::container::bind2nd(Eq_traits<Traits>(), c));
          return rresult != rend() ? (rresult.base() - 1) - begin() : npos;
       }
    }
@@ -2385,7 +2383,7 @@ class basic_string
    //!
    //! <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& str, size_type pos = 0) const
-      { return find_first_of(str.c_str(), pos, str.size()); }
+      { return this->find_first_of(str.c_str(), pos, str.size()); }
 
    //! <b>Effects</b>: Determines the lowest position xpos, if possible, such that both of the
    //!   following conditions obtain: a) pos <= xpos and xpos < size();
@@ -2396,7 +2394,7 @@ class basic_string
    //! <b>Returns</b>: xpos if the function can determine such a value for xpos. Otherwise, returns npos.
    template<template <class, class> class BasicStringView>
    size_type find_first_of(BasicStringView<CharT, Traits> sv, size_type pos = 0) const
-      { return find_first_of(sv.data(), pos, sv.size()); }
+      { return this->find_first_of(sv.data(), pos, sv.size()); }
 
    //! <b>Requires</b>: s points to an array of at least n elements of CharT.
    //!
@@ -2411,7 +2409,7 @@ class basic_string
       else {
          const pointer addr    = this->priv_addr();
          pointer finish = addr + sz;
-         const_iterator result = std::find_first_of
+         const_iterator result = boost::container::find_first_of
             (addr + pos, finish, s, s + n, Eq_traits<Traits>());
          return result != finish ? result - this->begin() : npos;
       }
@@ -2423,7 +2421,7 @@ class basic_string
    //!
    //! <b>Returns</b>: find_first_of(basic_string(s), pos).
    size_type find_first_of(const CharT* s, size_type pos = 0) const
-      { return find_first_of(s, pos, Traits::length(s)); }
+      { return this->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.
    //!
@@ -2431,7 +2429,7 @@ class basic_string
    //!
    //! <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
-    { return find(c, pos); }
+    { return this->find(c, pos); }
 
    //! <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)
@@ -2441,7 +2439,7 @@ class basic_string
    //!
    //! <b>Returns</b>: xpos if the function can determine such a value for xpos. Otherwise, returns npos.
    size_type find_last_of(const basic_string& str, size_type pos = npos) const
-      { return find_last_of(str.c_str(), pos, str.size()); }
+      { return this->find_last_of(str.c_str(), pos, str.size()); }
 
    //! <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)
@@ -2452,7 +2450,7 @@ class basic_string
    //! <b>Returns</b>: xpos if the function can determine such a value for xpos. Otherwise, returns npos.
    template<template <class, class> class BasicStringView>
    size_type find_last_of(BasicStringView<CharT, Traits> sv, size_type pos = npos) const
-      { return find_last_of(sv.data(), pos, sv.size()); }
+      { return this->find_last_of(sv.data(), pos, sv.size()); }
 
    //! <b>Requires</b>: s points to an array of at least n elements of CharT.
    //!
@@ -2467,9 +2465,9 @@ class basic_string
          return npos;
       else {
          const pointer addr    = this->priv_addr();
-         const const_iterator last = addr + container_detail::min_value(len - 1, pos) + 1;
+         const const_iterator last = addr + dtl::min_value(len - 1, pos) + 1;
          const const_reverse_iterator rresult =
-            std::find_first_of(const_reverse_iterator(last), rend(),
+            boost::container::find_first_of(const_reverse_iterator(last), rend(),
                                s, s + n, Eq_traits<Traits>());
          return rresult != rend() ? (rresult.base() - 1) - addr : npos;
       }
@@ -2524,7 +2522,7 @@ class basic_string
       else {
          const pointer addr   = this->priv_addr();
          const pointer finish = addr + this->priv_size();
-         const const_iterator result = std::find_if
+         const const_iterator result = boost::container::find_if
             (addr + pos, finish, Not_within_traits<Traits>(s, s + n));
          return result != finish ? result - addr : npos;
       }
@@ -2549,8 +2547,8 @@ class basic_string
          const pointer addr   = this->priv_addr();
          const pointer finish = addr + this->priv_size();
          const const_iterator result
-            = std::find_if(addr + pos, finish,
-                     std::not1(std::bind2nd(Eq_traits<Traits>(), c)));
+            = boost::container::find_if(addr + pos, finish,
+                     boost::container::not1(boost::container::bind2nd(Eq_traits<Traits>(), c)));
          return result != finish ? result - begin() : npos;
       }
    }
@@ -2588,9 +2586,9 @@ class basic_string
       if (len < 1)
          return npos;
       else {
-         const const_iterator last = begin() + container_detail::min_value(len - 1, pos) + 1;
+         const const_iterator last = begin() + dtl::min_value(len - 1, pos) + 1;
          const const_reverse_iterator rresult =
-            std::find_if(const_reverse_iterator(last), rend(),
+            boost::container::find_if(const_reverse_iterator(last), rend(),
                     Not_within_traits<Traits>(s, s + n));
          return rresult != rend() ? (rresult.base() - 1) - begin() : npos;
       }
@@ -2614,10 +2612,10 @@ class basic_string
       if (len < 1)
          return npos;
       else {
-         const const_iterator last = begin() + container_detail::min_value(len - 1, pos) + 1;
+         const const_iterator last = begin() + dtl::min_value(len - 1, pos) + 1;
          const const_reverse_iterator rresult =
-            std::find_if(const_reverse_iterator(last), rend(),
-                  std::not1(std::bind2nd(Eq_traits<Traits>(), c)));
+            boost::container::find_if(const_reverse_iterator(last), rend(),
+                  boost::container::not1(boost::container::bind2nd(Eq_traits<Traits>(), c)));
          return rresult != rend() ? (rresult.base() - 1) - begin() : npos;
       }
    }
@@ -2636,7 +2634,7 @@ class basic_string
          throw_out_of_range("basic_string::substr out of range position");
       const pointer addr = this->priv_addr();
       return basic_string(addr + pos,
-                          addr + pos + container_detail::min_value(n, size() - pos), this->alloc());
+                          addr + pos + dtl::min_value(n, size() - pos), this->alloc());
    }
 
    //! <b>Effects</b>: Determines the effective length rlen of the string to compare as
@@ -2681,7 +2679,7 @@ class basic_string
       const pointer addr    = this->priv_addr();
       const pointer str_addr = str.priv_addr();
       return s_compare(addr + pos1,
-                        addr + pos1 + container_detail::min_value(n1, this->size() - pos1),
+                        addr + pos1 + dtl::min_value(n1, this->size() - pos1),
                         str_addr, str_addr + str.priv_size());
    }
 
@@ -2697,7 +2695,7 @@ class basic_string
          throw_out_of_range("basic_string::compare out of range position");
       const pointer addr    = this->priv_addr() + pos1;
       const CharT* str_addr = sv.data();
-      return s_compare(addr, addr + container_detail::min_value(n1, this->size() - pos1),
+      return s_compare(addr, addr + dtl::min_value(n1, this->size() - pos1),
                        str_addr, str_addr + sv.size());
    }
 
@@ -2715,8 +2713,8 @@ class basic_string
          throw_out_of_range("basic_string::compare out of range position");
       const pointer addr     = this->priv_addr() + pos1;
       const pointer str_addr = str.priv_addr() + pos2;
-      return s_compare(addr, addr + container_detail::min_value(n1, this->size() - pos1),
-                        str_addr, str_addr + container_detail::min_value(n2, str.size() - pos2));
+      return s_compare(addr, addr + dtl::min_value(n1, this->size() - pos1),
+                        str_addr, str_addr + dtl::min_value(n2, str.size() - pos2));
    }
 
    //! <b>Requires</b>: pos1 <= size() and pos2 <= str.size()
@@ -2734,8 +2732,8 @@ class basic_string
          throw_out_of_range("basic_string::compare out of range position");
       const pointer addr     = this->priv_addr() + pos1;
       const CharT * str_addr = sv.data() + pos2;
-      return s_compare(addr, addr + container_detail::min_value(n1, this->size() - pos1),
-                       str_addr, str_addr + container_detail::min_value(n2, sv.size() - pos2));
+      return s_compare(addr, addr + dtl::min_value(n1, this->size() - pos1),
+                       str_addr, str_addr + dtl::min_value(n2, sv.size() - pos2));
    }
 
    //! <b>Throws</b>: Nothing
@@ -2758,7 +2756,7 @@ class basic_string
          throw_out_of_range("basic_string::compare out of range position");
       const pointer addr = this->priv_addr();
       return s_compare( addr + pos1,
-                        addr + pos1 + container_detail::min_value(n1, this->size() - pos1),
+                        addr + pos1 + dtl::min_value(n1, this->size() - pos1),
                         s, s + n2);
    }
 
@@ -2779,7 +2777,7 @@ class basic_string
       }
 
       if (this->capacity() < res_arg){
-         size_type n = container_detail::max_value(res_arg, this->size()) + 1;
+         size_type n = dtl::max_value(res_arg, this->size()) + 1;
          size_type new_cap = this->next_capacity(n);
          pointer reuse = 0;
          pointer new_start = this->allocation_command(allocate_new, n, new_cap, reuse);
@@ -2804,16 +2802,16 @@ class basic_string
    {
       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),
-                                      container_detail::min_value(n1, n2));
+      const int cmp = Traits::compare(boost::movelib::to_raw_pointer(f1),
+                                      boost::movelib::to_raw_pointer(f2),
+                                      dtl::min_value(n1, n2));
       return cmp != 0 ? cmp : (n1 < n2 ? -1 : (n1 > n2 ? 1 : 0));
    }
 
    template<class AllocVersion>
    void priv_shrink_to_fit_dynamic_buffer
       ( AllocVersion
-      , typename container_detail::enable_if<container_detail::is_same<AllocVersion, version_1> >::type* = 0)
+      , typename dtl::enable_if<dtl::is_same<AllocVersion, version_1> >::type* = 0)
    {
       //Allocate a new buffer.
       size_type real_cap = 0;
@@ -2826,8 +2824,8 @@ class basic_string
          real_cap = long_size+1;
          const pointer ret = this->allocation_command(allocate_new, long_size+1, real_cap, reuse);
          //Copy and update
-         Traits::copy( container_detail::to_raw_pointer(ret)
-                     , container_detail::to_raw_pointer(this->priv_long_addr())
+         Traits::copy( boost::movelib::to_raw_pointer(ret)
+                     , boost::movelib::to_raw_pointer(this->priv_long_addr())
                      , long_size+1);
          this->priv_long_addr(ret);
          this->priv_storage(real_cap);
@@ -2843,7 +2841,7 @@ class basic_string
    template<class AllocVersion>
    void priv_shrink_to_fit_dynamic_buffer
       ( AllocVersion
-      , typename container_detail::enable_if<container_detail::is_same<AllocVersion, version_2> >::type* = 0)
+      , typename dtl::enable_if<dtl::is_same<AllocVersion, version_2> >::type* = 0)
    {
       size_type received_size = this->priv_long_size()+1;
       pointer hint = this->priv_long_addr();
@@ -2920,13 +2918,13 @@ class basic_string
    template <class Integer>
    basic_string& priv_replace_dispatch(const_iterator first, const_iterator last,
                                        Integer n, Integer x,
-                                       container_detail::true_)
+                                       dtl::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_)
+                                       dtl::false_)
    {
       typedef typename boost::container::iterator_traits<InputIter>::iterator_category Category;
       return this->priv_replace(first, last, f, l, Category());
@@ -2953,6 +2951,24 @@ typedef basic_string
    ,new_allocator<wchar_t> >
 wstring;
 
+#else
+
+template <class CharT, class Traits, class Allocator>
+const typename basic_string<CharT,Traits,Allocator>::size_type
+   basic_string<CharT,Traits,Allocator>::npos;
+
+template<class S>
+struct is_string
+{
+   static const bool value = false;
+};
+
+template<class C, class T, class A>
+struct is_string< basic_string<C, T, A> >
+{
+   static const bool value = true;
+};
+
 #endif
 
 // ------------------------------------------------------------
@@ -3060,16 +3076,22 @@ operator==(const basic_string<CharT,Traits,Allocator>& x, const CharT* s)
 }
 
 template <class CharT, class Traits, class Allocator, template <class, class> class BasicStringView>
-inline bool
-operator==( BasicStringView<CharT,Traits> x, const basic_string<CharT,Traits,Allocator>& y)
+inline 
+   BOOST_CONTAINER_DOC1ST( bool, 
+                           typename dtl::disable_if
+                              <is_string< BasicStringView<CharT BOOST_MOVE_I Traits> > BOOST_MOVE_I bool >::type)
+      operator==( BasicStringView<CharT,Traits> x, const basic_string<CharT,Traits,Allocator>& y)
 {
    return x.size() == y.size() &&
           Traits::compare(x.data(), y.data(), x.size()) == 0;
 }
 
 template <class CharT, class Traits, class Allocator, template <class, class> class BasicStringView>
-inline bool
-operator==( const basic_string<CharT,Traits,Allocator>& x, BasicStringView<CharT,Traits> y)
+inline
+   BOOST_CONTAINER_DOC1ST( bool, 
+                           typename dtl::disable_if
+                              <is_string< BasicStringView<CharT BOOST_MOVE_I Traits> > BOOST_MOVE_I bool >::type)
+      operator==( const basic_string<CharT,Traits,Allocator>& x, BasicStringView<CharT,Traits> y)
 {
    return x.size() == y.size() &&
           Traits::compare(x.data(), y.data(), x.size()) == 0;
@@ -3092,12 +3114,18 @@ operator!=(const basic_string<CharT,Traits,Allocator>& x, const CharT* s)
 
 
 template <class CharT, class Traits, class Allocator, template <class, class> class BasicStringView>
-inline bool
+inline
+   BOOST_CONTAINER_DOC1ST( bool, 
+                           typename dtl::disable_if
+                              <is_string< BasicStringView<CharT BOOST_MOVE_I Traits> > BOOST_MOVE_I bool >::type)
 operator!=( BasicStringView<CharT,Traits> x, const basic_string<CharT,Traits,Allocator>& y)
    {  return !(x == y);  }
 
 template <class CharT, class Traits, class Allocator, template <class, class> class BasicStringView>
-inline bool
+inline
+   BOOST_CONTAINER_DOC1ST( bool, 
+                           typename dtl::disable_if
+                              <is_string< BasicStringView<CharT BOOST_MOVE_I Traits> > BOOST_MOVE_I bool >::type)
 operator!=( const basic_string<CharT,Traits,Allocator>& x, BasicStringView<CharT,Traits> y)
    {  return !(x == y);  }
 
@@ -3124,12 +3152,18 @@ operator<(const basic_string<CharT,Traits,Allocator>& x, const CharT* s)
 }
 
 template <class CharT, class Traits, class Allocator, template <class, class> class BasicStringView>
-inline bool
+inline
+   BOOST_CONTAINER_DOC1ST( bool, 
+                           typename dtl::disable_if
+                              <is_string< BasicStringView<CharT BOOST_MOVE_I Traits> > BOOST_MOVE_I bool >::type)
 operator<( BasicStringView<CharT,Traits> x, const basic_string<CharT,Traits,Allocator>& y)
    {  return y.compare(x) > 0;  }
 
 template <class CharT, class Traits, class Allocator, template <class, class> class BasicStringView>
-inline bool
+inline
+   BOOST_CONTAINER_DOC1ST( bool, 
+                           typename dtl::disable_if
+                              <is_string< BasicStringView<CharT BOOST_MOVE_I Traits> > BOOST_MOVE_I bool >::type)
 operator<(  const basic_string<CharT,Traits,Allocator>& x, BasicStringView<CharT,Traits> y)
    {  return x.compare(y) < 0;  }
 
@@ -3153,12 +3187,18 @@ operator>(const basic_string<CharT,Traits,Allocator>& x, const CharT* s)
 }
 
 template <class CharT, class Traits, class Allocator, template <class, class> class BasicStringView>
-inline bool
+inline
+   BOOST_CONTAINER_DOC1ST( bool, 
+                           typename dtl::disable_if
+                              <is_string< BasicStringView<CharT BOOST_MOVE_I Traits> > BOOST_MOVE_I bool >::type)
 operator>( BasicStringView<CharT,Traits> x, const basic_string<CharT,Traits,Allocator>& y)
    {  return y < x;  }
 
 template <class CharT, class Traits, class Allocator, template <class, class> class BasicStringView>
-inline bool
+inline
+   BOOST_CONTAINER_DOC1ST( bool, 
+                           typename dtl::disable_if
+                              <is_string< BasicStringView<CharT BOOST_MOVE_I Traits> > BOOST_MOVE_I bool >::type)
 operator>( const basic_string<CharT,Traits,Allocator>& x, BasicStringView<CharT,Traits> y)
    {  return y < x;  }
 
@@ -3181,12 +3221,18 @@ operator<=(const basic_string<CharT,Traits,Allocator>& x, const CharT* s)
 
 
 template <class CharT, class Traits, class Allocator, template <class, class> class BasicStringView>
-inline bool
+inline
+   BOOST_CONTAINER_DOC1ST( bool, 
+                           typename dtl::disable_if
+                              <is_string< BasicStringView<CharT BOOST_MOVE_I Traits> > BOOST_MOVE_I bool >::type)
 operator<=( BasicStringView<CharT,Traits> x, const basic_string<CharT,Traits,Allocator>& y)
    {  return !(y < x);  }
 
 template <class CharT, class Traits, class Allocator, template <class, class> class BasicStringView>
-inline bool
+inline
+   BOOST_CONTAINER_DOC1ST( bool, 
+                           typename dtl::disable_if
+                              <is_string< BasicStringView<CharT BOOST_MOVE_I Traits> > BOOST_MOVE_I bool >::type)
 operator<=( const basic_string<CharT,Traits,Allocator>& x, BasicStringView<CharT,Traits> y)
    {  return !(y < x);  }
 
@@ -3207,12 +3253,18 @@ operator>=(const basic_string<CharT,Traits,Allocator>& x, const CharT* s)
    {  return !(x < s);  }
 
 template <class CharT, class Traits, class Allocator, template <class, class> class BasicStringView>
-inline bool
+inline
+   BOOST_CONTAINER_DOC1ST( bool, 
+                           typename dtl::disable_if
+                              <is_string< BasicStringView<CharT BOOST_MOVE_I Traits> > BOOST_MOVE_I bool >::type)
 operator>=( BasicStringView<CharT,Traits> x, const basic_string<CharT,Traits,Allocator>& y)
    {  return !(x < y);  }
 
 template <class CharT, class Traits, class Allocator, template <class, class> class BasicStringView>
-inline bool
+inline
+   BOOST_CONTAINER_DOC1ST( bool, 
+                           typename dtl::disable_if
+                              <is_string< BasicStringView<CharT BOOST_MOVE_I Traits> > BOOST_MOVE_I bool >::type)
 operator>=( const basic_string<CharT,Traits,Allocator>& x, BasicStringView<CharT,Traits> y)
    {  return !(x < y);  }
 
@@ -3223,7 +3275,7 @@ inline void swap(basic_string<CharT,Traits,Allocator>& x, basic_string<CharT,Tra
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 // I/O.
-namespace container_detail {
+namespace dtl {
 
 template <class CharT, class Traits>
 inline bool
@@ -3240,7 +3292,7 @@ string_fill(std::basic_ostream<CharT, Traits>& os,
    return ok;
 }
 
-}  //namespace container_detail {
+}  //namespace dtl {
 #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
 template <class CharT, class Traits, class Allocator>
@@ -3262,13 +3314,13 @@ operator<<(std::basic_ostream<CharT, Traits>& os, const basic_string<CharT,Trait
          pad_len = w - n;
 
       if (!left)
-         ok = container_detail::string_fill(os, buf, pad_len);
+         ok = dtl::string_fill(os, buf, pad_len);
 
       ok = ok &&
             buf->sputn(s.data(), std::streamsize(n)) == std::streamsize(n);
 
       if (left)
-         ok = ok && container_detail::string_fill(os, buf, pad_len);
+         ok = ok && dtl::string_fill(os, buf, pad_len);
    }
 
    if (!ok)