passenger 5.3.3 → 5.3.4

data/src/cxx_supportlib/vendor-modified/boost/integer/integer_mask.hpp

@@ -57,19 +57,27 @@ struct high_bit_mask_t
 //  Makes masks for the lowest N bits
 //  (Specializations are needed when N fills up a type.)
 
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4310)  // cast truncates constant value
+#endif
+
 template < std::size_t Bits >
 struct low_bits_mask_t
 {
     typedef typename uint_t<Bits>::least  least;
     typedef typename uint_t<Bits>::fast   fast;
 
-    BOOST_STATIC_CONSTANT( least, sig_bits = (~( ~(least( 0u )) << Bits )) );
+    BOOST_STATIC_CONSTANT( least, sig_bits = least(~(least(~(least( 0u ))) << Bits )) );
     BOOST_STATIC_CONSTANT( fast, sig_bits_fast = fast(sig_bits) );
 
     BOOST_STATIC_CONSTANT( std::size_t, bit_count = Bits );
 
 };  // boost::low_bits_mask_t
 
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
 
 #define BOOST_LOW_BITS_MASK_SPECIALIZE( Type )                                  \
   template <  >  struct low_bits_mask_t< std::numeric_limits<Type>::digits >  { \

data/src/cxx_supportlib/vendor-modified/boost/integer_fwd.hpp

@@ -159,6 +159,8 @@ template <static_min_max_unsigned_type Value1, static_min_max_unsigned_type Valu
     struct static_unsigned_max;
 
 
+namespace integer
+{
 //  From <boost/integer/common_factor_ct.hpp>
 
 #ifdef BOOST_NO_INTEGRAL_INT64_T
@@ -180,6 +182,7 @@ template < typename IntegerType >
 template < typename IntegerType >
     class lcm_evaluator;
 
+} // namespace integer
 
 }  // namespace boost
 

data/src/cxx_supportlib/vendor-modified/boost/intrusive/bstree.hpp

@@ -255,7 +255,8 @@ struct get_key_of_value<void, T>
 template<class ValuePtr, class VoidOrKeyOfValue, class VoidOrKeyComp>
 struct bst_key_types
 {
-   typedef typename pointer_element<ValuePtr>::type   value_type;
+   typedef typename
+      boost::movelib::pointer_element<ValuePtr>::type value_type;
    typedef typename get_key_of_value
       < VoidOrKeyOfValue, value_type>::type           key_of_value;
    typedef typename key_of_value::type                key_type;
@@ -724,15 +725,22 @@ class bstree_impl
          this->insert_equal(b, e);
    }
 
-   //! <b>Effects</b>: to-do
+   //! <b>Effects</b>: Constructs a container moving resources from another container.
+   //!   Internal comparison object and value traits are move constructed and
+   //!   nodes belonging to x (except the node representing the "end") are linked to *this.
    //!
+   //! <b>Complexity</b>: Constant.
+   //!
+   //! <b>Throws</b>: If value_traits::node_traits::node's
+   //!   move constructor throws (this does not happen with predefined Boost.Intrusive hooks)
+   //!   or the move constructor of the comparison objet throws.
    bstree_impl(BOOST_RV_REF(bstree_impl) x)
       : data_type(::boost::move(x.comp()), ::boost::move(x.get_value_traits()))
    {
       this->swap(x);
    }
 
-   //! <b>Effects</b>: to-do
+   //! <b>Effects</b>: Equivalent to swap
    //!
    BOOST_INTRUSIVE_FORCEINLINE bstree_impl& operator=(BOOST_RV_REF(bstree_impl) x)
    {  this->swap(x); return *this;  }

data/src/cxx_supportlib/vendor-modified/boost/intrusive/circular_list_algorithms.hpp

@@ -69,7 +69,7 @@ class circular_list_algorithms
    //! <b>Throws</b>: Nothing.
    BOOST_INTRUSIVE_FORCEINLINE static void init(const node_ptr &this_node)
    {
-      const node_ptr null_node((node_ptr()));
+      const node_ptr null_node = node_ptr();
       NodeTraits::set_next(this_node, null_node);
       NodeTraits::set_previous(this_node, null_node);
    }

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/config_begin.hpp

