passenger 6.2.1 → 6.2.2

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

@@ -0,0 +1,180 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2015. 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_CONSTRUCTIBLE_HPP
+#define BOOST_CONTAINER_DETAIL_IS_CONSTRUCTIBLE_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/detail/workaround.hpp>
+
+#include <cstddef> // for size_t
+#include <boost/move/utility_core.hpp> //declval
+
+namespace boost_container_is_constructible {
+
+   typedef char yes_type;
+   struct no_type { char padding[8]; };
+
+   template<bool Cond, typename T = void> struct enable_if {};
+   template<typename T> struct enable_if<true, T> { typedef T type; };
+   template<typename E, typename T> struct t_enable { typedef T type; };
+
+}  //namespace boost_container_is_constructible {
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_DECLTYPE)
+
+   namespace boost {
+   namespace container {
+
+   template <typename T, typename ...Args>
+   struct is_constructible
+   {
+      private:
+      typedef char yes_type;
+      struct no_type { char padding[8]; };
+
+      template <typename U>
+      static decltype( new U(boost::move_detail::declval<Args>()...), yes_type() ) test(int);
+         
+      template <typename U>
+      static no_type test(...);
+         
+      public:
+      static const bool value = sizeof(test<T>(0)) == sizeof(yes_type);
+   };
+
+   }  //namespace container {
+   }  //namespace boost {
+
+#else //Use macro expansion
+
+   #include <boost/move/detail/fwd_macros.hpp>
+
+   #if defined(BOOST_NO_CXX11_DECLTYPE)
+
+      namespace boost_container_is_constructible {
+
+      //       Example for N == 2
+      //
+      //template <typename T, typename P0, typename P1>
+      //struct is_constructible2
+      //{
+      //    private:
+      //    template<typename U>
+      //    static char test( typename enable_if< (sizeof( new U(boost::move_detail::declval<P0>(), boost::move_detail::declval<P1>()))!= 0), int>::type );
+      //
+      //    template <typename U>
+      //    static no_type test(...);
+      //
+      //    public:
+      //    static const bool value = sizeof(test<T>(0)) == sizeof(yes_type);
+      //};
+      #define BOOST_INTRUSIVE_IS_CONSTRUCTIBLE_IMPL(N) \
+      template <typename T BOOST_MOVE_I##N BOOST_MOVE_CLASS##N>\
+      struct BOOST_MOVE_CAT(is_constructible_impl, N)\
+      {\
+         private:\
+         template <typename U>\
+         static yes_type test( typename enable_if< (sizeof( new U(BOOST_MOVE_DECLVAL##N))!= 0), int>::type );\
+         \
+         template <typename U>\
+         static no_type test(...);\
+         \
+         public:\
+         static const bool value = sizeof(test<T>(0)) == sizeof(yes_type);\
+      };\
+      //
+      BOOST_MOVE_ITERATE_0TO9(BOOST_INTRUSIVE_IS_CONSTRUCTIBLE_IMPL)
+      #undef BOOST_INTRUSIVE_IS_CONSTRUCTIBLE_IMPL
+
+      }//   namespace boost_container_is_constructible {
+
+   #else
+
+      namespace boost_container_is_constructible {
+
+      //       Example for N == 2
+      //
+      //template <typename T, typename P0, typename P1>
+      //struct is_constructible2
+      //{
+      //    private:
+      //    template<typename U, typename E = decltype( new U(boost::move_detail::declval<P0>(), boost::move_detail::declval<P1>()) ) >
+      //    static char test( int );
+      //
+      //    template <typename U>
+      //    static no_type test(...);
+      //
+      //    public:
+      //    static const bool value = sizeof(test<T>(0)) == sizeof(yes_type);
+      //};
+
+      #define BOOST_INTRUSIVE_IS_CONSTRUCTIBLE_IMPL(N) \
+      template <typename T BOOST_MOVE_I##N BOOST_MOVE_CLASS##N>\
+      struct BOOST_MOVE_CAT(is_constructible_impl, N)\
+      {\
+         private:\
+         template <typename U>\
+         static decltype( new U(BOOST_MOVE_DECLVAL##N), yes_type() ) test(int);\
+         \
+         template <typename U>\
+         static no_type test(...);\
+         \
+         public:\
+         static const bool value = sizeof(test<T>(0)) == sizeof(yes_type);\
+      };\
+      //
+      BOOST_MOVE_ITERATE_0TO9(BOOST_INTRUSIVE_IS_CONSTRUCTIBLE_IMPL)
+      #undef BOOST_INTRUSIVE_IS_CONSTRUCTIBLE_IMPL
+
+      }//   namespace boost_container_is_constructible {
+
+   #endif
+
+      namespace boost {
+      namespace container {
+
+      template<class T, BOOST_MOVE_CLASSDFLT9, class = void>
+      struct is_constructible;
+
+      //       Example for N == 2
+      //
+      //template <typename T, typename P0, typename P1>
+      //struct is_constructible
+      //  <T, P0, P1>
+      //    : boost_container_is_constructible::is_constructible_impl2<T, P0, P1>
+      //{};
+
+      #define BOOST_INTRUSIVE_IS_CONSTRUCTIBLE(N) \
+         template <typename T BOOST_MOVE_I##N BOOST_MOVE_CLASS##N>\
+         struct is_constructible\
+            <T BOOST_MOVE_I##N BOOST_MOVE_TARG##N>\
+            : boost_container_is_constructible::is_constructible_impl##N<T BOOST_MOVE_I##N BOOST_MOVE_TARG##N>\
+         {};\
+         //
+      BOOST_MOVE_ITERATE_0TO9(BOOST_INTRUSIVE_IS_CONSTRUCTIBLE)
+      #undef BOOST_INTRUSIVE_IS_CONSTRUCTIBLE
+
+      }  //namespace container {
+      }  //namespace boost {
+
+#endif
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif   //BOOST_CONTAINER_DETAIL_IS_CONSTRUCTIBLE_HPP

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

@@ -248,10 +248,11 @@ class value_init_construct_iterator
 
    //This pseudo-iterator's dereference operations have no sense since value is not
    //constructed until ::boost::container::construct_in_place is called.
-   //So comment them to catch bad uses
-   //const T& operator*() const;
+   // 
    //const T& operator[](difference_type) const;
    //const T* operator->() const;
+   inline const value_init_t& operator*() const
+   {  return value_init;  }
 
    private:
    std::size_t  m_num;

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

@@ -167,6 +167,18 @@ struct lcm_ct
    BOOST_STATIC_CONSTEXPR std::size_t value = I1 * I2 / gcd_ct<I1, I2>::value;
 };
 
+template <std::size_t N, std::size_t Count = 0>
+struct log2_pow2
+{
+    BOOST_STATIC_CONSTEXPR std::size_t value = log2_pow2<(N >> 1), Count + 1>::value;
+};
+
+// Base case: we've reached 1
+template <std::size_t Count>
+struct log2_pow2<1, Count> {
+    BOOST_STATIC_CONSTEXPR std::size_t value = Count;
+};
+
 } // namespace dtl
 } // namespace container
 } // namespace boost

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

@@ -63,6 +63,22 @@ using boost::move_detail::enable_if_or;
 using boost::move_detail::disable_if_or;
 using boost::move_detail::remove_const;
 
+//Equivalent to C++20 std::type_identity. Its only purpose is to put its
+//template argument in a non-deduced context. It is used for the allocator
+//argument of allocator-extended copy/move constructors so that class template
+//argument deduction is driven by the source container and not by the allocator
+//argument.
+template<typename T>
+struct type_identity
+{
+   typedef T type;
+};
+
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+template<typename T>
+using type_identity_t = typename type_identity<T>::type;
+#endif
+
 template <class FirstType>
 struct select1st
 {

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

@@ -114,7 +114,7 @@
 
    /* How to yield for a spin lock */
    #define SPINS_PER_YIELD       63
-   #if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
+   #if !defined(__CYGWIN__) && (defined(_WIN32) || defined(__WIN32__) || defined(WIN32))
       #if !defined( BOOST_USE_WINDOWS_H )
          #if defined (WIN32_PLATFORM_PSPC)
             #define BOOST_CONTAINERWINAPI_IMPORT BOOST_SYMBOL_IMPORT

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

@@ -84,10 +84,18 @@ inline void clamp_by_stored_size_type(SizeType &, SizeType)
 template<class SizeType, class SomeStoredSizeType>
 inline void clamp_by_stored_size_type(SizeType &s, SomeStoredSizeType)
 {
-   if (s >= SomeStoredSizeType(-1) ) 
+   if (s > SomeStoredSizeType(-1) ) 
       s = SomeStoredSizeType(-1);
 }
 
+template<class SizeType, class SomeStoredSizeType>
+inline void clamp_by_half_stored_size_type(SizeType &s, SomeStoredSizeType)
+{
+   const SizeType half_max = SizeType(SomeStoredSizeType(-1)) >> 1u;
+   if (s > half_max ) 
+      s = half_max;
+}
+
 }  //namespace container {
 }  //namespace boost {
 

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

@@ -38,7 +38,10 @@ namespace dtl {
 //!a reference count but the class does not delete itself, this is
 //!responsibility of user classes. Node size (NodeSize) and the number of
 //!nodes allocated per block (NodesPerBlock) are known at compile time
-template< std::size_t NodeSize, std::size_t NodesPerBlock >
+template< std::size_t NodeSize
+        , std::size_t NodesPerBlock
+        , std::size_t NodeAlign
+        >
 class private_node_pool
    //Inherit from the implementation to avoid template bloat
    :  public boost::container::dtl::
@@ -56,27 +59,28 @@ class private_node_pool
 
    //!Constructor from a segment manager. Never throws
    private_node_pool()
-      :  base_t(0, NodeSize, NodesPerBlock)
+      :  base_t(0, NodeSize, NodesPerBlock, NodeAlign)
    {}
 
 };
 
 template< std::size_t NodeSize
         , std::size_t NodesPerBlock
+        , std::size_t NodeAlign
         >
 class shared_node_pool
-   : public private_node_pool<NodeSize, NodesPerBlock>
+   : public private_node_pool<NodeSize, NodesPerBlock, NodeAlign>
 {
    private:
-   typedef private_node_pool<NodeSize, NodesPerBlock> private_node_allocator_t;
+   typedef private_node_pool<NodeSize, NodesPerBlock, NodeAlign> private_node_pool_t;
 
    public:
-   typedef typename private_node_allocator_t::free_nodes_t  free_nodes_t;
-   typedef typename private_node_allocator_t::multiallocation_chain multiallocation_chain;
+   typedef typename private_node_pool_t::free_nodes_t  free_nodes_t;
+   typedef typename private_node_pool_t::multiallocation_chain multiallocation_chain;
 
    //!Constructor from a segment manager. Never throws
    shared_node_pool()
-   : private_node_allocator_t(){}
+   : private_node_pool_t(){}
 
    //!Destructor. Deallocates all allocated blocks. Never throws
    ~shared_node_pool()
@@ -88,7 +92,7 @@ class shared_node_pool
       //-----------------------
       scoped_lock<default_mutex> guard(mutex_);
       //-----------------------
-      return private_node_allocator_t::allocate_node();
+      return private_node_pool_t::allocate_node();
    }
 
    //!Deallocates an array pointed by ptr. Never throws
@@ -97,7 +101,7 @@ class shared_node_pool
       //-----------------------
       scoped_lock<default_mutex> guard(mutex_);
       //-----------------------
-      private_node_allocator_t::deallocate_node(ptr);
+      private_node_pool_t::deallocate_node(ptr);
    }
 
    //!Allocates a singly linked list of n nodes ending in null pointer.
