passenger 6.0.0 → 6.0.5

data/src/cxx_supportlib/vendor-modified/boost/type_traits/is_member_function_pointer.hpp

@@ -12,109 +12,15 @@
 #define BOOST_TT_IS_MEMBER_FUNCTION_POINTER_HPP_INCLUDED
 
 #include <boost/type_traits/detail/config.hpp>
-#include <boost/detail/workaround.hpp>
 
-#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && !defined(BOOST_TT_TEST_MS_FUNC_SIGS)
-   //
-   // Note: we use the "workaround" version for MSVC because it works for 
-   // __stdcall etc function types, where as the partial specialisation
-   // version does not do so.
-   //
-#   include <boost/type_traits/detail/is_mem_fun_pointer_impl.hpp>
-#   include <boost/type_traits/remove_cv.hpp>
-#   include <boost/type_traits/integral_constant.hpp>
-#else
-#   include <boost/type_traits/is_reference.hpp>
-#   include <boost/type_traits/is_array.hpp>
-#   include <boost/type_traits/detail/yes_no_type.hpp>
-#   include <boost/type_traits/detail/is_mem_fun_pointer_tester.hpp>
-#endif
-
-namespace boost {
+#ifdef BOOST_TT_HAS_ASCCURATE_IS_FUNCTION
 
-#if defined( __CODEGEARC__ )
-template <class T> struct is_member_function_pointer : public integral_constant<bool, __is_member_function_pointer( T )> {};
-#elif !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && !defined(BOOST_TT_TEST_MS_FUNC_SIGS)
-
-template <class T> struct is_member_function_pointer 
-   : public ::boost::integral_constant<bool, ::boost::type_traits::is_mem_fun_pointer_impl<typename remove_cv<T>::type>::value>{};
+#include <boost/type_traits/detail/is_member_function_pointer_cxx_11.hpp>
 
 #else
 
-namespace detail {
-
-#ifndef __BORLANDC__
-
-template <bool>
-struct is_mem_fun_pointer_select
-{
-   template <class T> struct result_ : public false_type{};
-};
-
-template <>
-struct is_mem_fun_pointer_select<false>
-{
-    template <typename T> struct result_
-    {
-#if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000)
-#pragma warning(push)
-#pragma warning(disable:6334)
-#endif
-        static T* make_t;
-        typedef result_<T> self_type;
-
-        BOOST_STATIC_CONSTANT(
-            bool, value = (
-                1 == sizeof(::boost::type_traits::is_mem_fun_pointer_tester(self_type::make_t))
-            ));
-#if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000)
-#pragma warning(pop)
-#endif
-    };
-};
-
-template <typename T>
-struct is_member_function_pointer_impl
-    : public is_mem_fun_pointer_select< 
-      ::boost::is_reference<T>::value || ::boost::is_array<T>::value>::template result_<T>{};
+#include <boost/type_traits/detail/is_member_function_pointer_cxx_03.hpp>
 
-template <typename T>
-struct is_member_function_pointer_impl<T&> : public false_type{};
-
-#else // Borland C++
-
-template <typename T>
-struct is_member_function_pointer_impl
-{
-   static T* m_t;
-   BOOST_STATIC_CONSTANT(
-              bool, value =
-               (1 == sizeof(type_traits::is_mem_fun_pointer_tester(m_t))) );
-};
-
-template <typename T>
-struct is_member_function_pointer_impl<T&>
-{
-   BOOST_STATIC_CONSTANT(bool, value = false);
-};
-
-#endif
-
-template<> struct is_member_function_pointer_impl<void> : public false_type{};
-#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-template<> struct is_member_function_pointer_impl<void const> : public false_type{};
-template<> struct is_member_function_pointer_impl<void const volatile> : public false_type{};
-template<> struct is_member_function_pointer_impl<void volatile> : public false_type{};
 #endif
 
-} // namespace detail
-
-template <class T>
-struct is_member_function_pointer
-   : public integral_constant<bool, ::boost::detail::is_member_function_pointer_impl<T>::value>{};
-
-#endif
-
-} // namespace boost
-
 #endif // BOOST_TT_IS_MEMBER_FUNCTION_POINTER_HPP_INCLUDED

data/src/cxx_supportlib/vendor-modified/boost/type_traits/is_noncopyable.hpp

@@ -0,0 +1,39 @@
+#ifndef BOOST_TYPE_TRAITS_IS_NONCOPYABLE_HPP_INCLUDED
+#define BOOST_TYPE_TRAITS_IS_NONCOPYABLE_HPP_INCLUDED
+
+//
+//  Copyright 2018 Peter Dimov
+//
+//  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
+//
+//  is_noncopyable<T> returns whether T is derived from boost::noncopyable
+//
+
+#include <boost/type_traits/is_base_and_derived.hpp>
+
+namespace boost
+{
+
+#ifndef BOOST_NONCOPYABLE_BASE_TOKEN_DEFINED
+#define BOOST_NONCOPYABLE_BASE_TOKEN_DEFINED
+
+// boost::noncopyable derives from noncopyable_::base_token to enable us
+// to recognize it. The definition is macro-guarded so that we can replicate
+// it here without including boost/core/noncopyable.hpp, which is in Core.
+
+namespace noncopyable_
+{
+    struct base_token {};
+}
+
+#endif // #ifndef BOOST_NONCOPYABLE_BASE_TOKEN_DEFINED
+
+template<class T> struct is_noncopyable: is_base_and_derived<noncopyable_::base_token, T>
+{
+};
+
+} // namespace boost
+
+#endif // #ifndef BOOST_TYPE_TRAITS_IS_NONCOPYABLE_HPP_INCLUDED

data/src/cxx_supportlib/vendor-modified/boost/type_traits/is_nothrow_move_assignable.hpp

@@ -16,7 +16,7 @@
 #include <boost/type_traits/has_nothrow_assign.hpp>
 #include <boost/type_traits/is_array.hpp>
 #include <boost/type_traits/is_reference.hpp>
-#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/enable_if.hpp>
 #include <boost/type_traits/declval.hpp>
 #include <boost/type_traits/is_complete.hpp>
 #include <boost/static_assert.hpp>
@@ -48,7 +48,7 @@ struct false_or_cpp11_noexcept_move_assignable: public ::boost::false_type {};
 template <class T>
 struct false_or_cpp11_noexcept_move_assignable <
         T,
-        typename ::boost::enable_if_c<sizeof(T) && BOOST_NOEXCEPT_EXPR(::boost::declval<T&>() = ::boost::declval<T>())>::type
+        typename ::boost::enable_if_<sizeof(T) && BOOST_NOEXCEPT_EXPR(::boost::declval<T&>() = ::boost::declval<T>())>::type
     > : public ::boost::integral_constant<bool, BOOST_NOEXCEPT_EXPR(::boost::declval<T&>() = ::boost::declval<T>())>
 {};
 

data/src/cxx_supportlib/vendor-modified/boost/type_traits/is_nothrow_move_constructible.hpp

@@ -35,7 +35,7 @@ template  struct is_nothrow_move_constructible : publ
 #elif !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_SFINAE_EXPR) && !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40700)
 
 #include <boost/type_traits/declval.hpp>
-#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/enable_if.hpp>
 
 namespace boost{ namespace detail{
 
@@ -45,7 +45,7 @@ struct false_or_cpp11_noexcept_move_constructible: public ::boost::false_type {}
 template <class T>
 struct false_or_cpp11_noexcept_move_constructible <
         T,
-        typename ::boost::enable_if_c<sizeof(T) && BOOST_NOEXCEPT_EXPR(T(::boost::declval<T>()))>::type
+        typename ::boost::enable_if_<sizeof(T) && BOOST_NOEXCEPT_EXPR(T(::boost::declval<T>()))>::type
     > : public ::boost::integral_constant<bool, BOOST_NOEXCEPT_EXPR(T(::boost::declval<T>()))>
 {};
 

data/src/cxx_supportlib/vendor-modified/boost/type_traits/is_rvalue_reference.hpp

@@ -21,5 +21,9 @@ template  struct is_rvalue_reference : public true_type {};
 
 } // namespace boost
 
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, <= 1700)
+#include <boost/type_traits/detail/is_rvalue_reference_msvc10_fix.hpp>
+#endif
+
 #endif // BOOST_TT_IS_REFERENCE_HPP_INCLUDED
 

data/src/cxx_supportlib/vendor-modified/boost/type_traits/is_virtual_base_of.hpp

@@ -1,4 +1,5 @@
 //  (C) Copyright Daniel Frey and Robert Ramey 2009.
+//  (C) Copyright Balint Cserni 2017
 //  Use, modification and distribution are subject to 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).
@@ -10,9 +11,11 @@
 
 #include <boost/type_traits/is_base_of.hpp>
 #include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/make_void.hpp>
+#include <utility>
 
 namespace boost {
-namespace detail {
+   namespace detail {
 
 
 #ifdef BOOST_MSVC
@@ -22,84 +25,122 @@ namespace detail {
 #pragma GCC system_header
 #endif
 
-template<typename Base, typename Derived, typename tag>
-struct is_virtual_base_of_impl
-{
-    BOOST_STATIC_CONSTANT(bool, value = false);
-};
+#if !defined(BOOST_NO_SFINAE_EXPR) && !defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS) && !defined(BOOST_NO_CXX11_NULLPTR) && !BOOST_WORKAROUND(BOOST_GCC, < 40800)
 
-template<typename Base, typename Derived>
-struct is_virtual_base_of_impl<Base, Derived, true_type>
-{
-   union max_align
+      // Implementation based on the standard's rules of explicit type conversions.
+      // A pointer to an object of *derived* class type may be explicitly converted to a pointer to an *unambiguous* *base* class type.
+      // A pointer to an object of an *unambiguous* *non-virtual* *base* class type may be explicitly converted to a pointer of a *derived* class type.
+      // Therefore Derived has a virtual base Base if and only if
+      //   (1) a Derived* can be converted to Base* (so the base class is unambiguous, which comes necessarily from virtual inheritance)
+      //   (2) a Base* cannot be converted to Derived* (so the base class is either ambiguous or virtual)
+      // With both conditions true, Base must be a virtual base of Derived.
+      // The "is_base_of" is only needed so the compiler can (but is not required to) error out if the types are incomplete.
+      // This is in league with the the expected behaviour.
+
+      template<class T, class U>
+      constexpr bool is_virtual_base_impl(...) { return true; }
+
+      // C-style casts have the power to ignore inheritance visibility while still act as a static_cast.
+      // They can also fall back to the behaviour of reinterpret_cast, which allows is_virtual_base_of to work on non-class types too.
+      // Note that because we are casting pointers there can be no user-defined operators to interfere.
+      template<class T, class U,
+         boost::void_t<decltype((U*)(std::declval<T*>()))>* =
+         nullptr>
+         constexpr bool is_virtual_base_impl(int) { return false; }
+
+   } // namespace detail
+
+   template<class T, class U>
+   struct is_virtual_base_of : public
+      boost::integral_constant<
+      bool,
+      boost::is_base_of<T, U>::value &&
+      detail::is_virtual_base_impl<T, U>(0) &&
+      !detail::is_virtual_base_impl<U, T>(0)
+      > {};
+
+#else
+
+   template<typename Base, typename Derived, typename tag>
+   struct is_virtual_base_of_impl
+   {
+      BOOST_STATIC_CONSTANT(bool, value = false);
+   };
+
+   template<typename Base, typename Derived>
+   struct is_virtual_base_of_impl<Base, Derived, true_type>
    {
-      unsigned u;
-      unsigned long ul;
-      void* v;
-      double d;
-      long double ld;
+      union max_align
+      {
+         unsigned u;
+         unsigned long ul;
+         void* v;
+         double d;
+         long double ld;
 #ifndef BOOST_NO_LONG_LONG
-      long long ll;
+         long long ll;
 #endif
-   };
+      };
 #ifdef __BORLANDC__
-    struct boost_type_traits_internal_struct_X : public virtual Derived, public virtual Base 
-    {
-       boost_type_traits_internal_struct_X();
-       boost_type_traits_internal_struct_X(const boost_type_traits_internal_struct_X&);
-       boost_type_traits_internal_struct_X& operator=(const boost_type_traits_internal_struct_X&);
-       ~boost_type_traits_internal_struct_X()throw();
-       max_align data[4];
-    };
-    struct boost_type_traits_internal_struct_Y : public virtual Derived 
-    {
-       boost_type_traits_internal_struct_Y();
-       boost_type_traits_internal_struct_Y(const boost_type_traits_internal_struct_Y&);
-       boost_type_traits_internal_struct_Y& operator=(const boost_type_traits_internal_struct_Y&);
-       ~boost_type_traits_internal_struct_Y()throw();
-       max_align data[4];
-    };
+      struct boost_type_traits_internal_struct_X : public virtual Derived, public virtual Base
+      {
+         boost_type_traits_internal_struct_X();
+         boost_type_traits_internal_struct_X(const boost_type_traits_internal_struct_X&);
+         boost_type_traits_internal_struct_X& operator=(const boost_type_traits_internal_struct_X&);
+         ~boost_type_traits_internal_struct_X()throw();
+         max_align data[4];
+      };
+      struct boost_type_traits_internal_struct_Y : public virtual Derived
+      {
+         boost_type_traits_internal_struct_Y();
+         boost_type_traits_internal_struct_Y(const boost_type_traits_internal_struct_Y&);
+         boost_type_traits_internal_struct_Y& operator=(const boost_type_traits_internal_struct_Y&);
+         ~boost_type_traits_internal_struct_Y()throw();
+         max_align data[4];
+      };
 #else
-    struct boost_type_traits_internal_struct_X : public Derived, virtual Base 
-    {
-       boost_type_traits_internal_struct_X();
-       boost_type_traits_internal_struct_X(const boost_type_traits_internal_struct_X&);
-       boost_type_traits_internal_struct_X& operator=(const boost_type_traits_internal_struct_X&);
-       ~boost_type_traits_internal_struct_X()throw();
-       max_align data[16];
-    };
-    struct boost_type_traits_internal_struct_Y : public Derived 
-    {
-       boost_type_traits_internal_struct_Y();
-       boost_type_traits_internal_struct_Y(const boost_type_traits_internal_struct_Y&);
-       boost_type_traits_internal_struct_Y& operator=(const boost_type_traits_internal_struct_Y&);
-       ~boost_type_traits_internal_struct_Y()throw();
-       max_align data[16];
-    };
+      struct boost_type_traits_internal_struct_X : public Derived, virtual Base
+      {
+         boost_type_traits_internal_struct_X();
+         boost_type_traits_internal_struct_X(const boost_type_traits_internal_struct_X&);
+         boost_type_traits_internal_struct_X& operator=(const boost_type_traits_internal_struct_X&);
+         ~boost_type_traits_internal_struct_X()throw();
+         max_align data[16];
+      };
+      struct boost_type_traits_internal_struct_Y : public Derived
+      {
+         boost_type_traits_internal_struct_Y();
+         boost_type_traits_internal_struct_Y(const boost_type_traits_internal_struct_Y&);
+         boost_type_traits_internal_struct_Y& operator=(const boost_type_traits_internal_struct_Y&);
+         ~boost_type_traits_internal_struct_Y()throw();
+         max_align data[16];
+      };
 #endif
-    BOOST_STATIC_CONSTANT(bool, value = (sizeof(boost_type_traits_internal_struct_X)==sizeof(boost_type_traits_internal_struct_Y)));
-};
-
-template<typename Base, typename Derived>
-struct is_virtual_base_of_impl2
-{
-   typedef boost::integral_constant<bool, (boost::is_base_of<Base, Derived>::value && ! boost::is_same<Base, Derived>::value)> tag_type;
-   typedef is_virtual_base_of_impl<Base, Derived, tag_type> imp;
-   BOOST_STATIC_CONSTANT(bool, value = imp::value);
-};
+      BOOST_STATIC_CONSTANT(bool, value = (sizeof(boost_type_traits_internal_struct_X) == sizeof(boost_type_traits_internal_struct_Y)));
+   };
 
-#ifdef BOOST_MSVC
-#pragma warning( pop )
-#endif
+   template<typename Base, typename Derived>
+   struct is_virtual_base_of_impl2
+   {
+      typedef boost::integral_constant<bool, (boost::is_base_of<Base, Derived>::value && !boost::is_same<Base, Derived>::value)> tag_type;
+      typedef is_virtual_base_of_impl<Base, Derived, tag_type> imp;
+      BOOST_STATIC_CONSTANT(bool, value = imp::value);
+   };
 
 } // namespace detail
 
-template <class Base, class Derived> struct is_virtual_base_of : public integral_constant<bool, (::boost::detail::is_virtual_base_of_impl2<Base, Derived>::value)>{};
+template <class Base, class Derived> struct is_virtual_base_of : public integral_constant<bool, (::boost::detail::is_virtual_base_of_impl2<Base, Derived>::value)> {};
+
+#endif
 
 template <class Base, class Derived> struct is_virtual_base_of<Base&, Derived> : public false_type{};
 template <class Base, class Derived> struct is_virtual_base_of<Base, Derived&> : public false_type{};
 template <class Base, class Derived> struct is_virtual_base_of<Base&, Derived&> : public false_type{};
 
+#ifdef BOOST_MSVC
+#pragma warning( pop )
+#endif
+
 } // namespace boost
 
 #endif

data/src/cxx_supportlib/vendor-modified/boost/type_traits/make_void.hpp

@@ -1,6 +1,6 @@
 /*
 Copyright 2017 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+(glenjofe@gmail.com)
 
 Distributed under the Boost Software License,
 Version 1.0. (See accompanying file LICENSE_1_0.txt

data/src/cxx_supportlib/vendor-modified/boost/type_traits/nonesuch.hpp

@@ -1,6 +1,6 @@
 /*
 Copyright 2017 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+(glenjofe@gmail.com)
 
 Distributed under the Boost Software License,
 Version 1.0. (See accompanying file LICENSE_1_0.txt

data/src/cxx_supportlib/vendor-modified/boost/typeof/constant.hpp

@@ -0,0 +1,26 @@
+/*
+Copyright 2018 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_TYPEOF_CONSTANT_HPP
+#define BOOST_TYPEOF_CONSTANT_HPP
+
+#include <boost/config.hpp>
+
+namespace boost {
+namespace type_of {
+
+template<class T, T N>
+struct constant {
+    typedef constant<T, N> type;
+    typedef constant<T, N + 1> next;
+    BOOST_STATIC_CONSTANT(T, value=N);
+};
+
+} /* type_of */
+} /* boost */
+
+#endif

data/src/cxx_supportlib/vendor-modified/boost/typeof/dmc/typeof_impl.hpp