@@ -17,33 +17,20 @@
 #ifdef BOOST_MSVC
 
    #pragma warning (push)
-   //
-   //'function' : resolved overload was found by argument-dependent lookup
-   //A function found by argument-dependent lookup (Koenig lookup) was eventually
-   //chosen by overload resolution.
-   //
-   //In Visual C++ .NET and earlier compilers, a different function would have
-   //been called. To pick the original function, use an explicitly qualified name.
-   //
-
-   //warning C4275: non dll-interface class 'x' used as base for
-   //dll-interface class 'Y'
-   #pragma warning (disable : 4275)
-   //warning C4251: 'x' : class 'y' needs to have dll-interface to
-   //be used by clients of class 'z'
-   #pragma warning (disable : 4251)
-   #pragma warning (disable : 4675)
-   #pragma warning (disable : 4996)
-   #pragma warning (disable : 4503)
+   #pragma warning (disable : 4275) // non DLL-interface classkey "identifier" used as base for DLL-interface classkey "identifier"
+   #pragma warning (disable : 4251) // "identifier" : class "type" needs to have dll-interface to be used by clients of class "type2"
+   #pragma warning (disable : 4675) // "method" should be declared "static" and have exactly one parameter
+   #pragma warning (disable : 4996) // "function": was declared deprecated
+   #pragma warning (disable : 4503) // "identifier" : decorated name length exceeded, name was truncated
    #pragma warning (disable : 4284) // odd return type for operator->
    #pragma warning (disable : 4244) // possible loss of data
    #pragma warning (disable : 4521) ////Disable "multiple copy constructors specified"
    #pragma warning (disable : 4127) //conditional expression is constant
-   #pragma warning (disable : 4146)
+   #pragma warning (disable : 4146) // unary minus operator applied to unsigned type, result still unsigned
    #pragma warning (disable : 4267) //conversion from 'X' to 'Y', possible loss of data
    #pragma warning (disable : 4541) //'typeid' used on polymorphic type 'boost::exception' with /GR-
    #pragma warning (disable : 4512) //'typeid' used on polymorphic type 'boost::exception' with /GR-
-   #pragma warning (disable : 4522)
+   #pragma warning (disable : 4522) // "class" : multiple assignment operators specified
    #pragma warning (disable : 4706) //assignment within conditional expression
    #pragma warning (disable : 4710) // function not inlined
    #pragma warning (disable : 4714) // "function": marked as __forceinline not inlined

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/default_header_holder.hpp

@@ -23,7 +23,7 @@
 
 #include <boost/intrusive/detail/workaround.hpp>
 #include <boost/intrusive/pointer_traits.hpp>
