passenger 6.0.1 → 6.0.6

data/src/cxx_supportlib/vendor-modified/boost/circular_buffer/details.hpp

@@ -1,7 +1,9 @@
 // Helper classes and functions for the circular buffer.
 
 // Copyright (c) 2003-2008 Jan Gaspar
-// Copyright (c) 2014 Glen Joseph Fernandes   // C++11 allocator model support.
+
+// Copyright 2014,2018 Glen Joseph Fernandes
+// (glenjofe@gmail.com)
 
 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@@ -15,12 +17,11 @@
 #endif
 
 #include <boost/throw_exception.hpp>
-#include <boost/container/allocator_traits.hpp>
+#include <boost/circular_buffer/allocators.hpp>
 #include <boost/core/pointer_traits.hpp>
 #include <boost/move/move.hpp>
 #include <boost/type_traits/is_nothrow_move_constructible.hpp>
-#include <boost/utility/addressof.hpp>
-#include <boost/detail/no_exceptions_support.hpp>
+#include <boost/core/no_exceptions_support.hpp>
 #include <iterator>
 
 // Silence MS /W4 warnings like C4913:
@@ -56,7 +57,7 @@ struct const_traits {
     // Basic types
     typedef typename Traits::value_type value_type;
     typedef typename Traits::const_pointer pointer;
-    typedef typename Traits::const_reference reference;
+    typedef const value_type& reference;
     typedef typename Traits::size_type size_type;
     typedef typename Traits::difference_type difference_type;
 
@@ -73,7 +74,7 @@ struct nonconst_traits {
     // Basic types
     typedef typename Traits::value_type value_type;
     typedef typename Traits::pointer pointer;
-    typedef typename Traits::reference reference;
+    typedef value_type& reference;
     typedef typename Traits::size_type size_type;
     typedef typename Traits::difference_type difference_type;
 
@@ -113,7 +114,7 @@ private:
 */
 template <class Value, class Alloc>
 struct assign_n {
-    typedef typename boost::container::allocator_traits<Alloc>::size_type size_type;
+    typedef typename allocator_traits<Alloc>::size_type size_type;
     size_type m_n;
     Value m_item;
     Alloc& m_alloc;
@@ -195,46 +196,33 @@ public:
           for iterating from begin() to end() of the circular buffer.
 */
 template <class Buff, class Traits>
-struct iterator :
-    public std::iterator<
-    std::random_access_iterator_tag,
-    typename Traits::value_type,
-    typename Traits::difference_type,
-    typename Traits::pointer,
-    typename Traits::reference>
+struct iterator
 #if BOOST_CB_ENABLE_DEBUG
-    , public debug_iterator_base
+    : public debug_iterator_base
 #endif // #if BOOST_CB_ENABLE_DEBUG
 {
 // Helper types
 
-    //! Base iterator.
-    typedef std::iterator<
-        std::random_access_iterator_tag,
-        typename Traits::value_type,
-        typename Traits::difference_type,
-        typename Traits::pointer,
-        typename Traits::reference> base_iterator;
-
     //! Non-const iterator.
     typedef iterator<Buff, typename Traits::nonconst_self> nonconst_self;
 
 // Basic types
+    typedef std::random_access_iterator_tag iterator_category;
 
     //! The type of the elements stored in the circular buffer.
-    typedef typename base_iterator::value_type value_type;
+    typedef typename Traits::value_type value_type;
 
     //! Pointer to the element.
-    typedef typename base_iterator::pointer pointer;
+    typedef typename Traits::pointer pointer;
 
     //! Reference to the element.
-    typedef typename base_iterator::reference reference;
+    typedef typename Traits::reference reference;
 
     //! Size type.
     typedef typename Traits::size_type size_type;
 
     //! Difference type.
-    typedef typename base_iterator::difference_type difference_type;
+    typedef typename Traits::difference_type difference_type;
 
 // Member variables
 
@@ -436,10 +424,10 @@ inline ForwardIterator uninitialized_copy(InputIterator first, InputIterator las
     ForwardIterator next = dest;
     BOOST_TRY {
         for (; first != last; ++first, ++dest)
-            boost::container::allocator_traits<Alloc>::construct(a, boost::to_address(dest), *first);
+            allocator_traits<Alloc>::construct(a, boost::to_address(dest), *first);
     } BOOST_CATCH(...) {
         for (; next != dest; ++next)
-            boost::container::allocator_traits<Alloc>::destroy(a, boost::to_address(next));
+            allocator_traits<Alloc>::destroy(a, boost::to_address(next));
         BOOST_RETHROW
     }
     BOOST_CATCH_END
@@ -450,7 +438,7 @@ template
 ForwardIterator uninitialized_move_if_noexcept_impl(InputIterator first, InputIterator last, ForwardIterator dest, Alloc& a,
     true_type) {
     for (; first != last; ++first, ++dest)
-        boost::container::allocator_traits<Alloc>::construct(a, boost::to_address(dest), boost::move(*first));
+        allocator_traits<Alloc>::construct(a, boost::to_address(dest), boost::move(*first));
     return dest;
 }
 
@@ -466,7 +454,7 @@ ForwardIterator uninitialized_move_if_noexcept_impl(InputIterator first, InputIt
 */
 template<class InputIterator, class ForwardIterator, class Alloc>
 ForwardIterator uninitialized_move_if_noexcept(InputIterator first, InputIterator last, ForwardIterator dest, Alloc& a) {
-    typedef typename boost::is_nothrow_move_constructible<typename boost::container::allocator_traits<Alloc>::value_type>::type tag_t;
+    typedef typename boost::is_nothrow_move_constructible<typename allocator_traits<Alloc>::value_type>::type tag_t;
     return uninitialized_move_if_noexcept_impl(first, last, dest, a, tag_t());
 }
 
@@ -479,10 +467,10 @@ inline void uninitialized_fill_n_with_alloc(ForwardIterator first, Diff n, const
     ForwardIterator next = first;
     BOOST_TRY {
         for (; n > 0; ++first, --n)
-            boost::container::allocator_traits<Alloc>::construct(alloc, boost::to_address(first), item);
+            allocator_traits<Alloc>::construct(alloc, boost::to_address(first), item);
     } BOOST_CATCH(...) {
         for (; next != first; ++next)
-            boost::container::allocator_traits<Alloc>::destroy(alloc, boost::to_address(next));
+            allocator_traits<Alloc>::destroy(alloc, boost::to_address(next));
         BOOST_RETHROW
     }
     BOOST_CATCH_END

data/src/cxx_supportlib/vendor-modified/boost/circular_buffer/space_optimized.hpp

@@ -16,7 +16,7 @@
 #endif
 
 #include <boost/type_traits/is_same.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/config/workaround.hpp>
 
 namespace boost {
 
@@ -509,7 +509,7 @@ public:
         first, last, alloc)
     , m_capacity_ctrl(capacity_ctrl) {
         reduce_capacity(
-            is_same< BOOST_DEDUCED_TYPENAME iterator_category<InputIterator>::type, std::input_iterator_tag >());
+            is_same< BOOST_DEDUCED_TYPENAME std::iterator_traits<InputIterator>::iterator_category, std::input_iterator_tag >());
     }
 
 #if defined(BOOST_CB_NEVER_DEFINED)
@@ -579,7 +579,7 @@ public:
     */
     circular_buffer_space_optimized<T, Alloc>& operator = (circular_buffer_space_optimized<T, Alloc>&& cb) BOOST_NOEXCEPT {
         cb.swap(*this); // now `this` holds `cb`
-        circular_buffer<T, Alloc>(get_allocator()) // temprary that holds initial `cb` allocator
+        circular_buffer<T, Alloc>(get_allocator()) // temporary that holds initial `cb` allocator
             .swap(cb); // makes `cb` empty
         return *this;
     }
@@ -1605,10 +1605,10 @@ private:
         const false_type&) {
         BOOST_CB_IS_CONVERTIBLE(Iterator, value_type); // check for invalid iterator type
 #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581))
-        return init_capacity(capacity_ctrl, first, last, iterator_category<Iterator>::type());
+        return init_capacity(capacity_ctrl, first, last, std::iterator_traits<Iterator>::iterator_category());
 #else
         return init_capacity(
-            capacity_ctrl, first, last, BOOST_DEDUCED_TYPENAME iterator_category<Iterator>::type());
+            capacity_ctrl, first, last, BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::iterator_category());
 #endif
     }
 

data/src/cxx_supportlib/vendor-modified/boost/concept/assert.hpp

@@ -5,7 +5,7 @@
 # define BOOST_CONCEPT_ASSERT_DWA2006430_HPP
 
 # include <boost/config.hpp>
-# include <boost/detail/workaround.hpp>
+# include <boost/config/workaround.hpp>
 
 // The old protocol used a constraints() member function in concept
 // checking classes.  If the compiler supports SFINAE, we can detect

data/src/cxx_supportlib/vendor-modified/boost/concept/detail/general.hpp

@@ -10,7 +10,7 @@
 
 # ifdef BOOST_OLD_CONCEPT_SUPPORT
 #  include <boost/concept/detail/has_constraints.hpp>
-#  include <boost/mpl/if.hpp>
+#  include <boost/type_traits/conditional.hpp>
 # endif
 
 // This implementation works on Comeau and GCC, all the way back to
@@ -49,8 +49,8 @@ struct constraint
   
 template <class Model>
 struct requirement_<void(*)(Model)>
-  : mpl::if_<
-        concepts::not_satisfied<Model>
+  : boost::conditional<
+        concepts::not_satisfied<Model>::value
       , constraint<Model>
       , requirement<failed ************ Model::************>
     >::type

data/src/cxx_supportlib/vendor-modified/boost/concept/detail/has_constraints.hpp

@@ -4,8 +4,8 @@
 #ifndef BOOST_CONCEPT_DETAIL_HAS_CONSTRAINTS_DWA2006429_HPP
 # define BOOST_CONCEPT_DETAIL_HAS_CONSTRAINTS_DWA2006429_HPP
 
-# include <boost/mpl/bool.hpp>
-# include <boost/detail/workaround.hpp>
+# include <boost/type_traits/integral_constant.hpp>
+# include <boost/config/workaround.hpp>
 # include <boost/concept/detail/backward_compatibility.hpp>
 
 namespace boost { namespace concepts {
@@ -42,7 +42,7 @@ struct not_satisfied
     BOOST_STATIC_CONSTANT(
         bool
       , value = sizeof( detail::has_constraints_((Model*)0) ) == sizeof(detail::yes) );
-    typedef mpl::bool_<value> type;
+    typedef boost::integral_constant<bool, value> type;
 };
 
 }} // namespace boost::concepts::detail

data/src/cxx_supportlib/vendor-modified/boost/concept/usage.hpp

@@ -5,7 +5,7 @@
 # define BOOST_CONCEPT_USAGE_DWA2006919_HPP
 
 # include <boost/concept/assert.hpp>
-# include <boost/detail/workaround.hpp>
+# include <boost/config/workaround.hpp>
 # include <boost/concept/detail/backward_compatibility.hpp>
 
 namespace boost { namespace concepts { 

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

@@ -24,9 +24,9 @@
 # include <utility>
 # include <boost/type_traits/is_same.hpp>
 # include <boost/type_traits/is_void.hpp>
-# include <boost/mpl/assert.hpp>
-# include <boost/mpl/bool.hpp>
-# include <boost/detail/workaround.hpp>
+# include <boost/static_assert.hpp>
+# include <boost/type_traits/integral_constant.hpp>
+# include <boost/config/workaround.hpp>
 
 # include <boost/concept/usage.hpp>
 # include <boost/concept/detail/concept_def.hpp>
@@ -301,14 +301,14 @@ namespace boost
       BOOST_CONCEPT_USAGE(Generator) { test(is_void<Return>()); }
 
    private:
-      void test(boost::mpl::false_)
+      void test(boost::false_type)
       {
           // Do we really want a reference here?
           const Return& r = f();
           ignore_unused_variable_warning(r);
       }
 
-      void test(boost::mpl::true_)
+      void test(boost::true_type)
       {
           f();
       }
@@ -321,22 +321,22 @@ namespace boost
       BOOST_CONCEPT_USAGE(UnaryFunction) { test(is_void<Return>()); }
 
    private:
-      void test(boost::mpl::false_)
+      void test(boost::false_type)
       {
           f(arg);               // "priming the pump" this way keeps msvc6 happy (ICE)
           Return r = f(arg);
           ignore_unused_variable_warning(r);
       }
 
-      void test(boost::mpl::true_)
+      void test(boost::true_type)
       {
           f(arg);
       }
 
 #if (BOOST_WORKAROUND(__GNUC__, BOOST_TESTED_AT(4) \
                       && BOOST_WORKAROUND(__GNUC__, > 3)))
-      // Declare a dummy construktor to make gcc happy.
-      // It seems the compiler can not generate a sensible constructor when this is instantiated with a refence type.
+      // Declare a dummy constructor to make gcc happy.
+      // It seems the compiler can not generate a sensible constructor when this is instantiated with a reference type.
       // (warning: non-static reference "const double& boost::UnaryFunction<YourClassHere>::arg"
       // in class without a constructor [-Wuninitialized])
       UnaryFunction();
@@ -350,14 +350,14 @@ namespace boost
   {
       BOOST_CONCEPT_USAGE(BinaryFunction) { test(is_void<Return>()); }
    private:
-      void test(boost::mpl::false_)
+      void test(boost::false_type)
       {
           f(first,second);
           Return r = f(first, second); // require operator()
           (void)r;
       }
 
-      void test(boost::mpl::true_)
+      void test(boost::true_type)
       {
           f(first,second);
       }
@@ -365,7 +365,7 @@ namespace boost
 #if (BOOST_WORKAROUND(__GNUC__, BOOST_TESTED_AT(4) \
                       && BOOST_WORKAROUND(__GNUC__, > 3)))
       // Declare a dummy constructor to make gcc happy.
-      // It seems the compiler can not generate a sensible constructor when this is instantiated with a refence type.
+      // It seems the compiler can not generate a sensible constructor when this is instantiated with a reference type.
       // (warning: non-static reference "const double& boost::BinaryFunction<YourClassHere>::arg"
       // in class without a constructor [-Wuninitialized])
       BinaryFunction();
@@ -385,7 +385,7 @@ namespace boost
 #if (BOOST_WORKAROUND(__GNUC__, BOOST_TESTED_AT(4) \
                       && BOOST_WORKAROUND(__GNUC__, > 3)))
       // Declare a dummy constructor to make gcc happy.
