passenger 6.0.7 → 6.0.8

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

@@ -1,14 +1,83 @@
-// Copyright Daniel Wallin, David Abrahams 2005. Use, modification and
-// distribution is subject to the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
+// Copyright Daniel Wallin, David Abrahams 2005.
+// Copyright Cromwell D. Enage 2017.
+// 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_PARAMETER_CONFIG_050403_HPP
 #define BOOST_PARAMETER_CONFIG_050403_HPP
 
-#ifndef BOOST_PARAMETER_MAX_ARITY
-# define BOOST_PARAMETER_MAX_ARITY 8
+#include <boost/config.hpp>
+#include <boost/config/workaround.hpp>
+
+// Allow projects to #define BOOST_PARAMETER_DISABLE_PERFECT_FORWARDING to
+// turn off perfect forwarding as necessary.  Otherwise, also require correct
+// SFINAE support, needed explicitly by tagged_argument & keyword & cast;
+// correct function template ordering, needed by the code generation macros;
+// rvalue references, needed throughout; variadic templates, needed by
+// parameters; function template default arguments, needed by the code
+// generation macros; and the ability to handle multiple parameter packs,
+// needed by parameters.  Older versions of GCC either don't have the latter
+// ability or cannot disambiguate between keyword's overloaded
+// operators.  Older versions of Clang either fail to compile due to
+// differences in length between parameter packs 'Args' and 'args' or fail at
+// runtime due to segmentation faults.
+// -- Cromwell D. Enage
+#if !defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING) && \
+    !defined(BOOST_PARAMETER_DISABLE_PERFECT_FORWARDING) && \
+    !defined(BOOST_NO_SFINAE) && \
+    !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) && \
+    !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && \
+    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && \
+    !defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS) && \
+    !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && !( \
+        defined(BOOST_CLANG) && (1 == BOOST_CLANG) && ( \
+            (__clang_major__ < 3) || ( \
+                (3 == __clang_major__) && (__clang_minor__ < 2) \
+            ) \
+        ) \
+    ) && !BOOST_WORKAROUND(BOOST_GCC, < 40900)
+#define BOOST_PARAMETER_HAS_PERFECT_FORWARDING
 #endif
 
-#endif // BOOST_PARAMETER_CONFIG_050403_HPP
+#if defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING)
+#if !defined(BOOST_PARAMETER_CAN_USE_MP11) && \
+    !defined(BOOST_PARAMETER_DISABLE_MP11_USAGE) && \
+    !defined(BOOST_NO_CXX11_CONSTEXPR) && \
+    !defined(BOOST_NO_CXX11_DECLTYPE_N3276) && \
+    !defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && \
+    !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) && \
+    !defined(BOOST_NO_CXX11_STATIC_ASSERT) && \
+    !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS) && \
+    !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) && \
+    !defined(BOOST_NO_CXX11_HDR_TUPLE)
+// Boost.MP11 requires C++11. -- Cromwell D. Enage
+#define BOOST_PARAMETER_CAN_USE_MP11
+#endif
+#if !defined(BOOST_PARAMETER_MAX_ARITY)
+// Unlike the variadic MPL sequences provided by Boost.Fusion,
+// boost::mpl::vector has a size limit. -- Cromwell D. Enage
+#include <boost/mpl/limits/vector.hpp>
+#define BOOST_PARAMETER_MAX_ARITY BOOST_MPL_LIMIT_VECTOR_SIZE
+#endif
+#else   // !defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING)
+#if !defined(BOOST_PARAMETER_EXPONENTIAL_OVERLOAD_THRESHOLD_ARITY)
+#define BOOST_PARAMETER_EXPONENTIAL_OVERLOAD_THRESHOLD_ARITY 0
+#endif
+#if !defined(BOOST_PARAMETER_COMPOSE_MAX_ARITY)
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1800) || \
+    BOOST_WORKAROUND(BOOST_GCC, < 60000)
+// Some tests cause MSVC-11.0 and earlier to run out of heap space,
+// while some other tests cause GCC 5 and earlier to do the same,
+// if the value is set any higher. -- Cromwell D. Enage
+#define BOOST_PARAMETER_COMPOSE_MAX_ARITY 20
+#else
+#define BOOST_PARAMETER_COMPOSE_MAX_ARITY 64
+#endif
+#endif  // BOOST_PARAMETER_COMPOSE_MAX_ARITY
+#if !defined(BOOST_PARAMETER_MAX_ARITY)
+#define BOOST_PARAMETER_MAX_ARITY 8
+#endif
+#endif  // BOOST_PARAMETER_HAS_PERFECT_FORWARDING
+#endif  // include guard
 

data/src/cxx_supportlib/vendor-modified/boost/parameter/deduced.hpp

