passenger 5.3.3 → 5.3.4

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

@@ -0,0 +1,55 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2017-2017. 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)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_CONTAINER_DETAIL_IS_CONTAINER_HPP
+#define BOOST_CONTAINER_DETAIL_IS_CONTAINER_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+//empty
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME empty
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG namespace boost { namespace container { namespace is_container_detail {
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END   }}}
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN 0
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX 0
+#include <boost/intrusive/detail/has_member_function_callable_with.hpp>
+
+//size
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME size
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG namespace boost { namespace container { namespace is_container_detail {
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END   }}}
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN 0
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX 0
+#include <boost/intrusive/detail/has_member_function_callable_with.hpp>
+
+namespace boost {
+namespace container {
+namespace dtl {
+
+template <class Container>
+struct is_container
+{
+   static const bool value =
+      boost::container::is_container_detail::
+         has_member_function_callable_with_size <const Container>::value &&
+      boost::container::is_container_detail::
+         has_member_function_callable_with_empty<const Container>::value;
+};
+
+}  //namespace dtl {
+}  //namespace container {
+}  //namespace boost {
+
+#endif   //#ifndef BOOST_CONTAINER_DETAIL_IS_CONTAINER_HPP

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

@@ -0,0 +1,47 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2017-2017. 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)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_CONTAINER_DETAIL_IS_CONTIGUOUS_CONTAINER_HPP
+#define BOOST_CONTAINER_DETAIL_IS_CONTIGUOUS_CONTAINER_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+//data
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME data
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG namespace boost { namespace container { namespace is_contiguous_container_detail {
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END   }}}
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN 0
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX 0
+#include <boost/intrusive/detail/has_member_function_callable_with.hpp>
+
+namespace boost {
+namespace container {
+namespace dtl {
+
+template <class Container>
+struct is_contiguous_container
+{
+   static const bool value =
+      boost::container::is_contiguous_container_detail::
+         has_member_function_callable_with_data<Container>::value && 
+      boost::container::is_contiguous_container_detail::
+         has_member_function_callable_with_data<const Container>::value;
+};
+
+}  //namespace dtl {
+}  //namespace container {
+}  //namespace boost {
+
+#endif   //#ifndef BOOST_CONTAINER_DETAIL_IS_CONTIGUOUS_CONTAINER_HPP

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

@@ -20,7 +20,7 @@
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
 template <class ForwardIterator, class Pred>
 bool is_sorted (ForwardIterator first, ForwardIterator last, Pred pred)
@@ -50,7 +50,7 @@ bool is_sorted_and_unique (ForwardIterator first, ForwardIterator last, Pred pre
    return true;
 }
 
-}  //namespace container_detail {
+}  //namespace dtl {
 }  //namespace container {
 }  //namespace boost {
 

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

@@ -22,6 +22,7 @@
 #endif
 
 #include <boost/intrusive/detail/iterator.hpp>
+#include <boost/move/utility_core.hpp>
 
 namespace boost {
 namespace container {
@@ -34,6 +35,35 @@ using ::boost::intrusive::iterator_enable_if_tag;
 using ::boost::intrusive::iterator_disable_if_tag;
 using ::boost::intrusive::iterator_arrow_result;
 
+template <class Container>
+class back_emplacer
+{
+   private:
+   Container& container;
+
+   public:
+   typedef std::output_iterator_tag iterator_category;
+   typedef void                     value_type;
+   typedef void                     difference_type;
+   typedef void                     pointer;
+   typedef void                     reference;
+
+   back_emplacer(Container& x)
+      : container(x)
+   {}
+
+   template<class U>
+   back_emplacer& operator=(BOOST_FWD_REF(U) value)
+   {
+      container.emplace_back(boost::forward<U>(value));
+      return *this;
+   }
+   back_emplacer& operator*()    { return *this; }
+   back_emplacer& operator++()   { return *this; }
+   back_emplacer& operator++(int){ return *this; }
+};
+
+
 }  //namespace container {
 }  //namespace boost {
 

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

@@ -18,40 +18,15 @@
 #  pragma once
 #endif
 
