passenger 6.0.14 → 6.0.16

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

@@ -83,9 +83,8 @@ struct null_scoped_deallocator
 {
    typedef boost::container::allocator_traits<Allocator> AllocTraits;
    typedef typename AllocTraits::pointer    pointer;
-   typedef typename AllocTraits::size_type  size_type;
 
-   null_scoped_deallocator(pointer, Allocator&, size_type)
+   null_scoped_deallocator(pointer, Allocator&, std::size_t)
    {}
 
    void release()
@@ -107,11 +106,11 @@ struct scoped_array_deallocator
    typedef typename AllocTraits::pointer    pointer;
    typedef typename AllocTraits::size_type  size_type;
 
-   scoped_array_deallocator(pointer p, Allocator& a, size_type length)
+   scoped_array_deallocator(pointer p, Allocator& a, std::size_t length)
       : m_ptr(p), m_alloc(a), m_length(length) {}
 
    ~scoped_array_deallocator()
-   {  if (m_ptr) m_alloc.deallocate(m_ptr, m_length);  }
+   {  if (m_ptr) m_alloc.deallocate(m_ptr, size_type(m_length));  }
 
    void release()
    {  m_ptr = 0; }
@@ -119,7 +118,7 @@ struct scoped_array_deallocator
    private:
    pointer     m_ptr;
    Allocator&  m_alloc;
-   size_type   m_length;
+   std::size_t m_length;
 };
 
 template <class Allocator>
@@ -127,9 +126,8 @@ struct null_scoped_array_deallocator
 {
    typedef boost::container::allocator_traits<Allocator> AllocTraits;
    typedef typename AllocTraits::pointer    pointer;
-   typedef typename AllocTraits::size_type  size_type;
 
-   null_scoped_array_deallocator(pointer, Allocator&, size_type)
+   null_scoped_array_deallocator(pointer, Allocator&, std::size_t)
    {}
 
    void release()
@@ -137,22 +135,21 @@ struct null_scoped_array_deallocator
 };
 
 template <class Allocator>