@@ -0,0 +1,132 @@
+// Copyright David Abrahams, Daniel Wallin 2003.
+// 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_PARAMETER_DEDUCED_HPP
+#define BOOST_PARAMETER_DEDUCED_HPP
+
+#include <boost/parameter/aux_/use_default.hpp>
+
+namespace boost { namespace parameter {
+
+    // This metafunction can be used to describe the treatment of particular
+    // named parameters for the purposes of overload elimination with SFINAE,
+    // by placing specializations in the parameters<...> list.
+    //
+    // If a keyword k is specified with deduced<...>, that keyword
+    // will be automatically deduced from the argument list.
+    template <typename Tag>
+    struct deduced
+    {
+        typedef Tag key_type;
+    };
+}}
+
+#include <boost/parameter/config.hpp>
+
+#if defined(BOOST_PARAMETER_CAN_USE_MP11)
+#include <boost/mp11/integral.hpp>
+#else
+#include <boost/mpl/bool.hpp>
+#endif
+
+namespace boost { namespace parameter { namespace aux {
+
+    template <typename T>
+    struct is_deduced_aux
+#if defined(BOOST_PARAMETER_CAN_USE_MP11)
+      : ::boost::mp11::mp_false
+#else
+      : ::boost::mpl::false_
+#endif
+    {
+    };
+
+    template <typename Tag>
+    struct is_deduced_aux< ::boost::parameter::deduced<Tag> >
+#if defined(BOOST_PARAMETER_CAN_USE_MP11)
+      : ::boost::mp11::mp_true
+#else
+      : ::boost::mpl::true_
+#endif
+    {
+    };
+
+    template <typename T>
+    struct is_deduced0
+      : ::boost::parameter::aux::is_deduced_aux<typename T::key_type>::type
+    {
+    };
+}}} // namespace boost::parameter::aux
+
+#include <boost/parameter/required.hpp>
+#include <boost/parameter/optional.hpp>
+
+#if defined(BOOST_PARAMETER_CAN_USE_MP11)
+#include <boost/mp11/utility.hpp>
+#else
+#include <boost/mpl/if.hpp>
+#endif
+
+namespace boost { namespace parameter { namespace aux {
+
+    //
+    // tag_type, has_default, and predicate --
+    //
+    // These metafunctions accept a ParameterSpec and extract the
+    // keyword tag, whether or not a default is supplied for the
+    // parameter, and the predicate that the corresponding actual
+    // argument type is required match.
+    //
+    // a ParameterSpec is a specialization of either keyword<...>,
+    // required<...>, optional<...>
+    //
+
+    template <typename T>
+#if defined(BOOST_PARAMETER_CAN_USE_MP11)
+    using has_default = ::boost::mp11::mp_if<
+        ::boost::parameter::aux::is_required<T>
+      , ::boost::mp11::mp_false
+      , ::boost::mp11::mp_true
+    >;
+#else
+    struct has_default
+      : ::boost::mpl::if_<
+            ::boost::parameter::aux::is_required<T>
+          , ::boost::mpl::false_
+          , ::boost::mpl::true_
+        >::type
+    {
+    };
+#endif
+
+    template <typename T>
+#if defined(BOOST_PARAMETER_CAN_USE_MP11)
+    using is_deduced = ::boost::mp11::mp_if<
+        ::boost::mp11::mp_if<
+            ::boost::parameter::aux::is_optional<T>
+          , ::boost::mp11::mp_true
+          , ::boost::parameter::aux::is_required<T>
+        >
+      , ::boost::parameter::aux::is_deduced0<T>
+      , ::boost::mp11::mp_false
+    >;
+#else
+    struct is_deduced
+      : ::boost::mpl::if_<
+            typename ::boost::mpl::if_<
+                ::boost::parameter::aux::is_optional<T>
+              , ::boost::mpl::true_
+              , ::boost::parameter::aux::is_required<T>
+            >::type
+          , ::boost::parameter::aux::is_deduced0<T>
+          , ::boost::mpl::false_
+        >::type
+    {
+    };
+#endif  // BOOST_PARAMETER_CAN_USE_MP11
+}}} // namespace boost::parameter::aux
+
+#endif  // include guard
+

data/src/cxx_supportlib/vendor-modified/boost/parameter/is_argument_pack.hpp

@@ -0,0 +1,29 @@
+// Copyright Cromwell D. Enage 2018.
+// 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_PARAMETER_IS_ARGUMENT_PACK_HPP
+#define BOOST_PARAMETER_IS_ARGUMENT_PACK_HPP
+
+#include <boost/parameter/aux_/is_tagged_argument.hpp>
+#include <boost/parameter/aux_/arg_list.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_base_of.hpp>
+
+namespace boost { namespace parameter {
+
+    template <typename T>
+    struct is_argument_pack
+      : ::boost::mpl::if_<
+            ::boost::is_base_of< ::boost::parameter::aux::empty_arg_list,T>
+          , ::boost::mpl::true_
+          , ::boost::parameter::aux::is_tagged_argument<T>
+        >::type
+    {
+    };
+}}
+
+#endif  // include guard
+

data/src/cxx_supportlib/vendor-modified/boost/parameter/keyword.hpp