-#include <boost/container/detail/iterator.hpp>
-#include <boost/container/detail/to_raw_pointer.hpp>
-#include <boost/intrusive/pointer_traits.hpp>
+#include <boost/move/detail/iterator_to_raw_pointer.hpp>
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
-template <class T>
-inline T* iterator_to_pointer(T* i)
-{  return i; }
+using ::boost::movelib::iterator_to_raw_pointer;
 
-template <class Iterator>
-inline typename boost::container::iterator_traits<Iterator>::pointer
-   iterator_to_pointer(const Iterator &i)
-{  return i.operator->();  }
-
-template <class Iterator>
-struct iterator_to_element_ptr
-{
-   typedef typename boost::container::iterator_traits<Iterator>::pointer      pointer;
-   typedef typename boost::intrusive::pointer_traits<pointer>::element_type   element_type;
-   typedef element_type* type;
-};
-
-template <class Iterator>
-inline typename iterator_to_element_ptr<Iterator>::type
-   iterator_to_raw_pointer(const Iterator &i)
-{
-   return ::boost::intrusive::detail::to_raw_pointer
-      (  ::boost::container::container_detail::iterator_to_pointer(i)   );
-}
-
-}  //namespace container_detail {
+}  //namespace dtl {
 }  //namespace container {
 }  //namespace boost {
 

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

@@ -612,7 +612,7 @@ class emplace_iterator
 template<class ...Args>
 struct emplace_functor
 {
-   typedef typename container_detail::build_number_seq<sizeof...(Args)>::type index_tuple_t;
+   typedef typename dtl::build_number_seq<sizeof...(Args)>::type index_tuple_t;
 
    emplace_functor(BOOST_FWD_REF(Args)... args)
       : args_(args...)
@@ -628,21 +628,21 @@ struct emplace_functor
 
    private:
    template<class Allocator, class T, std::size_t ...IdxPack>
-   BOOST_CONTAINER_FORCEINLINE void inplace_impl(Allocator &a, T* ptr, const container_detail::index_tuple<IdxPack...>&)
+   BOOST_CONTAINER_FORCEINLINE void inplace_impl(Allocator &a, T* ptr, const dtl::index_tuple<IdxPack...>&)
    {
       allocator_traits<Allocator>::construct
-         (a, ptr, ::boost::forward<Args>(container_detail::get<IdxPack>(args_))...);
+         (a, ptr, ::boost::forward<Args>(dtl::get<IdxPack>(args_))...);
    }
 
    template<class DestIt, std::size_t ...IdxPack>
-   BOOST_CONTAINER_FORCEINLINE void inplace_impl(DestIt dest, const container_detail::index_tuple<IdxPack...>&)
+   BOOST_CONTAINER_FORCEINLINE void inplace_impl(DestIt dest, const dtl::index_tuple<IdxPack...>&)
    {
       typedef typename boost::container::iterator_traits<DestIt>::value_type value_type;
-      value_type && tmp= value_type(::boost::forward<Args>(container_detail::get<IdxPack>(args_))...);
+      value_type && tmp= value_type(::boost::forward<Args>(dtl::get<IdxPack>(args_))...);
       *dest = ::boost::move(tmp);
    }
 
-   container_detail::tuple<Args&...> args_;
+   dtl::tuple<Args&...> args_;
 };
 
 template<class ...Args>
