passenger 5.0.24 → 5.0.25

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

@@ -0,0 +1,188 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2014-2014. 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/intrusive for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_INTRUSIVE_POINTER_REBIND_HPP
+#define BOOST_INTRUSIVE_POINTER_REBIND_HPP
+
+#ifndef BOOST_INTRUSIVE_DETAIL_WORKAROUND_HPP
+#include <boost/intrusive/detail/workaround.hpp>
+#endif   //BOOST_INTRUSIVE_DETAIL_WORKAROUND_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+namespace boost {
+namespace intrusive {
+
+///////////////////////////
+//struct pointer_rebind_mode
+///////////////////////////
+template <typename Ptr, typename U>
+struct pointer_has_rebind
+{
+   template <typename V> struct any
+   {  any(const V&) { } };
+
+   template <typename X>
+   static char test(int, typename X::template rebind<U>*);
+
+   template <typename X>
+   static int test(any<int>, void*);
+
+   static const bool value = (1 == sizeof(test<Ptr>(0, 0)));
+};
+
+template <typename Ptr, typename U>
+struct pointer_has_rebind_other
+{
+   template <typename V> struct any
+   {  any(const V&) { } };
+
+   template <typename X>
+   static char test(int, typename X::template rebind<U>::other*);
+
+   template <typename X>
+   static int test(any<int>, void*);
+
+   static const bool value = (1 == sizeof(test<Ptr>(0, 0)));
+};
+
+template <typename Ptr, typename U>
+struct pointer_rebind_mode
+{
+   static const unsigned int rebind =       (unsigned int)pointer_has_rebind<Ptr, U>::value;
+   static const unsigned int rebind_other = (unsigned int)pointer_has_rebind_other<Ptr, U>::value;
+   static const unsigned int mode =         rebind + rebind*rebind_other;
+};
+
+////////////////////////
+//struct pointer_rebinder
+////////////////////////
+template <typename Ptr, typename U, unsigned int RebindMode>
+struct pointer_rebinder;
+
+// Implementation of pointer_rebinder<U>::type if Ptr has
+// its own rebind<U>::other type (C++03)
+template <typename Ptr, typename U>
+struct pointer_rebinder< Ptr, U, 2u >
+{
+   typedef typename Ptr::template rebind<U>::other type;
+};
+
+// Implementation of pointer_rebinder<U>::type if Ptr has
+// its own rebind template.
+template <typename Ptr, typename U>
+struct pointer_rebinder< Ptr, U, 1u >
+{
+   typedef typename Ptr::template rebind<U> type;
+};
+
+// Specialization of pointer_rebinder if Ptr does not
+// have its own rebind template but has a the form Ptr<A, An...>,
+// where An... comprises zero or more type parameters.
+// Many types fit this form, hence many pointers will get a
+// reasonable default for rebind.
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+
+template <template <class, class...> class Ptr, typename A, class... An, class U>
+struct pointer_rebinder<Ptr<A, An...>, U, 0u >
+{
+   typedef Ptr<U, An...> type;
+};
+
+//Needed for non-conforming compilers like GCC 4.3
+template <template <class> class Ptr, typename A, class U>
+struct pointer_rebinder<Ptr<A>, U, 0u >
+{
+   typedef Ptr<U> type;
+};
+
+#else //C++03 compilers
+
+template <template <class> class Ptr  //0arg
+         , typename A
+         , class U>
+struct pointer_rebinder<Ptr<A>, U, 0u>
+{  typedef Ptr<U> type;   };
+
+template <template <class, class> class Ptr  //1arg
+         , typename A, class P0
+         , class U>
+struct pointer_rebinder<Ptr<A, P0>, U, 0u>
+{  typedef Ptr<U, P0> type;   };
+
+template <template <class, class, class> class Ptr  //2arg
+         , typename A, class P0, class P1
+         , class U>
+struct pointer_rebinder<Ptr<A, P0, P1>, U, 0u>
+{  typedef Ptr<U, P0, P1> type;   };
+
+template <template <class, class, class, class> class Ptr  //3arg
+         , typename A, class P0, class P1, class P2
+         , class U>
+struct pointer_rebinder<Ptr<A, P0, P1, P2>, U, 0u>
+{  typedef Ptr<U, P0, P1, P2> type;   };
+
+template <template <class, class, class, class, class> class Ptr  //4arg
+         , typename A, class P0, class P1, class P2, class P3
+         , class U>
+struct pointer_rebinder<Ptr<A, P0, P1, P2, P3>, U, 0u>
+{  typedef Ptr<U, P0, P1, P2, P3> type;   };
+
+template <template <class, class, class, class, class, class> class Ptr  //5arg
+         , typename A, class P0, class P1, class P2, class P3, class P4
+         , class U>
+struct pointer_rebinder<Ptr<A, P0, P1, P2, P3, P4>, U, 0u>
+{  typedef Ptr<U, P0, P1, P2, P3, P4> type;   };
+
+template <template <class, class, class, class, class, class, class> class Ptr  //6arg
+         , typename A, class P0, class P1, class P2, class P3, class P4, class P5
+         , class U>
+struct pointer_rebinder<Ptr<A, P0, P1, P2, P3, P4, P5>, U, 0u>
+{  typedef Ptr<U, P0, P1, P2, P3, P4, P5> type;   };
+
+template <template <class, class, class, class, class, class, class, class> class Ptr  //7arg
+         , typename A, class P0, class P1, class P2, class P3, class P4, class P5, class P6
+         , class U>
+struct pointer_rebinder<Ptr<A, P0, P1, P2, P3, P4, P5, P6>, U, 0u>
+{  typedef Ptr<U, P0, P1, P2, P3, P4, P5, P6> type;   };
+
+template <template <class, class, class, class, class, class, class, class, class> class Ptr  //8arg
+         , typename A, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7
+         , class U>
+struct pointer_rebinder<Ptr<A, P0, P1, P2, P3, P4, P5, P6, P7>, U, 0u>
+{  typedef Ptr<U, P0, P1, P2, P3, P4, P5, P6, P7> type;   };
+
+template <template <class, class, class, class, class, class, class, class, class, class> class Ptr  //9arg
+         , typename A, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8
+         , class U>
+struct pointer_rebinder<Ptr<A, P0, P1, P2, P3, P4, P5, P6, P7, P8>, U, 0u>
+{  typedef Ptr<U, P0, P1, P2, P3, P4, P5, P6, P7, P8> type;   };
+
+#endif   //!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+
+template <typename Ptr, typename U>
+struct pointer_rebind
+   : public pointer_rebinder<Ptr, U, pointer_rebind_mode<Ptr, U>::mode>
+{};
+
+template <typename T, typename U>
+struct pointer_rebind<T*, U>
+{  typedef U* type; };
+
+}  //namespace container {
+}  //namespace boost {
+
+#endif // defined(BOOST_INTRUSIVE_POINTER_REBIND_HPP)

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

