passenger 5.3.3 → 5.3.4

data/src/cxx_supportlib/vendor-modified/boost/unordered/unordered_set_fwd.hpp

@@ -17,43 +17,46 @@
 #include <memory>
 
 namespace boost {
-namespace unordered {
-template <class T, class H = boost::hash<T>, class P = std::equal_to<T>,
-    class A = std::allocator<T> >
-class unordered_set;
-
-template <class T, class H, class P, class A>
-inline bool operator==(
-    unordered_set<T, H, P, A> const&, unordered_set<T, H, P, A> const&);
-template <class T, class H, class P, class A>
-inline bool operator!=(
-    unordered_set<T, H, P, A> const&, unordered_set<T, H, P, A> const&);
-template <class T, class H, class P, class A>
-inline void swap(unordered_set<T, H, P, A>& m1, unordered_set<T, H, P, A>& m2);
-
-template <class T, class H = boost::hash<T>, class P = std::equal_to<T>,
-    class A = std::allocator<T> >
-class unordered_multiset;
-
-template <class T, class H, class P, class A>
-inline bool operator==(unordered_multiset<T, H, P, A> const&,
-    unordered_multiset<T, H, P, A> const&);
-template <class T, class H, class P, class A>
-inline bool operator!=(unordered_multiset<T, H, P, A> const&,
-    unordered_multiset<T, H, P, A> const&);
-template <class T, class H, class P, class A>
-inline void swap(
-    unordered_multiset<T, H, P, A>& m1, unordered_multiset<T, H, P, A>& m2);
-
-template <class N, class T, class A> class node_handle_set;
-template <class N, class T, class A> struct insert_return_type_set;
-}
-
-using boost::unordered::unordered_set;
-using boost::unordered::unordered_multiset;
-using boost::unordered::swap;
-using boost::unordered::operator==;
-using boost::unordered::operator!=;
+  namespace unordered {
+    template <class T, class H = boost::hash<T>, class P = std::equal_to<T>,
+      class A = std::allocator<T> >
+    class unordered_set;
+
+    template <class T, class H, class P, class A>
+    inline bool operator==(
+      unordered_set<T, H, P, A> const&, unordered_set<T, H, P, A> const&);
+    template <class T, class H, class P, class A>
+    inline bool operator!=(
+      unordered_set<T, H, P, A> const&, unordered_set<T, H, P, A> const&);
+    template <class T, class H, class P, class A>
+    inline void swap(
+      unordered_set<T, H, P, A>& m1, unordered_set<T, H, P, A>& m2)
+      BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(m1.swap(m2)));
+
+    template <class T, class H = boost::hash<T>, class P = std::equal_to<T>,
+      class A = std::allocator<T> >
+    class unordered_multiset;
+
+    template <class T, class H, class P, class A>
+    inline bool operator==(unordered_multiset<T, H, P, A> const&,
+      unordered_multiset<T, H, P, A> const&);
+    template <class T, class H, class P, class A>
+    inline bool operator!=(unordered_multiset<T, H, P, A> const&,
+      unordered_multiset<T, H, P, A> const&);
+    template <class T, class H, class P, class A>
+    inline void swap(
+      unordered_multiset<T, H, P, A>& m1, unordered_multiset<T, H, P, A>& m2)
+      BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(m1.swap(m2)));
+
+    template <class N, class T, class A> class node_handle_set;
+    template <class N, class T, class A> struct insert_return_type_set;
+  }
+
+  using boost::unordered::unordered_set;
+  using boost::unordered::unordered_multiset;
+  using boost::unordered::swap;
+  using boost::unordered::operator==;
+  using boost::unordered::operator!=;
 }
 
 #endif

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

@@ -9,13 +9,16 @@
 #ifndef BOOST_UTILITY_HPP
 #define BOOST_UTILITY_HPP
 
-#include <boost/utility/addressof.hpp>
+// Use of this header is discouraged and it will be deprecated.
+// Please include one or more of the headers below instead.
+
 #include <boost/utility/base_from_member.hpp>
 #include <boost/utility/binary.hpp>
-#include <boost/utility/enable_if.hpp>
 #include <boost/utility/identity_type.hpp>