-      // It seems the compiler can not generate a sensible constructor when this is instantiated with a refence type.
+      // It seems the compiler can not generate a sensible constructor when this is instantiated with a reference type.
       // (warning: non-static reference "const double& boost::UnaryPredicate<YourClassHere>::arg"
       // in class without a constructor [-Wuninitialized])
       UnaryPredicate();
@@ -404,7 +404,7 @@ namespace boost
 #if (BOOST_WORKAROUND(__GNUC__, BOOST_TESTED_AT(4) \
                       && BOOST_WORKAROUND(__GNUC__, > 3)))
       // Declare a dummy constructor to make gcc happy.
-      // It seems the compiler can not generate a sensible constructor when this is instantiated with a refence type.
+      // It seems the compiler can not generate a sensible constructor when this is instantiated with a reference type.
       // (warning: non-static reference "const double& boost::BinaryPredicate<YourClassHere>::arg"
       // in class without a constructor [-Wuninitialized])
       BinaryPredicate();
@@ -429,7 +429,7 @@ namespace boost
 #if (BOOST_WORKAROUND(__GNUC__, BOOST_TESTED_AT(4) \
                       && BOOST_WORKAROUND(__GNUC__, > 3)))
       // Declare a dummy constructor to make gcc happy.
-      // It seems the compiler can not generate a sensible constructor when this is instantiated with a refence type.
+      // It seems the compiler can not generate a sensible constructor when this is instantiated with a reference type.
       // (warning: non-static reference "const double& boost::Const_BinaryPredicate<YourClassHere>::arg"
       // in class without a constructor [-Wuninitialized])
       Const_BinaryPredicate();