@@ -7,8 +7,8 @@
 # define BOOST_TYPEOF_MSVC_TYPEOF_IMPL_HPP_INCLUDED
 
 # include <boost/config.hpp>
-# include <boost/detail/workaround.hpp>
-# include <boost/mpl/int.hpp>
+# include <boost/config/workaround.hpp>
+# include <boost/typeof/constant.hpp>
 
 namespace boost
 {
@@ -45,7 +45,7 @@ namespace boost
 
         template<int ID>
         struct msvc_typeid_wrapper {
-            typedef typename msvc_extract_type<mpl::int_<ID> >::id2type id2type;
+            typedef typename msvc_extract_type<constant<int,ID> >::id2type id2type;
             typedef typename id2type::type type;
         };
 
@@ -56,7 +56,7 @@ namespace boost
             //Get the next available compile time constants index
             BOOST_STATIC_CONSTANT(unsigned,value=BOOST_TYPEOF_INDEX(T));
             //Instantiate the template
-            typedef typename msvc_register_type<T,mpl::int_<value> >::id2type type;
+            typedef typename msvc_register_type<T,constant<int,value> >::id2type type;
             //Set the next compile time constants index
             BOOST_STATIC_CONSTANT(unsigned,next=value+1);
             //Increment the compile time constant (only needed when extensions are not active