passenger 6.0.2 → 6.0.3

data/src/cxx_supportlib/vendor-modified/boost/type_traits/detail/is_rvalue_reference_msvc10_fix.hpp

@@ -0,0 +1,43 @@
+
+//  (C) Copyright John Maddock 2018. 
+//  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).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_IS_RVALUE_REFERENCE_MSVC10_FIX_HPP_INCLUDED
+#define BOOST_TT_IS_RVALUE_REFERENCE_MSVC10_FIX_HPP_INCLUDED
+
+namespace boost {
+
+template <class R> struct is_rvalue_reference<R(&&)()> : public true_type {};
+template <class R> struct is_rvalue_reference<R(&&)(...)> : public true_type {};
+template <class R, class Arg1> struct is_rvalue_reference<R(&&)(Arg1)> : public true_type {};
+template <class R, class Arg1> struct is_rvalue_reference<R(&&)(Arg1, ...)> : public true_type {};
+template <class R, class Arg1, class Arg2> struct is_rvalue_reference<R(&&)(Arg1, Arg2)> : public true_type {};
+template <class R, class Arg1, class Arg2> struct is_rvalue_reference<R(&&)(Arg1, Arg2, ...)> : public true_type {};
+template <class R, class Arg1, class Arg2, class Arg3> struct is_rvalue_reference<R(&&)(Arg1, Arg2, Arg3)> : public true_type {};
+template <class R, class Arg1, class Arg2, class Arg3> struct is_rvalue_reference<R(&&)(Arg1, Arg2, Arg3, ...)> : public true_type {};
+template <class R, class Arg1, class Arg2, class Arg3, class Arg4> struct is_rvalue_reference<R(&&)(Arg1, Arg2, Arg3, Arg4)> : public true_type {};
+template <class R, class Arg1, class Arg2, class Arg3, class Arg4> struct is_rvalue_reference<R(&&)(Arg1, Arg2, Arg3, Arg4, ...)> : public true_type {};
+template <class R, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5> struct is_rvalue_reference<R(&&)(Arg1, Arg2, Arg3, Arg4, Arg5)> : public true_type {};
+template <class R, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5> struct is_rvalue_reference<R(&&)(Arg1, Arg2, Arg3, Arg4, Arg5, ...)> : public true_type {};
+
+template <class R> struct is_rvalue_reference<R(&)()> : public false_type {};
+template <class R> struct is_rvalue_reference<R(&)(...)> : public false_type {};
+template <class R, class Arg1> struct is_rvalue_reference<R(&)(Arg1)> : public false_type {};
+template <class R, class Arg1> struct is_rvalue_reference<R(&)(Arg1, ...)> : public false_type {};
+template <class R, class Arg1, class Arg2> struct is_rvalue_reference<R(&)(Arg1, Arg2)> : public false_type {};
+template <class R, class Arg1, class Arg2> struct is_rvalue_reference<R(&)(Arg1, Arg2, ...)> : public false_type {};
+template <class R, class Arg1, class Arg2, class Arg3> struct is_rvalue_reference<R(&)(Arg1, Arg2, Arg3)> : public false_type {};
+template <class R, class Arg1, class Arg2, class Arg3> struct is_rvalue_reference<R(&)(Arg1, Arg2, Arg3, ...)> : public false_type {};
+template <class R, class Arg1, class Arg2, class Arg3, class Arg4> struct is_rvalue_reference<R(&)(Arg1, Arg2, Arg3, Arg4)> : public false_type {};
+template <class R, class Arg1, class Arg2, class Arg3, class Arg4> struct is_rvalue_reference<R(&)(Arg1, Arg2, Arg3, Arg4, ...)> : public false_type {};
+template <class R, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5> struct is_rvalue_reference<R(&)(Arg1, Arg2, Arg3, Arg4, Arg5)> : public false_type {};
+template <class R, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5> struct is_rvalue_reference<R(&)(Arg1, Arg2, Arg3, Arg4, Arg5, ...)> : public false_type {};
+
+} // namespace boost
+
+#endif // BOOST_TT_IS_REFERENCE_HPP_INCLUDED
+

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