@@ -1,122 +1,744 @@
-// Copyright Daniel Wallin, David Abrahams 2005. Use, modification and
-// distribution is subject to the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
+// Copyright Daniel Wallin, David Abrahams 2005.
+// Copyright Cromwell D. Enage 2017.
+// 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 KEYWORD_050328_HPP
-#define KEYWORD_050328_HPP
+#ifndef BOOST_PARAMETER_KEYWORD_HPP
+#define BOOST_PARAMETER_KEYWORD_HPP
 
-#include <boost/parameter/aux_/unwrap_cv_reference.hpp>
 #include <boost/parameter/aux_/tag.hpp>
 #include <boost/parameter/aux_/default.hpp>
+#include <boost/parameter/keyword_fwd.hpp>
+#include <boost/parameter/config.hpp>
+
+#if defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING)
+#include <boost/core/enable_if.hpp>
+#include <utility>
+
+#if defined(BOOST_PARAMETER_CAN_USE_MP11)
+#include <boost/mp11/integral.hpp>
+#include <boost/mp11/utility.hpp>
+#include <type_traits>
+#else
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/is_scalar.hpp>
+#include <boost/type_traits/is_const.hpp>
+#endif
 
 namespace boost { namespace parameter {
 
-// Instances of unique specializations of keyword<...> serve to
-// associate arguments with parameter names.  For example:
-//
-//    struct rate_;           // parameter names
-//    struct skew_;
-//    namespace
-//    {
-//      keyword<rate_> rate;  // keywords
-//      keyword<skew_> skew;
-//    }
-//
-//    ...
-//
-//    f(rate = 1, skew = 2.4);
-//
-template <class Tag>
-struct keyword
-{
-    template <class T>
-    typename aux::tag<Tag, T>::type const
-    operator=(T& x) const
+    // Instances of unique specializations of keyword<...> serve to
+    // associate arguments with parameter names.  For example:
+    //
+    //     struct rate_;             // parameter names
+    //     struct skew_;
+    //
+    //     namespace
+    //     {
+    //         keyword<rate_> rate;  // keywords
+    //         keyword<skew_> skew;
+    //     }
+    //
+    //     ...
+    //
+    //     f(rate = 1, skew = 2.4);
+    template <typename Tag>
+    struct keyword
     {
-        typedef typename aux::tag<Tag, T>::type result;
-        return result(x);
-    }
+        typedef Tag tag;
 
-    template <class Default>
-    aux::default_<Tag, Default>
-    operator|(Default& default_) const
-    {
-        return aux::default_<Tag, Default>(default_);
-    }
+        inline BOOST_CONSTEXPR keyword()
+        {
+        }
 
-    template <class Default>
-    aux::lazy_default<Tag, Default>
-    operator||(Default& default_) const
-    {
-        return aux::lazy_default<Tag, Default>(default_);
-    }
+        template <typename T>
+        inline BOOST_CONSTEXPR typename ::boost::lazy_enable_if<
+#if defined(BOOST_PARAMETER_CAN_USE_MP11)
+            ::boost::mp11::mp_if<
+                ::std::is_scalar<T>
+              , ::boost::mp11::mp_true
+              , ::boost::mp11::mp_if<
+                    ::std::is_same<
+                        typename Tag::qualifier
+                      , ::boost::parameter::in_reference
+                    >
+                  , ::boost::mp11::mp_true
+                  , ::std::is_same<
+                        typename Tag::qualifier
+                      , ::boost::parameter::forward_reference
+                    >
+                >
+            >
+#else   // !defined(BOOST_PARAMETER_CAN_USE_MP11)
+            typename ::boost::mpl::eval_if<
+                ::boost::is_scalar<T>
+              , ::boost::mpl::true_
+              , ::boost::mpl::eval_if<
+                    ::boost::is_same<
+                        typename Tag::qualifier
+                      , ::boost::parameter::in_reference
+                    >
+                  , ::boost::mpl::true_
+                  , ::boost::mpl::if_<
+                        ::boost::is_same<
+                            typename Tag::qualifier
+                          , ::boost::parameter::forward_reference
+                        >
+                      , ::boost::mpl::true_
+                      , ::boost::mpl::false_
+                    >
+                >
+            >::type
+#endif  // BOOST_PARAMETER_CAN_USE_MP11
+          , ::boost::parameter::aux::tag<Tag,T const&>
+        >::type
+            operator=(T const& x) const
+        {
+            typedef typename ::boost::parameter::aux
+            ::tag<Tag,T const&>::type result;
+            return result(x);
+        }
 
-    template <class T>
-    typename aux::tag<Tag, T const>::type const
-    operator=(T const& x) const
-    {
-        typedef typename aux::tag<Tag, T const>::type result;
-        return result(x);
-    }
+        template <typename Default>
+        inline BOOST_CONSTEXPR typename ::boost::enable_if<
+#if defined(BOOST_PARAMETER_CAN_USE_MP11)
+            ::boost::mp11::mp_if<
+                ::std::is_scalar<Default>
+              , ::boost::mp11::mp_true
+              , ::boost::mp11::mp_if<
+                    ::std::is_same<
+                        typename Tag::qualifier
+                      , ::boost::parameter::in_reference
+                    >
+                  , ::boost::mp11::mp_true
+                  , ::std::is_same<
+                        typename Tag::qualifier
+                      , ::boost::parameter::forward_reference
+                    >
+                >
+            >
+#else   // !defined(BOOST_PARAMETER_CAN_USE_MP11)
+            typename ::boost::mpl::eval_if<
+                ::boost::is_scalar<Default>
+              , ::boost::mpl::true_
+              , ::boost::mpl::eval_if<
+                    ::boost::is_same<
+                        typename Tag::qualifier
+                      , ::boost::parameter::in_reference
+                    >
+                  , ::boost::mpl::true_
+                  , ::boost::mpl::if_<
+                        ::boost::is_same<
+                            typename Tag::qualifier
+                          , ::boost::parameter::forward_reference
+                        >
+                      , ::boost::mpl::true_
+                      , ::boost::mpl::false_
+                    >
+                >
+            >::type
+#endif  // BOOST_PARAMETER_CAN_USE_MP11
+          , ::boost::parameter::aux::default_<Tag,Default const>
+        >::type
+            operator|(Default const& d) const
+        {
+            return ::boost::parameter::aux::default_<Tag,Default const>(d);
+        }
 
-    template <class Default>
-    aux::default_<Tag, const Default>
-    operator|(const Default& default_) const
-    {
-        return aux::default_<Tag, const Default>(default_);
-    }
+        template <typename T>
+        inline BOOST_CONSTEXPR typename ::boost::lazy_enable_if<
+#if defined(BOOST_PARAMETER_CAN_USE_MP11)
+            ::boost::mp11::mp_if<
+                ::boost::mp11::mp_if<
+                    ::std::is_same<
+                        typename Tag::qualifier
+                      , ::boost::parameter::out_reference
+                    >
+                  , ::boost::mp11::mp_true
+                  , ::std::is_same<
+                        typename Tag::qualifier
+                      , ::boost::parameter::forward_reference
+                    >
+                >
+              , ::boost::mp11::mp_if<
+                    ::std::is_const<T>
+                  , ::boost::mp11::mp_false
+                  , ::boost::mp11::mp_true
+                >
+              , ::boost::mp11::mp_false
+            >
+#else   // !defined(BOOST_PARAMETER_CAN_USE_MP11)
+            typename ::boost::mpl::eval_if<
+                typename ::boost::mpl::if_<
+                    ::boost::is_same<
+                        typename Tag::qualifier
+                      , ::boost::parameter::out_reference
+                    >
+                  , ::boost::mpl::true_
+                  , ::boost::is_same<
+                        typename Tag::qualifier
+                      , ::boost::parameter::forward_reference
+                    >
+                >::type
+              , ::boost::mpl::if_<
+                    ::boost::is_const<T>
+                  , ::boost::mpl::false_
+                  , ::boost::mpl::true_
+                >
+              , ::boost::mpl::false_
+            >::type
+#endif  // BOOST_PARAMETER_CAN_USE_MP11
+          , ::boost::parameter::aux::tag<Tag,T&>
+        >::type
+            operator=(T& x) const
+        {
+            typedef typename ::boost::parameter::aux
+            ::tag<Tag,T&>::type result;
+            return result(x);
+        }
 
-    template <class Default>
-    aux::lazy_default<Tag, Default>
-    operator||(Default const& default_) const
-    {
-        return aux::lazy_default<Tag, Default>(default_);
-    }
+        template <typename Default>
+        inline BOOST_CONSTEXPR typename ::boost::enable_if<
+#if defined(BOOST_PARAMETER_CAN_USE_MP11)
+            ::boost::mp11::mp_if<
+                ::boost::mp11::mp_if<
+                    ::std::is_same<
+                        typename Tag::qualifier
+                      , ::boost::parameter::out_reference
+                    >
+                  , ::boost::mp11::mp_true
+                  , ::std::is_same<
+                        typename Tag::qualifier
+                      , ::boost::parameter::forward_reference
+                    >
+                >
+              , ::boost::mp11::mp_if<
+                    ::std::is_const<Default>
+                  , ::boost::mp11::mp_false
+                  , ::boost::mp11::mp_true
+                >
+              , ::boost::mp11::mp_false
+            >
+#else   // !defined(BOOST_PARAMETER_CAN_USE_MP11)
+            typename ::boost::mpl::eval_if<
+                typename ::boost::mpl::if_<
+                    ::boost::is_same<
+                        typename Tag::qualifier
+                      , ::boost::parameter::out_reference
+                    >
+                  , ::boost::mpl::true_
+                  , ::boost::is_same<
+                        typename Tag::qualifier
+                      , ::boost::parameter::forward_reference
+                    >
+                >::type
+              , ::boost::mpl::if_<
+                    ::boost::is_const<Default>
+                  , ::boost::mpl::false_
+                  , ::boost::mpl::true_
+                >
+              , ::boost::mpl::false_
+            >::type
+#endif  // BOOST_PARAMETER_CAN_USE_MP11
+          , ::boost::parameter::aux::default_<Tag,Default>
+        >::type
+            operator|(Default& d) const
+        {
+            return ::boost::parameter::aux::default_<Tag,Default>(d);
+        }
+
+        template <typename Default>
+        inline BOOST_CONSTEXPR
+        ::boost::parameter::aux::lazy_default<Tag,Default const>
+            operator||(Default const& d) const
+        {
+            return ::boost::parameter::aux
+            ::lazy_default<Tag,Default const>(d);
+        }
+
+        template <typename Default>
+        inline BOOST_CONSTEXPR
+        ::boost::parameter::aux::lazy_default<Tag,Default>
+            operator||(Default& d) const
+        {
+            return ::boost::parameter::aux::lazy_default<Tag,Default>(d);
+        }
+
+        template <typename T>
+        inline BOOST_CONSTEXPR typename ::boost::lazy_enable_if<
+#if defined(BOOST_PARAMETER_CAN_USE_MP11)
+            ::boost::mp11::mp_if<
+                ::std::is_scalar<T>
+              , ::boost::mp11::mp_false
+              , ::boost::mp11::mp_if<
+                    ::std::is_same<
+                        typename Tag::qualifier
+                      , ::boost::parameter::in_reference
+                    >
+                  , ::boost::mp11::mp_true
+                  , ::std::is_same<
+                        typename Tag::qualifier
+                      , ::boost::parameter::forward_reference
+                    >
+                >
+            >
+#else   // !defined(BOOST_PARAMETER_CAN_USE_MP11)
+            typename ::boost::mpl::eval_if<
+                ::boost::is_scalar<T>
+              , ::boost::mpl::false_
+              , ::boost::mpl::eval_if<
+                    ::boost::is_same<
+                        typename Tag::qualifier
+                      , ::boost::parameter::in_reference
+                    >
+                  , ::boost::mpl::true_
+                  , ::boost::mpl::if_<
+                        ::boost::is_same<
+                            typename Tag::qualifier
+                          , ::boost::parameter::forward_reference
+                        >
+                      , ::boost::mpl::true_
+                      , ::boost::mpl::false_
+                    >
+                >
+            >::type
+#endif  // BOOST_PARAMETER_CAN_USE_MP11
+          , ::boost::parameter::aux::tag<Tag,T const>
+        >::type
+            operator=(T const&& x) const
+        {
+            typedef typename ::boost::parameter::aux
+            ::tag<Tag,T const>::type result;
+            return result(::std::forward<T const>(x));
+        }
+
+        template <typename T>
+        inline BOOST_CONSTEXPR typename ::boost::lazy_enable_if<
+#if defined(BOOST_PARAMETER_CAN_USE_MP11)
+            ::boost::mp11::mp_if<
+                ::std::is_scalar<T>
+              , ::boost::mp11::mp_false
+              , ::boost::mp11::mp_if<
+                    ::std::is_same<
+                        typename Tag::qualifier
+                      , ::boost::parameter::consume_reference
+                    >
+                  , ::boost::mp11::mp_true
+                  , ::std::is_same<
+                        typename Tag::qualifier
+                      , ::boost::parameter::forward_reference
+                    >
+                >
+            >
+#else   // !defined(BOOST_PARAMETER_CAN_USE_MP11)
+            typename ::boost::mpl::eval_if<
+                ::boost::is_scalar<T>
+              , ::boost::mpl::false_
+              , ::boost::mpl::eval_if<
+                    ::boost::is_same<
+                        typename Tag::qualifier
+                      , ::boost::parameter::consume_reference
+                    >
+                  , ::boost::mpl::true_
+                  , ::boost::mpl::if_<
+                        ::boost::is_same<
+                            typename Tag::qualifier
+                          , ::boost::parameter::forward_reference
+                        >
+                      , ::boost::mpl::true_
+                      , ::boost::mpl::false_
+                    >
+                >
+            >::type
+#endif  // BOOST_PARAMETER_CAN_USE_MP11
+          , ::boost::parameter::aux::tag<Tag,T>
+        >::type
+            operator=(T&& x) const
+        {
+            typedef typename ::boost::parameter::aux::tag<Tag,T>::type result;
+            return result(::std::forward<T>(x));
+        }
 
- public: // Insurance against ODR violations
-    
-    // People will need to define these keywords in header files.  To
-    // prevent ODR violations, it's important that the keyword used in
-    // every instantiation of a function template is the same object.
-    // We provide a reference to a common instance of each keyword
-    // object and prevent construction by users.
-    static keyword<Tag> const instance;
-
-    // This interface is deprecated
-    static keyword<Tag>& get()
+        template <typename Default>
+        inline BOOST_CONSTEXPR typename ::boost::enable_if<
+#if defined(BOOST_PARAMETER_CAN_USE_MP11)
+            ::boost::mp11::mp_if<
+                ::std::is_scalar<Default>
+              , ::boost::mp11::mp_false
+              , ::boost::mp11::mp_if<
+                    ::std::is_same<
+                        typename Tag::qualifier
+                      , ::boost::parameter::in_reference
+                    >
+                  , ::boost::mp11::mp_true
+                  , ::std::is_same<
+                        typename Tag::qualifier
+                      , ::boost::parameter::forward_reference
+                    >
+                >
+            >
+#else   // !defined(BOOST_PARAMETER_CAN_USE_MP11)
+            typename ::boost::mpl::eval_if<
+                ::boost::is_scalar<Default>
+              , ::boost::mpl::false_
+              , ::boost::mpl::eval_if<
+                    ::boost::is_same<
+                        typename Tag::qualifier
+                      , ::boost::parameter::in_reference
+                    >
+                  , ::boost::mpl::true_
+                  , ::boost::mpl::if_<
+                        ::boost::is_same<
+                            typename Tag::qualifier
+                          , ::boost::parameter::forward_reference
+                        >
+                      , ::boost::mpl::true_
+                      , ::boost::mpl::false_
+                    >
+                >
+            >::type
+#endif  // BOOST_PARAMETER_CAN_USE_MP11
+          , ::boost::parameter::aux::default_r_<Tag,Default const>
+        >::type
+            operator|(Default const&& d) const
+        {
+            return ::boost::parameter::aux::default_r_<Tag,Default const>(
+                ::std::forward<Default const>(d)
+            );
+        }
+
+        template <typename Default>
+        inline BOOST_CONSTEXPR typename ::boost::enable_if<
+#if defined(BOOST_PARAMETER_CAN_USE_MP11)
+            ::boost::mp11::mp_if<
+                ::std::is_scalar<Default>
+              , ::boost::mp11::mp_false
+              , ::boost::mp11::mp_if<
+                    ::std::is_same<
+                        typename Tag::qualifier
+                      , ::boost::parameter::consume_reference
+                    >
+                  , ::boost::mp11::mp_true
+                  , ::std::is_same<
+                        typename Tag::qualifier
+                      , ::boost::parameter::forward_reference
+                    >
+                >
+            >
+#else   // !defined(BOOST_PARAMETER_CAN_USE_MP11)
+            typename ::boost::mpl::eval_if<
+                ::boost::is_scalar<Default>
+              , ::boost::mpl::false_
+              , ::boost::mpl::eval_if<
+                    ::boost::is_same<
+                        typename Tag::qualifier
+                      , ::boost::parameter::consume_reference
+                    >
+                  , ::boost::mpl::true_
+                  , ::boost::mpl::if_<
+                        ::boost::is_same<
+                            typename Tag::qualifier
+                          , ::boost::parameter::forward_reference
+                        >
+                      , ::boost::mpl::true_
+                      , ::boost::mpl::false_
+                    >
+                >
+            >::type
+#endif  // BOOST_PARAMETER_CAN_USE_MP11
+          , ::boost::parameter::aux::default_r_<Tag,Default>
+        >::type
+            operator|(Default&& d) const
+        {
+            return ::boost::parameter::aux
+            ::default_r_<Tag,Default>(::std::forward<Default>(d));
+        }
+
+     public: // Insurance against ODR violations
+        // Users will need to define their keywords in header files.  To
+        // prevent ODR violations, it's important that the keyword used in
+        // every instantiation of a function template is the same object.
+        // We provide a reference to a common instance of each keyword
+        // object and prevent construction by users.
+        static ::boost::parameter::keyword<Tag> const instance;
+
+        // This interface is deprecated.
+        static ::boost::parameter::keyword<Tag>& get()
+        {
+            return const_cast< ::boost::parameter::keyword<Tag>&>(instance);
+        }
+    };
+
+    template <typename Tag>
+    ::boost::parameter::keyword<Tag> const ::boost::parameter
+    ::keyword<Tag>::instance = ::boost::parameter::keyword<Tag>();
+}} // namespace boost::parameter
+
+#else   // !defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING)
+
+#if !defined(BOOST_NO_SFINAE)
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/core/enable_if.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/is_scalar.hpp>
+#include <boost/type_traits/is_const.hpp>
+#endif  // BOOST_NO_SFINAE
+
+namespace boost { namespace parameter {
+
+    // Instances of unique specializations of keyword<...> serve to
+    // associate arguments with parameter names.  For example:
+    //
+    //     struct rate_;             // parameter names
+    //     struct skew_;
+    //
+    //     namespace
+    //     {
+    //         keyword<rate_> rate;  // keywords
+    //         keyword<skew_> skew;
+    //     }
+    //
+    //     ...
+    //
+    //     f(rate = 1, skew = 2.4);
+    template <typename Tag>
+    struct keyword
     {
-        return const_cast<keyword<Tag>&>(instance);
-    }
-};
-
-template <class Tag>
-keyword<Tag> const keyword<Tag>::instance = {};
-
-// Reduces boilerplate required to declare and initialize keywords
-// without violating ODR.  Declares a keyword tag type with the given
-// name in namespace tag_namespace, and declares and initializes a
-// reference in an anonymous namespace to a singleton instance of that
-// type.
-
-#define BOOST_PARAMETER_KEYWORD(tag_namespace,name)                 \
-    namespace tag_namespace                                         \
-    {                                                               \
-      struct name                                                   \
-      {                                                             \
-          static char const* keyword_name()                         \
-          {                                                         \
-              return #name;                                         \
-          }                                                         \
-      };                                                            \
-    }                                                               \
-    namespace                                                       \
-    {                                                               \
-       ::boost::parameter::keyword<tag_namespace::name> const& name \
-       = ::boost::parameter::keyword<tag_namespace::name>::instance;\
-    }
+        typedef Tag tag;
+
+        inline BOOST_CONSTEXPR keyword()
+        {
+        }
+
+        template <typename T>
+#if defined(BOOST_NO_SFINAE)
+        inline typename ::boost::parameter::aux::tag<Tag,T const&>::type
+#else
+        inline BOOST_CONSTEXPR typename ::boost::lazy_enable_if<
+            typename ::boost::mpl::eval_if<
+                ::boost::is_scalar<T>
+              , ::boost::mpl::true_
+              , ::boost::mpl::eval_if<
+                    ::boost::is_same<
+                        typename Tag::qualifier
+                      , ::boost::parameter::in_reference
+                    >
+                  , ::boost::mpl::true_
+                  , ::boost::mpl::if_<
+                        ::boost::is_same<
+                            typename Tag::qualifier
+                          , ::boost::parameter::forward_reference
+                        >
+                      , ::boost::mpl::true_
+                      , ::boost::mpl::false_
+                    >
+                >
+            >::type
+          , ::boost::parameter::aux::tag<Tag,T const&>
+        >::type
+#endif  // BOOST_NO_SFINAE
+            operator=(T const& x) const
+        {
+            typedef typename ::boost::parameter::aux
+            ::tag<Tag,T const&>::type result;
+            return result(x);
+        }
+
+        template <typename Default>
+#if defined(BOOST_NO_SFINAE)
+        inline ::boost::parameter::aux::default_<Tag,Default const>
+#else
+        inline BOOST_CONSTEXPR typename ::boost::enable_if<
+            typename ::boost::mpl::eval_if<
+                ::boost::is_scalar<Default>
+              , ::boost::mpl::true_
+              , ::boost::mpl::eval_if<
+                    ::boost::is_same<
+                        typename Tag::qualifier
+                      , ::boost::parameter::in_reference
+                    >
+                  , ::boost::mpl::true_
+                  , ::boost::mpl::if_<
+                        ::boost::is_same<
+                            typename Tag::qualifier
+                          , ::boost::parameter::forward_reference
+                        >
+                      , ::boost::mpl::true_
+                      , ::boost::mpl::false_
+                    >
+                >
+            >::type
+          , ::boost::parameter::aux::default_<Tag,Default const>
+        >::type
+#endif  // BOOST_NO_SFINAE
+            operator|(Default const& d) const
+        {
+            return ::boost::parameter::aux::default_<Tag,Default const>(d);
+        }
+
+        template <typename T>
+#if defined(BOOST_NO_SFINAE)
+        inline typename ::boost::parameter::aux::tag<Tag,T&>::type
+#else
+        inline BOOST_CONSTEXPR typename ::boost::lazy_enable_if<
+            typename ::boost::mpl::eval_if<
+                typename ::boost::mpl::if_<
+                    ::boost::is_same<
+                        typename Tag::qualifier
+                      , ::boost::parameter::out_reference
+                    >
+                  , ::boost::mpl::true_
+                  , ::boost::is_same<
+                        typename Tag::qualifier
+                      , ::boost::parameter::forward_reference
+                    >
+                >::type
+              , ::boost::mpl::if_<
+                    ::boost::is_const<T>
+                  , ::boost::mpl::false_
+                  , ::boost::mpl::true_
+                >
+              , ::boost::mpl::false_
+            >::type
+          , ::boost::parameter::aux::tag<Tag,T&>
+        >::type
+#endif  // BOOST_NO_SFINAE
+            operator=(T& x) const
+        {
+            typedef typename ::boost::parameter::aux
+            ::tag<Tag,T&>::type result;
+            return result(x);
+        }
 
+        template <typename Default>
+#if defined(BOOST_NO_SFINAE)
+        inline ::boost::parameter::aux::default_<Tag,Default>
+#else
+        inline BOOST_CONSTEXPR typename ::boost::enable_if<
+            typename ::boost::mpl::eval_if<
+                typename ::boost::mpl::if_<
+                    ::boost::is_same<
+                        typename Tag::qualifier
+                      , ::boost::parameter::out_reference
+                    >
+                  , ::boost::mpl::true_
+                  , ::boost::is_same<
+                        typename Tag::qualifier
+                      , ::boost::parameter::forward_reference
+                    >
+                >::type
+              , ::boost::mpl::if_<
+                    ::boost::is_const<Default>
+                  , ::boost::mpl::false_
+                  , ::boost::mpl::true_
+                >
+              , ::boost::mpl::false_
+            >::type
+          , ::boost::parameter::aux::default_<Tag,Default>
+        >::type
+#endif  // BOOST_NO_SFINAE
+            operator|(Default& d) const
+        {
+            return ::boost::parameter::aux::default_<Tag,Default>(d);
+        }
+
+        template <typename Default>
+        inline BOOST_CONSTEXPR
+        ::boost::parameter::aux::lazy_default<Tag,Default const>
+            operator||(Default const& d) const
+        {
+            return ::boost::parameter::aux
+            ::lazy_default<Tag,Default const>(d);
+        }
+
+        template <typename Default>
+        inline BOOST_CONSTEXPR
+        ::boost::parameter::aux::lazy_default<Tag,Default>
+            operator||(Default& d) const
+        {
+            return ::boost::parameter::aux::lazy_default<Tag,Default>(d);
+        }
+
+     public: // Insurance against ODR violations
+        // Users will need to define their keywords in header files.  To
+        // prevent ODR violations, it's important that the keyword used in
+        // every instantiation of a function template is the same object.
+        // We provide a reference to a common instance of each keyword
+        // object and prevent construction by users.
+        static ::boost::parameter::keyword<Tag> const instance;
+
+        // This interface is deprecated.
+        static ::boost::parameter::keyword<Tag>& get()
+        {
+            return const_cast< ::boost::parameter::keyword<Tag>&>(instance);
+        }
+    };
+
+    template <typename Tag>
+    ::boost::parameter::keyword<Tag> const ::boost::parameter
+    ::keyword<Tag>::instance = ::boost::parameter::keyword<Tag>();
 }} // namespace boost::parameter
 