-struct scoped_destroy_deallocator
+struct scoped_node_destroy_deallocator
 {
    typedef boost::container::allocator_traits<Allocator> AllocTraits;
    typedef typename AllocTraits::pointer    pointer;
-   typedef typename AllocTraits::size_type  size_type;
    typedef dtl::integral_constant<unsigned,
       boost::container::dtl::
          version<Allocator>::value>                          alloc_version;
 
-   scoped_destroy_deallocator(pointer p, Allocator& a)
+   scoped_node_destroy_deallocator(pointer p, Allocator& a)
       : m_ptr(p), m_alloc(a) {}
 
-   ~scoped_destroy_deallocator()
+   ~scoped_node_destroy_deallocator()
    {
       if(m_ptr){
-         AllocTraits::destroy(m_alloc, boost::movelib::to_raw_pointer(m_ptr));
+         boost::movelib::to_raw_pointer(m_ptr)->destructor(m_alloc);
          priv_deallocate(m_ptr, alloc_version());
       }
    }
@@ -181,23 +178,22 @@ struct scoped_destructor_n
    typedef boost::container::allocator_traits<Allocator> AllocTraits;
    typedef typename AllocTraits::pointer    pointer;
    typedef typename AllocTraits::value_type value_type;
-   typedef typename AllocTraits::size_type  size_type;
 
-   BOOST_CONTAINER_FORCEINLINE scoped_destructor_n(pointer p, Allocator& a, size_type n)
+   BOOST_CONTAINER_FORCEINLINE scoped_destructor_n(pointer p, Allocator& a, std::size_t n)
       : m_p(p), m_a(a), m_n(n)
    {}
 
    BOOST_CONTAINER_FORCEINLINE void release()
    {  m_p = 0; m_n = 0; }
 
-   BOOST_CONTAINER_FORCEINLINE void increment_size(size_type inc)
+   BOOST_CONTAINER_FORCEINLINE void increment_size(std::size_t inc)
    {  m_n += inc;   }
 
-   BOOST_CONTAINER_FORCEINLINE void increment_size_backwards(size_type inc)
-   {  m_n += inc;   m_p -= inc;  }
+   BOOST_CONTAINER_FORCEINLINE void increment_size_backwards(std::size_t inc)
+   {  m_n += inc;   m_p -= std::ptrdiff_t(inc);  }
 
-   BOOST_CONTAINER_FORCEINLINE void shrink_forward(size_type inc)
-   {  m_n -= inc;   m_p += inc;  }
+   BOOST_CONTAINER_FORCEINLINE void shrink_forward(std::size_t inc)
+   {  m_n -= inc;   m_p += std::ptrdiff_t(inc);  }
 
    ~scoped_destructor_n()
    {
@@ -214,7 +210,7 @@ struct scoped_destructor_n
    private:
    pointer     m_p;
    Allocator & m_a;
-   size_type   m_n;
+   std::size_t m_n;
 };
 
 //!A deleter for scoped_ptr that destroys
@@ -224,18 +220,17 @@ struct null_scoped_destructor_n
 {
    typedef boost::container::allocator_traits<Allocator> AllocTraits;
    typedef typename AllocTraits::pointer pointer;
-   typedef typename AllocTraits::size_type size_type;
 
-   BOOST_CONTAINER_FORCEINLINE null_scoped_destructor_n(pointer, Allocator&, size_type)
+   BOOST_CONTAINER_FORCEINLINE null_scoped_destructor_n(pointer, Allocator&, std::size_t)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE void increment_size(size_type)
+   BOOST_CONTAINER_FORCEINLINE void increment_size(std::size_t)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE void increment_size_backwards(size_type)
+   BOOST_CONTAINER_FORCEINLINE void increment_size_backwards(std::size_t)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE void shrink_forward(size_type)
+   BOOST_CONTAINER_FORCEINLINE void shrink_forward(std::size_t)
    {}
 
    BOOST_CONTAINER_FORCEINLINE void release()
@@ -360,7 +355,7 @@ class value_destructor
 };
 
 template <class Allocator>
-class allocator_destroyer
+class allocator_node_destroyer
 {
    typedef boost::container::allocator_traits<Allocator> AllocTraits;
    typedef typename AllocTraits::value_type value_type;
@@ -380,19 +375,51 @@ class allocator_destroyer
    {  a_.deallocate_one(p); }
 
    public:
-   BOOST_CONTAINER_FORCEINLINE explicit allocator_destroyer(Allocator &a)
+   BOOST_CONTAINER_FORCEINLINE explicit allocator_node_destroyer(Allocator &a)
       : a_(a)
    {}
 
    BOOST_CONTAINER_FORCEINLINE void operator()(const pointer &p)
    {
-      AllocTraits::destroy(a_, boost::movelib::to_raw_pointer(p));
+      boost::movelib::to_raw_pointer(p)->destructor(a_);
       this->priv_deallocate(p, alloc_version());
    }
 };
 
+template<class Allocator>
+class scoped_node_destructor
+{
+   typedef boost::container::allocator_traits<Allocator> AllocTraits;
+   public:
+   typedef typename Allocator::value_type value_type;
+   BOOST_CONTAINER_FORCEINLINE scoped_node_destructor(Allocator &a, value_type *pv)
+      : pv_(pv), a_(a)
+   {}
+
+   BOOST_CONTAINER_FORCEINLINE ~scoped_node_destructor()
+   {
+      if(pv_){
+         pv_->destructor(a_);
+      }
+   }
+
+   BOOST_CONTAINER_FORCEINLINE void release()
+   {  pv_ = 0; }
+
+
+   BOOST_CONTAINER_FORCEINLINE void set(value_type *ptr) { pv_ = ptr; }
+
+   BOOST_CONTAINER_FORCEINLINE value_type *get() const { return pv_; }
+
+   private:
+   value_type *pv_;
+   Allocator &a_;
+};
+
+
+
 template <class Allocator>
-class allocator_destroyer_and_chain_builder
+class allocator_node_destroyer_and_chain_builder
 {
    typedef allocator_traits<Allocator> allocator_traits_type;
    typedef typename allocator_traits_type::value_type value_type;
@@ -402,13 +429,13 @@ class allocator_destroyer_and_chain_builder
    multiallocation_chain &c_;
 
    public:
-   BOOST_CONTAINER_FORCEINLINE allocator_destroyer_and_chain_builder(Allocator &a, multiallocation_chain &c)
+   BOOST_CONTAINER_FORCEINLINE allocator_node_destroyer_and_chain_builder(Allocator &a, multiallocation_chain &c)
       :  a_(a), c_(c)
    {}
 
    BOOST_CONTAINER_FORCEINLINE void operator()(const typename Allocator::pointer &p)
    {
-      allocator_traits<Allocator>::destroy(a_, boost::movelib::to_raw_pointer(p));
+      boost::movelib::to_raw_pointer(p)->destructor(a_);
       c_.push_back(p);
    }
 };
@@ -419,7 +446,7 @@ class allocator_multialloc_chain_node_deallocator
    typedef allocator_traits<Allocator> allocator_traits_type;
    typedef typename allocator_traits_type::value_type value_type;
    typedef typename Allocator::multiallocation_chain    multiallocation_chain;
-   typedef allocator_destroyer_and_chain_builder<Allocator> chain_builder;
+   typedef allocator_node_destroyer_and_chain_builder<Allocator> chain_builder;
 
    Allocator & a_;
    multiallocation_chain c_;

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

@@ -23,11 +23,13 @@
 
 #include <boost/container/detail/addressof.hpp>
 #include <boost/container/detail/mpl.hpp>
-#include <boost/container/detail/pair.hpp>
+#include <boost/container/detail/is_pair.hpp>
 #include <boost/container/detail/type_traits.hpp>
 
 #if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 #include <boost/move/detail/fwd_macros.hpp>
+#else
+#include <boost/container/detail/variadic_templates_tools.hpp>
 #endif
 #include <boost/move/utility_core.hpp>
 

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

@@ -46,6 +46,7 @@
 #include <boost/move/make_unique.hpp>
 #include <boost/move/iterator.hpp>
 #include <boost/move/adl_move_swap.hpp>
+#include <boost/move/detail/force_ptr.hpp>
 #include <boost/move/algo/adaptive_sort.hpp>
 #include <boost/move/algo/detail/pdqsort.hpp>
 
@@ -212,15 +213,16 @@ 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::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()+old_sz, comp, contiguous_tag);
+   (flat_tree_container_inplace_merge)(dest, dest.begin() + difference_type(old_sz), comp, contiguous_tag);
 }
 
 ///////////////////////////////////////