@@ -734,8 +734,8 @@ namespace boost
    private:
       void const_constraints(const C& cc)
       {
-          const_reverse_iterator i = cc.rbegin();
-          i = cc.rend();
+          const_reverse_iterator _i = cc.rbegin();
+          _i = cc.rend();
       }
       C c;
   };
@@ -966,7 +966,7 @@ namespace boost
       {
           typedef typename C::key_type key_type;
           typedef typename C::value_type value_type;
-          BOOST_MPL_ASSERT((boost::is_same<key_type,value_type>));
+          BOOST_STATIC_ASSERT((boost::is_same<key_type,value_type>::value));
       }
   };
 
@@ -979,7 +979,7 @@ namespace boost
           typedef typename C::value_type value_type;
           typedef typename C::mapped_type mapped_type;
           typedef std::pair<const key_type, mapped_type> required_value_type;
-          BOOST_MPL_ASSERT((boost::is_same<value_type,required_value_type>));
+          BOOST_STATIC_ASSERT((boost::is_same<value_type,required_value_type>::value));
       }
   };
 

data/src/cxx_supportlib/vendor-modified/boost/config/auto_link.hpp

@@ -28,6 +28,9 @@ BOOST_AUTO_LINK_NOMANGLE: Specifies that we should link to BOOST_LIB_NAME.lib,
 BOOST_AUTO_LINK_TAGGED:   Specifies that we link to libraries built with the --layout=tagged option.
                           This is essentially the same as the default name-mangled version, but without
                           the compiler name and version, or the Boost version.  Just the build options.