@@ -1,6 +1,6 @@
 /*
 Copyright 2017-2018 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/detected_or.hpp

@@ -1,6 +1,6 @@
 /*
 Copyright 2017-2018 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/enable_if.hpp

@@ -0,0 +1,37 @@
+/*
+Copyright 2003 The Trustees of Indiana University
+
+Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
+         Jeremiah Willcock (jewillco at osl.iu.edu)
+         Andrew Lumsdaine (lums at osl.iu.edu)
+
+Copyright 2018 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+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)
+*/
+#ifndef BOOST_TT_ENABLE_IF_HPP_INCLUDED
+#define BOOST_TT_ENABLE_IF_HPP_INCLUDED
+
+#include <boost/config.hpp>
+
+namespace boost {
+
+template<bool B, class T = void>
+struct enable_if_ {
+    typedef T type;
+};
+
+template<class T>
+struct enable_if_<false, T> { };
+
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+template<bool B, class T = void>
+using enable_if_t = typename enable_if_<B, T>::type;
+#endif
+
+} /* boost */
+
+#endif

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

@@ -27,5 +27,349 @@
 #undef BOOST_TT_TRAIT_NAME
 #undef BOOST_TT_TRAIT_OP
 #undef BOOST_TT_FORBIDDEN_IF
+#if defined(BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION)
 