@@ -107,7 +111,7 @@ class shared_node_pool
       //-----------------------
       scoped_lock<default_mutex> guard(mutex_);
       //-----------------------
-      return private_node_allocator_t::allocate_nodes(n, chain);
+      return private_node_pool_t::allocate_nodes(n, chain);
    }
 
    void deallocate_nodes(multiallocation_chain &chain)
@@ -115,7 +119,7 @@ class shared_node_pool
       //-----------------------
       scoped_lock<default_mutex> guard(mutex_);
       //-----------------------
-      private_node_allocator_t::deallocate_nodes(chain);
+      private_node_pool_t::deallocate_nodes(chain);
    }
 
    //!Deallocates all the free blocks of memory. Never throws
@@ -124,7 +128,7 @@ class shared_node_pool
       //-----------------------
       scoped_lock<default_mutex> guard(mutex_);
       //-----------------------
-      private_node_allocator_t::deallocate_free_blocks();
+      private_node_pool_t::deallocate_free_blocks();
    }
 
    //!Deallocates all blocks. Never throws
@@ -133,7 +137,7 @@ class shared_node_pool
       //-----------------------
       scoped_lock<default_mutex> guard(mutex_);
       //-----------------------
-      private_node_allocator_t::purge_blocks();
+      private_node_pool_t::purge_blocks();
    }
 
    std::size_t num_free_nodes()
@@ -141,7 +145,7 @@ class shared_node_pool
       //-----------------------
       scoped_lock<default_mutex> guard(mutex_);
       //-----------------------
-      return private_node_allocator_t::num_free_nodes();
+      return private_node_pool_t::num_free_nodes();
    }
 
    private: