passenger 6.0.23 → 6.0.24

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

@@ -51,6 +51,7 @@
 #include <boost/move/iterator.hpp>
 #include <boost/move/traits.hpp>
 #include <boost/move/utility_core.hpp>
+#include <boost/move/detail/launder.hpp>
 // move/detail
 #if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 #include <boost/move/detail/fwd_macros.hpp>
@@ -268,15 +269,15 @@ inline Pointer &get_ptr(vec_iterator<Pointer, IsConst> &it) BOOST_NOEXCEPT_OR_NO
 struct initial_capacity_t {};
 
 struct vector_uninitialized_size_t {};
-static const vector_uninitialized_size_t vector_uninitialized_size = vector_uninitialized_size_t();
+BOOST_CONTAINER_CONSTANT_VAR vector_uninitialized_size_t vector_uninitialized_size = vector_uninitialized_size_t();
 
 struct maybe_initial_capacity_t {};
 
 template <class T>
 struct vector_value_traits_base
 {
-   static const bool trivial_dctr = dtl::is_trivially_destructible<T>::value;
-   static const bool trivial_dctr_after_move = has_trivial_destructor_after_move<T>::value;
+   BOOST_STATIC_CONSTEXPR bool trivial_dctr = dtl::is_trivially_destructible<T>::value;
+   BOOST_STATIC_CONSTEXPR bool trivial_dctr_after_move = has_trivial_destructor_after_move<T>::value;
 };
 
 template <class Allocator>
@@ -351,23 +352,23 @@ struct vector_alloc_holder
 
    public:
 
-   inline
-      static bool is_propagable_from(const allocator_type &from_alloc, pointer p, const allocator_type &to_alloc, bool const propagate_allocator)
+   template <bool PropagateAllocator>
+   inline static bool is_propagable_from(const allocator_type &from_alloc, pointer p, const allocator_type &to_alloc)
    {
-      (void)propagate_allocator; (void)p; (void)to_alloc; (void)from_alloc;
+      (void)p; (void)to_alloc; (void)from_alloc;
       const bool all_storage_propagable = !allocator_traits_type::is_partially_propagable::value ||
                                           !allocator_traits_type::storage_is_unpropagable(from_alloc, p);
       return all_storage_propagable &&
-         (propagate_allocator || allocator_traits_type::is_always_equal::value || allocator_traits_type::equal(from_alloc, to_alloc));
+         (PropagateAllocator || allocator_traits_type::is_always_equal::value || allocator_traits_type::equal(from_alloc, to_alloc));
    }
 
-   inline
-      static bool are_swap_propagable(const allocator_type &l_a, pointer l_p, const allocator_type &r_a, pointer r_p, bool const propagate_allocator)
+   template <bool PropagateAllocator>
+   inline static bool are_swap_propagable(const allocator_type &l_a, pointer l_p, const allocator_type &r_a, pointer r_p)
    {
-      (void)propagate_allocator; (void)l_p; (void)r_p; (void)l_a; (void)r_a;
+      (void)l_p; (void)r_p; (void)l_a; (void)r_a;
       const bool all_storage_propagable = !allocator_traits_type::is_partially_propagable::value || 
               !(allocator_traits_type::storage_is_unpropagable(l_a, l_p) || allocator_traits_type::storage_is_unpropagable(r_a, r_p));
-      return all_storage_propagable && (propagate_allocator || allocator_traits_type::equal(l_a, r_a));
+      return all_storage_propagable && (PropagateAllocator || allocator_traits_type::is_always_equal::value || allocator_traits_type::equal(l_a, r_a));
    }
 
    //Constructor, does not throw
@@ -545,7 +546,7 @@ struct vector_alloc_holder
    inline const allocator_type &alloc() const BOOST_NOEXCEPT_OR_NOTHROW
    {  return *this;  }
 
-   inline const pointer   &start() const     BOOST_NOEXCEPT_OR_NOTHROW
+   inline pointer   start() const     BOOST_NOEXCEPT_OR_NOTHROW
       {  return m_start;  }
    inline       size_type capacity() const     BOOST_NOEXCEPT_OR_NOTHROW
       {  return m_capacity;  }