@@ -672,7 +672,7 @@ struct emplace_functor##N\
    void operator()(DestIt dest)\
    {\
       typedef typename boost::container::iterator_traits<DestIt>::value_type value_type;\
-      BOOST_MOVE_IF(N, value_type tmp(BOOST_MOVE_MFWD##N), container_detail::value_init<value_type> tmp) ;\
+      BOOST_MOVE_IF(N, value_type tmp(BOOST_MOVE_MFWD##N), dtl::value_init<value_type> tmp) ;\
       *dest = ::boost::move(const_cast<value_type &>(BOOST_MOVE_IF(N, tmp, tmp.get())));\
    }\
    \
@@ -692,7 +692,7 @@ BOOST_MOVE_ITERATE_0TO9(BOOST_MOVE_ITERATOR_EMPLACE_FUNCTOR_CODE)
 
 #endif
 
-namespace container_detail {
+namespace dtl {
 
 template<class T>
 struct has_iterator_category
@@ -863,7 +863,7 @@ class iterator_from_iiterator
    IIterator m_iit;
 };
 
-}  //namespace container_detail {
+}  //namespace dtl {
 
 using ::boost::intrusive::reverse_iterator;
 

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

@@ -32,7 +32,7 @@
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
 // Greatest common divisor and least common multiple
 
@@ -114,7 +114,7 @@ inline std::size_t floor_log2 (std::size_t x)
    return log2;
 }
 
-} // namespace container_detail
+} // namespace dtl
 } // namespace container
 } // namespace boost
 

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

@@ -20,7 +20,7 @@
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
 template<class T>
 const T &max_value(const T &a, const T &b)
@@ -30,7 +30,7 @@ template<class T>
 const T &min_value(const T &a, const T &b)
 {  return a < b ? a : b;   }
 
-}  //namespace container_detail {
+}  //namespace dtl {
 }  //namespace container {
 }  //namespace boost {
 

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

@@ -30,7 +30,7 @@
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
 using boost::move_detail::integral_constant;
 using boost::move_detail::true_type;
@@ -76,7 +76,7 @@ struct select1st
    {  return const_cast<type&>(x.first);   }
 };
 
-}  //namespace container_detail {
+}  //namespace dtl {
 }  //namespace container {
 }  //namespace boost {
 

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

@@ -24,7 +24,7 @@
 // container
 #include <boost/container/container_fwd.hpp>
 // container/detail
-#include <boost/container/detail/to_raw_pointer.hpp>
+#include <boost/move/detail/to_raw_pointer.hpp>
 #include <boost/container/detail/transform_iterator.hpp>
 #include <boost/container/detail/type_traits.hpp>
 // intrusive
@@ -35,7 +35,7 @@
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
 template<class VoidPointer>
 class basic_multiallocation_chain
@@ -53,7 +53,7 @@ class basic_multiallocation_chain
    typedef bi::slist< node
                     , bi::linear<true>
                     , bi::cache_last<true>
-                    , bi::size_type<typename boost::container::container_detail::make_unsigned<difference_type>::type>
+                    , bi::size_type<typename boost::container::dtl::make_unsigned<difference_type>::type>
                     > slist_impl_t;
    slist_impl_t slist_impl_;
 
@@ -63,7 +63,7 @@ class basic_multiallocation_chain
       pointer_traits<node_ptr>                              node_ptr_traits;
 
    static node & to_node(const VoidPointer &p)
-   {  return *static_cast<node*>(static_cast<void*>(container_detail::to_raw_pointer(p)));  }
+   {  return *static_cast<node*>(static_cast<void*>(boost::movelib::to_raw_pointer(p)));  }
 
    static VoidPointer from_node(node &n)
    {  return node_ptr_traits::pointer_to(n);  }
@@ -152,7 +152,7 @@ class basic_multiallocation_chain
          char_ptr prev_elem = elem;
          elem += unit_bytes;
          for(size_type i = 0; i != num_units-1; ++i, elem += unit_bytes){
-            ::new (container_detail::to_raw_pointer(prev_elem)) void_pointer(elem);
+            ::new (boost::movelib::to_raw_pointer(prev_elem)) void_pointer(elem);
             prev_elem = elem;
          }
          slist_impl_.incorporate_after(after_this, to_node_ptr(b), to_node_ptr(prev_elem), num_units);
@@ -182,7 +182,7 @@ class basic_multiallocation_chain
 template<class T>
 struct cast_functor
 {
-   typedef typename container_detail::add_reference<T>::type result_type;
+   typedef typename dtl::add_reference<T>::type result_type;
    template<class U>
    result_type operator()(U &ptr) const
    {  return *static_cast<T*>(static_cast<void*>(&ptr));  }
@@ -211,7 +211,7 @@ class transform_multiallocation_chain
    public:
    typedef transform_iterator
       < typename MultiallocationChain::iterator
-      , container_detail::cast_functor <T> >             iterator;
+      , dtl::cast_functor <T> >             iterator;
    typedef typename MultiallocationChain::size_type      size_type;
 
    transform_multiallocation_chain()
@@ -289,7 +289,7 @@ class transform_multiallocation_chain
 
 }}}
 