-#endif // KEYWORD_050328_HPP
+#endif  // BOOST_PARAMETER_HAS_PERFECT_FORWARDING
+
+#include <boost/parameter/aux_/name.hpp>
+#include <boost/preprocessor/stringize.hpp>
+
+// Reduces boilerplate required to declare and initialize keywords without
+// violating ODR.  Declares a keyword tag type with the given name in
+// namespace tag_namespace, and declares and initializes a reference in an
+// anonymous namespace to a singleton instance of that type.
+#if defined(BOOST_PARAMETER_CAN_USE_MP11)
+#define BOOST_PARAMETER_KEYWORD(tag_namespace, name)                         \
+    namespace tag_namespace                                                  \
+    {                                                                        \
+        struct name                                                          \
+        {                                                                    \
+            static BOOST_CONSTEXPR char const* keyword_name()                \
+            {                                                                \
+                return BOOST_PP_STRINGIZE(name);                             \
+            }                                                                \
+            using _ = BOOST_PARAMETER_TAG_PLACEHOLDER_TYPE(name);            \
+            using _1 = _;                                                    \
+            BOOST_PARAMETER_TAG_MP11_PLACEHOLDER_BINDING(binding_fn, name);  \
+            BOOST_PARAMETER_TAG_MP11_PLACEHOLDER_VALUE(fn, name);            \
+            using qualifier = ::boost::parameter::forward_reference;         \
+        };                                                                   \
+    }                                                                        \
+    namespace                                                                \
+    {                                                                        \
+        ::boost::parameter::keyword<tag_namespace::name> const& name         \
+            = ::boost::parameter::keyword<tag_namespace::name>::instance;    \
+    }
+/**/
+#else   // !defined(BOOST_PARAMETER_CAN_USE_MP11)
+#define BOOST_PARAMETER_KEYWORD(tag_namespace, name)                         \
+    namespace tag_namespace                                                  \
+    {                                                                        \
+        struct name                                                          \
+        {                                                                    \
+            static BOOST_CONSTEXPR char const* keyword_name()                \
+            {                                                                \
+                return BOOST_PP_STRINGIZE(name);                             \
+            }                                                                \
+            typedef BOOST_PARAMETER_TAG_PLACEHOLDER_TYPE(name) _;            \
+            typedef BOOST_PARAMETER_TAG_PLACEHOLDER_TYPE(name) _1;           \
+            typedef ::boost::parameter::forward_reference qualifier;         \
+        };                                                                   \
+    }                                                                        \
+    namespace                                                                \
+    {                                                                        \
+        ::boost::parameter::keyword<tag_namespace::name> const& name         \
+            = ::boost::parameter::keyword<tag_namespace::name>::instance;    \
+    }
+/**/
+#endif  // BOOST_PARAMETER_CAN_USE_MP11
+
+#endif  // include guard