@@ -263,7 +265,7 @@ BOOST_CONTAINER_FORCEINLINE Iterator
    flat_tree_nth  // has_nth == false
       (SequenceContainer& cont, typename SequenceContainer::size_type n, dtl::false_)
 {
-   return cont.begin()+ n;
+   return cont.begin()+ typename SequenceContainer::difference_type(n);
 }
 
 ///////////////////////////////////////
@@ -959,9 +961,9 @@ class flat_tree
    std::pair<iterator, bool> emplace_unique(BOOST_FWD_REF(Args)... args)
    {
       typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;
-      value_type *pval = reinterpret_cast<value_type *>(v.data);
       get_stored_allocator_noconst_return_t a = this->get_stored_allocator();
-      stored_allocator_traits::construct(a, pval, ::boost::forward<Args>(args)... );
+      stored_allocator_traits::construct(a, move_detail::force_ptr<value_type *>(&v), ::boost::forward<Args>(args)... );
+      value_type *pval = move_detail::force_ptr<value_type *>(&v);
       value_destructor<stored_allocator_type, value_type> d(a, *pval);
       return this->insert_unique(::boost::move(*pval));
    }
@@ -971,9 +973,9 @@ class flat_tree
    {
       //hint checked in insert_unique
       typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;
-      value_type *pval = reinterpret_cast<value_type *>(v.data);
       get_stored_allocator_noconst_return_t a = this->get_stored_allocator();
-      stored_allocator_traits::construct(a, pval, ::boost::forward<Args>(args)... );
+      stored_allocator_traits::construct(a, move_detail::force_ptr<value_type *>(&v), ::boost::forward<Args>(args)... );
+      value_type *pval = move_detail::force_ptr<value_type *>(&v);
       value_destructor<stored_allocator_type, value_type> d(a, *pval);
       return this->insert_unique(hint, ::boost::move(*pval));
    }