+namespace boost {
+
+   template <class R>
+   struct has_dereference<void*, R> : public false_type {};
+   template <>
+   struct has_dereference<void*, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<void*, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<const void*, R> : public false_type {};
+   template <>
+   struct has_dereference<const void*, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<const void*, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<volatile void*, R> : public false_type {};
+   template <>
+   struct has_dereference<volatile void*, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<volatile void*, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<const volatile void*, R> : public false_type {};
+   template <>
+   struct has_dereference<const volatile void*, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<const volatile void*, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<void*const, R> : public false_type {};
+   template <>
+   struct has_dereference<void*const, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<void*const, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<const void*const, R> : public false_type {};
+   template <>
+   struct has_dereference<const void*const, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<const void*const, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<volatile void*const, R> : public false_type {};
+   template <>
+   struct has_dereference<volatile void*const, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<volatile void*const, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<const volatile void*const, R> : public false_type {};
+   template <>
+   struct has_dereference<const volatile void*const, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<const volatile void*const, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<void*volatile, R> : public false_type {};
+   template <>
+   struct has_dereference<void*volatile, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<void*volatile, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<const void*volatile, R> : public false_type {};
+   template <>
+   struct has_dereference<const void*volatile, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<const void*volatile, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<volatile void*volatile, R> : public false_type {};
+   template <>
+   struct has_dereference<volatile void*volatile, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<volatile void*volatile, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<const volatile void*volatile, R> : public false_type {};
+   template <>
+   struct has_dereference<const volatile void*volatile, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<const volatile void*volatile, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<void*const volatile, R> : public false_type {};
+   template <>
+   struct has_dereference<void*const volatile, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<void*const volatile, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<const void*const volatile, R> : public false_type {};
+   template <>
+   struct has_dereference<const void*const volatile, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<const void*const volatile, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<volatile void*const volatile, R> : public false_type {};
+   template <>
+   struct has_dereference<volatile void*const volatile, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<volatile void*const volatile, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<const volatile void*const volatile, R> : public false_type {};
+   template <>
+   struct has_dereference<const volatile void*const volatile, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<const volatile void*const volatile, void> : public false_type {};
+
+   // references:
+   template <class R>
+   struct has_dereference<void*&, R> : public false_type {};
+   template <>
+   struct has_dereference<void*&, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<void*&, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<const void*&, R> : public false_type {};
+   template <>
+   struct has_dereference<const void*&, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<const void*&, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<volatile void*&, R> : public false_type {};
+   template <>
+   struct has_dereference<volatile void*&, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<volatile void*&, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<const volatile void*&, R> : public false_type {};
+   template <>
+   struct has_dereference<const volatile void*&, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<const volatile void*&, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<void*const&, R> : public false_type {};
+   template <>
+   struct has_dereference<void*const&, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<void*const&, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<const void*const&, R> : public false_type {};
+   template <>
+   struct has_dereference<const void*const&, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<const void*const&, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<volatile void*const&, R> : public false_type {};
+   template <>
+   struct has_dereference<volatile void*const&, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<volatile void*const&, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<const volatile void*const&, R> : public false_type {};
+   template <>
+   struct has_dereference<const volatile void*const&, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<const volatile void*const&, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<void*volatile&, R> : public false_type {};
+   template <>
+   struct has_dereference<void*volatile&, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<void*volatile&, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<const void*volatile&, R> : public false_type {};
+   template <>
+   struct has_dereference<const void*volatile&, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<const void*volatile&, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<volatile void*volatile&, R> : public false_type {};
+   template <>
+   struct has_dereference<volatile void*volatile&, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<volatile void*volatile&, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<const volatile void*volatile&, R> : public false_type {};
+   template <>
+   struct has_dereference<const volatile void*volatile&, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<const volatile void*volatile&, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<void*const volatile&, R> : public false_type {};
+   template <>
+   struct has_dereference<void*const volatile&, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<void*const volatile&, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<const void*const volatile&, R> : public false_type {};
+   template <>
+   struct has_dereference<const void*const volatile&, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<const void*const volatile&, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<volatile void*const volatile&, R> : public false_type {};
+   template <>
+   struct has_dereference<volatile void*const volatile&, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<volatile void*const volatile&, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<const volatile void*const volatile&, R> : public false_type {};
+   template <>
+   struct has_dereference<const volatile void*const volatile&, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<const volatile void*const volatile&, void> : public false_type {};
+
+   // rvalue refs:
+   template <class R>
+   struct has_dereference<void*&&, R> : public false_type {};
+   template <>
+   struct has_dereference<void*&&, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<void*&&, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<const void*&&, R> : public false_type {};
+   template <>
+   struct has_dereference<const void*&&, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<const void*&&, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<volatile void*&&, R> : public false_type {};
+   template <>
+   struct has_dereference<volatile void*&&, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<volatile void*&&, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<const volatile void*&&, R> : public false_type {};
+   template <>
+   struct has_dereference<const volatile void*&&, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<const volatile void*&&, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<void*const&&, R> : public false_type {};
+   template <>
+   struct has_dereference<void*const&&, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<void*const&&, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<const void*const&&, R> : public false_type {};
+   template <>
+   struct has_dereference<const void*const&&, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<const void*const&&, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<volatile void*const&&, R> : public false_type {};
+   template <>
+   struct has_dereference<volatile void*const&&, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<volatile void*const&&, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<const volatile void*const&&, R> : public false_type {};
+   template <>
+   struct has_dereference<const volatile void*const&&, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<const volatile void*const&&, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<void*volatile&&, R> : public false_type {};
+   template <>
+   struct has_dereference<void*volatile&&, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<void*volatile&&, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<const void*volatile&&, R> : public false_type {};
+   template <>
+   struct has_dereference<const void*volatile&&, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<const void*volatile&&, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<volatile void*volatile&&, R> : public false_type {};
+   template <>
+   struct has_dereference<volatile void*volatile&&, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<volatile void*volatile&&, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<const volatile void*volatile&&, R> : public false_type {};
+   template <>
+   struct has_dereference<const volatile void*volatile&&, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<const volatile void*volatile&&, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<void*const volatile&&, R> : public false_type {};
+   template <>
+   struct has_dereference<void*const volatile&&, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<void*const volatile&&, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<const void*const volatile&&, R> : public false_type {};
+   template <>
+   struct has_dereference<const void*const volatile&&, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<const void*const volatile&&, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<volatile void*const volatile&&, R> : public false_type {};
+   template <>
+   struct has_dereference<volatile void*const volatile&&, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<volatile void*const volatile&&, void> : public false_type {};
+
+   template <class R>
+   struct has_dereference<const volatile void*const volatile&&, R> : public false_type {};
+   template <>
+   struct has_dereference<const volatile void*const volatile&&, boost::binary_op_detail::dont_care> : public false_type {};
+   template <>
+   struct has_dereference<const volatile void*const volatile&&, void> : public false_type {};
+
+
+}
+#endif
 #endif

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

@@ -150,4 +150,9 @@ namespace boost
 #undef BOOST_TT_FORBIDDEN_IF
 
 #endif
+
+#if defined(BOOST_MSVC)
+#   pragma warning (pop)
+#endif
+
 #endif