-// namespace container_detail {
+// namespace dtl {
 // namespace container {
 // namespace boost {
 

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

@@ -171,7 +171,7 @@
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
 #if BOOST_MUTEX_HELPER == BOOST_MUTEX_HELPER_NONE
    class null_mutex
@@ -268,7 +268,7 @@ class scoped_lock
    Mutex &m_;
 };
 
-} // namespace container_detail
+} // namespace dtl
 } // namespace container
 } // namespace boost
 

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

@@ -23,52 +23,54 @@
 // container/detail
 #include <boost/container/detail/min_max.hpp>
 
+#include <boost/static_assert.hpp>
+
 namespace boost {
 namespace container {
-namespace container_detail {
-
-enum NextCapacityOption { NextCapacityDouble, NextCapacity60Percent };
-
-template<class SizeType, NextCapacityOption Option>
-struct next_capacity_calculator;
+namespace dtl {
 
-template<class SizeType>
-struct next_capacity_calculator<SizeType, NextCapacityDouble>
+template<unsigned Minimum, unsigned Numerator, unsigned Denominator>
+struct grow_factor_ratio
 {
-   static SizeType get(const SizeType max_size
-                      ,const SizeType capacity
-                      ,const SizeType n)
-   {
-      const SizeType remaining = max_size - capacity;
-      if ( remaining < n )
-         boost::container::throw_length_error("get_next_capacity, allocator's max_size reached");
-      const SizeType additional = max_value(n, capacity);
-      return ( remaining < additional ) ? max_size : ( capacity + additional );
-   }
-};
+   BOOST_STATIC_ASSERT(Numerator > Denominator);
+   BOOST_STATIC_ASSERT(Numerator   < 100);
+   BOOST_STATIC_ASSERT(Denominator < 100);
+   BOOST_STATIC_ASSERT(Denominator == 1 || (0 != Numerator % Denominator));
 
-template<class SizeType>
-struct next_capacity_calculator<SizeType, NextCapacity60Percent>
-{
-   static SizeType get(const SizeType max_size
-                     ,const SizeType capacity
-                     ,const SizeType n)
+   template<class SizeType>
+   SizeType operator()(const SizeType cur_cap, const SizeType add_min_cap, const SizeType max_cap) const
    {
-      const SizeType remaining = max_size - capacity;
-      if ( remaining < n )
-         boost::container::throw_length_error("get_next_capacity, allocator's max_size reached");
-      const SizeType m3 = max_size/3;
+      const SizeType overflow_limit  = ((SizeType)-1) / Numerator;
 
-      if (capacity < m3)
-         return capacity + max_value(3*(capacity+1)/5, n);
+      SizeType new_cap = 0;
 
-      if (capacity < m3*2)
-         return capacity + max_value((capacity+1)/2, n);
-      return max_size;
+      if(cur_cap <= overflow_limit){
+         new_cap = cur_cap * Numerator / Denominator;
+      }
+      else if(Denominator == 1 || (SizeType(new_cap = cur_cap) / Denominator) > overflow_limit){
+         new_cap = (SizeType)-1;
+      }
+      else{
+         new_cap *= Numerator;
+      }
+      return max_value(SizeType(Minimum), max_value(cur_cap+add_min_cap, min_value(max_cap, new_cap)));
    }
 };
 
-}  //namespace container_detail {
+}  //namespace dtl {
+
+struct growth_factor_50
+   : dtl::grow_factor_ratio<0, 3, 2>
+{};
+
+struct growth_factor_60
+   : dtl::grow_factor_ratio<0, 8, 5>
+{};
+
+struct growth_factor_100
+   : dtl::grow_factor_ratio<0, 2, 1>
+{};
+
 }  //namespace container {
 }  //namespace boost {