@@ -982,9 +984,9 @@ class flat_tree
    iterator emplace_equal(BOOST_FWD_REF(Args)... args)
    {
       typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;
-      value_type *pval = reinterpret_cast<value_type *>(v.data);
       get_stored_allocator_noconst_return_t a = this->get_stored_allocator();
-      stored_allocator_traits::construct(a, pval, ::boost::forward<Args>(args)... );
+      stored_allocator_traits::construct(a, move_detail::force_ptr<value_type *>(&v), ::boost::forward<Args>(args)... );
+      value_type *pval = move_detail::force_ptr<value_type *>(&v);
       value_destructor<stored_allocator_type, value_type> d(a, *pval);
       return this->insert_equal(::boost::move(*pval));
    }
@@ -994,9 +996,9 @@ class flat_tree
    {
       //hint checked in insert_equal
       typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;
-      value_type *pval = reinterpret_cast<value_type *>(v.data);
       get_stored_allocator_noconst_return_t a = this->get_stored_allocator();
-      stored_allocator_traits::construct(a, pval, ::boost::forward<Args>(args)... );
+      stored_allocator_traits::construct(a, move_detail::force_ptr<value_type *>(&v), ::boost::forward<Args>(args)... );
+      value_type *pval = move_detail::force_ptr<value_type *>(&v);
       value_destructor<stored_allocator_type, value_type> d(a, *pval);
       return this->insert_equal(hint, ::boost::move(*pval));
    }