+
+#include <boost/core/addressof.hpp>
+#include <boost/core/enable_if.hpp>
 #include <boost/core/checked_delete.hpp>
 #include <boost/core/noncopyable.hpp>
-#include <boost/next_prior.hpp>
 
 #endif  // BOOST_UTILITY_HPP

data/src/cxx_supportlib/vendor-modified/boost/utility/detail/minstd_rand.hpp

@@ -0,0 +1,55 @@
+#ifndef BOOST_UTILITY_DETAIL_MINSTD_RAND_HPP_INCLUDED
+#define BOOST_UTILITY_DETAIL_MINSTD_RAND_HPP_INCLUDED
+
+// Copyright 2017 Peter Dimov
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// An implementation of minstd_rand that does not require
+// the Random library
+
+#include <boost/cstdint.hpp>
+
+namespace boost
+{
+namespace detail
+{
+
+class minstd_rand
+{
+private:
+
+    boost::uint_least32_t x_;
+
+    enum { a = 48271, m = 2147483647 };
+
+public:
+
+    minstd_rand(): x_( 1 )
+    {
+    }
+
+    explicit minstd_rand( boost::uint_least32_t x ): x_( x % m )
+    {
+        if( x_ == 0 )
+        {
+            x_ = 1;
+        }
+    }
+
+    boost::uint_least32_t operator()()
+    {
+        boost::uint_least64_t y = x_;
+
+        y = ( a * y ) % m;
+
+        x_ = static_cast<boost::uint_least32_t>( y );
+
+        return x_;
+    }
+};
+
+} // namespace detail
+} // namespace boost
+
+#endif // #ifndef BOOST_UTILITY_DETAIL_MINSTD_RAND_HPP_INCLUDED

data/src/cxx_supportlib/vendor-modified/boost/utility/detail/result_of_iterate.hpp

@@ -25,16 +25,16 @@
 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
 template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
 struct tr1_result_of<F(BOOST_RESULT_OF_ARGS)>
-    : mpl::if_<
-          mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
+    : conditional<
+        is_pointer<F>::value || is_member_function_pointer<F>::value
         , boost::detail::tr1_result_of_impl<
             typename remove_cv<F>::type,
             typename remove_cv<F>::type(BOOST_RESULT_OF_ARGS),
-            (boost::detail::has_result_type<F>::value)>
+            (boost::detail::result_of_has_result_type<F>::value)>
         , boost::detail::tr1_result_of_impl<
             F,
             F(BOOST_RESULT_OF_ARGS),
-            (boost::detail::has_result_type<F>::value)> >::type { };
+            (boost::detail::result_of_has_result_type<F>::value)> >::type { };
 #endif
 
 #ifdef BOOST_RESULT_OF_USE_DECLTYPE
@@ -46,7 +46,7 @@ struct result_of<F(BOOST_RESULT_OF_ARGS)>
 #ifdef BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK
 template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
 struct result_of<F(BOOST_RESULT_OF_ARGS)>
-    : mpl::if_<mpl::or_<detail::has_result_type<F>, detail::has_result<F> >,
+    : conditional<detail::result_of_has_result_type<F>::value || detail::result_of_has_result<F>::value,
                tr1_result_of<F(BOOST_RESULT_OF_ARGS)>,
                detail::cpp0x_result_of<F(BOOST_RESULT_OF_ARGS)> >::type { };
 #endif // BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK
@@ -57,8 +57,8 @@ namespace detail {
 
 template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
 struct cpp0x_result_of<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T))>
-    : mpl::if_<
-          is_member_function_pointer<F>
+    : conditional<
+          is_member_function_pointer<F>::value
         , detail::tr1_result_of_impl<
             typename remove_cv<F>::type,
             typename remove_cv<F>::type(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), false
@@ -82,25 +82,22 @@ struct BOOST_PP_CAT(result_of_callable_fun_2_, BOOST_PP_ITERATION())<R(BOOST_PP_
 };
 
 template<typename F>
-struct BOOST_PP_CAT(result_of_callable_fun_, BOOST_PP_ITERATION());
-
-template<typename F>
-struct BOOST_PP_CAT(result_of_callable_fun_, BOOST_PP_ITERATION())<F *>
+struct BOOST_PP_CAT(result_of_callable_fun_, BOOST_PP_ITERATION())
   : BOOST_PP_CAT(result_of_callable_fun_2_, BOOST_PP_ITERATION())<F>
 {};
 
 template<typename F>
