passenger 6.0.18 → 6.0.20

data/src/cxx_supportlib/vendor-modified/boost/container/detail/copy_move_algo.hpp

@@ -34,7 +34,7 @@
 #include <boost/move/utility_core.hpp>
 #include <boost/move/traits.hpp>
 // other
-#include <boost/core/no_exceptions_support.hpp>
+#include <boost/assert.hpp>
 // std
 #include <cstring> //for memmove/memcpy
 
@@ -296,9 +296,6 @@ struct is_memzero_initializable
       #if defined(BOOST_CONTAINER_MEMZEROED_FLOATING_POINT_IS_ZERO)
       || dtl::is_floating_point<value_type>::value
       #endif
-      #if defined(BOOST_CONTAINER_MEMZEROED_FLOATING_POINT_IS_ZERO) && defined(BOOST_CONTAINER_MEMZEROED_POINTER_IS_NULL)
-      || dtl::is_pod<value_type>::value
-      #endif
       );
 };
 
@@ -350,19 +347,19 @@ inline typename dtl::disable_if_memtransfer_copy_constructible<I, F, F>::type
    uninitialized_move_alloc(Allocator &a, I f, I l, F r)
 {
    F back = r;
-   BOOST_TRY{
+   BOOST_CONTAINER_TRY{
       while (f != l) {
          allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r), boost::move(*f));
          ++f; ++r;
       }
    }
-   BOOST_CATCH(...){
+   BOOST_CONTAINER_CATCH(...){
       for (; back != r; ++back){
          allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
       }
-      BOOST_RETHROW;
+      BOOST_CONTAINER_RETHROW;
    }
-   BOOST_CATCH_END
+   BOOST_CONTAINER_CATCH_END
    return r;
 }
 
@@ -395,20 +392,20 @@ inline typename dtl::disable_if_memtransfer_copy_constructible<I, F, F>::type
    uninitialized_move_alloc_n(Allocator &a, I f, std::size_t n, F r)
 {
    F back = r;
-   BOOST_TRY{
+   BOOST_CONTAINER_TRY{
       while (n) {
          --n;
          allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r), boost::move(*f));
          ++f; ++r;
       }
    }
-   BOOST_CATCH(...){
+   BOOST_CONTAINER_CATCH(...){
       for (; back != r; ++back){
          allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
       }
-      BOOST_RETHROW;
+      BOOST_CONTAINER_RETHROW;
    }
-   BOOST_CATCH_END
+   BOOST_CONTAINER_CATCH_END
    return r;
 }
 
@@ -441,20 +438,20 @@ inline typename dtl::disable_if_memtransfer_copy_constructible<I, F, I>::type
    uninitialized_move_alloc_n_source(Allocator &a, I f, std::size_t n, F r)
 {
    F back = r;
-   BOOST_TRY{
+   BOOST_CONTAINER_TRY{
       while (n) {
          --n;
          allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r), boost::move(*f));
          ++f; ++r;
       }
    }
-   BOOST_CATCH(...){
+   BOOST_CONTAINER_CATCH(...){
       for (; back != r; ++back){
          allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
       }
-      BOOST_RETHROW;
+      BOOST_CONTAINER_RETHROW;
    }
-   BOOST_CATCH_END
+   BOOST_CONTAINER_CATCH_END
    return f;
 }
 
@@ -487,19 +484,19 @@ inline typename dtl::disable_if_memtransfer_copy_constructible<I, F, F>::type
    uninitialized_copy_alloc(Allocator &a, I f, I l, F r)
 {
    F back = r;
-   BOOST_TRY{
+   BOOST_CONTAINER_TRY{
       while (f != l) {
          allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r), *f);
          ++f; ++r;
       }
    }
-   BOOST_CATCH(...){
+   BOOST_CONTAINER_CATCH(...){
       for (; back != r; ++back){
          allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
       }
-      BOOST_RETHROW;
+      BOOST_CONTAINER_RETHROW;
    }
-   BOOST_CATCH_END
+   BOOST_CONTAINER_CATCH_END
    return r;
 }
 