-#include <boost/intrusive/detail/to_raw_pointer.hpp>
+#include <boost/move/detail/to_raw_pointer.hpp>
 
 namespace boost {
 namespace intrusive {
@@ -48,7 +48,7 @@ struct default_header_holder : public NodeTraits::node
 
    // (unsafe) downcast used to implement container-from-iterator
    BOOST_INTRUSIVE_FORCEINLINE static default_header_holder* get_holder(const node_ptr &p)
-   { return static_cast< default_header_holder* >(boost::intrusive::detail::to_raw_pointer(p)); }
+   { return static_cast< default_header_holder* >(boost::movelib::to_raw_pointer(p)); }
 };
 
 // type function producing the header node holder

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/ebo_functor_holder.hpp

@@ -35,7 +35,7 @@ namespace detail {
 #define BOOST_INTRUSIVE_TT_DECL
 #endif
 
-#if defined(_MSC_EXTENSIONS) && !defined(__BORLAND__) && !defined(_WIN64) && !defined(_M_ARM) && !defined(UNDER_CE)
+#if defined(_MSC_EXTENSIONS) && !defined(__BORLAND__) && !defined(_WIN64) && !defined(_M_ARM) && !defined(_M_ARM64) && !defined(UNDER_CE)
 #define BOOST_INTRUSIVE_TT_TEST_MSC_FUNC_SIGS
 #endif
 

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/hashtable_node.hpp

@@ -246,7 +246,7 @@ class hashtable_iterator
    void increment()
    {
       const bucket_traits &rbuck_traits = this->priv_bucket_traits();
-      bucket_type* const buckets = boost::intrusive::detail::to_raw_pointer(rbuck_traits.bucket_begin());
+      bucket_type* const buckets = boost::movelib::to_raw_pointer(rbuck_traits.bucket_begin());
       const size_type buckets_len = rbuck_traits.bucket_count();
 
       ++slist_it_;

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/hook_traits.hpp

@@ -26,7 +26,7 @@
 #include <boost/intrusive/detail/parent_from_member.hpp>
 #include <boost/intrusive/link_mode.hpp>
 #include <boost/intrusive/detail/mpl.hpp>
-#include <boost/intrusive/detail/to_raw_pointer.hpp>
+#include <boost/move/detail/to_raw_pointer.hpp>
 #include <boost/intrusive/detail/node_holder.hpp>
 
 namespace boost {
@@ -128,14 +128,14 @@ struct mhtraits
    {
       return pointer_traits<pointer>::pointer_to
          (*detail::parent_from_member<T, Hook>
-            (static_cast<Hook*>(boost::intrusive::detail::to_raw_pointer(n)), P));
+            (static_cast<Hook*>(boost::movelib::to_raw_pointer(n)), P));
    }
 
    BOOST_INTRUSIVE_FORCEINLINE static const_pointer to_value_ptr(const const_node_ptr & n)
    {
       return pointer_traits<const_pointer>::pointer_to
          (*detail::parent_from_member<T, Hook>
-            (static_cast<const Hook*>(boost::intrusive::detail::to_raw_pointer(n)), P));
+            (static_cast<const Hook*>(boost::movelib::to_raw_pointer(n)), P));
    }
 };
 
@@ -161,10 +161,10 @@ struct fhtraits
    static const link_mode_type link_mode = hook_type::hooktags::link_mode;
 
    static node_ptr to_node_ptr(reference value)
-   {  return static_cast<node*>(boost::intrusive::detail::to_raw_pointer(Functor::to_hook_ptr(value)));  }
+   {  return static_cast<node*>(boost::movelib::to_raw_pointer(Functor::to_hook_ptr(value)));  }
 
    static const_node_ptr to_node_ptr(const_reference value)
-   {  return static_cast<const node*>(boost::intrusive::detail::to_raw_pointer(Functor::to_hook_ptr(value)));  }
+   {  return static_cast<const node*>(boost::movelib::to_raw_pointer(Functor::to_hook_ptr(value)));  }
 
    static pointer to_value_ptr(const node_ptr & n)
    {  return Functor::to_value_ptr(to_hook_ptr(n));  }

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

@@ -27,6 +27,24 @@
 #include <boost/move/detail/iterator_traits.hpp>
 #include <boost/move/detail/meta_utils_core.hpp>
 
+namespace boost{
+namespace iterators{
+
+struct incrementable_traversal_tag;
+struct single_pass_traversal_tag;
+struct forward_traversal_tag;
+struct bidirectional_traversal_tag;
+struct random_access_traversal_tag;
+
+namespace detail{
+
+template <class Category, class Traversal>
+struct iterator_category_with_traversal;
+
+} //namespace boost{
+} //namespace iterators{
+} //namespace detail{
+
 namespace boost {
 namespace intrusive {
 
@@ -45,6 +63,28 @@ struct iterator
    typedef Reference    reference;
 };
 
+////////////////////////////////////////
+//    iterator_[dis|en]able_if_boost_iterator
+////////////////////////////////////////
+template<class I>
+struct is_boost_iterator
+{
+   static const bool value = false;
+};
+
+template<class Category, class Traversal>
+struct is_boost_iterator< boost::iterators::detail::iterator_category_with_traversal<Category, Traversal> >
+{
+   static const bool value = true;
+};
+
+template<class I, class R = void>
+struct iterator_enable_if_boost_iterator
+   : ::boost::move_detail::enable_if_c
+      < is_boost_iterator<typename boost::intrusive::iterator_traits<I>::iterator_category >::value
+      , R>
+{};
+
 ////////////////////////////////////////
 //    iterator_[dis|en]able_if_tag
 ////////////////////////////////////////
@@ -68,6 +108,23 @@ struct iterator_disable_if_tag
          , R>
 {};
 
+////////////////////////////////////////
+//    iterator_[dis|en]able_if_tag
+////////////////////////////////////////
+template<class I, class Tag, class Tag2, class R = void>
+struct iterator_enable_if_convertible_tag
+   : ::boost::move_detail::enable_if_c
+      < ::boost::move_detail::is_same_or_convertible
+         < typename boost::intrusive::iterator_traits<I>::iterator_category 
+         , Tag
+         >::value &&
+        !::boost::move_detail::is_same_or_convertible
+         < typename boost::intrusive::iterator_traits<I>::iterator_category 
+         , Tag2
+         >::value
+         , R>
+{};
+
 ////////////////////////////////////////
 //    iterator_[dis|en]able_if_tag_difference_type
 ////////////////////////////////////////
@@ -84,8 +141,9 @@ struct iterator_disable_if_tag_difference_type
 ////////////////////
 //    advance
 ////////////////////
+
 template<class InputIt, class Distance>
-typename iterator_enable_if_tag<InputIt, std::input_iterator_tag>::type
+BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::input_iterator_tag>::type
    iterator_advance(InputIt& it, Distance n)
 {
    while(n--)
@@ -101,7 +159,7 @@ typename iterator_enable_if_tag<InputIt, std::forward_iterator_tag>::type
 }
 
 template<class InputIt, class Distance>
-typename iterator_enable_if_tag<InputIt, std::bidirectional_iterator_tag>::type
+BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::bidirectional_iterator_tag>::type
    iterator_advance(InputIt& it, Distance n)
 {
    for (; 0 < n; --n)
@@ -117,6 +175,54 @@ BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::random
    it += n;
 }
 
+template<class InputIt, class Distance>
+BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
+   <InputIt, const boost::iterators::incrementable_traversal_tag&, const boost::iterators::single_pass_traversal_tag&>::type
+   iterator_advance(InputIt& it, Distance n)
+{
+   while(n--)
+	   ++it;
+}
+
+template<class InputIt, class Distance>
+BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
+   <InputIt, const boost::iterators::single_pass_traversal_tag &, const boost::iterators::forward_traversal_tag&>::type
+   iterator_advance(InputIt& it, Distance n)
+{
+   while(n--)
+	   ++it;
+}
+
+template<class InputIt, class Distance>
+BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
+   <InputIt, const boost::iterators::forward_traversal_tag&, const boost::iterators::bidirectional_traversal_tag&>::type
+   iterator_advance(InputIt& it, Distance n)
+{
+   while(n--)
+	   ++it;
+}
+
+template<class InputIt, class Distance>
+BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
+   <InputIt, const boost::iterators::bidirectional_traversal_tag&, const boost::iterators::random_access_traversal_tag&>::type
+   iterator_advance(InputIt& it, Distance n)
+{
+   for (; 0 < n; --n)
+	   ++it;
+   for (; n < 0; ++n)
+	   --it;
+}
+
+class fake{};
+
+template<class InputIt, class Distance>
+BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
+   <InputIt, const boost::iterators::random_access_traversal_tag&, const fake&>::type
+   iterator_advance(InputIt& it, Distance n)
+{
+   it += n;
+}
+
 ////////////////////
 //    distance
 ////////////////////

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

@@ -86,8 +86,8 @@ struct ls_zeros<1>
 
 // Infrastructure for providing a default type for T::TNAME if absent.
 #define BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(TNAME)     \
-   template <typename T, typename DefaultType>                    \
-   struct boost_intrusive_default_type_ ## TNAME                  \
+   template <typename T>                                          \
+   struct boost_intrusive_has_type_ ## TNAME                      \
    {                                                              \
       template <typename X>                                       \
       static char test(int, typename X::TNAME*);                  \
@@ -95,13 +95,18 @@ struct ls_zeros<1>
       template <typename X>                                       \
       static int test(...);                                       \
                                                                   \
-      struct DefaultWrap { typedef DefaultType TNAME; };          \
-                                                                  \
       static const bool value = (1 == sizeof(test<T>(0, 0)));     \
+   };                                                             \
+                                                                  \
+   template <typename T, typename DefaultType>                    \
+   struct boost_intrusive_default_type_ ## TNAME                  \
+   {                                                              \
+      struct DefaultWrap { typedef DefaultType TNAME; };          \
                                                                   \
       typedef typename                                            \
          ::boost::intrusive::detail::if_c                         \
-            <value, T, DefaultWrap>::type::TNAME type;            \
+            < boost_intrusive_has_type_ ## TNAME<T>::value        \
+            , T, DefaultWrap>::type::TNAME type;                  \
    };                                                             \
    //
 
@@ -110,6 +115,11 @@ struct ls_zeros<1>
          boost_intrusive_default_type_ ## TNAME< T, TIMPL >::type                            \
 //
 
+#define BOOST_INTRUSIVE_HAS_TYPE(INSTANTIATION_NS_PREFIX, T, TNAME)  \
+      INSTANTIATION_NS_PREFIX                                        \
+         boost_intrusive_has_type_ ## TNAME< T >::value              \
+//
+
 #define BOOST_INTRUSIVE_INSTANTIATE_EVAL_DEFAULT_TYPE_TMPLT(TNAME)\
    template <typename T, typename DefaultType>                    \
    struct boost_intrusive_eval_default_type_ ## TNAME             \

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/node_to_value.hpp

@@ -59,7 +59,7 @@ struct constptr
    {}
 
    const void *get_ptr() const
-   {  return boost::intrusive::detail::to_raw_pointer(const_void_ptr_);  }
+   {  return boost::movelib::to_raw_pointer(const_void_ptr_);  }
 
    ConstVoidPtr const_void_ptr_;
 };

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/tree_value_compare.hpp

@@ -37,7 +37,8 @@ struct disable_if_smartref_to
       || detail::is_same
             <From, typename pointer_traits
                      < typename pointer_rebind
-                           <ValuePtr, const typename pointer_element<ValuePtr>::type>::type>
+                           < ValuePtr
+                           , const typename boost::movelib::pointer_element<ValuePtr>::type>::type>
                   ::reference>::value
       >
 {};
@@ -45,11 +46,13 @@ struct disable_if_smartref_to
 //This function object takes a KeyCompare function object
 //and compares values that contains keys using KeyOfValue
 template< class ValuePtr, class KeyCompare, class KeyOfValue
-        , bool = boost::intrusive::detail::is_same<typename pointer_element<ValuePtr>::type, typename KeyOfValue::type>::value >
+        , bool = boost::intrusive::detail::is_same
+   <typename boost::movelib::pointer_element<ValuePtr>::type, typename KeyOfValue::type>::value >
 struct tree_value_compare
    :  public boost::intrusive::detail::ebo_functor_holder<KeyCompare>
 {
-   typedef typename pointer_element<ValuePtr>::type   value_type;
+   typedef typename
+      boost::movelib::pointer_element<ValuePtr>::type value_type;
    typedef KeyCompare                                 key_compare;
    typedef KeyOfValue                                 key_of_value;
    typedef typename KeyOfValue::type                  key_type;
@@ -114,7 +117,8 @@ template<class ValuePtr, class KeyCompare, class KeyOfValue>
 struct tree_value_compare<ValuePtr, KeyCompare, KeyOfValue, true>
    :  public boost::intrusive::detail::ebo_functor_holder<KeyCompare>
 {
-   typedef typename pointer_element<ValuePtr>::type   value_type;
+   typedef typename
+      boost::movelib::pointer_element<ValuePtr>::type value_type;
    typedef KeyCompare                                 key_compare;
    typedef KeyOfValue                                 key_of_value;
    typedef typename KeyOfValue::type                  key_type;