+BOOST_AUTO_LINK_SYSTEM:   Specifies that we link to libraries built with the --layout=system option.
+                          This is essentially the same as the non-name-mangled version, but with
+                          the prefix to differentiate static and dll builds
 
 These macros will be undef'ed at the end of the header, further this header
 has no include guards - so be sure to include it only once from your library!
@@ -406,6 +409,11 @@ BOOST_LIB_VERSION:    The Boost version, in the form x_y, for Boost version x.y.
 #  ifdef BOOST_LIB_DIAGNOSTIC
 #     pragma message ("Linking to lib file: " BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT ".lib")
 #  endif
+#elif defined(BOOST_AUTO_LINK_SYSTEM)
+#  pragma comment(lib, BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) ".lib")
+#  ifdef BOOST_LIB_DIAGNOSTIC
+#     pragma message ("Linking to lib file: " BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) ".lib")
+#  endif
 #elif defined(BOOST_AUTO_LINK_NOMANGLE)
 #  pragma comment(lib, BOOST_STRINGIZE(BOOST_LIB_NAME) ".lib")
 #  ifdef BOOST_LIB_DIAGNOSTIC

data/src/cxx_supportlib/vendor-modified/boost/config/compiler/borland.hpp

@@ -19,9 +19,9 @@
 // last known compiler version:
 #if (__BORLANDC__ > 0x613)
 //#  if defined(BOOST_ASSERT_CONFIG)
