passenger 6.0.1 → 6.0.6

data/src/cxx_supportlib/vendor-modified/boost/core/ref.hpp

@@ -19,7 +19,8 @@
 //  Copyright (C) 2002 David Abrahams
 //
 //  Copyright (C) 2014 Glen Joseph Fernandes
-//  glenfe at live dot com
+//  (glenjofe@gmail.com)
+//
 //  Copyright (C) 2014 Agustin Berge
 //
 // Distributed under the Boost Software License, Version 1.0. (See

data/src/cxx_supportlib/vendor-modified/boost/core/swap.hpp

@@ -21,13 +21,19 @@
 // avoid ambiguity when swapping objects of a Boost type that does
 // not have its own boost::swap overload.
 
+#include <boost/core/enable_if.hpp>
+#include <boost/config.hpp>
 #include <utility> //for std::swap (C++11)
 #include <algorithm> //for std::swap (C++98)
 #include <cstddef> //for std::size_t
-#include <boost/config.hpp>
 
 namespace boost_swap_impl
 {
+  // we can't use type_traits here
+
+  template<class T> struct is_const { enum _vt { value = 0 }; };
+  template<class T> struct is_const<T const> { enum _vt { value = 1 }; };
+
   template<class T>
   BOOST_GPU_ENABLED
   void swap_impl(T& left, T& right)
@@ -51,7 +57,8 @@ namespace boost
 {
   template<class T1, class T2>
   BOOST_GPU_ENABLED
-  void swap(T1& left, T2& right)
+  typename enable_if_c< !boost_swap_impl::is_const<T1>::value && !boost_swap_impl::is_const<T2>::value >::type
+  swap(T1& left, T2& right)
   {
     ::boost_swap_impl::swap_impl(left, right);
   }

data/src/cxx_supportlib/vendor-modified/boost/core/typeinfo.hpp

@@ -21,6 +21,7 @@
 
 #include <boost/current_function.hpp>
 #include <functional>
+#include <cstring>
 
 namespace boost
 {
@@ -36,26 +37,43 @@ private:
     typeinfo& operator=( typeinfo const& );
 
     char const * name_;
+    void (*lib_id_)();
 
 public:
 
-    explicit typeinfo( char const * name ): name_( name )
+    typeinfo( char const * name, void (*lib_id)() ): name_( name ), lib_id_( lib_id )
     {
     }
 
     bool operator==( typeinfo const& rhs ) const
     {
+#if ( defined(_WIN32) || defined(__CYGWIN__) ) && defined(__GNUC__) && !defined(BOOST_DISABLE_CURRENT_FUNCTION)
+
+        return lib_id_ == rhs.lib_id_? this == &rhs: std::strcmp( name_, rhs.name_ ) == 0;
+
+#else
+
         return this == &rhs;
+
+#endif
     }
 
     bool operator!=( typeinfo const& rhs ) const
     {
-        return this != &rhs;
+        return !( *this == rhs );
     }
 
     bool before( typeinfo const& rhs ) const
     {
+#if ( defined(_WIN32) || defined(__CYGWIN__) ) && defined(__GNUC__) && !defined(BOOST_DISABLE_CURRENT_FUNCTION)
+
+        return lib_id_ == rhs.lib_id_? std::less< typeinfo const* >()( this, &rhs ): std::strcmp( name_, rhs.name_ ) < 0;
+
+#else
+
         return std::less< typeinfo const* >()( this, &rhs );
+
+#endif
     }
 
     char const* name() const
@@ -74,7 +92,7 @@ inline char const * demangled_name( core::typeinfo const & ti )
 namespace detail
 {
 
-template<class T> struct core_typeid_
+template<class T> struct BOOST_SYMBOL_VISIBLE core_typeid_
 {
     static boost::core::typeinfo ti_;
 
@@ -84,13 +102,11 @@ template struct core_typeid_
     }
 };
 
-#if defined(__SUNPRO_CC)
-// see #4199, the Sun Studio compiler gets confused about static initialization 
-// constructor arguments. But an assignment works just fine. 
-template<class T> boost::core::typeinfo core_typeid_< T >::ti_ = core_typeid_< T >::name();
-#else
-template<class T> boost::core::typeinfo core_typeid_< T >::ti_(core_typeid_< T >::name());
-#endif
+BOOST_SYMBOL_VISIBLE inline void core_typeid_lib_id()
+{
+}
+
+template<class T> boost::core::typeinfo core_typeid_< T >::ti_( core_typeid_< T >::name(), &core_typeid_lib_id );
 
 template<class T> struct core_typeid_< T & >: core_typeid_< T >
 {

data/src/cxx_supportlib/vendor-modified/boost/date_time/compiler_config.hpp

@@ -165,5 +165,10 @@ namespace std {
 #  endif
 #endif
 
+#if defined(BOOST_NO_CXX11_NULLPTR)
+#  define BOOST_DATE_TIME_NULLPTR 0
+#else
+#  define BOOST_DATE_TIME_NULLPTR nullptr
+#endif
 
 #endif

data/src/cxx_supportlib/vendor-modified/boost/date_time/posix_time/posix_time_duration.hpp

@@ -27,7 +27,7 @@ namespace posix_time {
   public:
       template <typename T>
       explicit hours(T const& h,
-          typename boost::enable_if<boost::is_integral<T>, void>::type* = 0) :
+          typename boost::enable_if<boost::is_integral<T>, void>::type* = BOOST_DATE_TIME_NULLPTR) :
       time_duration(numeric_cast<hour_type>(h), 0, 0)
     {}
   };
@@ -41,7 +41,7 @@ namespace posix_time {
   public:
       template <typename T>
       explicit minutes(T const& m,
-          typename boost::enable_if<boost::is_integral<T>, void>::type* = 0) :
+          typename boost::enable_if<boost::is_integral<T>, void>::type* = BOOST_DATE_TIME_NULLPTR) :
       time_duration(0, numeric_cast<min_type>(m),0)
     {}
   };
@@ -55,7 +55,7 @@ namespace posix_time {
   public:
       template <typename T>
       explicit seconds(T const& s,
-          typename boost::enable_if<boost::is_integral<T>, void>::type* = 0) :
+          typename boost::enable_if<boost::is_integral<T>, void>::type* = BOOST_DATE_TIME_NULLPTR) :
       time_duration(0,0, numeric_cast<sec_type>(s))
     {}
   };

data/src/cxx_supportlib/vendor-modified/boost/date_time/time_duration.hpp

@@ -283,7 +283,7 @@ namespace date_time {
     // The argument (ss) must be an integral type
     template <typename T>
     explicit subsecond_duration(T const& ss,
-                                typename boost::enable_if<boost::is_integral<T>, void>::type* = 0) :
+                                typename boost::enable_if<boost::is_integral<T>, void>::type* = BOOST_DATE_TIME_NULLPTR) :
       base_duration(impl_type(traits_type::ticks_per_second >= frac_of_second ? ss * adjustment_ratio : ss / adjustment_ratio))
     {
     }

data/src/cxx_supportlib/vendor-modified/boost/detail/basic_pointerbuf.hpp

@@ -39,7 +39,7 @@ protected:
    typedef typename base_type::off_type off_type;
 
 public:
-   basic_pointerbuf() : base_type() { setbuf(0, 0); }
+   basic_pointerbuf() : base_type() { this_type::setbuf(0, 0); }
    const charT* getnext() { return this->gptr(); }
 
 #ifndef BOOST_NO_USING_TEMPLATE

data/src/cxx_supportlib/vendor-modified/boost/detail/indirect_traits.hpp

@@ -4,6 +4,7 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 #ifndef INDIRECT_TRAITS_DWA2002131_HPP
 # define INDIRECT_TRAITS_DWA2002131_HPP
+# include <boost/type_traits/integral_constant.hpp>
 # include <boost/type_traits/is_function.hpp>
 # include <boost/type_traits/is_reference.hpp>
 # include <boost/type_traits/is_pointer.hpp>
@@ -17,13 +18,7 @@
 # include <boost/type_traits/remove_pointer.hpp>
 
 # include <boost/detail/workaround.hpp>
-
-# include <boost/mpl/eval_if.hpp>
-# include <boost/mpl/if.hpp>
-# include <boost/mpl/bool.hpp>
-# include <boost/mpl/and.hpp>
-# include <boost/mpl/not.hpp>
-# include <boost/mpl/aux_/lambda_support.hpp>
+# include <boost/detail/select_type.hpp>
 
 
 namespace boost { namespace detail {
@@ -31,24 +26,24 @@ namespace boost { namespace detail {
 namespace indirect_traits {
 
 template <class T>
-struct is_reference_to_const : mpl::false_
+struct is_reference_to_const : boost::false_type
 {
 };
 
 template <class T>
-struct is_reference_to_const<T const&> : mpl::true_
+struct is_reference_to_const<T const&> : boost::true_type
 {
 };
 
 #   if defined(BOOST_MSVC) && _MSC_FULL_VER <= 13102140 // vc7.01 alpha workaround
 template<class T>
-struct is_reference_to_const<T const volatile&> : mpl::true_
+struct is_reference_to_const<T const volatile&> : boost::true_type
 {
 };
-#   endif 
+#   endif
 
 template <class T>
-struct is_reference_to_function : mpl::false_
+struct is_reference_to_function : boost::false_type
 {
 };
 
@@ -58,7 +53,7 @@ struct is_reference_to_function : is_function
 };
 
 template <class T>
-struct is_pointer_to_function : mpl::false_
+struct is_pointer_to_function : boost::false_type
 {
 };
 
@@ -70,7 +65,7 @@ struct is_pointer_to_function : is_function
 };
 
 template <class T>
-struct is_reference_to_member_function_pointer_impl : mpl::false_
+struct is_reference_to_member_function_pointer_impl : boost::false_type
 {
 };
 
@@ -85,18 +80,17 @@ template
 struct is_reference_to_member_function_pointer
     : is_reference_to_member_function_pointer_impl<T>
 {
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_member_function_pointer,(T))
 };
 
 template <class T>
 struct is_reference_to_function_pointer_aux
-    : mpl::and_<
-          is_reference<T>
-        , is_pointer_to_function<
+    : boost::integral_constant<bool,
+          is_reference<T>::value &&
+          is_pointer_to_function<
               typename remove_cv<
                   typename remove_reference<T>::type
               >::type
-          >
+          >::value
       >
 {
     // There's no such thing as a pointer-to-cv-function, so we don't need specializations for those
@@ -104,94 +98,91 @@ struct is_reference_to_function_pointer_aux
 
 template <class T>
 struct is_reference_to_function_pointer
-    : mpl::if_<
-          is_reference_to_function<T>
-        , mpl::false_
+    : boost::detail::if_true<
+          is_reference_to_function<T>::value
+      >::template then<
+          boost::false_type
         , is_reference_to_function_pointer_aux<T>
-     >::type
+      >::type
 {
 };
 
 template <class T>
 struct is_reference_to_non_const
-    : mpl::and_<
-          is_reference<T>
-        , mpl::not_<
-             is_reference_to_const<T>
-          >
+    : boost::integral_constant<bool,
+          is_reference<T>::value &&
+          !is_reference_to_const<T>::value
       >
 {
 };
 
 template <class T>
-struct is_reference_to_volatile : mpl::false_
+struct is_reference_to_volatile : boost::false_type
 {
 };
 
 template <class T>
-struct is_reference_to_volatile<T volatile&> : mpl::true_
+struct is_reference_to_volatile<T volatile&> : boost::true_type
 {
 };
 
 #   if defined(BOOST_MSVC) && _MSC_FULL_VER <= 13102140 // vc7.01 alpha workaround
 template <class T>
-struct is_reference_to_volatile<T const volatile&> : mpl::true_
+struct is_reference_to_volatile<T const volatile&> : boost::true_type
 {
 };
-#   endif 
+#   endif
 
 
 template <class T>
-struct is_reference_to_pointer : mpl::false_
+struct is_reference_to_pointer : boost::false_type
 {
 };
 
 template <class T>
-struct is_reference_to_pointer<T*&> : mpl::true_
+struct is_reference_to_pointer<T*&> : boost::true_type
 {
 };
 
 template <class T>
-struct is_reference_to_pointer<T* const&> : mpl::true_
+struct is_reference_to_pointer<T* const&> : boost::true_type
 {
 };
 
 template <class T>
-struct is_reference_to_pointer<T* volatile&> : mpl::true_
+struct is_reference_to_pointer<T* volatile&> : boost::true_type
 {
 };
 
 template <class T>
-struct is_reference_to_pointer<T* const volatile&> : mpl::true_
+struct is_reference_to_pointer<T* const volatile&> : boost::true_type
 {
 };
 
 template <class T>
 struct is_reference_to_class
-    : mpl::and_<
-          is_reference<T>
-        , is_class<
+    : boost::integral_constant<bool,
+          is_reference<T>::value &&
+          is_class<
               typename remove_cv<
                   typename remove_reference<T>::type
               >::type
-          >
+          >::value
       >
 {
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_class,(T))
 };
 
 template <class T>
 struct is_pointer_to_class
-    : mpl::and_<
-          is_pointer<T>
-        , is_class<
+    : boost::integral_constant<bool,
+          is_pointer<T>::value &&
+          is_class<
               typename remove_cv<
                   typename remove_pointer<T>::type
               >::type
-          >
+          >::value
       >
 {
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_pointer_to_class,(T))
 };
 
 

data/src/cxx_supportlib/vendor-modified/boost/detail/lcast_precision.hpp

@@ -17,7 +17,7 @@
 
 #ifndef BOOST_NO_IS_ABSTRACT
 // Fix for SF:1358600 - lexical_cast & pure virtual functions & VC 8 STL
-#include <boost/mpl/if.hpp>
+#include <boost/type_traits/conditional.hpp>
 #include <boost/type_traits/is_abstract.hpp>
 #endif
 
@@ -47,8 +47,8 @@ struct lcast_precision
 #ifdef BOOST_NO_IS_ABSTRACT
     typedef std::numeric_limits<T> limits; // No fix for SF:1358600.
 #else
-    typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_<
-        boost::is_abstract<T>
+    typedef BOOST_DEDUCED_TYPENAME boost::conditional<
+        boost::is_abstract<T>::value
       , std::numeric_limits<lcast_abstract_stub>
       , std::numeric_limits<T>
       >::type limits;
@@ -105,8 +105,8 @@ inline std::streamsize lcast_get_precision(T* = 0)
 #ifdef BOOST_NO_IS_ABSTRACT
     typedef std::numeric_limits<T> limits; // No fix for SF:1358600.
 #else
-    typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_<
-        boost::is_abstract<T>
+    typedef BOOST_DEDUCED_TYPENAME boost::conditional<
+        boost::is_abstract<T>::value
       , std::numeric_limits<lcast_abstract_stub>
       , std::numeric_limits<T>
       >::type limits;

data/src/cxx_supportlib/vendor-modified/boost/detail/reference_content.hpp

@@ -15,15 +15,15 @@
 
 #include "boost/config.hpp"
 
-#   include "boost/mpl/bool.hpp"
+#   include "boost/type_traits/integral_constant.hpp"
 #   include "boost/type_traits/has_nothrow_copy.hpp"
 
-#include "boost/mpl/void.hpp"
-
 namespace boost {
 
 namespace detail {
 
+struct void_type {};
+
 ///////////////////////////////////////////////////////////////////////////////
 // (detail) class template reference_content
 //
@@ -71,7 +71,7 @@ public: // queries
 // Wraps with reference_content if specified type is reference.
 //
 
-template <typename T = mpl::void_> struct make_reference_content;
+template <typename T = void_type> struct make_reference_content;
 
 
 template <typename T>
@@ -88,7 +88,7 @@ struct make_reference_content< T& >
 
 
 template <>
-struct make_reference_content< mpl::void_ >
+struct make_reference_content< void_type >
 {
     template <typename T>
     struct apply
@@ -96,7 +96,7 @@ struct make_reference_content< mpl::void_ >
     {
     };
 
-    typedef mpl::void_ type;
+    typedef void_type type;
 };
 
 } // namespace detail
@@ -110,7 +110,7 @@ template
 struct has_nothrow_copy<
       ::boost::detail::reference_content< T& >
     >
-    : mpl::true_
+    : boost::true_type
 {
 };