@@ -837,14 +838,14 @@ private:
 
 
    protected:
-   inline
-      static bool is_propagable_from(const allocator_type &from_alloc, pointer p, const allocator_type &to_alloc, bool const propagate_allocator)
-   {  return alloc_holder_t::is_propagable_from(from_alloc, p, to_alloc, propagate_allocator);  }
+   template <bool PropagateAllocator>
+   inline static bool is_propagable_from(const allocator_type &from_alloc, pointer p, const allocator_type &to_alloc)
+   {  return alloc_holder_t::template is_propagable_from<PropagateAllocator>(from_alloc, p, to_alloc);  }
 
-   inline
-      static bool are_swap_propagable( const allocator_type &l_a, pointer l_p
-                                     , const allocator_type &r_a, pointer r_p, bool const propagate_allocator)
-   {  return alloc_holder_t::are_swap_propagable(l_a, l_p, r_a, r_p, propagate_allocator);  }
+   template <bool PropagateAllocator>
+   inline static bool are_swap_propagable( const allocator_type &l_a, pointer l_p
+                                         , const allocator_type &r_a, pointer r_p)
+   {  return alloc_holder_t::template are_swap_propagable<PropagateAllocator>(l_a, l_p, r_a, r_p);  }
 
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
@@ -866,6 +867,25 @@ private:
       : m_holder(initial_capacity_t(), initial_memory, cap, ::boost::forward<AllocFwd>(a))
    {}
 
+   template<class AllocFwd>
+   inline vector(initial_capacity_t, pointer initial_memory, size_type cap, BOOST_FWD_REF(AllocFwd) a, vector &x)
+      : m_holder(initial_capacity_t(), initial_memory, cap, ::boost::forward<AllocFwd>(a))
+   {
+      allocator_type &this_al = this->get_stored_allocator();
+      if (this->template is_propagable_from<true>(x.get_stored_allocator(), x.data(), this_al)) {
+         this->steal_resources(x);
+      }
+      else {
+         const size_type sz = x.size();
+         ::boost::container::uninitialized_move_alloc_n_source
+            ( this_al, x.priv_raw_begin(), sz
+            //Use launder to stop false positives from -Warray-bounds
+            , boost::move_detail::launder(this->priv_raw_begin()));
+         this->protected_set_size(sz);
+         x.clear();
+      }
+   }
+
    inline vector(initial_capacity_t, pointer initial_memory, size_type cap)
       : m_holder(initial_capacity_t(), initial_memory, cap)
    {}