@@ -532,20 +529,20 @@ inline typename dtl::disable_if_memtransfer_copy_constructible<I, F, F>::type
    uninitialized_copy_alloc_n(Allocator &a, I f, std::size_t n, F r)
 {
    F back = r;
-   BOOST_TRY{
+   BOOST_CONTAINER_TRY{
       while (n) {
          --n;
          allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r), *f);
          ++f; ++r;
       }
    }
-   BOOST_CATCH(...){
+   BOOST_CONTAINER_CATCH(...){
       for (; back != r; ++back){
          allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
       }
-      BOOST_RETHROW;
+      BOOST_CONTAINER_RETHROW;
    }
-   BOOST_CATCH_END
+   BOOST_CONTAINER_CATCH_END
    return r;
 }
 
@@ -578,19 +575,19 @@ inline typename dtl::disable_if_memtransfer_copy_constructible<I, F, I>::type
    uninitialized_copy_alloc_n_source(Allocator &a, I f, std::size_t n, F r)
 {
    F back = r;
-   BOOST_TRY{
+   BOOST_CONTAINER_TRY{
       while (n) {
          boost::container::construct_in_place(a, boost::movelib::iterator_to_raw_pointer(r), f);
          ++f; ++r; --n;
       }
    }
-   BOOST_CATCH(...){
+   BOOST_CONTAINER_CATCH(...){
       for (; back != r; ++back){
          allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
       }
-      BOOST_RETHROW;
+      BOOST_CONTAINER_RETHROW;
    }
-   BOOST_CATCH_END
+   BOOST_CONTAINER_CATCH_END
    return f;
 }
 
@@ -622,20 +619,20 @@ inline typename dtl::disable_if_memzero_initializable<F, F>::type
    uninitialized_value_init_alloc_n(Allocator &a, std::size_t n, F r)
 {
    F back = r;
-   BOOST_TRY{
+   BOOST_CONTAINER_TRY{
       while (n) {
          --n;
          allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r));
          ++r;
       }
    }
-   BOOST_CATCH(...){
+   BOOST_CONTAINER_CATCH(...){
       for (; back != r; ++back){
          allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
       }
-      BOOST_RETHROW;
+      BOOST_CONTAINER_RETHROW;
    }
-   BOOST_CATCH_END
+   BOOST_CONTAINER_CATCH_END
    return r;
 }
 
@@ -674,20 +671,20 @@ template
 inline F uninitialized_default_init_alloc_n(Allocator &a, std::size_t n, F r)
 {
    F back = r;
-   BOOST_TRY{
+   BOOST_CONTAINER_TRY{
       while (n) {
          --n;
          allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r), default_init);
          ++r;
       }
    }
-   BOOST_CATCH(...){
+   BOOST_CONTAINER_CATCH(...){
       for (; back != r; ++back){
          allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
       }
-      BOOST_RETHROW;
+      BOOST_CONTAINER_RETHROW;
    }
-   BOOST_CATCH_END
+   BOOST_CONTAINER_CATCH_END
    return r;
 }
 
@@ -711,19 +708,19 @@ template
 inline void uninitialized_fill_alloc(Allocator &a, F f, F l, const T &t)
 {
    F back = f;
-   BOOST_TRY{
+   BOOST_CONTAINER_TRY{
       while (f != l) {
          allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(f), t);
          ++f;
       }
    }
-   BOOST_CATCH(...){
+   BOOST_CONTAINER_CATCH(...){
       for (; back != l; ++back){
          allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
       }
-      BOOST_RETHROW;
+      BOOST_CONTAINER_RETHROW;
    }
-   BOOST_CATCH_END
+   BOOST_CONTAINER_CATCH_END
 }
 
 
@@ -747,20 +744,20 @@ template
 inline F uninitialized_fill_alloc_n(Allocator &a, const T &v, std::size_t n, F r)
 {
    F back = r;
-   BOOST_TRY{
+   BOOST_CONTAINER_TRY{
       while (n) {
          --n;
          allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r), v);
          ++r;
       }
    }
-   BOOST_CATCH(...){
+   BOOST_CONTAINER_CATCH(...){
       for (; back != r; ++back){
          allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
       }
-      BOOST_RETHROW;
+      BOOST_CONTAINER_RETHROW;
    }
-   BOOST_CATCH_END
+   BOOST_CONTAINER_CATCH_END
    return r;
 }
 

data/src/cxx_supportlib/vendor-modified/boost/container/detail/dispatch_uses_allocator.hpp

@@ -33,8 +33,6 @@
 #endif
 #include <boost/move/utility_core.hpp>
 
-#include <boost/core/no_exceptions_support.hpp>
-
 namespace boost { namespace container {
 
 namespace dtl {
@@ -228,14 +226,14 @@ BOOST_CONTAINER_DOC1ST(void, typename dtl::enable_if<dtl::is_pair<Pair> BOOST_MO
    , Pair* p)
 {
    dispatch_uses_allocator(construct_alloc, arg_alloc, dtl::addressof(p->first));
-   BOOST_TRY{
+   BOOST_CONTAINER_TRY{
       dispatch_uses_allocator(construct_alloc, arg_alloc, dtl::addressof(p->second));
    }
-   BOOST_CATCH(...) {
+   BOOST_CONTAINER_CATCH(...) {
       allocator_traits<ConstructAlloc>::destroy(construct_alloc, dtl::addressof(p->first));
-      BOOST_RETHROW
+      BOOST_CONTAINER_RETHROW
    }
-   BOOST_CATCH_END
+   BOOST_CONTAINER_CATCH_END
 }
 
 
@@ -249,14 +247,14 @@ BOOST_CONTAINER_DOC1ST(void, typename dtl::enable_if<dtl::is_pair<Pair> BOOST_MO
    , Pair* p, BOOST_FWD_REF(U) x, BOOST_FWD_REF(V) y)
 {
    dispatch_uses_allocator(construct_alloc, arg_alloc, dtl::addressof(p->first), ::boost::forward<U>(x));
-   BOOST_TRY{
+   BOOST_CONTAINER_TRY{
       dispatch_uses_allocator(construct_alloc, arg_alloc, dtl::addressof(p->second), ::boost::forward<V>(y));
    }
-   BOOST_CATCH(...){
+   BOOST_CONTAINER_CATCH(...){
       allocator_traits<ConstructAlloc>::destroy(construct_alloc, dtl::addressof(p->first));
-      BOOST_RETHROW
+      BOOST_CONTAINER_RETHROW
    }
-   BOOST_CATCH_END
+   BOOST_CONTAINER_CATCH_END
 }
 
 template < typename ConstructAlloc
@@ -296,15 +294,15 @@ typename dtl::enable_if< dtl::is_pair<Pair> BOOST_MOVE_I void>::type\
    (void)p; (void)q;\
    dispatch_uses_allocator\
       (construct_alloc, arg_alloc, dtl::addressof(pair->first) BOOST_MOVE_I_IF(N) BOOST_MOVE_TMPL_GET##N);\
-   BOOST_TRY{\
+   BOOST_CONTAINER_TRY{\
       dispatch_uses_allocator\
          (construct_alloc, arg_alloc, dtl::addressof(pair->second) BOOST_MOVE_I_IF(M) BOOST_MOVE_TMPL_GETQ##M);\
    }\
-   BOOST_CATCH(...) {\
+   BOOST_CONTAINER_CATCH(...) {\
       allocator_traits<ConstructAlloc>::destroy(construct_alloc, dtl::addressof(pair->first));\
-      BOOST_RETHROW\
+      BOOST_CONTAINER_RETHROW\
    }\
-   BOOST_CATCH_END\
+   BOOST_CONTAINER_CATCH_END\
 }\
 //
 BOOST_MOVE_ITER2D_0TOMAX(9, BOOST_DISPATCH_USES_ALLOCATOR_PIECEWISE_CONSTRUCT_BOOST_TUPLE_CODE)
@@ -320,14 +318,14 @@ BOOST_MOVE_ITER2D_0TOMAX(9, BOOST_DISPATCH_USES_ALLOCATOR_PIECEWISE_CONSTRUCT_BO
    {
       (void)t1; (void)t2;
       dispatch_uses_allocator(construct_alloc, arg_alloc, dtl::addressof(pair->first), ::boost::forward<Args1>(get<Indexes1>(t1))...);
-      BOOST_TRY{
+      BOOST_CONTAINER_TRY{
          dispatch_uses_allocator(construct_alloc, arg_alloc, dtl::addressof(pair->second), ::boost::forward<Args2>(get<Indexes2>(t2))...);
       }
-      BOOST_CATCH(...){
+      BOOST_CONTAINER_CATCH(...){
          allocator_traits<ConstructAlloc>::destroy(construct_alloc, dtl::addressof(pair->first));
-         BOOST_RETHROW
+         BOOST_CONTAINER_RETHROW
       }
-      BOOST_CATCH_END
+      BOOST_CONTAINER_CATCH_END
    }
 
    template< typename ConstructAlloc, typename ArgAlloc, class Pair
@@ -356,15 +354,15 @@ BOOST_MOVE_ITER2D_0TOMAX(9, BOOST_DISPATCH_USES_ALLOCATOR_PIECEWISE_CONSTRUCT_BO
       (void)p; (void)q;\
       dispatch_uses_allocator\
          (construct_alloc, arg_alloc, dtl::addressof(pair->first) BOOST_MOVE_I_IF(N) BOOST_MOVE_GET_IDX##N);\
-      BOOST_TRY{\
+      BOOST_CONTAINER_TRY{\
          dispatch_uses_allocator\
             (construct_alloc, arg_alloc, dtl::addressof(pair->second) BOOST_MOVE_I_IF(M) BOOST_MOVE_GET_IDXQ##M);\
       }\
-      BOOST_CATCH(...) {\
+      BOOST_CONTAINER_CATCH(...) {\
          allocator_traits<ConstructAlloc>::destroy(construct_alloc, dtl::addressof(pair->first));\
-         BOOST_RETHROW\
+         BOOST_CONTAINER_RETHROW\
       }\
-      BOOST_CATCH_END\
+      BOOST_CONTAINER_CATCH_END\
    }\
    //
    BOOST_MOVE_ITER2D_0TOMAX(9, BOOST_DISPATCH_USES_ALLOCATOR_PIECEWISE_CONSTRUCT_MSVC2010_TUPLE_CODE)
@@ -391,15 +389,15 @@ BOOST_MOVE_ITER2D_0TOMAX(9, BOOST_DISPATCH_USES_ALLOCATOR_PIECEWISE_CONSTRUCT_BO
       (void)p; (void)q;\
       dispatch_uses_allocator\
          (construct_alloc, arg_alloc, dtl::addressof(pair->first) BOOST_MOVE_I_IF(N) BOOST_MOVE_GET_IDX##N);\
-      BOOST_TRY{\
+      BOOST_CONTAINER_TRY{\
          dispatch_uses_allocator\
             (construct_alloc, arg_alloc, dtl::addressof(pair->second) BOOST_MOVE_I_IF(M) BOOST_MOVE_GET_IDXQ##M);\
       }\
-      BOOST_CATCH(...) {\
+      BOOST_CONTAINER_CATCH(...) {\
          allocator_traits<ConstructAlloc>::destroy(construct_alloc, dtl::addressof(pair->first));\
-         BOOST_RETHROW\
+         BOOST_CONTAINER_RETHROW\
       }\
-      BOOST_CATCH_END\
+      BOOST_CONTAINER_CATCH_END\
    }\
    //
    BOOST_MOVE_ITER2D_0TOMAX(BOOST_DISPATCH_USES_ALLOCATOR_PIECEWISE_CONSTRUCT_MSVC2012_TUPLE_MAX_IT, BOOST_DISPATCH_USES_ALLOCATOR_PIECEWISE_CONSTRUCT_MSVC2012_TUPLE_CODE)
@@ -418,14 +416,14 @@ typename dtl::enable_if< dtl::is_pair<Pair>, void >::type
    (ConstructAlloc & construct_alloc, BOOST_FWD_REF(ArgAlloc) arg_alloc, Pair* p, try_emplace_t, BOOST_FWD_REF(KeyType) k, BOOST_FWD_REF(Args) ...args)
 {
    dispatch_uses_allocator(construct_alloc, arg_alloc, dtl::addressof(p->first), ::boost::forward<KeyType>(k));
-   BOOST_TRY{
+   BOOST_CONTAINER_TRY{
       dispatch_uses_allocator(construct_alloc, arg_alloc, dtl::addressof(p->second), ::boost::forward<Args>(args)...);
    }
-   BOOST_CATCH(...) {
+   BOOST_CONTAINER_CATCH(...) {
       allocator_traits<ConstructAlloc>::destroy(construct_alloc, dtl::addressof(p->first));
-      BOOST_RETHROW
+      BOOST_CONTAINER_RETHROW
    }
-   BOOST_CATCH_END
+   BOOST_CONTAINER_CATCH_END
 }
 
 #else
@@ -439,14 +437,14 @@ typename dtl::enable_if< dtl::is_pair<Pair>, void >::type
        BOOST_FWD_REF(KeyType) k BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
    {\
       dispatch_uses_allocator(construct_alloc, arg_alloc, dtl::addressof(p->first), ::boost::forward<KeyType>(k));\
-      BOOST_TRY{\
+      BOOST_CONTAINER_TRY{\
          dispatch_uses_allocator(construct_alloc, arg_alloc, dtl::addressof(p->second) BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
       }\
-      BOOST_CATCH(...) {\
+      BOOST_CONTAINER_CATCH(...) {\
          allocator_traits<ConstructAlloc>::destroy(construct_alloc, dtl::addressof(p->first));\
-         BOOST_RETHROW\
+         BOOST_CONTAINER_RETHROW\
       }\
-      BOOST_CATCH_END\
+      BOOST_CONTAINER_CATCH_END\
    }\
 //
 BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_DISPATCH_USES_ALLOCATOR_PAIR_TRY_EMPLACE_CODE)

data/src/cxx_supportlib/vendor-modified/boost/container/detail/flat_tree.hpp

@@ -139,9 +139,11 @@ BOOST_CONTAINER_FORCEINLINE void flat_tree_container_inplace_merge //is_contiguo
    (SequenceContainer& dest, typename SequenceContainer::iterator it, Compare comp , dtl::true_)
 {
    typedef typename SequenceContainer::value_type  value_type;
-   value_type *const braw = boost::movelib::iterator_to_raw_pointer(dest.begin());
+   value_type *const braw = boost::movelib::to_raw_pointer(dest.data());
    value_type *const iraw = boost::movelib::iterator_to_raw_pointer(it);
-   value_type *const eraw = boost::movelib::iterator_to_raw_pointer(dest.end());
+   //Don't use iterator_to_raw_pointer for end as debug iterators can assert when
+   //"operator ->" is used with the end iterator
+   value_type *const eraw = braw + dest.size();
    boost::movelib::adaptive_merge
       (braw, iraw, eraw, comp, eraw, back_free_capacity<SequenceContainer>::get(dest));
 }
@@ -164,7 +166,11 @@ BOOST_CONTAINER_FORCEINLINE void flat_tree_container_inplace_sort_ending //is_co
 {
    typedef typename SequenceContainer::value_type  value_type;
    value_type *const iraw = boost::movelib::iterator_to_raw_pointer(it);
-   value_type *const eraw = boost::movelib::iterator_to_raw_pointer(dest.end());
+   //Don't use iterator_to_raw_pointer for end as debug iterators can assert when
+   //"operator ->" is used with the end iterator
+   value_type* const eraw = boost::movelib::to_raw_pointer(dest.data()) + dest.size();
+
+
    boost::movelib::adaptive_sort
       (iraw, eraw, comp, eraw, back_free_capacity<SequenceContainer>::get(dest));
 }
@@ -192,10 +198,12 @@ template<class SequenceContainer, class Iterator, class Compare>
 BOOST_CONTAINER_FORCEINLINE void flat_tree_merge_equal   //has_merge_unique == false
    (SequenceContainer& dest, Iterator first, Iterator last, Compare comp, dtl::false_)
 {
-   typedef typename SequenceContainer::iterator    iterator;
-   iterator const it = dest.insert( dest.end(), first, last );
-   dtl::bool_<is_contiguous_container<SequenceContainer>::value> contiguous_tag;
-   (flat_tree_container_inplace_merge)(dest, it, comp, contiguous_tag);
+   if(first != last) {
+      typedef typename SequenceContainer::iterator    iterator;
+      iterator const it = dest.insert( dest.end(), first, last );
+      dtl::bool_<is_contiguous_container<SequenceContainer>::value> contiguous_tag;
+      (flat_tree_container_inplace_merge)(dest, it, comp, contiguous_tag);
+   }
 }
 
 ///////////////////////////////////////
@@ -214,16 +222,18 @@ template<class SequenceContainer, class Iterator, class Compare>
 BOOST_CONTAINER_FORCEINLINE void flat_tree_merge_unique  //has_merge_unique == false
    (SequenceContainer& dest, Iterator first, Iterator last, Compare comp, dtl::false_)
 {
-   typedef typename SequenceContainer::iterator          iterator;
-   typedef typename SequenceContainer::size_type         size_type;
-   typedef typename SequenceContainer::difference_type   difference_type;
-
-   size_type const old_sz = dest.size();
-   iterator const first_new = dest.insert(dest.cend(), first, last );
-   iterator e = boost::movelib::inplace_set_unique_difference(first_new, dest.end(), dest.begin(), first_new, comp);
-   dest.erase(e, dest.end());
-   dtl::bool_<is_contiguous_container<SequenceContainer>::value> contiguous_tag;
-   (flat_tree_container_inplace_merge)(dest, dest.begin() + difference_type(old_sz), comp, contiguous_tag);
+   if (first != last) {
+      typedef typename SequenceContainer::iterator          iterator;
+      typedef typename SequenceContainer::size_type         size_type;
+      typedef typename SequenceContainer::difference_type   difference_type;
+
+      size_type const old_sz = dest.size();
+      iterator const first_new = dest.insert(dest.cend(), first, last );
+      iterator e = boost::movelib::inplace_set_unique_difference(first_new, dest.end(), dest.begin(), first_new, comp);
+      dest.erase(e, dest.end());
+      dtl::bool_<is_contiguous_container<SequenceContainer>::value> contiguous_tag;
+      (flat_tree_container_inplace_merge)(dest, dest.begin() + difference_type(old_sz), comp, contiguous_tag);
+   }
 }
 
 ///////////////////////////////////////
@@ -931,11 +941,13 @@ class flat_tree
    template <class InIt>
    void insert_equal(InIt first, InIt last)
    {
-      dtl::bool_<is_contiguous_container<container_type>::value> contiguous_tag;
-      container_type &seq = this->m_data.m_seq;
-      typename container_type::iterator const it = seq.insert(seq.cend(), first, last);
-      (flat_tree_container_inplace_sort_ending)(seq, it, this->priv_value_comp(), contiguous_tag);
-      (flat_tree_container_inplace_merge)      (seq, it, this->priv_value_comp(), contiguous_tag);
+      if (first != last) {
+         dtl::bool_<is_contiguous_container<container_type>::value> contiguous_tag;
+         container_type &seq = this->m_data.m_seq;
+         typename container_type::iterator const it = seq.insert(seq.cend(), first, last);
+         (flat_tree_container_inplace_sort_ending)(seq, it, this->priv_value_comp(), contiguous_tag);
+         (flat_tree_container_inplace_merge)      (seq, it, this->priv_value_comp(), contiguous_tag);
+      }
    }
 
    //Ordered
@@ -1129,8 +1141,8 @@ class flat_tree
 
    size_type erase_unique(const key_type& k)
    {
-      iterator i = this->find(k);
-      size_type ret = static_cast<size_type>(i != this->end());
+      const_iterator i = static_cast<const flat_tree &>(*this).find(k);
+      size_type ret = static_cast<size_type>(i != this->cend());
       if (ret)
          this->erase(i);
       return ret;

data/src/cxx_supportlib/vendor-modified/boost/container/detail/mutex.hpp

@@ -30,6 +30,8 @@
 
 // Extremely Light-Weight wrapper classes for OS thread synchronization
 
+
+
 #define BOOST_MUTEX_HELPER_NONE         0
 #define BOOST_MUTEX_HELPER_WIN32        1
 #define BOOST_MUTEX_HELPER_PTHREAD      2
@@ -50,14 +52,6 @@
          defined(__i386__) || defined(__x86_64__))) ||                     \
       (defined(_MSC_VER) && _MSC_VER>=1310))
       #define BOOST_MUTEX_HELPER BOOST_MUTEX_HELPER_SPINLOCKS
-   #endif
-
-   #if defined(BOOST_WINDOWS)
-      #include <boost/winapi/critical_section.hpp>
-      #include <boost/winapi/thread.hpp>
-      #ifndef BOOST_MUTEX_HELPER
-         #define BOOST_MUTEX_HELPER BOOST_MUTEX_HELPER_WIN32
-      #endif
    #elif defined(BOOST_HAS_UNISTD_H)
       #include <unistd.h>
       #if !defined(BOOST_MUTEX_HELPER) && (defined(_POSIX_THREADS) || defined(BOOST_HAS_PTHREADS))
@@ -74,11 +68,9 @@
    //...
 #elif BOOST_MUTEX_HELPER == BOOST_MUTEX_HELPER_SPINLOCKS
    #if defined(_MSC_VER)
-      #include <boost/detail/interlocked.hpp>
-      #define interlockedcompareexchange _InterlockedCompareExchange
+      #include <intrin.h>
       #define interlockedexchange        _InterlockedExchange
    #elif defined(WIN32) && defined(__GNUC__)
-      #define interlockedcompareexchange(a, b, c) __sync_val_compare_and_swap(a, c, b)
       #define interlockedexchange                 __sync_lock_test_and_set
    #endif /* Win32 */
 
@@ -123,8 +115,52 @@
    /* How to yield for a spin lock */
    #define SPINS_PER_YIELD       63
    #if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
+      #if !defined( BOOST_USE_WINDOWS_H )
+         #if defined (WIN32_PLATFORM_PSPC)
+            #define BOOST_CONTAINERWINAPI_IMPORT BOOST_SYMBOL_IMPORT
+         #elif defined (_WIN32_WCE)
+            #define BOOST_CONTAINERWINAPI_IMPORT
+         #else
+            #define BOOST_CONTAINERWINAPI_IMPORT BOOST_SYMBOL_IMPORT
+         #endif
+
+         #if defined(WINAPI)
+            #define BOOST_CONTAINERWINAPI_WINAPI_CC WINAPI
+         #else
+            #if defined(_M_IX86) || defined(__i386__)
+               #define BOOST_CONTAINERWINAPI_DETAIL_STDCALL __stdcall
+            #else
+               #define BOOST_CONTAINERWINAPI_DETAIL_STDCALL
+            #endif
+            #define BOOST_CONTAINERWINAPI_WINAPI_CC BOOST_CONTAINERWINAPI_DETAIL_STDCALL
+         #endif
+
+         #if !defined(__LP64__)
+         namespace boost {
+            namespace container_winapi {
+            typedef unsigned long DWORD_;
+            #else
+            typedef unsigned int DWORD_;
+            #endif
+            typedef int BOOL_;
+         }}
+
+      extern "C" {
+         BOOST_CONTAINERWINAPI_IMPORT boost::container_winapi::DWORD_ BOOST_CONTAINERWINAPI_WINAPI_CC
+            SleepEx(
+               boost::container_winapi::DWORD_ dwMilliseconds,
+               boost::container_winapi::BOOL_ bAlertable);
+      } // extern "C"
+      #endif
+
+      namespace boost {
+         namespace container_winapi {
+            using ::SleepEx;
+         }
+      }
+
       #define SLEEP_EX_DURATION     50 /* delay for yield/sleep */
-      #define SPIN_LOCK_YIELD  boost::winapi::SleepEx(SLEEP_EX_DURATION, 0)
+      #define SPIN_LOCK_YIELD  boost::container_winapi::SleepEx(SLEEP_EX_DURATION, 0)
    #elif defined (__SVR4) && defined (__sun) /* solaris */
       #include <thread.h>
       #define SPIN_LOCK_YIELD   thr_yield();