@@ -1013,7 +1015,7 @@ class flat_tree
          : this->priv_insert_unique_prepare(hint, k, data);
 
       if(!ret.second){
-         ret.first  = this->nth(data.position - this->cbegin());
+         ret.first  = this->nth(size_type(data.position - this->cbegin()));
       }
       else{
          ret.first = this->m_data.m_seq.emplace(data.position, try_emplace_t(), ::boost::forward<KeyType>(key), ::boost::forward<Args>(args)...);
@@ -1028,9 +1030,9 @@ class flat_tree
    std::pair<iterator, bool> emplace_unique(BOOST_MOVE_UREF##N)\
    {\
       typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;\
-      value_type *pval = reinterpret_cast<value_type *>(v.data);\
       get_stored_allocator_noconst_return_t a = this->get_stored_allocator();\
-      stored_allocator_traits::construct(a, pval BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+      stored_allocator_traits::construct(a, move_detail::force_ptr<value_type *>(&v) BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+      value_type *pval = move_detail::force_ptr<value_type *>(&v);\
       value_destructor<stored_allocator_type, value_type> d(a, *pval);\
       return this->insert_unique(::boost::move(*pval));\
    }\
@@ -1039,9 +1041,9 @@ class flat_tree
    iterator emplace_hint_unique(const_iterator hint BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
    {\
       typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;\
-      value_type *pval = reinterpret_cast<value_type *>(v.data);\
       get_stored_allocator_noconst_return_t a = this->get_stored_allocator();\
-      stored_allocator_traits::construct(a, pval BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+      stored_allocator_traits::construct(a, move_detail::force_ptr<value_type *>(&v) BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+      value_type *pval = move_detail::force_ptr<value_type *>(&v);\
       value_destructor<stored_allocator_type, value_type> d(a, *pval);\
       return this->insert_unique(hint, ::boost::move(*pval));\
    }\
@@ -1050,9 +1052,9 @@ class flat_tree
    iterator emplace_equal(BOOST_MOVE_UREF##N)\
    {\
       typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;\
-      value_type *pval = reinterpret_cast<value_type *>(v.data);\
       get_stored_allocator_noconst_return_t a = this->get_stored_allocator();\
-      stored_allocator_traits::construct(a, pval BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+      stored_allocator_traits::construct(a, move_detail::force_ptr<value_type *>(&v) BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+      value_type *pval = move_detail::force_ptr<value_type *>(&v);\
       value_destructor<stored_allocator_type, value_type> d(a, *pval);\
       return this->insert_equal(::boost::move(*pval));\
    }\
@@ -1061,9 +1063,9 @@ class flat_tree
    iterator emplace_hint_equal(const_iterator hint BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
    {\
       typename dtl::aligned_storage <sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;\
-      value_type *pval = reinterpret_cast<value_type *>(v.data);\
       get_stored_allocator_noconst_return_t a = this->get_stored_allocator();\
-      stored_allocator_traits::construct(a, pval BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+      stored_allocator_traits::construct(a, move_detail::force_ptr<value_type *>(&v) BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+      value_type *pval = move_detail::force_ptr<value_type *>(&v);\
       value_destructor<stored_allocator_type, value_type> d(a, *pval);\
       return this->insert_equal(hint, ::boost::move(*pval));\
    }\
@@ -1079,7 +1081,7 @@ class flat_tree
          : this->priv_insert_unique_prepare(hint, k, data);\
       \
       if(!ret.second){\
-         ret.first  = this->nth(data.position - this->cbegin());\
+         ret.first  = this->nth(size_type(data.position - this->cbegin()));\
       }\
       else{\
          ret.first = this->m_data.m_seq.emplace(data.position, try_emplace_t(), ::boost::forward<KeyType>(key) BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
@@ -1102,7 +1104,7 @@ class flat_tree
          ? this->priv_insert_unique_prepare(k, data)
          : this->priv_insert_unique_prepare(hint, k, data);
       if(!ret.second){
-         ret.first  = this->nth(data.position - this->cbegin());
+         ret.first  = this->nth(size_type(data.position - this->cbegin()));
          ret.first->second = boost::forward<M>(obj);
       }
       else{
@@ -1124,6 +1126,15 @@ class flat_tree
       return ret;
    }
 
+   size_type erase_unique(const key_type& k)
+   {
+      iterator i = this->find(k);
+      size_type ret = static_cast<size_type>(i != this->end());
+      if (ret)
+         this->erase(i);
+      return ret;
+   }
+
    BOOST_CONTAINER_FORCEINLINE iterator erase(const_iterator first, const_iterator last)
    {  return this->m_data.m_seq.erase(first, last);  }
 
@@ -1225,7 +1236,7 @@ class flat_tree
       size_type count(const key_type& k) const
    {
       std::pair<const_iterator, const_iterator> p = this->equal_range(k);
-      size_type n = p.second - p.first;
+      size_type n = size_type(p.second - p.first);
       return n;
    }
 
@@ -1235,7 +1246,7 @@ class flat_tree
       count(const K& k) const
    {
       std::pair<const_iterator, const_iterator> p = this->equal_range(k);
-      size_type n = p.second - p.first;
+      size_type n = size_type(p.second - p.first);
       return n;
    }
 
@@ -1385,15 +1396,15 @@ class flat_tree
 
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
       container_type extract_sequence()
-   {
-      return boost::move(m_data.m_seq);
-   }
+   {  return boost::move(m_data.m_seq);   }
 
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
       container_type &get_sequence_ref()
-   {
-      return m_data.m_seq;
-   }
+   {  return m_data.m_seq; }
+
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+      const container_type &get_sequence_cref() const
+   {  return m_data.m_seq; }
 
    BOOST_CONTAINER_FORCEINLINE void adopt_sequence_equal(BOOST_RV_REF(container_type) seq)
    {
@@ -1579,7 +1590,7 @@ class flat_tree
       while (len) {
          size_type step = len >> 1;
          middle = first;
-         middle += step;
+         middle += difference_type(step);
 
          if (key_cmp(key_extract(*middle), key)) {
             first = ++middle;
@@ -1604,7 +1615,7 @@ class flat_tree
       while (len) {
          size_type step = len >> 1;
          middle = first;
-         middle += step;
+         middle += difference_type(step);
 
          if (key_cmp(key, key_extract(*middle))) {
             len = step;
@@ -1629,7 +1640,7 @@ class flat_tree
       while (len) {
          size_type step = len >> 1;
          middle = first;
-         middle += step;
+         middle += difference_type(step);
 
          if (key_cmp(key_extract(*middle), key)){
             first = ++middle;
@@ -1641,7 +1652,7 @@ class flat_tree
          else {
             //Middle is equal to key
             last = first;
-            last += len;
+            last += difference_type(len);
             RanIt const first_ret = this->priv_lower_bound(first, middle, key);
             return std::pair<RanIt, RanIt>
                ( first_ret, this->priv_upper_bound(++middle, last, key));