-struct BOOST_PP_CAT(result_of_callable_fun_, BOOST_PP_ITERATION())<F &>
+struct BOOST_PP_CAT(result_of_callable_fun_, BOOST_PP_ITERATION())<F *>
   : BOOST_PP_CAT(result_of_callable_fun_2_, BOOST_PP_ITERATION())<F>
 {};
 
 template<typename F>
 struct BOOST_PP_CAT(result_of_select_call_wrapper_type_, BOOST_PP_ITERATION())
-  : mpl::eval_if<
-        is_class<typename remove_reference<F>::type>,
+  : conditional<
+        is_class<typename remove_reference<F>::type>::value,
         result_of_wrap_callable_class<F>,
-        mpl::identity<BOOST_PP_CAT(result_of_callable_fun_, BOOST_PP_ITERATION())<typename remove_cv<F>::type> >
-    >
+        type_identity<BOOST_PP_CAT(result_of_callable_fun_, BOOST_PP_ITERATION())<typename remove_cv<typename remove_reference<F>::type>::type> >
+    >::type
 {};
 
 template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(), typename T)>
@@ -111,7 +108,7 @@ struct BOOST_PP_CAT(result_of_is_callable_, BOOST_PP_ITERATION()) {
             (boost::declval<wrapper_t>()(BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_ITERATION(), boost::declval<T, >() BOOST_PP_INTERCEPT)), result_of_weird_type())
         ))
     );
-    typedef mpl::bool_<value> type;
+    typedef integral_constant<bool, value> type;
 };
 
 template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>

data/src/cxx_supportlib/vendor-modified/boost/utility/result_of.hpp

@@ -18,19 +18,16 @@
 #include <boost/preprocessor/repetition/enum_shifted_params.hpp>
 #include <boost/preprocessor/facilities/intercept.hpp>
 #include <boost/detail/workaround.hpp>
-#include <boost/mpl/has_xxx.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/mpl/or.hpp>
 #include <boost/type_traits/is_class.hpp>
 #include <boost/type_traits/is_pointer.hpp>
 #include <boost/type_traits/is_member_function_pointer.hpp>
 #include <boost/type_traits/remove_cv.hpp>
 #include <boost/type_traits/remove_reference.hpp>
-#include <boost/utility/declval.hpp>
-#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/declval.hpp>
+#include <boost/type_traits/conditional.hpp>
+#include <boost/type_traits/type_identity.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/core/enable_if.hpp>
 
 #ifndef BOOST_RESULT_OF_NUM_ARGS
 #  define BOOST_RESULT_OF_NUM_ARGS 16
@@ -47,10 +44,6 @@
   BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK cannot be defined at the same time.
 #endif
 
-#if defined(BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK) && defined(BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE)
-#  error Cannot fallback to decltype if BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE is not defined.
-#endif
-
 #ifndef BOOST_RESULT_OF_USE_TR1
 #  ifndef BOOST_RESULT_OF_USE_DECLTYPE
 #    ifndef BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK
@@ -71,11 +64,40 @@ template<typename F> struct tr1_result_of; // a TR1-style implementation of resu
 #if !defined(BOOST_NO_SFINAE)
 namespace detail {
 
-BOOST_MPL_HAS_XXX_TRAIT_DEF(result_type)
+typedef char result_of_yes_type;      // sizeof(result_of_yes_type) == 1
+typedef char (&result_of_no_type)[2]; // sizeof(result_of_no_type)  == 2
+
+template<class T> struct result_of_has_type {};
+
+template<class T> struct result_of_has_result_type_impl
+{
+    template<class U> static result_of_yes_type f( result_of_has_type<typename U::result_type>* );
+    template<class U> static result_of_no_type f( ... );
+
+    typedef boost::integral_constant<bool, sizeof(f<T>(0)) == sizeof(result_of_yes_type)> type;
+};
+
+template<class T> struct result_of_has_result_type: result_of_has_result_type_impl<T>::type
+{
+};
 
 // Work around a nvcc bug by only defining has_result when it's needed.
 #ifdef BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK
-BOOST_MPL_HAS_XXX_TEMPLATE_DEF(result)
+
+template<template<class> class C> struct result_of_has_template {};
+
+template<class T> struct result_of_has_result_impl
+{
+    template<class U> static result_of_yes_type f( result_of_has_template<U::template result>* );
+    template<class U> static result_of_no_type f( ... );
+
+    typedef boost::integral_constant<bool, sizeof(f<T>(0)) == sizeof(result_of_yes_type)> type;
+};
+
+template<class T> struct result_of_has_result: result_of_has_result_impl<T>::type
+{
+};
+
 #endif
 
 template<typename F, typename FArgs, bool HasResultType> struct tr1_result_of_impl;
@@ -97,9 +119,6 @@ struct result_of_weird_type {
   friend result_of_private_type operator,(result_of_private_type, result_of_weird_type);
 };
 
-typedef char result_of_yes_type;      // sizeof(result_of_yes_type) == 1
-typedef char (&result_of_no_type)[2]; // sizeof(result_of_no_type)  == 2
-
 template<typename T>
 result_of_no_type result_of_is_private_type(T const &);
 result_of_yes_type result_of_is_private_type(result_of_private_type);
@@ -180,10 +199,10 @@ struct tr1_result_of_impl<F, FArgs, true>
 };
 
 template<typename FArgs>
-struct is_function_with_no_args : mpl::false_ {};
+struct is_function_with_no_args : false_type {};
 
 template<typename F>
-struct is_function_with_no_args<F(void)> : mpl::true_ {};
+struct is_function_with_no_args<F(void)> : true_type {};
 
 template<typename F, typename FArgs>
 struct result_of_nested_result : F::template result<FArgs>
@@ -191,7 +210,7 @@ struct result_of_nested_result : F::template result<FArgs>
 
 template<typename F, typename FArgs>
 struct tr1_result_of_impl<F, FArgs, false>
-  : mpl::if_<is_function_with_no_args<FArgs>,
+  : conditional<is_function_with_no_args<FArgs>::value,
              result_of_void_impl<F>,
              result_of_nested_result<F, FArgs> >::type
 {};
@@ -201,6 +220,11 @@ struct tr1_result_of_impl<F, FArgs, false>
 #define BOOST_PP_ITERATION_PARAMS_1 (3,(0,BOOST_RESULT_OF_NUM_ARGS,<boost/utility/detail/result_of_iterate.hpp>))
 #include BOOST_PP_ITERATE()
 
+#if 0
+// inform dependency trackers, as they can't see through macro includes
+#include <boost/utility/detail/result_of_iterate.hpp>
+#endif
+
 #else
 #  define BOOST_NO_RESULT_OF 1
 #endif

data/src/cxx_supportlib/vendor-modified/boost/utility/string_view.hpp