@@ -1163,11 +1183,11 @@ private:
    vector(BOOST_RV_REF(vector) x, const allocator_type &a)
       :  m_holder( vector_uninitialized_size, a
                  //In this allocator move constructor the allocator won't be propagated --v
-                 , is_propagable_from(x.get_stored_allocator(), x.m_holder.start(), a, false) ? 0 : x.size()
+                 , is_propagable_from<false>(x.get_stored_allocator(), x.m_holder.start(), a) ? 0 : x.size()
                  )
    {
       //In this allocator move constructor the allocator won't be propagated ---v
-      if(is_propagable_from(x.get_stored_allocator(), x.m_holder.start(), a, false)){
+      if(is_propagable_from<false>(x.get_stored_allocator(), x.m_holder.start(), a)){
          this->m_holder.steal_resources(x.m_holder);
       }
       else{
@@ -2228,7 +2248,7 @@ private:
 
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
-   //! <b>Effects</b>: Erases all the elements of the vector.
+   //! <b>Effects</b>: Erases all the elements of the vector. Leaves the capacity() of the vector unchanged.
    //!
    //! <b>Throws</b>: Nothing.
    //!
@@ -2531,6 +2551,38 @@ private:
       x.clear();
    }
 
+   template<class OtherA>
+   void priv_move_assign_steal_or_assign(BOOST_RV_REF_BEG vector<T, OtherA, Options> BOOST_RV_REF_END x, dtl::true_type /*data_can_be_always_stolen*/)
+   {
+      this->clear();
+      if (BOOST_LIKELY(!!this->m_holder.m_start))
+         this->m_holder.deallocate(this->m_holder.m_start, this->m_holder.m_capacity);
+      this->m_holder.steal_resources(x.m_holder);
+   }
+
+   template<class OtherA>
+   void priv_move_assign_steal_or_assign(BOOST_RV_REF_BEG vector<T, OtherA, Options> BOOST_RV_REF_END x, dtl::false_type /*data_can_be_always_stolen*/)
+   {
+      const bool propagate_alloc = allocator_traits_type::propagate_on_container_move_assignment::value;
+      allocator_type& this_alloc = this->m_holder.alloc();
+      allocator_type& x_alloc = x.m_holder.alloc();
+
+      //In this allocator move constructor the allocator might will be propagated, but to support small_vector-like
+      //types, we need to check the currently owned buffers to know if they are propagable.
+      const bool is_buffer_propagable_from_x = is_propagable_from<propagate_alloc>(x_alloc, x.m_holder.start(), this_alloc);
+
+      if (is_buffer_propagable_from_x) {
+         this->priv_move_assign_steal_or_assign(boost::move(x), dtl::true_type());
+      }
+      //Else do a one by one move. Also, clear the source as users find confusing
+      //elements are still alive in the source container.
+      else {
+         this->assign( boost::make_move_iterator(boost::movelib::iterator_to_raw_pointer(x.begin()))
+                     , boost::make_move_iterator(boost::movelib::iterator_to_raw_pointer(x.end()))   );
+         x.clear();
+      }
+   }
+
    template<class OtherA>
    void priv_move_assign(BOOST_RV_REF_BEG vector<T, OtherA, Options> BOOST_RV_REF_END x
       , typename dtl::disable_if_or
@@ -2542,30 +2594,16 @@ private:
       //for move assignment, no aliasing (&x != this) is assumed.
       //x.size() == 0 is allowed for buggy std libraries.
       BOOST_ASSERT(this != &x || x.size() == 0);
-      allocator_type &this_alloc = this->m_holder.alloc();
-      allocator_type &x_alloc    = x.m_holder.alloc();
+      const bool alloc_is_always_equal = allocator_traits_type::is_always_equal::value;
       const bool propagate_alloc = allocator_traits_type::propagate_on_container_move_assignment::value;
+      const bool partially_propagable_alloc = allocator_traits_type::is_partially_propagable::value;
+      const bool data_can_be_always_be_stolen = alloc_is_always_equal || (propagate_alloc && !partially_propagable_alloc);
 
-      //In this allocator move constructor the allocator maybe will be propagated -----------------------v
-      const bool is_propagable_from_x = is_propagable_from(x_alloc, x.m_holder.start(), this_alloc, propagate_alloc);
+      this->priv_move_assign_steal_or_assign(boost::move(x), dtl::bool_<data_can_be_always_be_stolen>());
 
-      //Resources can be transferred if both allocators are
-      //going to be equal after this function (either propagated or already equal)
-      if(is_propagable_from_x){
-         this->clear();
-         if(BOOST_LIKELY(!!this->m_holder.m_start))
-            this->m_holder.deallocate(this->m_holder.m_start, this->m_holder.m_capacity);
-         this->m_holder.steal_resources(x.m_holder);
-      }
-      //Else do a one by one move. Also, clear the source as users find confusing
-      //elements are still alive in the source container.
-      else{
-         this->assign( boost::make_move_iterator(boost::movelib::iterator_to_raw_pointer(x.begin()))
-                     , boost::make_move_iterator(boost::movelib::iterator_to_raw_pointer(x.end()  ))
-                     );
-         x.clear();
-      }
       //Move allocator if needed
+      allocator_type& this_alloc = this->m_holder.alloc();
+      allocator_type& x_alloc    = x.m_holder.alloc();
       dtl::move_alloc(this_alloc, x_alloc, dtl::bool_<propagate_alloc>());
    }
 
@@ -2613,46 +2651,115 @@ private:
    template<class Vector>  //Template it to avoid it in explicit instantiations
    void priv_swap(Vector &x, dtl::false_type)  //version_N
    {
-      const bool propagate_alloc = allocator_traits_type::propagate_on_container_swap::value;
+      BOOST_ASSERT(allocator_traits_type::propagate_on_container_swap::value ||
+                   allocator_traits_type::is_always_equal::value ||
+                   this->get_stored_allocator() == x.get_stored_allocator());
+
+      if (BOOST_UNLIKELY(&x == this)) {
+         return;
+      }
+
+      //Just swap internals
+      this->m_holder.swap_resources(x.m_holder);
+      //And now swap the allocator
+      dtl::bool_<allocator_traits_type::propagate_on_container_swap::value> flag;
+      dtl::swap_alloc(this->m_holder.alloc(), x.m_holder.alloc(), flag);
+   }
+
+   protected:
+   template<class Vector>  //Template it to avoid it in explicit instantiations
+   void prot_swap_small(Vector &x, std::size_t internal_capacity)  //version_N
+   {
       if (BOOST_UNLIKELY(&x == this)){
          return;
       }
-      else if(are_swap_propagable( this->get_stored_allocator(), this->m_holder.start()
-                                 , x.get_stored_allocator(), x.m_holder.start(), propagate_alloc)){
-         //Just swap internals
-         this->m_holder.swap_resources(x.m_holder);
+
+      const bool propagate_alloc = allocator_traits_type::propagate_on_container_swap::value;
+      if(are_swap_propagable<propagate_alloc>
+         ( this->get_stored_allocator(), this->m_holder.start(), x.get_stored_allocator(), x.m_holder.start())){
+         this->priv_swap(x, dtl::false_());
+         return;
       }
-      else{
-         //Else swap element by element...
+
+      allocator_type &th_al = this->get_stored_allocator();
+      allocator_type &ot_al = x.get_stored_allocator();
+
+      const bool is_this_data_propagable = is_propagable_from<propagate_alloc>(th_al, this->data(), ot_al);
+      const bool is_that_data_propagable = is_propagable_from<propagate_alloc>(ot_al, x.data(), th_al);
+
+      if(internal_capacity && (is_this_data_propagable || is_that_data_propagable)) {
+         //steal memory from src to dst, but move elements from dst to src
+         vector& extmem = is_this_data_propagable ? *this : x;
+         vector& intmem = is_this_data_propagable ? x : *this;
+
+         //Reset extmem to the internal storage and backup data
+         pointer const orig_extdata = extmem.data();
+         const size_type orig_extmem_size = extmem.size();
+         const size_type orig_extmem_cap = extmem.capacity();
+
+         //New safe state for extmem -> empty, internal storage
+         extmem.m_holder.m_start = extmem.get_stored_allocator().internal_storage();
+         extmem.m_holder.set_stored_size(0u);
+         extmem.m_holder.set_stored_capacity(internal_capacity);
+
+         {
+            //Deallocate on exception
+            typename value_traits::ArrayDeallocator new_buffer_deallocator(orig_extdata, extmem.get_stored_allocator(), orig_extmem_cap);
+            typename value_traits::ArrayDestructor  new_values_destroyer(orig_extdata, extmem.get_stored_allocator(), orig_extmem_size);
+
+            //Move internal memory data to the internal memory data of the target, this can throw
+            BOOST_ASSERT(extmem.capacity() >= intmem.size());
+            ::boost::container::uninitialized_move_alloc_n
+               (intmem.get_stored_allocator(), this->priv_raw_begin(), intmem.size(), extmem.priv_raw_begin());
+
+            //Exception not thrown, commit new state
+            extmem.m_holder.set_stored_size(intmem.size());
+            //Throwing part passed, disable rollback
+            new_buffer_deallocator.release();
+            new_values_destroyer.release();
+         }
+
+         //Destroy moved elements from intmem
+         boost::container::destroy_alloc_n
+            ( intmem.get_stored_allocator(), this->priv_raw_begin()
+            , intmem.size());
+
+         //Adopt dynamic buffer
+         intmem.m_holder.m_start = orig_extdata;
+         intmem.m_holder.set_stored_size(orig_extmem_size);
+         intmem.m_holder.set_stored_capacity(orig_extmem_cap);
+
+         //And now swap the allocator
+         dtl::swap_alloc(this->m_holder.alloc(), x.m_holder.alloc(), dtl::bool_<propagate_alloc>());
+      }
+      else {   //swap element by element and insert rest
          bool const t_smaller = this->size() < x.size();
          vector &sml = t_smaller ? *this : x;
          vector &big = t_smaller ? x : *this;
 
-         //For empty containers, maybe storage can be moved from the other (just like in the move constructor)         
-         if(sml.empty() && is_propagable_from(big.get_stored_allocator(), big.data(), sml.get_allocator(), propagate_alloc)){
-            if(BOOST_LIKELY(0u != sml.capacity()))
-               sml.m_holder.deallocate(sml.m_holder.m_start, sml.m_holder.m_capacity);
-            sml.steal_resources(big);
-         }
-         else {
-            //Else swap element by element...
-            size_type const common_elements = sml.size();
-            for(size_type i = 0; i != common_elements; ++i){
-               boost::adl_move_swap(sml[i], big[i]);
-            }
-            //... and move-insert the remaining range
-            sml.insert( sml.cend()
-                      , boost::make_move_iterator(boost::movelib::iterator_to_raw_pointer(big.nth(common_elements)))
-                      , boost::make_move_iterator(boost::movelib::iterator_to_raw_pointer(big.end()))
-                      );
-            //Destroy remaining elements
-            big.erase(big.nth(common_elements), big.cend());
+         //swap element by element until common size
+         size_type const common_elements = sml.size();
+         for(size_type i = 0; i != common_elements; ++i){
+            boost::adl_move_swap(sml[i], big[i]);
          }
+
+         //And now swap the allocator to be able to construct new elements in sml with the proper allocator
+         dtl::swap_alloc(this->m_holder.alloc(), x.m_holder.alloc(), dtl::bool_<propagate_alloc>());
+
+         //move-insert the remaining range
+         T *const raw_big_nth = boost::movelib::iterator_to_raw_pointer(big.nth(common_elements));
+         sml.insert(sml.cend()
+            , boost::make_move_iterator(raw_big_nth)
+            , boost::make_move_iterator(boost::movelib::iterator_to_raw_pointer(big.end())));
+
+         //Destroy remaining, moved, elements with their original allocator
+         boost::container::destroy_alloc_n
+            ( sml.get_stored_allocator(), raw_big_nth
+            , std::size_t(big.m_holder.m_size - common_elements));
+         big.m_holder.set_stored_size(common_elements);
       }
-      //And now swap the allocator
-      dtl::swap_alloc(this->m_holder.alloc(), x.m_holder.alloc(), dtl::bool_<propagate_alloc>());
    }
-
+   private:
    inline void priv_move_to_new_buffer(size_type, version_0)
    {  alloc_holder_t::on_capacity_overflow();  }
 
@@ -2762,6 +2869,41 @@ private:
    inline dtl::insert_value_initialized_n_proxy<allocator_type> priv_resize_proxy(value_init_t)
    {  return dtl::insert_value_initialized_n_proxy<allocator_type>(); }
 
+   protected:
+   void prot_shrink_to_fit_small(pointer const small_buffer, const size_type small_capacity)
+   {
+      const size_type cp = this->m_holder.capacity();
+      if (cp && this->m_holder.m_start != small_buffer) {   //Do something only if a dynamic buffer is used
+         const size_type sz = this->size();
+         if (!sz) {
+            if (BOOST_LIKELY(!!this->m_holder.m_start))
+               this->m_holder.deallocate(this->m_holder.m_start, cp);
+            this->m_holder.m_start = small_buffer;
+            this->m_holder.set_stored_capacity(small_capacity);
+         }
+         else if(sz <= small_capacity) {
+            T *const oldbuf = boost::movelib::to_raw_pointer(this->m_holder.m_start);
+            ::boost::container::uninitialized_move_alloc_n
+               ( this->get_stored_allocator()
+               , oldbuf
+               , sz
+               , boost::movelib::to_raw_pointer(small_buffer)
+               );
+            boost::container::destroy_alloc_n(this->get_stored_allocator(), oldbuf, sz);
+
+            if (BOOST_LIKELY(!!this->m_holder.m_start))
+               this->m_holder.deallocate(this->m_holder.m_start, cp);
+
+            this->m_holder.m_start = small_buffer;
+            this->m_holder.set_stored_capacity(small_capacity);
+         }
+         else if (sz < cp) {
+            this->priv_move_to_new_buffer(sz, alloc_version());
+         }
+      }
+   }
+
+   private:
    inline void priv_shrink_to_fit(version_0) BOOST_NOEXCEPT_OR_NOTHROW
    {}
 
@@ -2807,12 +2949,19 @@ private:
       }
    }
 
+   #ifdef _MSC_VER
+   #pragma warning (push)
+   #pragma warning(disable: 4702)   //Disable unreachable code warning
+   #endif
    template <class InsertionProxy>
    inline iterator priv_insert_forward_range_no_capacity
       (T * const, const size_type, const InsertionProxy , version_0)
    {
       return alloc_holder_t::on_capacity_overflow(), iterator();
    }
+   #ifdef _MSC_VER
+   #pragma warning (pop)
+   #endif
 
    template <class InsertionProxy>
    BOOST_CONTAINER_NOINLINE iterator priv_insert_forward_range_no_capacity
@@ -3161,8 +3310,8 @@ struct has_trivial_destructor_after_move<boost::container::vector<T, Allocator,
 {
    typedef typename boost::container::vector<T, Allocator, Options>::allocator_type allocator_type;
    typedef typename ::boost::container::allocator_traits<allocator_type>::pointer pointer;
-   static const bool value = ::boost::has_trivial_destructor_after_move<allocator_type>::value &&
-                             ::boost::has_trivial_destructor_after_move<pointer>::value;
+   BOOST_STATIC_CONSTEXPR bool value = ::boost::has_trivial_destructor_after_move<allocator_type>::value &&
+                                                ::boost::has_trivial_destructor_after_move<pointer>::value;
 };
 
 }

data/src/cxx_supportlib/vendor-modified/boost/core/detail/minstd_rand.hpp

@@ -0,0 +1,58 @@
+#ifndef BOOST_CORE_DETAIL_MINSTD_RAND_HPP_INCLUDED
+#define BOOST_CORE_DETAIL_MINSTD_RAND_HPP_INCLUDED
+
+// Copyright 2017 Peter Dimov
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+//
+// An implementation of minstd_rand that does not require
+// the Random library
+
+#include <boost/cstdint.hpp>
+
+namespace boost
+{
+namespace detail
+{
+
+class minstd_rand
+{
+private:
+
+    boost::uint_least32_t x_;
+
+    enum { a = 48271, m = 2147483647 };
+
+public:
+
+    minstd_rand(): x_( 1 )
+    {
+    }
+
+    explicit minstd_rand( boost::uint_least32_t x ): x_( x % m )
+    {
+        if( x_ == 0 )
+        {
+            x_ = 1;
+        }
+    }
+
+    boost::uint_least32_t operator()()
+    {
+        boost::uint_least64_t y = x_;
+
+        y = ( a * y ) % m;
+
+        x_ = static_cast<boost::uint_least32_t>( y );
+
+        return x_;
+    }
+};
+
+} // namespace detail
+} // namespace boost
+
+#endif // #ifndef BOOST_CORE_DETAIL_MINSTD_RAND_HPP_INCLUDED

data/src/cxx_supportlib/vendor-modified/boost/core/detail/string_view.hpp

@@ -74,7 +74,7 @@ template<class Ch> BOOST_CXX14_CONSTEXPR std::size_t find_first_of( Ch const* p_
 
     for( std::size_t j = 0; j < n; ++j )
     {
-        UCh ch = s[ j ];
+        UCh ch = static_cast<UCh>( s[ j ] );
 
         if( ch >= 0 && ch < 256 )
         {
@@ -91,7 +91,7 @@ template<class Ch> BOOST_CXX14_CONSTEXPR std::size_t find_first_of( Ch const* p_
     {
         for( std::size_t i = pos; i < n_; ++i )
         {
-            UCh ch = p_[ i ];
+            UCh ch = static_cast<UCh>( p_[ i ] );
             if( ch >= 0 && ch < 256 && table[ ch ] ) return i;
         }
     }
@@ -129,7 +129,7 @@ template<class Ch> BOOST_CXX14_CONSTEXPR std::size_t find_last_of( Ch const* p_,
 
     for( std::size_t j = 0; j < n; ++j )
     {
-        UCh ch = s[ j ];
+        UCh ch = static_cast<UCh>( s[ j ] );
 
         if( ch >= 0 && ch < 256 )
         {
@@ -150,7 +150,7 @@ template<class Ch> BOOST_CXX14_CONSTEXPR std::size_t find_last_of( Ch const* p_,
     {
         do
         {
-            UCh ch = p_[ i ];
+            UCh ch = static_cast<UCh>( p_[ i ] );
 
             if( ch >= 0 && ch < 256 && table[ ch ] ) return i;
 
@@ -199,7 +199,7 @@ template<class Ch> BOOST_CXX14_CONSTEXPR std::size_t find_first_not_of( Ch const
 
     for( std::size_t j = 0; j < n; ++j )
     {
-        UCh ch = s[ j ];
+        UCh ch = static_cast<UCh>( s[ j ] );
 
         if( ch >= 0 && ch < 256 )
         {
@@ -216,7 +216,7 @@ template<class Ch> BOOST_CXX14_CONSTEXPR std::size_t find_first_not_of( Ch const
     {
         for( std::size_t i = pos; i < n_; ++i )
         {
-            UCh ch = p_[ i ];
+            UCh ch = static_cast<UCh>( p_[ i ] );
             if( !( ch >= 0 && ch < 256 && table[ ch ] ) ) return i;
         }
     }
@@ -262,7 +262,7 @@ template<class Ch> BOOST_CXX14_CONSTEXPR std::size_t find_last_not_of( Ch const*
 
     for( std::size_t j = 0; j < n; ++j )
     {
-        UCh ch = s[ j ];
+        UCh ch = static_cast<UCh>( s[ j ] );
 
         if( ch >= 0 && ch < 256 )
         {
@@ -283,7 +283,7 @@ template<class Ch> BOOST_CXX14_CONSTEXPR std::size_t find_last_not_of( Ch const*
     {
         do
         {
-            UCh ch = p_[ i ];
+            UCh ch = static_cast<UCh>( p_[ i ] );
 
             if( !( ch >= 0 && ch < 256 && table[ ch ] ) ) return i;
 
@@ -381,7 +381,7 @@ public:
     }
 
     template<class End> BOOST_CXX14_CONSTEXPR basic_string_view( Ch const* first, End last,
-        typename boost::enable_if<boost::core::detail::is_same<End, Ch const*> >::type* = 0 ) BOOST_NOEXCEPT: p_( first ), n_( last - first )
+        typename boost::enable_if<boost::core::detail::is_same<End, Ch const*> >::type* = 0 ) BOOST_NOEXCEPT: p_( first ), n_( static_cast<size_type>( last - first ) )
     {
         BOOST_ASSERT( last - first >= 0 );
     }
@@ -681,7 +681,7 @@ public:
 
         Ch const* r = traits_type::find( data() + pos, size() - pos, c );
 
-        return r? r - data(): npos;
+        return r? static_cast<size_type>( r - data() ): npos;
     }
 
     BOOST_CXX14_CONSTEXPR size_type find( Ch const* s, size_type pos, size_type n ) const BOOST_NOEXCEPT
@@ -696,11 +696,11 @@ public:
 
         for( ;; )
         {
-            p = traits_type::find( p, last - p, s[0] );
+            p = traits_type::find( p, static_cast<size_type>( last - p ), s[0] );
 
             if( p == 0 ) break;
 
-            if( traits_type::compare( p + 1, s + 1, n - 1 ) == 0 ) return p - data();
+            if( traits_type::compare( p + 1, s + 1, n - 1 ) == 0 ) return static_cast<size_type>( p - data() );
 
             ++p;
         }
@@ -1193,7 +1193,7 @@ public:
 template<class Ch> std::basic_ostream<Ch>& operator<<( std::basic_ostream<Ch>& os, basic_string_view<Ch> str )
 {
     Ch const* p = str.data();
-    std::streamsize n = str.size();
+    std::streamsize n = static_cast<std::streamsize>( str.size() );
 
     std::streamsize m = os.width();