-#     error "Unknown compiler version - please run the configure tests and report the results"
+#     error "boost: Unknown compiler version - please run the configure tests and report the results"
 //#  else
-//#     pragma message( "Unknown compiler version - please run the configure tests and report the results")
+//#     pragma message( "boost: Unknown compiler version - please run the configure tests and report the results")
 //#  endif
 #elif (__BORLANDC__ == 0x600)
 #  error "CBuilderX preview compiler is no longer supported"
@@ -239,6 +239,9 @@
 #if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603)
 #  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
 #endif
+#if !defined(__cpp_if_constexpr) || (__cpp_if_constexpr < 201606)
+#  define BOOST_NO_CXX17_IF_CONSTEXPR
+#endif
 
 #if __BORLANDC__ >= 0x590
 #  define BOOST_HAS_TR1_HASH

data/src/cxx_supportlib/vendor-modified/boost/config/compiler/clang.hpp

@@ -104,9 +104,9 @@
 #  define BOOST_SYMBOL_IMPORT __attribute__((__dllimport__))
 #else
 #  define BOOST_SYMBOL_EXPORT __attribute__((__visibility__("default")))
+#  define BOOST_SYMBOL_VISIBLE __attribute__((__visibility__("default")))
 #  define BOOST_SYMBOL_IMPORT
 #endif
-#define BOOST_SYMBOL_VISIBLE __attribute__((__visibility__("default")))
 
 //
 // The BOOST_FALLTHROUGH macro can be used to annotate implicit fall-through
@@ -294,6 +294,10 @@
 #  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
 #endif
 
+#if !defined(__cpp_if_constexpr) || (__cpp_if_constexpr < 201606)
+#  define BOOST_NO_CXX17_IF_CONSTEXPR
+#endif
+
 // Clang 3.9+ in c++1z
 #if !__has_cpp_attribute(fallthrough) || __cplusplus < 201406L
 #  define BOOST_NO_CXX17_INLINE_VARIABLES

data/src/cxx_supportlib/vendor-modified/boost/config/compiler/codegear.hpp

@@ -22,9 +22,9 @@
 // last known and checked version is 0x621
 #if (__CODEGEARC__ > 0x621)
 #  if defined(BOOST_ASSERT_CONFIG)
-#     error "Unknown compiler version - please run the configure tests and report the results"
+#     error "boost: Unknown compiler version - please run the configure tests and report the results"
 #  else
-#     pragma message( "Unknown compiler version - please run the configure tests and report the results")
+#     pragma message( "boost: Unknown compiler version - please run the configure tests and report the results")
 #  endif
 #endif
 
@@ -167,6 +167,10 @@
 #  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
 #endif
 
+#if !defined(__cpp_if_constexpr) || (__cpp_if_constexpr < 201606)
+#  define BOOST_NO_CXX17_IF_CONSTEXPR
+#endif
+
 //
 // TR1 macros:
 //