@@ -368,7 +368,7 @@ namespace boost {
 //  Comparison operators
 //  Equality
     template<typename charT, typename traits>
-    inline bool operator==(basic_string_view<charT, traits> x,
+    inline BOOST_CXX14_CONSTEXPR bool operator==(basic_string_view<charT, traits> x,
                            basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
         if (x.size () != y.size ()) return false;
         return x.compare(y) == 0;
@@ -376,7 +376,7 @@ namespace boost {
 
 //  Inequality
     template<typename charT, typename traits>
-    inline bool operator!=(basic_string_view<charT, traits> x,
+    inline BOOST_CXX14_CONSTEXPR bool operator!=(basic_string_view<charT, traits> x,
                            basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
         if ( x.size () != y.size ()) return true;
         return x.compare(y) != 0;
@@ -384,173 +384,173 @@ namespace boost {
 
 //  Less than
     template<typename charT, typename traits>
-    inline bool operator<(basic_string_view<charT, traits> x,
+    inline BOOST_CXX14_CONSTEXPR bool operator<(basic_string_view<charT, traits> x,
                           basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
         return x.compare(y) < 0;
         }
 
 //  Greater than
     template<typename charT, typename traits>
-    inline bool operator>(basic_string_view<charT, traits> x,
+    inline BOOST_CXX14_CONSTEXPR bool operator>(basic_string_view<charT, traits> x,
                           basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
         return x.compare(y) > 0;
         }
 
 //  Less than or equal to
     template<typename charT, typename traits>
-    inline bool operator<=(basic_string_view<charT, traits> x,
+    inline BOOST_CXX14_CONSTEXPR bool operator<=(basic_string_view<charT, traits> x,
                            basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
         return x.compare(y) <= 0;
         }
 
 //  Greater than or equal to
     template<typename charT, typename traits>
-    inline bool operator>=(basic_string_view<charT, traits> x,
+    inline BOOST_CXX14_CONSTEXPR bool operator>=(basic_string_view<charT, traits> x,
                            basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
         return x.compare(y) >= 0;
         }
 
 // "sufficient additional overloads of comparison functions"
     template<typename charT, typename traits, typename Allocator>
-    inline bool operator==(basic_string_view<charT, traits> x,
+    inline BOOST_CXX14_CONSTEXPR bool operator==(basic_string_view<charT, traits> x,
                      const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT {
         return x == basic_string_view<charT, traits>(y);
         }
 
     template<typename charT, typename traits, typename Allocator>
-    inline bool operator==(const std::basic_string<charT, traits, Allocator> & x,
+    inline BOOST_CXX14_CONSTEXPR bool operator==(const std::basic_string<charT, traits, Allocator> & x,
                                  basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
         return basic_string_view<charT, traits>(x) == y;
         }
 
     template<typename charT, typename traits>
-    inline bool operator==(basic_string_view<charT, traits> x,
+    inline BOOST_CXX14_CONSTEXPR bool operator==(basic_string_view<charT, traits> x,
                                               const charT * y) BOOST_NOEXCEPT {
         return x == basic_string_view<charT, traits>(y);
         }
 
     template<typename charT, typename traits>
-    inline bool operator==(const charT * x,
+    inline BOOST_CXX14_CONSTEXPR bool operator==(const charT * x,
                            basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
         return basic_string_view<charT, traits>(x) == y;
         }
 
     template<typename charT, typename traits, typename Allocator>
-    inline bool operator!=(basic_string_view<charT, traits> x,
+    inline BOOST_CXX14_CONSTEXPR bool operator!=(basic_string_view<charT, traits> x,
                      const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT {
         return x != basic_string_view<charT, traits>(y);
         }
 
     template<typename charT, typename traits, typename Allocator>
-    inline bool operator!=(const std::basic_string<charT, traits, Allocator> & x,
+    inline BOOST_CXX14_CONSTEXPR bool operator!=(const std::basic_string<charT, traits, Allocator> & x,
                                  basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
         return basic_string_view<charT, traits>(x) != y;
         }
 
     template<typename charT, typename traits>
-    inline bool operator!=(basic_string_view<charT, traits> x,
+    inline BOOST_CXX14_CONSTEXPR bool operator!=(basic_string_view<charT, traits> x,
                            const charT * y) BOOST_NOEXCEPT {
         return x != basic_string_view<charT, traits>(y);
         }
 
     template<typename charT, typename traits>
-    inline bool operator!=(const charT * x,
+    inline BOOST_CXX14_CONSTEXPR bool operator!=(const charT * x,
                            basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
         return basic_string_view<charT, traits>(x) != y;
         }
 
     template<typename charT, typename traits, typename Allocator>
-    inline bool operator<(basic_string_view<charT, traits> x,
+    inline BOOST_CXX14_CONSTEXPR bool operator<(basic_string_view<charT, traits> x,
                     const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT {
         return x < basic_string_view<charT, traits>(y);
         }
 
     template<typename charT, typename traits, typename Allocator>
-    inline bool operator<(const std::basic_string<charT, traits, Allocator> & x,
+    inline BOOST_CXX14_CONSTEXPR bool operator<(const std::basic_string<charT, traits, Allocator> & x,
                                 basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
         return basic_string_view<charT, traits>(x) < y;
         }
 
     template<typename charT, typename traits>
-    inline bool operator<(basic_string_view<charT, traits> x,
+    inline BOOST_CXX14_CONSTEXPR bool operator<(basic_string_view<charT, traits> x,
                           const charT * y) BOOST_NOEXCEPT {
         return x < basic_string_view<charT, traits>(y);
         }
 
     template<typename charT, typename traits>
-    inline bool operator<(const charT * x,
+    inline BOOST_CXX14_CONSTEXPR bool operator<(const charT * x,
                           basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
         return basic_string_view<charT, traits>(x) < y;
         }
 
     template<typename charT, typename traits, typename Allocator>
-    inline bool operator>(basic_string_view<charT, traits> x,
+    inline BOOST_CXX14_CONSTEXPR bool operator>(basic_string_view<charT, traits> x,
                     const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT {
         return x > basic_string_view<charT, traits>(y);
         }
 
     template<typename charT, typename traits, typename Allocator>
-    inline bool operator>(const std::basic_string<charT, traits, Allocator> & x,
+    inline BOOST_CXX14_CONSTEXPR bool operator>(const std::basic_string<charT, traits, Allocator> & x,
                                 basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
         return basic_string_view<charT, traits>(x) > y;
         }
 
     template<typename charT, typename traits>
-    inline bool operator>(basic_string_view<charT, traits> x,
+    inline BOOST_CXX14_CONSTEXPR bool operator>(basic_string_view<charT, traits> x,
                           const charT * y) BOOST_NOEXCEPT {
         return x > basic_string_view<charT, traits>(y);
         }
 
     template<typename charT, typename traits>
-    inline bool operator>(const charT * x,
+    inline BOOST_CXX14_CONSTEXPR bool operator>(const charT * x,
                           basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
         return basic_string_view<charT, traits>(x) > y;
         }
 
     template<typename charT, typename traits, typename Allocator>
-    inline bool operator<=(basic_string_view<charT, traits> x,
+    inline BOOST_CXX14_CONSTEXPR bool operator<=(basic_string_view<charT, traits> x,
                      const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT {
         return x <= basic_string_view<charT, traits>(y);
         }
 
     template<typename charT, typename traits, typename Allocator>
-    inline bool operator<=(const std::basic_string<charT, traits, Allocator> & x,
+    inline BOOST_CXX14_CONSTEXPR bool operator<=(const std::basic_string<charT, traits, Allocator> & x,
                                  basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
         return basic_string_view<charT, traits>(x) <= y;
         }
 
     template<typename charT, typename traits>
-    inline bool operator<=(basic_string_view<charT, traits> x,
+    inline BOOST_CXX14_CONSTEXPR bool operator<=(basic_string_view<charT, traits> x,
                            const charT * y) BOOST_NOEXCEPT {
         return x <= basic_string_view<charT, traits>(y);
         }
 
     template<typename charT, typename traits>
-    inline bool operator<=(const charT * x,
+    inline BOOST_CXX14_CONSTEXPR bool operator<=(const charT * x,
                            basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
         return basic_string_view<charT, traits>(x) <= y;
         }
 
     template<typename charT, typename traits, typename Allocator>
-    inline bool operator>=(basic_string_view<charT, traits> x,
+    inline BOOST_CXX14_CONSTEXPR bool operator>=(basic_string_view<charT, traits> x,
                      const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT {
         return x >= basic_string_view<charT, traits>(y);
         }
 
     template<typename charT, typename traits, typename Allocator>
-    inline bool operator>=(const std::basic_string<charT, traits, Allocator> & x,
+    inline BOOST_CXX14_CONSTEXPR bool operator>=(const std::basic_string<charT, traits, Allocator> & x,
                                  basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
         return basic_string_view<charT, traits>(x) >= y;
         }
 
     template<typename charT, typename traits>
-    inline bool operator>=(basic_string_view<charT, traits> x,
+    inline BOOST_CXX14_CONSTEXPR bool operator>=(basic_string_view<charT, traits> x,
                            const charT * y) BOOST_NOEXCEPT {
         return x >= basic_string_view<charT, traits>(y);
         }
 
     template<typename charT, typename traits>
-    inline bool operator>=(const charT * x,
+    inline BOOST_CXX14_CONSTEXPR bool operator>=(const charT * x,
                            basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
         return basic_string_view<charT, traits>(x) >= y;
         }