@@ -6,7 +6,7 @@
 //
 //////////////////////////////////////////////////////////////////////////////
 //
-// (C) Copyright Ion Gaztanaga 2011-2012. Distributed under the Boost
+// (C) Copyright Ion Gaztanaga 2011-2014. 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)
 //
@@ -17,23 +17,53 @@
 #ifndef BOOST_INTRUSIVE_POINTER_TRAITS_HPP
 #define BOOST_INTRUSIVE_POINTER_TRAITS_HPP
 
-#if (defined _MSC_VER) && (_MSC_VER >= 1200)
-#  pragma once
-#endif
-
 #include <boost/intrusive/detail/config_begin.hpp>
 #include <boost/intrusive/detail/workaround.hpp>
-#include <boost/intrusive/detail/memory_util.hpp>
-#include <boost/type_traits/integral_constant.hpp>
+#include <boost/intrusive/pointer_rebind.hpp>
+#include <boost/intrusive/detail/pointer_element.hpp>
+#include <boost/intrusive/detail/mpl.hpp>
 #include <cstddef>
 
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
 namespace boost {
 namespace intrusive {
+namespace detail {
+
+#if !defined(BOOST_MSVC) || (BOOST_MSVC > 1310)
+BOOST_INTRUSIVE_HAS_STATIC_MEMBER_FUNC_SIGNATURE(has_member_function_callable_with_pointer_to, pointer_to)
+BOOST_INTRUSIVE_HAS_STATIC_MEMBER_FUNC_SIGNATURE(has_member_function_callable_with_dynamic_cast_from, dynamic_cast_from)
+BOOST_INTRUSIVE_HAS_STATIC_MEMBER_FUNC_SIGNATURE(has_member_function_callable_with_static_cast_from, static_cast_from)
+BOOST_INTRUSIVE_HAS_STATIC_MEMBER_FUNC_SIGNATURE(has_member_function_callable_with_const_cast_from, const_cast_from)
+#else
+BOOST_INTRUSIVE_HAS_MEMBER_FUNC_CALLED_IGNORE_SIGNATURE(has_member_function_callable_with_pointer_to, pointer_to)
+BOOST_INTRUSIVE_HAS_MEMBER_FUNC_CALLED_IGNORE_SIGNATURE(has_member_function_callable_with_dynamic_cast_from, dynamic_cast_from)
+BOOST_INTRUSIVE_HAS_MEMBER_FUNC_CALLED_IGNORE_SIGNATURE(has_member_function_callable_with_static_cast_from, static_cast_from)
+BOOST_INTRUSIVE_HAS_MEMBER_FUNC_CALLED_IGNORE_SIGNATURE(has_member_function_callable_with_const_cast_from, const_cast_from)
+#endif
+
+BOOST_INTRUSIVE_INSTANTIATE_EVAL_DEFAULT_TYPE_TMPLT(element_type)
+BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(difference_type)
+BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(reference)
+BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(value_traits_ptr)
+
+}  //namespace detail {
+
 
 //! pointer_traits is the implementation of C++11 std::pointer_traits class with some
 //! extensions like castings.
 //!
 //! pointer_traits supplies a uniform interface to certain attributes of pointer-like types.
+//!
+//! <b>Note</b>: When defining a custom family of pointers or references to be used with BI
+//! library, make sure the public static conversion functions accessed through
+//! the `pointer_traits` interface (`*_cast_from` and `pointer_to`) can
+//! properly convert between const and nonconst referred member types
+//! <b>without the use of implicit constructor calls</b>. It is suggested these
+//! conversions be implemented as function templates, where the template
+//! argument is the type of the object being converted from.
 template <typename Ptr>
 struct pointer_traits
 {
@@ -59,11 +89,9 @@ struct pointer_traits
       //!shall be used instead of rebind<U> to obtain a pointer to U.
       template <class U> using rebind = unspecified;
 
-      //!Ptr::rebind<U> if such a type exists; otherwise, SomePointer<U, Args> if Ptr is
-      //!a class template instantiation of the form SomePointer<T, Args>, where Args is zero or
-      //!more type arguments ; otherwise, the instantiation of rebind is ill-formed.
+      //!Ptr::reference if such a type exists (non-standard extension); otherwise, element_type &
       //!
-      typedef element_type &reference;
+      typedef unspecified_type reference;
    #else
       typedef Ptr                                                             pointer;
       //
@@ -73,75 +101,100 @@ struct pointer_traits
       //
       typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT
          (boost::intrusive::detail::, Ptr, difference_type, std::ptrdiff_t)   difference_type;
-      //
-      typedef typename boost::intrusive::detail::unvoid<element_type>::type&  reference;
+
+      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT
+         (boost::intrusive::detail::, Ptr, reference, typename boost::intrusive::detail::unvoid_ref<element_type>::type)   reference;
       //
       template <class U> struct rebind_pointer
       {
-         typedef typename boost::intrusive::detail::type_rebinder<Ptr, U>::type  type;
+         typedef typename boost::intrusive::pointer_rebind<Ptr, U>::type  type;
       };
 
       #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
-         template <class U> using rebind = typename boost::intrusive::detail::type_rebinder<Ptr, U>::type;
+         template <class U> using rebind = typename boost::intrusive::pointer_rebind<Ptr, U>::type;
       #endif
    #endif   //#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 
    //! <b>Remark</b>: If element_type is (possibly cv-qualified) void, r type is unspecified; otherwise,
    //!   it is element_type &.
    //!
-   //! <b>Returns</b>: A dereferenceable pointer to r obtained by calling Ptr::pointer_to(r).
+   //! <b>Returns</b>: A dereferenceable pointer to r obtained by calling Ptr::pointer_to(reference).
    //!   Non-standard extension: If such function does not exist, returns pointer(addressof(r));
+   //!
+   //! <b>Note</b>: For non-conforming compilers only the existence of a member function called
+   //!   <code>pointer_to</code> is checked.
    static pointer pointer_to(reference r)
    {
       //Non-standard extension, it does not require Ptr::pointer_to. If not present
       //tries to converts &r to pointer.
       const bool value = boost::intrusive::detail::
          has_member_function_callable_with_pointer_to
-            <Ptr, typename boost::intrusive::detail::unvoid<element_type &>::type>::value;
-      ::boost::integral_constant<bool, value> flag;
+            <Ptr, Ptr (*)(reference)>::value;
+      boost::intrusive::detail::bool_<value> flag;
       return pointer_traits::priv_pointer_to(flag, r);
    }
 
    //! <b>Remark</b>: Non-standard extension.
    //!
-   //! <b>Returns</b>: A dereferenceable pointer to r obtained by calling Ptr::static_cast_from(r).
+   //! <b>Returns</b>: A dereferenceable pointer to r obtained by calling the static template function
+   //!   Ptr::static_cast_from(UPpr/const UPpr &).
    //!   If such function does not exist, returns pointer_to(static_cast<element_type&>(*uptr))
+   //!
+   //! <b>Note</b>: For non-conforming compilers only the existence of a member function called
+   //!   <code>static_cast_from</code> is checked.
    template<class UPtr>
    static pointer static_cast_from(const UPtr &uptr)
    {
+      typedef const UPtr &RefArg;
       const bool value = boost::intrusive::detail::
          has_member_function_callable_with_static_cast_from
-            <Ptr, const UPtr>::value;
-      ::boost::integral_constant<bool, value> flag;
-      return pointer_traits::priv_static_cast_from(flag, uptr);
+            <pointer, pointer(*)(RefArg)>::value
+         || boost::intrusive::detail::
+               has_member_function_callable_with_static_cast_from
+                  <pointer, pointer(*)(UPtr)>::value;
+      return pointer_traits::priv_static_cast_from(boost::intrusive::detail::bool_<value>(), uptr);
    }
 
    //! <b>Remark</b>: Non-standard extension.
    //!
-   //! <b>Returns</b>: A dereferenceable pointer to r obtained by calling Ptr::const_cast_from(r).
+   //! <b>Returns</b>: A dereferenceable pointer to r obtained by calling the static template function
+   //!   Ptr::const_cast_from<UPtr>(UPpr/const UPpr &).
    //!   If such function does not exist, returns pointer_to(const_cast<element_type&>(*uptr))
+   //!
+   //! <b>Note</b>: For non-conforming compilers only the existence of a member function called
+   //!   <code>const_cast_from</code> is checked.
    template<class UPtr>
    static pointer const_cast_from(const UPtr &uptr)
    {
+      typedef const UPtr &RefArg;
       const bool value = boost::intrusive::detail::
          has_member_function_callable_with_const_cast_from
-            <Ptr, const UPtr>::value;
-      ::boost::integral_constant<bool, value> flag;
-      return pointer_traits::priv_const_cast_from(flag, uptr);
+            <pointer, pointer(*)(RefArg)>::value
+         || boost::intrusive::detail::
+               has_member_function_callable_with_const_cast_from
+                  <pointer, pointer(*)(UPtr)>::value;
+      return pointer_traits::priv_const_cast_from(boost::intrusive::detail::bool_<value>(), uptr);
    }
 
    //! <b>Remark</b>: Non-standard extension.
    //!
-   //! <b>Returns</b>: A dereferenceable pointer to r obtained by calling Ptr::dynamic_cast_from(r).
+   //! <b>Returns</b>: A dereferenceable pointer to r obtained by calling the static template function
+   //!   Ptr::dynamic_cast_from<UPtr>(UPpr/const UPpr &).
    //!   If such function does not exist, returns pointer_to(*dynamic_cast<element_type*>(&*uptr))
+   //!
+   //! <b>Note</b>: For non-conforming compilers only the existence of a member function called
+   //!   <code>dynamic_cast_from</code> is checked.
    template<class UPtr>
    static pointer dynamic_cast_from(const UPtr &uptr)
    {
+      typedef const UPtr &RefArg;
       const bool value = boost::intrusive::detail::
          has_member_function_callable_with_dynamic_cast_from
-            <Ptr, const UPtr>::value;
-      ::boost::integral_constant<bool, value> flag;
-      return pointer_traits::priv_dynamic_cast_from(flag, uptr);
+            <pointer, pointer(*)(RefArg)>::value
+         || boost::intrusive::detail::
+               has_member_function_callable_with_dynamic_cast_from
+                  <pointer, pointer(*)(UPtr)>::value;
+      return pointer_traits::priv_dynamic_cast_from(boost::intrusive::detail::bool_<value>(), uptr);
    }
 
    ///@cond
@@ -157,38 +210,38 @@ struct pointer_traits
    {  return pointer_traits::to_raw_pointer(p.operator->());  }
 
    //priv_pointer_to
-   static pointer priv_pointer_to(boost::true_type, typename boost::intrusive::detail::unvoid<element_type>::type& r)
-      { return Ptr::pointer_to(r); }
+   static pointer priv_pointer_to(boost::intrusive::detail::true_, reference r)
+   { return Ptr::pointer_to(r); }
 
-   static pointer priv_pointer_to(boost::false_type, typename boost::intrusive::detail::unvoid<element_type>::type& r)
-      { return pointer(boost::intrusive::detail::addressof(r)); }
+   static pointer priv_pointer_to(boost::intrusive::detail::false_, reference r)
+   { return pointer(boost::intrusive::detail::addressof(r)); }
 
    //priv_static_cast_from
    template<class UPtr>
-   static pointer priv_static_cast_from(boost::true_type, const UPtr &uptr)
+   static pointer priv_static_cast_from(boost::intrusive::detail::true_, const UPtr &uptr)
    { return Ptr::static_cast_from(uptr); }
 
    template<class UPtr>
-   static pointer priv_static_cast_from(boost::false_type, const UPtr &uptr)
-   {  return pointer_to(*static_cast<element_type*>(to_raw_pointer(uptr)));  }
+   static pointer priv_static_cast_from(boost::intrusive::detail::false_, const UPtr &uptr)
+   {  return uptr ? pointer_to(*static_cast<element_type*>(to_raw_pointer(uptr))) : pointer();  }
 
    //priv_const_cast_from
    template<class UPtr>
-   static pointer priv_const_cast_from(boost::true_type, const UPtr &uptr)
+   static pointer priv_const_cast_from(boost::intrusive::detail::true_, const UPtr &uptr)
    { return Ptr::const_cast_from(uptr); }
 
    template<class UPtr>
-   static pointer priv_const_cast_from(boost::false_type, const UPtr &uptr)
-   {  return pointer_to(const_cast<element_type&>(*uptr));  }
+   static pointer priv_const_cast_from(boost::intrusive::detail::false_, const UPtr &uptr)
+   {  return uptr ? pointer_to(const_cast<element_type&>(*uptr)) : pointer();  }
 
    //priv_dynamic_cast_from
    template<class UPtr>
-   static pointer priv_dynamic_cast_from(boost::true_type, const UPtr &uptr)
+   static pointer priv_dynamic_cast_from(boost::intrusive::detail::true_, const UPtr &uptr)
    { return Ptr::dynamic_cast_from(uptr); }
 
    template<class UPtr>
-   static pointer priv_dynamic_cast_from(boost::false_type, const UPtr &uptr)
-   {  return pointer_to(*dynamic_cast<element_type*>(&*uptr));  }
+   static pointer priv_dynamic_cast_from(boost::intrusive::detail::false_, const UPtr &uptr)
+   {  return uptr ? pointer_to(dynamic_cast<element_type&>(*uptr)) : pointer();  }
    ///@endcond
 };
 
@@ -224,7 +277,7 @@ struct pointer_traits<T*>
       //!shall be used instead of rebind<U> to obtain a pointer to U.
       template <class U> using rebind = U*;
    #else
-      typedef typename boost::intrusive::detail::unvoid<element_type>::type& reference;
+      typedef typename boost::intrusive::detail::unvoid_ref<element_type>::type reference;
       #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
          template <class U> using rebind = U*;
       #endif

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

@@ -16,23 +16,48 @@
 #include <boost/intrusive/detail/config_begin.hpp>
 #include <boost/intrusive/intrusive_fwd.hpp>
 
-#include <functional>
+#include <boost/intrusive/detail/minimal_less_equal_header.hpp>
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
 
 namespace boost {
 namespace intrusive {
 
 template <class T>
 struct priority_compare
-   : public std::binary_function<T, T, bool>
 {
+   //Compatibility with std::binary_function
+   typedef T      first_argument_type;
+   typedef T      second_argument_type;
+   typedef bool   result_type;
+
    bool operator()(const T &val, const T &val2) const
    {
       return priority_order(val, val2);
    }
 };
 
-} //namespace intrusive 
-} //namespace boost 
+/// @cond
+
+template<class Less, class T>
+struct get_prio
+{
+   typedef Less type;
+};
+
+
+template<class T>
+struct get_prio<void, T>
+{
+   typedef ::boost::intrusive::priority_compare<T> type;
+};
+
+/// @endcond
+
+} //namespace intrusive
+} //namespace boost
 
 #include <boost/intrusive/detail/config_end.hpp>