diff options
Diffstat (limited to 'boost/parameter')
100 files changed, 18693 insertions, 3789 deletions
diff --git a/boost/parameter/are_tagged_arguments.hpp b/boost/parameter/are_tagged_arguments.hpp new file mode 100644 index 0000000000..84157c4118 --- /dev/null +++ b/boost/parameter/are_tagged_arguments.hpp @@ -0,0 +1,125 @@ +// 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_ARE_TAGGED_ARGUMENTS_HPP +#define BOOST_PARAMETER_ARE_TAGGED_ARGUMENTS_HPP + +#include <boost/parameter/config.hpp> + +#if defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING) + +namespace boost { namespace parameter { + + template <typename TaggedArg0, typename ...TaggedArgs> + struct are_tagged_arguments; +}} // namespace boost::parameter + +#include <boost/parameter/aux_/is_tagged_argument.hpp> + +namespace boost { namespace parameter { + + template <typename TaggedArg0> + struct are_tagged_arguments<TaggedArg0> + : ::boost::parameter::aux::is_tagged_argument<TaggedArg0> + { + }; +}} // namespace boost::parameter + +#include <boost/mpl/bool.hpp> +#include <boost/mpl/if.hpp> + +namespace boost { namespace parameter { + + template <typename TaggedArg0, typename ...TaggedArgs> + struct are_tagged_arguments + : ::boost::mpl::if_< + ::boost::parameter::aux::is_tagged_argument<TaggedArg0> + , ::boost::parameter::are_tagged_arguments<TaggedArgs...> + , ::boost::mpl::false_ + >::type + { + }; +}} // namespace boost::parameter + +#else // !defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING) + +#define BOOST_PARAMETER_ARE_TAGGED_ARGUMENTS_END_Z(z, n, false_t) , false_t> +/**/ + +#include <boost/parameter/aux_/is_tagged_argument.hpp> +#include <boost/mpl/eval_if.hpp> +#include <boost/preprocessor/cat.hpp> + +#define BOOST_PARAMETER_ARE_TAGGED_ARGUMENTS_BEGIN_Z(z, n, prefix) \ + ::boost::mpl::eval_if< \ + ::boost::parameter::aux::is_tagged_argument<BOOST_PP_CAT(prefix, n)>, +/**/ + +#include <boost/parameter/aux_/void.hpp> +#include <boost/mpl/bool.hpp> +#include <boost/preprocessor/arithmetic/sub.hpp> +#include <boost/preprocessor/facilities/intercept.hpp> +#include <boost/preprocessor/repetition/repeat.hpp> +#include <boost/preprocessor/repetition/enum_params.hpp> +#include <boost/preprocessor/repetition/enum_trailing_params.hpp> + +#define BOOST_PARAMETER_ARE_TAGGED_ARGUMENTS_OVERLOADS_Z(z, n, prefix) \ + template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename prefix)> \ + struct are_tagged_arguments< \ + BOOST_PP_ENUM_PARAMS_Z(z, n, prefix) \ + BOOST_PP_ENUM_TRAILING_PARAMS_Z( \ + z \ + , BOOST_PP_SUB(BOOST_PARAMETER_COMPOSE_MAX_ARITY, n) \ + , ::boost::parameter::void_ BOOST_PP_INTERCEPT \ + ) \ + > : BOOST_PP_CAT(BOOST_PP_REPEAT_, z)( \ + n \ + , BOOST_PARAMETER_ARE_TAGGED_ARGUMENTS_BEGIN_Z \ + , prefix \ + ) \ + ::boost::mpl::true_ \ + BOOST_PP_CAT(BOOST_PP_REPEAT_, z)( \ + n \ + , BOOST_PARAMETER_ARE_TAGGED_ARGUMENTS_END_Z \ + , ::boost::mpl::false_ \ + )::type \ + { \ + }; +/**/ + +#include <boost/preprocessor/arithmetic/inc.hpp> +#include <boost/preprocessor/repetition/enum_binary_params.hpp> + +namespace boost { namespace parameter { + + template < + BOOST_PP_ENUM_BINARY_PARAMS( + BOOST_PP_INC(BOOST_PARAMETER_COMPOSE_MAX_ARITY) + , typename TaggedArg + , = ::boost::parameter::void_ BOOST_PP_INTERCEPT + ) + > + struct are_tagged_arguments; +}} // namespace boost::parameter + +#include <boost/preprocessor/repetition/repeat_from_to.hpp> + +namespace boost { namespace parameter { + + BOOST_PP_REPEAT_FROM_TO( + 1 + , BOOST_PP_INC(BOOST_PARAMETER_COMPOSE_MAX_ARITY) + , BOOST_PARAMETER_ARE_TAGGED_ARGUMENTS_OVERLOADS_Z + , TaggedArg + ) +}} // namespace boost::parameter + +#undef BOOST_PARAMETER_ARE_TAGGED_ARGUMENTS_OVERLOADS_Z +#undef BOOST_PARAMETER_ARE_TAGGED_ARGUMENTS_BEGIN_Z +#undef BOOST_PARAMETER_ARE_TAGGED_ARGUMENTS_END_Z + +#endif // BOOST_PARAMETER_HAS_PERFECT_FORWARDING +#endif // include guard + diff --git a/boost/parameter/aux_/always_true_predicate.hpp b/boost/parameter/aux_/always_true_predicate.hpp new file mode 100644 index 0000000000..ca1ece42f6 --- /dev/null +++ b/boost/parameter/aux_/always_true_predicate.hpp @@ -0,0 +1,42 @@ +// Copyright Cromwell D. Enage 2019. +// 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_AUX_ALWAYS_TRUE_PREDICATE_HPP +#define BOOST_PARAMETER_AUX_ALWAYS_TRUE_PREDICATE_HPP + +#include <boost/parameter/config.hpp> +#include <boost/mpl/bool.hpp> + +#if defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING) +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <boost/mp11/integral.hpp> +#endif +#else +#include <boost/mpl/always.hpp> +#endif + +namespace boost { namespace parameter { namespace aux { + +#if defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING) + struct always_true_predicate + { + template <typename ...> + struct apply + { + typedef ::boost::mpl::true_ type; + }; + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + template <typename ...> + using fn = ::boost::mp11::mp_true; +#endif + }; +#else + typedef ::boost::mpl::always< ::boost::mpl::true_> always_true_predicate; +#endif // BOOST_NO_CXX11_VARIADIC_TEMPLATES +}}} // namespace boost::parameter::aux + +#endif // include guard + diff --git a/boost/parameter/aux_/arg_list.hpp b/boost/parameter/aux_/arg_list.hpp index 721ce04004..ffe1bac184 100644 --- a/boost/parameter/aux_/arg_list.hpp +++ b/boost/parameter/aux_/arg_list.hpp @@ -1,437 +1,1331 @@ -// 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 ARG_LIST_050329_HPP #define ARG_LIST_050329_HPP +namespace boost { namespace parameter { namespace aux { + + // + // Structures used to build the tuple of actual arguments. The tuple is a + // nested cons-style list of arg_list specializations terminated by an + // empty_arg_list. + // + // Each specialization of arg_list is derived from its successor in the + // list type. This feature is used along with using declarations to build + // member function overload sets that can match against keywords. + // + + // MPL sequence support + struct arg_list_tag; + + template <typename T> + struct get_reference + { + typedef typename T::reference type; + }; +}}} // namespace boost::parameter::aux + +#include <boost/parameter/config.hpp> + +#if defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING) + +namespace boost { namespace parameter { namespace aux { + + struct value_type_is_void + { + }; + + struct value_type_is_not_void + { + }; +}}} // namespace boost::parameter::aux + +#endif + #include <boost/parameter/aux_/void.hpp> +#include <boost/parameter/aux_/yesno.hpp> #include <boost/parameter/aux_/result_of0.hpp> #include <boost/parameter/aux_/default.hpp> -#include <boost/parameter/aux_/parameter_requirements.hpp> + +#if defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING) +#include <utility> + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <boost/mp11/integral.hpp> +#include <boost/mp11/list.hpp> +#include <boost/mp11/utility.hpp> +#include <type_traits> +#endif + +namespace boost { namespace parameter { namespace aux { + + // Terminates arg_list<> and represents an empty list. Since this is just + // the terminating case, you might want to look at arg_list first to get a + // feel for what's really happening here. + struct empty_arg_list + { + struct tagged_arg + { + typedef ::boost::parameter::void_ value_type; + }; + + // Variadic constructor also serves as default constructor. + template <typename ...Args> + inline BOOST_CONSTEXPR empty_arg_list(Args&&...) + { + } + + // A metafunction class that, given a keyword and a default type, + // returns the appropriate result type for a keyword lookup given + // that default. + struct binding + { + template <typename KW, typename Default, typename Reference> + struct apply + { + typedef Default type; + }; + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + template <typename KW, typename Default, typename Reference> + using fn = Default; +#endif + }; + + // Terminator for has_key, indicating that the keyword is unique. + template <typename KW> + static ::boost::parameter::aux::no_tag has_key(KW*); + + // If either of these operators are called, it means there is no + // argument in the list that matches the supplied keyword. Just + // return the default value. + template <typename K, typename Default> + inline BOOST_CONSTEXPR Default& + operator[](::boost::parameter::aux::default_<K,Default> x) const + { + return x.value; + } + + template <typename K, typename Default> + inline BOOST_CONSTEXPR Default&& + operator[](::boost::parameter::aux::default_r_<K,Default> x) const + { + return ::std::forward<Default>(x.value); + } + + // If this operator is called, it means there is no argument in the + // list that matches the supplied keyword. Just evaluate and return + // the default value. + template <typename K, typename F> + inline BOOST_CONSTEXPR + typename ::boost::parameter::aux::result_of0<F>::type + operator[](BOOST_PARAMETER_lazy_default_fallback<K,F> x) const + { + return x.compute_default(); + } + + // No argument corresponding to ParameterRequirements::key_type + // was found if we match this overload, so unless that parameter + // has a default, we indicate that the actual arguments don't + // match the function's requirements. + template <typename ParameterRequirements, typename ArgPack> + static typename ParameterRequirements::has_default + satisfies(ParameterRequirements*, ArgPack*); + + // MPL sequence support + typedef ::boost::parameter::aux::empty_arg_list type; // convenience + // For dispatching to sequence intrinsics + typedef ::boost::parameter::aux::arg_list_tag tag; + }; +}}} // namespace boost::parameter::aux + +#include <boost/parameter/aux_/preprocessor/nullptr.hpp> #include <boost/parameter/aux_/yesno.hpp> #include <boost/parameter/aux_/is_maybe.hpp> -#include <boost/parameter/config.hpp> - -#include <boost/mpl/apply.hpp> +#include <boost/parameter/aux_/tagged_argument_fwd.hpp> +#include <boost/parameter/aux_/parameter_requirements.hpp> +#include <boost/parameter/aux_/augment_predicate.hpp> +#include <boost/parameter/keyword_fwd.hpp> +#include <boost/mpl/bool.hpp> +#include <boost/mpl/if.hpp> +#include <boost/mpl/eval_if.hpp> +#include <boost/mpl/apply_wrap.hpp> #include <boost/mpl/assert.hpp> -#include <boost/mpl/begin.hpp> -#include <boost/mpl/end.hpp> -#include <boost/mpl/iterator_tags.hpp> - -#include <boost/type_traits/add_reference.hpp> #include <boost/type_traits/is_same.hpp> +#include <boost/core/enable_if.hpp> + +namespace boost { namespace parameter { namespace aux { + + // A tuple of tagged arguments, terminated with empty_arg_list. Every + // TaggedArg is an instance of tagged_argument<> or + // tagged_argument_rref<>. + template < + typename TaggedArg + , typename Next = ::boost::parameter::aux::empty_arg_list +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + , typename EmitsErrors = ::boost::mp11::mp_true +#else + , typename EmitsErrors = ::boost::mpl::true_ +#endif + > + class arg_list : public Next + { +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using _holds_maybe = typename ::boost::parameter::aux + ::is_maybe<typename TaggedArg::value_type>::type; +#else + typedef typename ::boost::parameter::aux + ::is_maybe<typename TaggedArg::value_type>::type _holds_maybe; +#endif + + TaggedArg arg; // Stores the argument + + public: + typedef TaggedArg tagged_arg; + typedef ::boost::parameter::aux::arg_list<TaggedArg,Next> self; + typedef typename TaggedArg::key_type key_type; + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using reference = typename ::boost::mp11::mp_if< + _holds_maybe + , ::boost::parameter::aux + ::get_reference<typename TaggedArg::value_type> + , ::boost::parameter::aux::get_reference<TaggedArg> + >::type; + + using value_type = ::boost::mp11 + ::mp_if<_holds_maybe,reference,typename TaggedArg::value_type>; +#else // !defined(BOOST_PARAMETER_CAN_USE_MP11) + typedef typename ::boost::mpl::eval_if< + _holds_maybe + , ::boost::parameter::aux + ::get_reference<typename TaggedArg::value_type> + , ::boost::parameter::aux::get_reference<TaggedArg> + >::type reference; + + typedef typename ::boost::mpl::if_< + _holds_maybe + , reference + , typename TaggedArg::value_type + >::type value_type; +#endif // BOOST_PARAMETER_CAN_USE_MP11 + + // Create a new list by prepending arg to a copy of tail. Used when + // incrementally building this structure with the comma operator. + inline BOOST_CONSTEXPR arg_list( + TaggedArg const& head + , Next const& tail + ) : Next(tail), arg(head) + { + } + + // Store the arguments in successive nodes of this list. + // Use tag dispatching to determine whether to forward all arguments + // to the Next constructor, or store the first argument and forward + // the rest. -- Cromwell D. Enage + template <typename A0> + inline BOOST_CONSTEXPR arg_list( + ::boost::parameter::aux::value_type_is_not_void + , A0&& a0 + ) : Next( +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + ::boost::mp11::mp_if< + ::std::is_same< +#else + typename ::boost::mpl::if_< + ::boost::is_same< +#endif + typename Next::tagged_arg::value_type + , ::boost::parameter::void_ + > + , ::boost::parameter::aux::value_type_is_void + , ::boost::parameter::aux::value_type_is_not_void +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + >() +#else + >::type() +#endif + ) + , arg(::std::forward<A0>(a0)) + { + } + + template <typename ...Args> + inline BOOST_CONSTEXPR arg_list( + ::boost::parameter::aux::value_type_is_void + , Args&&... args + ) : Next( +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + ::boost::mp11::mp_if< + ::std::is_same< +#else + typename ::boost::mpl::if_< + ::boost::is_same< +#endif + typename Next::tagged_arg::value_type + , ::boost::parameter::void_ + > + , ::boost::parameter::aux::value_type_is_void + , ::boost::parameter::aux::value_type_is_not_void +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + >() +#else + >::type() +#endif + , ::std::forward<Args>(args)... + ) + , arg(::boost::parameter::aux::void_reference()) + { + } + + template <typename A0, typename A1, typename ...Args> + inline BOOST_CONSTEXPR arg_list( + ::boost::parameter::aux::value_type_is_not_void + , A0&& a0 + , A1&& a1 + , Args&&... args + ) : Next( +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + ::boost::mp11::mp_if< + ::std::is_same< +#else + typename ::boost::mpl::if_< + ::boost::is_same< +#endif + typename Next::tagged_arg::value_type + , ::boost::parameter::void_ + > + , ::boost::parameter::aux::value_type_is_void + , ::boost::parameter::aux::value_type_is_not_void +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + >() +#else + >::type() +#endif + , ::std::forward<A1>(a1) + , ::std::forward<Args>(args)... + ) + , arg(::std::forward<A0>(a0)) + { + } + + // A metafunction class that, given a keyword and a default type, + // returns the appropriate result type for a keyword lookup given + // that default. + struct binding + { + typedef typename Next::binding next_binding; + + template <typename KW, typename Default, typename Reference> + struct apply + { + typedef typename ::boost::mpl::eval_if< + ::boost::is_same<KW,key_type> + , ::boost::mpl::if_<Reference,reference,value_type> + , ::boost::mpl + ::apply_wrap3<next_binding,KW,Default,Reference> + >::type type; + }; + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + template <typename KW, typename Default, typename Reference> + using fn = ::boost::mp11::mp_if< + ::std::is_same<KW,key_type> + , ::boost::mp11::mp_if<Reference,reference,value_type> + , ::boost::mp11::mp_apply_q< + next_binding + , ::boost::mp11::mp_list<KW,Default,Reference> + > + >; +#endif + }; + + // Overload for key_type, so the assert below will fire + // if the same keyword is used again. + static ::boost::parameter::aux::yes_tag has_key(key_type*); + using Next::has_key; + + private: +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using _has_unique_key = ::boost::mp11::mp_bool< +#else + typedef ::boost::mpl::bool_< +#endif + sizeof( + Next::has_key( + static_cast<key_type*>(BOOST_PARAMETER_AUX_PP_NULLPTR) + ) + ) == sizeof(::boost::parameter::aux::no_tag) +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + >; +#else + > _has_unique_key; +#endif + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + static_assert( + !(EmitsErrors::value) || (_has_unique_key::value) + , "duplicate keyword" + ); +#else + BOOST_MPL_ASSERT_MSG( + !(EmitsErrors::value) || (_has_unique_key::value) + , duplicate_keyword + , (key_type) + ); +#endif + + // + // Begin implementation of indexing operators + // for looking up specific arguments by name. + // + + // Helpers that handle the case when TaggedArg is empty<T>. + template <typename D> + inline BOOST_CONSTEXPR reference +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + get_default(D const&, ::boost::mp11::mp_false) const +#else + get_default(D const&, ::boost::mpl::false_) const +#endif + { + return this->arg.get_value(); + } + + template <typename D> + inline BOOST_CONSTEXPR reference +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + get_default(D const& d, ::boost::mp11::mp_true) const +#else + get_default(D const& d, ::boost::mpl::true_) const +#endif + { + return ( + this->arg.get_value() + ? this->arg.get_value().get() + : this->arg.get_value().construct(d.value) + ); + } + + public: + inline BOOST_CONSTEXPR reference + operator[](::boost::parameter::keyword<key_type> const&) const + { +#if !defined(BOOST_NO_CXX14_CONSTEXPR) +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + static_assert(!_holds_maybe::value, "must not hold maybe"); +#elif !( \ + BOOST_WORKAROUND(BOOST_GCC, >= 40700) && \ + BOOST_WORKAROUND(BOOST_GCC, < 40900) \ + ) && !BOOST_WORKAROUND(BOOST_GCC, >= 50000) && \ + !BOOST_WORKAROUND(BOOST_MSVC, < 1910) + BOOST_MPL_ASSERT_NOT((_holds_maybe)); +#endif +#endif + return this->arg.get_value(); + } + + template <typename Default> + inline BOOST_CONSTEXPR reference + operator[]( + ::boost::parameter::aux::default_<key_type,Default> const& d + ) const + { + return this->get_default(d, _holds_maybe()); + } + + template <typename Default> + inline BOOST_CONSTEXPR reference + operator[]( + ::boost::parameter::aux::default_r_<key_type,Default> const& d + ) const + { + return this->get_default(d, _holds_maybe()); + } + + template <typename Default> + inline BOOST_CONSTEXPR reference + operator[]( + BOOST_PARAMETER_lazy_default_fallback<key_type,Default> const& + ) const + { +#if !defined(BOOST_NO_CXX14_CONSTEXPR) +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + static_assert(!_holds_maybe::value, "must not hold maybe"); +#elif !( \ + BOOST_WORKAROUND(BOOST_GCC, >= 40700) && \ + BOOST_WORKAROUND(BOOST_GCC, < 40900) \ + ) && !BOOST_WORKAROUND(BOOST_GCC, >= 50000) && \ + !BOOST_WORKAROUND(BOOST_MSVC, < 1910) + BOOST_MPL_ASSERT_NOT((_holds_maybe)); +#endif +#endif + return this->arg.get_value(); + } + + // Builds an overload set including operator[]s defined + // in base classes. + using Next::operator[]; + + // + // End of indexing support + // + + // For parameter_requirements matching this node's key_type, return + // a bool constant wrapper indicating whether the requirements are + // satisfied by TaggedArg. Used only for compile-time computation + // and never really called, so a declaration is enough. + template <typename HasDefault, typename Predicate, typename ArgPack> + static typename ::boost::lazy_enable_if< +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + ::boost::mp11::mp_if< + EmitsErrors + , ::boost::mp11::mp_true + , _has_unique_key + > + , ::boost::parameter::aux::augment_predicate_mp11< +#else + typename ::boost::mpl::if_< + EmitsErrors + , ::boost::mpl::true_ + , _has_unique_key + >::type + , ::boost::parameter::aux::augment_predicate< +#endif + Predicate + , reference + , key_type + , value_type + , ArgPack + > + >::type + satisfies( + ::boost::parameter::aux::parameter_requirements< + key_type + , Predicate + , HasDefault + >* + , ArgPack* + ); + + // Builds an overload set including satisfies functions defined + // in base classes. + using Next::satisfies; + + // Comma operator to compose argument list without using parameters<>. + // Useful for argument lists with undetermined length. + template <typename KW, typename T2> + inline BOOST_CONSTEXPR ::boost::parameter::aux::arg_list< + ::boost::parameter::aux::tagged_argument<KW,T2> + , self + > + operator,( + ::boost::parameter::aux::tagged_argument<KW,T2> const& x + ) const + { + return ::boost::parameter::aux::arg_list< + ::boost::parameter::aux::tagged_argument<KW,T2> + , self + >(x, *this); + } + + template <typename KW, typename T2> + inline BOOST_CONSTEXPR ::boost::parameter::aux::arg_list< + ::boost::parameter::aux::tagged_argument_rref<KW,T2> + , self + > + operator,( + ::boost::parameter::aux::tagged_argument_rref<KW,T2> const& x + ) const + { + return ::boost::parameter::aux::arg_list< + ::boost::parameter::aux::tagged_argument_rref<KW,T2> + , self + >(x, *this); + } + + // MPL sequence support + typedef self type; // Convenience for users + typedef Next tail_type; // For the benefit of iterators + // For dispatching to sequence intrinsics + typedef ::boost::parameter::aux::arg_list_tag tag; + }; +}}} // namespace boost::parameter::aux + +#else // !defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING) + #include <boost/preprocessor/repetition/enum_params.hpp> -#include <boost/preprocessor/repetition/enum_binary_params.hpp> #include <boost/preprocessor/facilities/intercept.hpp> -namespace boost { namespace parameter { +namespace boost { namespace parameter { namespace aux { -// Forward declaration for aux::arg_list, below. -template<class T> struct keyword; + // Terminates arg_list<> and represents an empty list. Since this is just + // the terminating case, you might want to look at arg_list first to get a + // feel for what's really happening here. + struct empty_arg_list + { + inline BOOST_CONSTEXPR empty_arg_list() + { + } + + // Constructor taking BOOST_PARAMETER_COMPOSE_MAX_ARITY empty_arg_list + // arguments; this makes initialization. + inline BOOST_CONSTEXPR empty_arg_list( + BOOST_PP_ENUM_PARAMS( + BOOST_PARAMETER_COMPOSE_MAX_ARITY + , ::boost::parameter::void_ BOOST_PP_INTERCEPT + ) + ) + { + } -namespace aux { + // A metafunction class that, given a keyword and a default type, + // returns the appropriate result type for a keyword lookup given + // that default. + struct binding + { + template <typename KW, typename Default, typename Reference> + struct apply + { + typedef Default type; + }; + }; -// Tag type passed to MPL lambda. -struct lambda_tag; + // Terminator for has_key, indicating that the keyword is unique. + template <typename KW> + static ::boost::parameter::aux::no_tag has_key(KW*); -// -// Structures used to build the tuple of actual arguments. The -// tuple is a nested cons-style list of arg_list specializations -// terminated by an empty_arg_list. -// -// Each specialization of arg_list is derived from its successor in -// the list type. This feature is used along with using -// declarations to build member function overload sets that can -// match against keywords. -// +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) + // The overload set technique doesn't work with these older compilers, + // so they need some explicit handholding. -// MPL sequence support -struct arg_list_tag; - -// Terminates arg_list<> and represents an empty list. Since this -// is just the terminating case you might want to look at arg_list -// first, to get a feel for what's really happening here. - -struct empty_arg_list -{ - empty_arg_list() {} - - // Constructor taking BOOST_PARAMETER_MAX_ARITY empty_arg_list - // arguments; this makes initialization - empty_arg_list( - BOOST_PP_ENUM_PARAMS( - BOOST_PARAMETER_MAX_ARITY, void_ BOOST_PP_INTERCEPT - )) - {} - - // A metafunction class that, given a keyword and a default - // type, returns the appropriate result type for a keyword - // lookup given that default - struct binding - { - template<class KW, class Default, class Reference> - struct apply + // A metafunction class that, given a keyword, returns the type of the + // base sublist whose get() function can produce the value for that key. + struct key_owner { - typedef Default type; + template <typename KW> + struct apply + { + typedef ::boost::parameter::aux::empty_arg_list type; + }; }; +#endif // Borland workarounds needed + + // If either of these operators are called, it means there is no + // argument in the list that matches the supplied keyword. Just + // return the default value. + template <typename K, typename Default> + inline BOOST_CONSTEXPR Default& + operator[](::boost::parameter::aux::default_<K,Default> x) const + { + return x.value; + } + + // If this operator is called, it means there is no argument in the + // list that matches the supplied keyword. Just evaluate and return + // the default value. + template <typename K, typename F> + inline BOOST_CONSTEXPR + typename ::boost::parameter::aux::result_of0<F>::type + operator[](BOOST_PARAMETER_lazy_default_fallback<K,F> x) const + { + return x.compute_default(); + } + + // No argument corresponding to ParameterRequirements::key_type + // was found if we match this overload, so unless that parameter + // has a default, we indicate that the actual arguments don't + // match the function's requirements. + template <typename ParameterRequirements, typename ArgPack> + static typename ParameterRequirements::has_default + satisfies(ParameterRequirements*, ArgPack*); + + // MPL sequence support + typedef ::boost::parameter::aux::empty_arg_list type; // convenience + // For dispatching to sequence intrinsics + typedef ::boost::parameter::aux::arg_list_tag tag; }; +}}} // namespace boost::parameter::aux - // Terminator for has_key, indicating that the keyword is unique - template <class KW> - static no_tag has_key(KW*); +#include <boost/parameter/aux_/yesno.hpp> +#include <boost/parameter/aux_/is_maybe.hpp> +#include <boost/parameter/aux_/tagged_argument_fwd.hpp> +#include <boost/parameter/aux_/parameter_requirements.hpp> +#include <boost/parameter/aux_/augment_predicate.hpp> +#include <boost/parameter/keyword_fwd.hpp> +#include <boost/mpl/bool.hpp> +#include <boost/mpl/if.hpp> +#include <boost/mpl/eval_if.hpp> +#include <boost/mpl/apply_wrap.hpp> +#include <boost/mpl/assert.hpp> +#include <boost/type_traits/is_same.hpp> +#include <boost/preprocessor/repetition/enum_binary_params.hpp> +#include <boost/preprocessor/repetition/enum_shifted_params.hpp> -#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +#if !defined(BOOST_NO_SFINAE) && !BOOST_WORKAROUND(BOOST_MSVC, < 1800) +#include <boost/core/enable_if.hpp> +#endif + +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +#include <boost/parameter/aux_/preprocessor/nullptr.hpp> +#endif - // The overload set technique doesn't work with these older - // compilers, so they need some explicit handholding. +namespace boost { namespace parameter { namespace aux { - // A metafunction class that, given a keyword, returns the type - // of the base sublist whose get() function can produce the - // value for that key - struct key_owner + // A tuple of tagged arguments, terminated with empty_arg_list. Every + // TaggedArg is an instance of tagged_argument<>. + template < + typename TaggedArg + , typename Next = ::boost::parameter::aux::empty_arg_list + , typename EmitsErrors = ::boost::mpl::true_ + > + class arg_list : public Next { - template<class KW> - struct apply + typedef typename ::boost::parameter::aux + ::is_maybe<typename TaggedArg::value_type>::type _holds_maybe; + + TaggedArg arg; // Stores the argument + + public: + typedef TaggedArg tagged_arg; + typedef ::boost::parameter::aux::arg_list<TaggedArg,Next> self; + typedef typename TaggedArg::key_type key_type; + + typedef typename ::boost::mpl::eval_if< + _holds_maybe + , ::boost::parameter::aux + ::get_reference<typename TaggedArg::value_type> + , ::boost::parameter::aux::get_reference<TaggedArg> + >::type reference; + + typedef typename ::boost::mpl::if_< + _holds_maybe + , reference + , typename TaggedArg::value_type + >::type value_type; + + // Create a new list by prepending arg to a copy of tail. Used when + // incrementally building this structure with the comma operator. + inline BOOST_CONSTEXPR arg_list( + TaggedArg const& head + , Next const& tail + ) : Next(tail), arg(head) + { + } + + // Store the arguments in successive nodes of this list. + template < + // typename A0, typename A1, ... + BOOST_PP_ENUM_PARAMS( + BOOST_PARAMETER_COMPOSE_MAX_ARITY + , typename A + ) + > + inline BOOST_CONSTEXPR arg_list( + // A0& a0, A1& a1, ... + BOOST_PP_ENUM_BINARY_PARAMS( + BOOST_PARAMETER_COMPOSE_MAX_ARITY + , A + , & a + ) + ) : Next( + // a1, a2, ... + BOOST_PP_ENUM_SHIFTED_PARAMS( + BOOST_PARAMETER_COMPOSE_MAX_ARITY + , a + ) + , ::boost::parameter::aux::void_reference() + ) + , arg(a0) + { + } + + // A metafunction class that, given a keyword and a default type, + // returns the appropriate result type for a keyword lookup given + // that default. + struct binding + { + typedef typename Next::binding next_binding; + + template <typename KW, typename Default, typename Reference> + struct apply + { + typedef typename ::boost::mpl::eval_if< + ::boost::is_same<KW,key_type> + , ::boost::mpl::if_<Reference,reference,value_type> + , ::boost::mpl::apply_wrap3< + next_binding + , KW + , Default + , Reference + > + >::type type; + }; + }; + +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) + // Overload for key_type, so the assert below will fire + // if the same keyword is used again. + static ::boost::parameter::aux::yes_tag has_key(key_type*); + using Next::has_key; + + private: +#if defined(BOOST_NO_SFINAE) || BOOST_WORKAROUND(BOOST_MSVC, < 1800) + BOOST_MPL_ASSERT_MSG( + sizeof( + Next::has_key( + static_cast<key_type*>(BOOST_PARAMETER_AUX_PP_NULLPTR) + ) + ) == sizeof(::boost::parameter::aux::no_tag) + , duplicate_keyword + , (key_type) + ); +#else + typedef ::boost::mpl::bool_< + sizeof( + Next::has_key( + static_cast<key_type*>(BOOST_PARAMETER_AUX_PP_NULLPTR) + ) + ) == sizeof(::boost::parameter::aux::no_tag) + > _has_unique_key; + + BOOST_MPL_ASSERT_MSG( + !(EmitsErrors::value) || (_has_unique_key::value) + , duplicate_keyword + , (key_type) + ); +#endif // SFINAE/MSVC workarounds needed +#endif // Borland workarounds not needed + + private: + // + // Begin implementation of indexing operators + // for looking up specific arguments by name. + // + + // Helpers that handle the case when TaggedArg is empty<T>. + template <typename D> + inline BOOST_CONSTEXPR reference + get_default(D const&, ::boost::mpl::false_) const + { + return this->arg.get_value(); + } + + template <typename D> + inline BOOST_CONSTEXPR reference + get_default(D const& d, ::boost::mpl::true_) const + { + return ( + this->arg.get_value() + ? this->arg.get_value().get() + : this->arg.get_value().construct(d.value) + ); + } + + public: +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) + // These older compilers don't support the overload set creation + // idiom well, so we need to do all the return type calculation + // for the compiler and dispatch through an outer function template. + + // A metafunction class that, given a keyword, returns the base + // sublist whose get() function can produce the value for that key. + struct key_owner { - typedef empty_arg_list type; + typedef typename Next::key_owner next_key_owner; + + template <typename KW> + struct apply + { + typedef typename ::boost::mpl::eval_if< + ::boost::is_same<KW,key_type> + , ::boost::mpl::identity< + ::boost::parameter::aux::arg_list<TaggedArg,Next> + > + , ::boost::mpl::apply_wrap1<next_key_owner,KW> + >::type type; + }; }; + + // Outer indexing operators that dispatch to the right node's + // get() function. + template <typename KW> + inline BOOST_CONSTEXPR typename ::boost::mpl::apply_wrap3< + binding + , KW + , ::boost::parameter::void_ + , ::boost::mpl::true_ + >::type + operator[](::boost::parameter::keyword<KW> const& x) const + { + typename ::boost::mpl::apply_wrap1<key_owner,KW>::type const& + sublist = *this; + return sublist.get(x); + } + + template <typename KW, typename Default> + inline BOOST_CONSTEXPR typename ::boost::mpl::apply_wrap3< + binding + , KW + , Default& + , ::boost::mpl::true_ + >::type + operator[]( + ::boost::parameter::aux::default_<KW,Default> const& x + ) const + { + typename ::boost::mpl::apply_wrap1<key_owner,KW>::type const& + sublist = *this; + return sublist.get(x); + } + + template <typename KW, typename F> + inline BOOST_CONSTEXPR typename ::boost::mpl::apply_wrap3< + binding + , KW + , typename ::boost::parameter::aux::result_of0<F>::type + , ::boost::mpl::true_ + >::type + operator[]( + BOOST_PARAMETER_lazy_default_fallback<KW,F> const& x + ) const + { + typename ::boost::mpl::apply_wrap1<key_owner,KW>::type const& + sublist = *this; + return sublist.get(x); + } + + // These just return the stored value; when empty_arg_list is reached, + // indicating no matching argument was passed, the default is + // returned, or if no default_ or lazy_default was passed, compilation + // fails. + inline BOOST_CONSTEXPR reference + get(::boost::parameter::keyword<key_type> const&) const + { + BOOST_MPL_ASSERT_NOT((_holds_maybe)); + return this->arg.get_value(); + } + + template <typename Default> + inline BOOST_CONSTEXPR reference + get( + ::boost::parameter::aux::default_<key_type,Default> const& d + ) const + { + return this->get_default(d, _holds_maybe()); + } + + template <typename Default> + inline BOOST_CONSTEXPR reference + get( + BOOST_PARAMETER_lazy_default_fallback<key_type,Default> const& + ) const + { + return this->arg.get_value(); + } +#else // !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) + inline BOOST_CONSTEXPR reference + operator[](::boost::parameter::keyword<key_type> const&) const + { + BOOST_MPL_ASSERT_NOT((_holds_maybe)); + return this->arg.get_value(); + } + + template <typename Default> + inline BOOST_CONSTEXPR reference + operator[]( + ::boost::parameter::aux::default_<key_type,Default> const& d + ) const + { + return this->get_default(d, _holds_maybe()); + } + + template <typename Default> + inline BOOST_CONSTEXPR reference + operator[]( + BOOST_PARAMETER_lazy_default_fallback<key_type,Default> const& + ) const + { + BOOST_MPL_ASSERT_NOT((_holds_maybe)); + return this->arg.get_value(); + } + + // Builds an overload set including operator[]s defined + // in base classes. + using Next::operator[]; + + // + // End of indexing support + // + + // For parameter_requirements matching this node's key_type, return + // a bool constant wrapper indicating whether the requirements are + // satisfied by TaggedArg. Used only for compile-time computation + // and never really called, so a declaration is enough. + template <typename HasDefault, typename Predicate, typename ArgPack> + static typename +#if !defined(BOOST_NO_SFINAE) && !BOOST_WORKAROUND(BOOST_MSVC, < 1800) + ::boost::lazy_enable_if< + typename ::boost::mpl::if_< + EmitsErrors + , ::boost::mpl::true_ + , _has_unique_key + >::type, +#endif + ::boost::parameter::aux::augment_predicate< + Predicate + , reference + , key_type + , value_type + , ArgPack +#if !defined(BOOST_NO_SFINAE) && !BOOST_WORKAROUND(BOOST_MSVC, < 1800) + > +#endif + >::type + satisfies( + ::boost::parameter::aux::parameter_requirements< + key_type + , Predicate + , HasDefault + >* + , ArgPack* + ); + + // Builds an overload set including satisfies functions defined + // in base classes. + using Next::satisfies; +#endif // Borland workarounds needed + + // Comma operator to compose argument list without using parameters<>. + // Useful for argument lists with undetermined length. + template <typename KW, typename T2> + inline BOOST_CONSTEXPR ::boost::parameter::aux::arg_list< + ::boost::parameter::aux::tagged_argument<KW,T2> + , self + > + operator,( + ::boost::parameter::aux::tagged_argument<KW,T2> const& x + ) const + { + return ::boost::parameter::aux::arg_list< + ::boost::parameter::aux::tagged_argument<KW,T2> + , self + >(x, *this); + } + + // MPL sequence support + typedef self type; // Convenience for users + typedef Next tail_type; // For the benefit of iterators + // For dispatching to sequence intrinsics + typedef ::boost::parameter::aux::arg_list_tag tag; }; +}}} // namespace boost::parameter::aux + +#endif // BOOST_PARAMETER_HAS_PERFECT_FORWARDING - template <class K, class T> - T& get(default_<K,T> x) const +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + +namespace boost { namespace parameter { namespace aux { + + template <typename ...ArgTuples> + struct arg_list_cons; + + template <> + struct arg_list_cons<> { - return x.value; - } + using type = ::boost::parameter::aux::empty_arg_list; + }; - template <class K, class F> - typename result_of0<F>::type - get(lazy_default<K,F> x) const + template <typename ArgTuple0, typename ...Tuples> + struct arg_list_cons<ArgTuple0,Tuples...> { - return x.compute_default(); - } -#endif + using type = ::boost::parameter::aux::arg_list< + typename ArgTuple0::tagged_arg + , typename ::boost::parameter::aux::arg_list_cons<Tuples...>::type + , typename ArgTuple0::emits_errors + >; + }; - // If this function is called, it means there is no argument - // in the list that matches the supplied keyword. Just return - // the default value. - template <class K, class Default> - Default& operator[](default_<K, Default> x) const + template < + typename Keyword + , typename TaggedArg + , typename EmitsErrors = ::boost::mp11::mp_true + > + struct flat_like_arg_tuple { - return x.value; - } - - // If this function is called, it means there is no argument - // in the list that matches the supplied keyword. Just evaluate - // and return the default value. - template <class K, class F> - typename result_of0<F>::type - operator[]( - BOOST_PARAMETER_lazy_default_fallback<K,F> x) const + using tagged_arg = TaggedArg; + using emits_errors = EmitsErrors; + }; + + template <typename ...ArgTuples> + class flat_like_arg_list + : public ::boost::parameter::aux::arg_list_cons<ArgTuples...>::type { - return x.compute_default(); - } + using _base_type = typename ::boost::parameter::aux + ::arg_list_cons<ArgTuples...>::type; + + public: + inline BOOST_CONSTEXPR flat_like_arg_list( + typename _base_type::tagged_arg const& head + , typename _base_type::tail_type const& tail + ) : _base_type(head, tail) + { + } - // No argument corresponding to ParameterRequirements::key_type - // was found if we match this overload, so unless that parameter - // has a default, we indicate that the actual arguments don't - // match the function's requirements. - template <class ParameterRequirements, class ArgPack> - static typename ParameterRequirements::has_default - satisfies(ParameterRequirements*, ArgPack*); + template <typename ...Args> + inline BOOST_CONSTEXPR flat_like_arg_list(Args&&... args) + : _base_type(::std::forward<Args>(args)...) + { + } + + using _base_type::operator[]; + using _base_type::satisfies; + + // Comma operator to compose argument list without using parameters<>. + // Useful for argument lists with undetermined length. + template <typename TaggedArg> + inline BOOST_CONSTEXPR ::boost::parameter::aux::flat_like_arg_list< + ::boost::parameter::aux::flat_like_arg_tuple< + typename TaggedArg::base_type::key_type + , typename TaggedArg::base_type + > + , ArgTuples... + > + operator,(TaggedArg const& x) const + { + return ::boost::parameter::aux::flat_like_arg_list< + ::boost::parameter::aux::flat_like_arg_tuple< + typename TaggedArg::base_type::key_type + , typename TaggedArg::base_type + > + , ArgTuples... + >( + static_cast<typename TaggedArg::base_type const&>(x) + , static_cast<_base_type const&>(*this) + ); + } + }; - // MPL sequence support - typedef empty_arg_list type; // convenience - typedef arg_list_tag tag; // For dispatching to sequence intrinsics -}; - -// Forward declaration for arg_list::operator, -template <class KW, class T> -struct tagged_argument; - -template <class T> -struct get_reference -{ - typedef typename T::reference type; -}; - -// A tuple of tagged arguments, terminated with empty_arg_list. -// Every TaggedArg is an instance of tagged_argument<>. -template <class TaggedArg, class Next = empty_arg_list> -struct arg_list : Next -{ - typedef arg_list<TaggedArg,Next> self; - typedef typename TaggedArg::key_type key_type; - - typedef typename is_maybe<typename TaggedArg::value_type>::type holds_maybe; - - typedef typename mpl::eval_if< - holds_maybe - , get_reference<typename TaggedArg::value_type> - , get_reference<TaggedArg> - >::type reference; - - typedef typename mpl::if_< - holds_maybe - , reference - , typename TaggedArg::value_type - >::type value_type; - - TaggedArg arg; // Stores the argument - - // Store the arguments in successive nodes of this list - template< // class A0, class A1, ... - BOOST_PP_ENUM_PARAMS(BOOST_PARAMETER_MAX_ARITY, class A) - > - arg_list( // A0& a0, A1& a1, ... - BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PARAMETER_MAX_ARITY, A, & a) - ) - : Next( // a1, a2, ... - BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PARAMETER_MAX_ARITY, a) - , void_reference() - ) - , arg(a0) - {} - - // Create a new list by prepending arg to a copy of tail. Used - // when incrementally building this structure with the comma - // operator. - arg_list(TaggedArg head, Next const& tail) - : Next(tail) - , arg(head) - {} - - // A metafunction class that, given a keyword and a default - // type, returns the appropriate result type for a keyword - // lookup given that default - struct binding + template <> + class flat_like_arg_list<> + : public ::boost::parameter::aux::empty_arg_list { - template <class KW, class Default, class Reference> - struct apply + using _base_type = ::boost::parameter::aux::empty_arg_list; + + public: + template <typename ...Args> + inline BOOST_CONSTEXPR flat_like_arg_list(Args&&... args) + : _base_type(::std::forward<Args>(args)...) { - typedef typename mpl::eval_if< - boost::is_same<KW, key_type> - , mpl::if_<Reference, reference, value_type> - , mpl::apply_wrap3<typename Next::binding, KW, Default, Reference> - >::type type; - }; + } + + using _base_type::operator[]; + using _base_type::satisfies; + + // Comma operator to compose argument list without using parameters<>. + // Useful for argument lists with undetermined length. + template <typename TaggedArg> + inline BOOST_CONSTEXPR ::boost::parameter::aux::flat_like_arg_list< + ::boost::parameter::aux::flat_like_arg_tuple< + typename TaggedArg::base_type::key_type + , typename TaggedArg::base_type + > + > + operator,(TaggedArg const& x) const + { + return ::boost::parameter::aux::flat_like_arg_list< + ::boost::parameter::aux::flat_like_arg_tuple< + typename TaggedArg::base_type::key_type + , typename TaggedArg::base_type + > + >( + static_cast<typename TaggedArg::base_type const&>(x) + , static_cast<_base_type const&>(*this) + ); + } }; +}}} // namespace boost::parameter::aux -#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) - // Overload for key_type, so the assert below will fire if the - // same keyword is used again - static yes_tag has_key(key_type*); - using Next::has_key; +#endif // BOOST_PARAMETER_CAN_USE_MP11 - BOOST_MPL_ASSERT_MSG( - sizeof(Next::has_key((key_type*)0)) == sizeof(no_tag) - , duplicate_keyword, (key_type) - ); +#include <boost/mpl/iterator_tags.hpp> -#endif - // - // Begin implementation of indexing operators for looking up - // specific arguments by name - // +namespace boost { namespace parameter { namespace aux { - // Helpers that handle the case when TaggedArg is - // empty<T>. - template <class D> - reference get_default(D const&, mpl::false_) const + // MPL sequence support + template <typename ArgumentPack> + struct arg_list_iterator { - return arg.value; - } + typedef ::boost::mpl::forward_iterator_tag category; + + // The incremented iterator + typedef ::boost::parameter::aux + ::arg_list_iterator<typename ArgumentPack::tail_type> next; - template <class D> - reference get_default(D const& d, mpl::true_) const + // dereferencing yields the key type + typedef typename ArgumentPack::key_type type; + }; + + template <> + struct arg_list_iterator< ::boost::parameter::aux::empty_arg_list> { - return arg.value ? arg.value.get() : arg.value.construct(d.value); - } + }; +}}} // namespace boost::parameter::aux -#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) - // These older compilers don't support the overload set creation - // idiom well, so we need to do all the return type calculation - // for the compiler and dispatch through an outer function template - - // A metafunction class that, given a keyword, returns the base - // sublist whose get() function can produce the value for that - // key. - struct key_owner +#include <boost/mpl/begin_end_fwd.hpp> + +// MPL sequence support +namespace boost { namespace mpl { + + template <> + struct begin_impl< ::boost::parameter::aux::arg_list_tag> { - template<class KW> + template <typename S> struct apply { - typedef typename mpl::eval_if< - boost::is_same<KW, key_type> - , mpl::identity<arg_list<TaggedArg,Next> > - , mpl::apply_wrap1<typename Next::key_owner,KW> - >::type type; + typedef ::boost::parameter::aux::arg_list_iterator<S> type; }; }; - // Outer indexing operators that dispatch to the right node's - // get() function. - template <class KW> - typename mpl::apply_wrap3<binding, KW, void_, mpl::true_>::type - operator[](keyword<KW> const& x) const + template <> + struct end_impl< ::boost::parameter::aux::arg_list_tag> { - typename mpl::apply_wrap1<key_owner, KW>::type const& sublist = *this; - return sublist.get(x); - } + template <typename> + struct apply + { + typedef ::boost::parameter::aux::arg_list_iterator< + ::boost::parameter::aux::empty_arg_list + > type; + }; + }; +}} // namespace boost::mpl - template <class KW, class Default> - typename mpl::apply_wrap3<binding, KW, Default&, mpl::true_>::type - operator[](default_<KW, Default> x) const - { - typename mpl::apply_wrap1<key_owner, KW>::type const& sublist = *this; - return sublist.get(x); - } - - template <class KW, class F> - typename mpl::apply_wrap3< - binding,KW - , typename result_of0<F>::type - , mpl::true_ - >::type - operator[](lazy_default<KW,F> x) const - { - typename mpl::apply_wrap1<key_owner, KW>::type const& sublist = *this; - return sublist.get(x); - } - - // These just return the stored value; when empty_arg_list is - // reached, indicating no matching argument was passed, the - // default is returned, or if no default_ or lazy_default was - // passed, compilation fails. - reference get(keyword<key_type> const&) const - { - BOOST_MPL_ASSERT_NOT((holds_maybe)); - return arg.value; - } +#include <boost/parameter/value_type.hpp> +#include <boost/mpl/has_key_fwd.hpp> +#include <boost/type_traits/is_void.hpp> - template <class Default> - reference get(default_<key_type,Default> const& d) const - { - return get_default(d, holds_maybe()); - } +namespace boost { namespace mpl { - template <class Default> - reference get(lazy_default<key_type, Default>) const + template <> + struct has_key_impl< ::boost::parameter::aux::arg_list_tag> { - return arg.value; - } + template <typename ArgList, typename Keyword> + struct apply + { + typedef typename ::boost::mpl::if_< + ::boost::is_void< + typename ::boost::parameter + ::value_type<ArgList,Keyword,void>::type + > + , ::boost::mpl::false_ + , ::boost::mpl::true_ + >::type type; + }; + }; +}} // namespace boost::mpl -#else +#include <boost/mpl/count_fwd.hpp> +#include <boost/mpl/int.hpp> - reference operator[](keyword<key_type> const&) const - { - BOOST_MPL_ASSERT_NOT((holds_maybe)); - return arg.value; - } +namespace boost { namespace mpl { - template <class Default> - reference operator[](default_<key_type, Default> const& d) const + template <> + struct count_impl< ::boost::parameter::aux::arg_list_tag> { - return get_default(d, holds_maybe()); - } + template <typename ArgList, typename Keyword> + struct apply + { + typedef typename ::boost::mpl::if_< + ::boost::is_void< + typename ::boost::parameter + ::value_type<ArgList,Keyword,void>::type + > + , ::boost::mpl::int_<0> + , ::boost::mpl::int_<1> + >::type type; + }; + }; +}} // namespace boost::mpl - template <class Default> - reference operator[](lazy_default<key_type, Default>) const - { - BOOST_MPL_ASSERT_NOT((holds_maybe)); - return arg.value; - } +#include <boost/mpl/key_type_fwd.hpp> +#include <boost/mpl/identity.hpp> - // Builds an overload set including operator[]s defined in base - // classes. - using Next::operator[]; +namespace boost { namespace mpl { - // - // End of indexing support - // + template <> + struct key_type_impl< ::boost::parameter::aux::arg_list_tag> + { + template <typename ArgList, typename Keyword> + struct apply + { + typedef typename ::boost::mpl::eval_if< + ::boost::is_void< + typename ::boost::parameter + ::value_type<ArgList,Keyword,void>::type + > + , void + , ::boost::mpl::identity<Keyword> + >::type type; + }; + }; +}} // namespace boost::mpl +#include <boost/mpl/value_type_fwd.hpp> - // - // For parameter_requirements matching this node's key_type, - // return a bool constant wrapper indicating whether the - // requirements are satisfied by TaggedArg. Used only for - // compile-time computation and never really called, so a - // declaration is enough. - // - template <class HasDefault, class Predicate, class ArgPack> - static typename mpl::apply_wrap2< - typename mpl::lambda<Predicate, lambda_tag>::type - , value_type, ArgPack - >::type - satisfies( - parameter_requirements<key_type,Predicate,HasDefault>* - , ArgPack* - ); - - // Builds an overload set including satisfies functions defined - // in base classes. - using Next::satisfies; -#endif +namespace boost { namespace mpl { - // Comma operator to compose argument list without using parameters<>. - // Useful for argument lists with undetermined length. - template <class KW, class T2> - arg_list<tagged_argument<KW, T2>, self> - operator,(tagged_argument<KW,T2> x) const + template <> + struct value_type_impl< ::boost::parameter::aux::arg_list_tag> + : ::boost::mpl::key_type_impl< ::boost::parameter::aux::arg_list_tag> { - return arg_list<tagged_argument<KW,T2>, self>(x, *this); - } + }; +}} // namespace boost::mpl - // MPL sequence support - typedef self type; // Convenience for users - typedef Next tail_type; // For the benefit of iterators - typedef arg_list_tag tag; // For dispatching to sequence intrinsics -}; +#include <boost/mpl/at_fwd.hpp> -// MPL sequence support -template <class ArgumentPack> -struct arg_list_iterator -{ - typedef mpl::forward_iterator_tag category; +namespace boost { namespace mpl { - // The incremented iterator - typedef arg_list_iterator<typename ArgumentPack::tail_type> next; + template <> + struct at_impl< ::boost::parameter::aux::arg_list_tag> + : ::boost::mpl::key_type_impl< ::boost::parameter::aux::arg_list_tag> + { + }; +}} // namespace boost::mpl - // dereferencing yields the key type - typedef typename ArgumentPack::key_type type; -}; +#include <boost/mpl/order_fwd.hpp> +#include <boost/mpl/void.hpp> +#include <boost/mpl/find.hpp> +#include <boost/mpl/distance.hpp> -template <> -struct arg_list_iterator<empty_arg_list> {}; +namespace boost { namespace mpl { -}} // namespace parameter::aux + template <> + struct order_impl< ::boost::parameter::aux::arg_list_tag> + { + template <typename ArgList, typename Keyword> + struct apply + { + typedef typename ::boost::mpl::find<ArgList,Keyword>::type Itr; + typedef typename ::boost::mpl::eval_if< + ::boost::is_void< + typename ::boost::parameter + ::value_type<ArgList,Keyword,void>::type + > + , ::boost::mpl::identity< ::boost::mpl::void_> + , ::boost::mpl::distance< + Itr + , ::boost::parameter::aux::arg_list_iterator< + ::boost::parameter::aux::empty_arg_list + > + > + >::type type; + }; + }; +}} // namespace boost::mpl -// MPL sequence support -namespace mpl -{ - template <> - struct begin_impl<parameter::aux::arg_list_tag> - { - template <class S> - struct apply - { - typedef parameter::aux::arg_list_iterator<S> type; - }; - }; - - template <> - struct end_impl<parameter::aux::arg_list_tag> - { - template <class> - struct apply - { - typedef parameter::aux::arg_list_iterator<parameter::aux::empty_arg_list> type; - }; - }; -} - -} // namespace boost - -#endif // ARG_LIST_050329_HPP +#endif // include guard diff --git a/boost/parameter/aux_/as_lvalue.hpp b/boost/parameter/aux_/as_lvalue.hpp new file mode 100644 index 0000000000..d50b89778e --- /dev/null +++ b/boost/parameter/aux_/as_lvalue.hpp @@ -0,0 +1,25 @@ +// Copyright Daniel Wallin 2006. +// 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_AUX_AS_LVALUE_HPP +#define BOOST_PARAMETER_AUX_AS_LVALUE_HPP + +namespace boost { namespace parameter { namespace aux { + + template <typename T> + T const& as_lvalue(T const& value) + { + return value; + } + + template <typename T> + T& as_lvalue(T& value) + { + return value; + } +}}} // namespace boost::parameter::aux + +#endif // include guard + diff --git a/boost/parameter/aux_/augment_predicate.hpp b/boost/parameter/aux_/augment_predicate.hpp new file mode 100644 index 0000000000..497af08439 --- /dev/null +++ b/boost/parameter/aux_/augment_predicate.hpp @@ -0,0 +1,198 @@ +// 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_AUGMENT_PREDICATE_HPP +#define BOOST_PARAMETER_AUGMENT_PREDICATE_HPP + +#include <boost/parameter/keyword_fwd.hpp> +#include <boost/mpl/bool.hpp> +#include <boost/mpl/if.hpp> +#include <boost/mpl/eval_if.hpp> +#include <boost/type_traits/is_lvalue_reference.hpp> +#include <boost/type_traits/is_scalar.hpp> +#include <boost/type_traits/is_same.hpp> + +namespace boost { namespace parameter { namespace aux { + + template <typename V, typename R, typename Tag> + struct augment_predicate_check_consume_ref + : ::boost::mpl::eval_if< + ::boost::is_scalar<V> + , ::boost::mpl::true_ + , ::boost::mpl::eval_if< + ::boost::is_same< + typename Tag::qualifier + , ::boost::parameter::consume_reference + > + , ::boost::mpl::if_< + ::boost::is_lvalue_reference<R> + , ::boost::mpl::false_ + , ::boost::mpl::true_ + > + , boost::mpl::true_ + > + >::type + { + }; +}}} // namespace boost::parameter::aux + +#include <boost/type_traits/is_const.hpp> + +namespace boost { namespace parameter { namespace aux { + + template <typename V, typename R, typename Tag> + struct augment_predicate_check_out_ref + : ::boost::mpl::eval_if< + ::boost::is_same< + typename Tag::qualifier + , ::boost::parameter::out_reference + > + , ::boost::mpl::eval_if< + ::boost::is_lvalue_reference<R> + , ::boost::mpl::if_< + ::boost::is_const<V> + , ::boost::mpl::false_ + , ::boost::mpl::true_ + > + , ::boost::mpl::false_ + > + , ::boost::mpl::true_ + >::type + { + }; +}}} // namespace boost::parameter::aux + +#include <boost/parameter/aux_/lambda_tag.hpp> +#include <boost/mpl/apply_wrap.hpp> +#include <boost/mpl/lambda.hpp> + +namespace boost { namespace parameter { namespace aux { + + template < + typename Predicate + , typename R + , typename Tag + , typename T + , typename Args + > + class augment_predicate + { + typedef typename ::boost::mpl::lambda< + Predicate + , ::boost::parameter::aux::lambda_tag + >::type _actual_predicate; + + public: + typedef typename ::boost::mpl::eval_if< + typename ::boost::mpl::if_< + ::boost::parameter::aux + ::augment_predicate_check_consume_ref<T,R,Tag> + , ::boost::parameter::aux + ::augment_predicate_check_out_ref<T,R,Tag> + , ::boost::mpl::false_ + >::type + , ::boost::mpl::apply_wrap2<_actual_predicate,T,Args> + , ::boost::mpl::false_ + >::type type; + }; +}}} // namespace boost::parameter::aux + +#include <boost/parameter/config.hpp> + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <boost/mp11/integral.hpp> +#include <boost/mp11/utility.hpp> +#include <type_traits> + +namespace boost { namespace parameter { namespace aux { + + template <typename V, typename R, typename Tag> + using augment_predicate_check_consume_ref_mp11 = ::boost::mp11::mp_if< + ::std::is_scalar<V> + , ::boost::mp11::mp_true + , ::boost::mp11::mp_if< + ::std::is_same< + typename Tag::qualifier + , ::boost::parameter::consume_reference + > + , ::boost::mp11::mp_if< + ::std::is_lvalue_reference<R> + , ::boost::mp11::mp_false + , ::boost::mp11::mp_true + > + , boost::mp11::mp_true + > + >; + + template <typename V, typename R, typename Tag> + using augment_predicate_check_out_ref_mp11 = ::boost::mp11::mp_if< + ::std::is_same< + typename Tag::qualifier + , ::boost::parameter::out_reference + > + , ::boost::mp11::mp_if< + ::std::is_lvalue_reference<R> + , ::boost::mp11::mp_if< + ::std::is_const<V> + , ::boost::mp11::mp_false + , ::boost::mp11::mp_true + > + , ::boost::mp11::mp_false + > + , ::boost::mp11::mp_true + >; +}}} // namespace boost::parameter::aux + +#include <boost/mp11/list.hpp> + +namespace boost { namespace parameter { namespace aux { + + template < + typename Predicate + , typename R + , typename Tag + , typename T + , typename Args + > + struct augment_predicate_mp11_impl + { + using type = ::boost::mp11::mp_if< + ::boost::mp11::mp_if< + ::boost::parameter::aux + ::augment_predicate_check_consume_ref_mp11<T,R,Tag> + , ::boost::parameter::aux + ::augment_predicate_check_out_ref_mp11<T,R,Tag> + , ::boost::mp11::mp_false + > + , ::boost::mp11 + ::mp_apply_q<Predicate,::boost::mp11::mp_list<T,Args> > + , ::boost::mp11::mp_false + >; + }; +}}} // namespace boost::parameter::aux + +#include <boost/parameter/aux_/has_nested_template_fn.hpp> + +namespace boost { namespace parameter { namespace aux { + + template < + typename Predicate + , typename R + , typename Tag + , typename T + , typename Args + > + using augment_predicate_mp11 = ::boost::mp11::mp_if< + ::boost::parameter::aux::has_nested_template_fn<Predicate> + , ::boost::parameter::aux + ::augment_predicate_mp11_impl<Predicate,R,Tag,T,Args> + , ::boost::parameter::aux + ::augment_predicate<Predicate,R,Tag,T,Args> + >; +}}} // namespace boost::parameter::aux + +#endif // BOOST_PARAMETER_CAN_USE_MP11 +#endif // include guard + diff --git a/boost/parameter/aux_/cast.hpp b/boost/parameter/aux_/cast.hpp index bd3de2bef5..0125e2209c 100644 --- a/boost/parameter/aux_/cast.hpp +++ b/boost/parameter/aux_/cast.hpp @@ -1,141 +1,12 @@ -// Copyright Daniel Wallin 2006. Use, modification and distribution is -// subject to the Boost Software License, Version 1.0. (See accompanying -// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +// Copyright Daniel Wallin 2006. +// 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_CAST_060902_HPP -# define BOOST_PARAMETER_CAST_060902_HPP +#define BOOST_PARAMETER_CAST_060902_HPP -# include <boost/detail/workaround.hpp> +#include <boost/parameter/aux_/preprocessor/impl/function_cast.hpp> -# if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) -# include <boost/type_traits/add_reference.hpp> -# include <boost/type_traits/remove_const.hpp> -# endif - -namespace boost { namespace parameter { namespace aux { - -struct use_default_tag {}; - -# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) - -# define BOOST_PARAMETER_FUNCTION_CAST(value, predicate) value - -# else - -// Handles possible implicit casts. Used by preprocessor.hpp to -// normalize user input. -// -// cast<void*>::execute() is identity -// cast<void*(X)>::execute() is identity -// cast<void(X)>::execute() casts to X -// -// preprocessor.hpp uses this like this: -// -// #define X(value, predicate) -// cast<void predicate>::execute(value) -// -// X(something, *) -// X(something, *(predicate)) -// X(something, (int)) - -template <class T, class Args> -struct cast; - -template <class Args> -struct cast<void*, Args> -{ - static use_default_tag execute(use_default_tag) - { - return use_default_tag(); - } - - static use_default_tag remove_const(use_default_tag) - { - return use_default_tag(); - } - - template <class U> - static U& execute(U& value) - { - return value; - } - - template <class U> - static U& remove_const(U& x) - { - return x; - } -}; - -#if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x580)) - -typedef void* voidstar; - -template <class T, class Args> -struct cast<voidstar(T), Args> - : cast<void*, Args> -{ -}; - -#else - -template <class T, class Args> -struct cast<void*(T), Args> - : cast<void*, Args> -{ -}; - -#endif - -// This is a hack used in cast<> to turn the user supplied type, -// which may or may not be a placeholder expression into one, so -// that it will be properly evaluated by mpl::apply. -template <class T, class Dummy = mpl::_1> -struct as_placeholder_expr -{ - typedef T type; -}; - -template <class T, class Args> -struct cast<void(T), Args> -{ - typedef typename mpl::apply2< - as_placeholder_expr<T>, Args, Args>::type type0; - - typedef typename boost::add_reference< - typename boost::remove_const<type0>::type - >::type reference; - - static use_default_tag execute(use_default_tag) - { - return use_default_tag(); - } - - static use_default_tag remove_const(use_default_tag) - { - return use_default_tag(); - } - - static type0 execute(type0 value) - { - return value; - } - - template <class U> - static reference remove_const(U const& x) - { - return const_cast<reference>(x); - } -}; - -# define BOOST_PARAMETER_FUNCTION_CAST(value, predicate, args) \ - boost::parameter::aux::cast<void predicate, args>::remove_const( \ - boost::parameter::aux::cast<void predicate, args>::execute(value) \ - ) - -# endif - -}}} // namespace boost::parameter::aux - -#endif // BOOST_PARAMETER_CAST_060902_HPP +#endif // include guard diff --git a/boost/parameter/aux_/default.hpp b/boost/parameter/aux_/default.hpp index 604da61299..531111c3e8 100644 --- a/boost/parameter/aux_/default.hpp +++ b/boost/parameter/aux_/default.hpp @@ -1,69 +1,100 @@ -// 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 DEFAULT_050329_HPP -# define DEFAULT_050329_HPP +#define DEFAULT_050329_HPP -# include <boost/detail/workaround.hpp> +namespace boost { namespace parameter { namespace aux { + + // A wrapper for the default value passed by the user when resolving + // the value of the parameter with the given Keyword + template <typename Keyword, typename Value> + struct default_ + { + inline BOOST_CONSTEXPR default_(Value& x) : value(x) + { + } + + Value& value; + }; +}}} // namespace boost::parameter::aux + +#include <boost/parameter/config.hpp> + +namespace boost { namespace parameter { namespace aux { + + // lazy_default -- A wrapper for the default value computation function + // passed by the user when resolving the value of the parameter with the + // given keyword. +#if BOOST_WORKAROUND(__EDG_VERSION__, <= 300) + // These compilers need a little extra help with overload resolution; + // we have empty_arg_list's operator[] accept a base class + // to make that overload less preferable. + template <typename KW, typename DefaultComputer> + struct lazy_default_base + { + inline BOOST_CONSTEXPR lazy_default_base(DefaultComputer& x) + : compute_default(x) + { + } + + DefaultComputer& compute_default; + }; + + template <typename KW, typename DefaultComputer> + struct lazy_default + : ::boost::parameter::aux::lazy_default_base<KW,DefaultComputer> + { + inline BOOST_CONSTEXPR lazy_default(DefaultComputer& x) + : ::boost::parameter::aux::lazy_default_base<KW,DefaultComputer>(x) + { + } + }; +#else // !BOOST_WORKAROUND(__EDG_VERSION__, <= 300) + template <typename KW, typename DefaultComputer> + struct lazy_default + { + inline BOOST_CONSTEXPR lazy_default(DefaultComputer& x) + : compute_default(x) + { + } + + DefaultComputer& compute_default; + }; +#endif // EDG workarounds needed. +}}} // namespace boost::parameter::aux + +#if BOOST_WORKAROUND(__EDG_VERSION__, <= 300) +#define BOOST_PARAMETER_lazy_default_fallback \ + ::boost::parameter::aux::lazy_default_base +/**/ +#else +#define BOOST_PARAMETER_lazy_default_fallback \ + ::boost::parameter::aux::lazy_default +/**/ +#endif + +#if defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING) + +#include <utility> namespace boost { namespace parameter { namespace aux { -// A wrapper for the default value passed by the user when resolving -// the value of the parameter with the given Keyword -template <class Keyword, class Value> -struct default_ -{ - default_(Value& x) - : value(x) - {} - - Value& value; -}; - -// -// lazy_default -- -// -// A wrapper for the default value computation function passed by -// the user when resolving the value of the parameter with the -// given keyword -// -# if BOOST_WORKAROUND(__EDG_VERSION__, <= 300) -// These compilers need a little extra help with overload -// resolution; we have empty_arg_list's operator[] accept a base -// class to make that overload less preferable. -template <class KW, class DefaultComputer> -struct lazy_default_base -{ - lazy_default_base(DefaultComputer const& x) - : compute_default(x) - {} - DefaultComputer const& compute_default; -}; - -template <class KW, class DefaultComputer> -struct lazy_default - : lazy_default_base<KW,DefaultComputer> - { - lazy_default(DefaultComputer const & x) - : lazy_default_base<KW,DefaultComputer>(x) - {} - }; -# define BOOST_PARAMETER_lazy_default_fallback lazy_default_base -# else -template <class KW, class DefaultComputer> -struct lazy_default -{ - lazy_default(const DefaultComputer& x) - : compute_default(x) - {} - DefaultComputer const& compute_default; -}; -# define BOOST_PARAMETER_lazy_default_fallback lazy_default -# endif + template <typename Keyword, typename Value> + struct default_r_ + { + inline BOOST_CONSTEXPR default_r_(Value&& x) + : value(::std::forward<Value>(x)) + { + } + Value&& value; + }; }}} // namespace boost::parameter::aux -#endif // DEFAULT_050329_HPP +#endif // BOOST_PARAMETER_HAS_PERFECT_FORWARDING +#endif // include guard diff --git a/boost/parameter/aux_/has_nested_template_fn.hpp b/boost/parameter/aux_/has_nested_template_fn.hpp new file mode 100644 index 0000000000..e68857d572 --- /dev/null +++ b/boost/parameter/aux_/has_nested_template_fn.hpp @@ -0,0 +1,111 @@ +// Copyright Cromwell D. Enage 2019. +// 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_AUX_HAS_NESTED_TEMPLATE_FN_HPP +#define BOOST_PARAMETER_AUX_HAS_NESTED_TEMPLATE_FN_HPP + +#include <boost/parameter/aux_/yesno.hpp> +#include <boost/parameter/aux_/preprocessor/nullptr.hpp> +#include <boost/parameter/config.hpp> + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <boost/mp11/integral.hpp> +#include <boost/mp11/utility.hpp> +#else +#include <boost/mpl/bool.hpp> +#include <boost/mpl/identity.hpp> +#endif + +namespace boost { namespace parameter { namespace aux { + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + template <template <typename ...> class F> + struct has_nested_template_fn_variadic + { + }; +#else + template <template <typename P0, typename P1> class F> + struct has_nested_template_fn_arity_2 + { + }; +#endif + + template <typename T> + class has_nested_template_fn_impl + { + template <typename U> + static ::boost::parameter::aux::no_tag _check(...); + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + template <typename U> + static ::boost::parameter::aux::yes_tag + _check( + ::boost::mp11::mp_identity<U> const volatile* + , ::boost::parameter::aux::has_nested_template_fn_variadic< + U::template fn + >* = BOOST_PARAMETER_AUX_PP_NULLPTR + ); +#else + template <typename U> + static BOOST_CONSTEXPR ::boost::parameter::aux::yes_tag + _check( + ::boost::mpl::identity<U> const volatile* + , ::boost::parameter::aux::has_nested_template_fn_arity_2< + U::template fn + >* = BOOST_PARAMETER_AUX_PP_NULLPTR + ); +#endif + + public: +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using type = ::boost::mp11::mp_bool< +#else + typedef ::boost::mpl::bool_< +#endif + sizeof( + ::boost::parameter::aux::has_nested_template_fn_impl<T> + ::template _check<T>( + static_cast< +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + ::boost::mp11::mp_identity<T> const volatile* +#else + ::boost::mpl::identity<T> const volatile* +#endif + >(BOOST_PARAMETER_AUX_PP_NULLPTR) + ) + ) == sizeof(::boost::parameter::aux::yes_tag) +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + >; +#else + > type; +#endif + }; +}}} // namespace boost::parameter::aux + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <type_traits> +#else +#include <boost/type_traits/remove_const.hpp> +#endif + +namespace boost { namespace parameter { namespace aux { + + template <typename T> +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using has_nested_template_fn = typename ::boost::parameter::aux + ::has_nested_template_fn_impl<typename ::std::remove_const<T>::type> + ::type; +#else + struct has_nested_template_fn + : ::boost::parameter::aux::has_nested_template_fn_impl< + typename ::boost::remove_const<T>::type + >::type + { + }; +#endif +}}} // namespace boost::parameter::aux + +#endif // include guard + diff --git a/boost/parameter/aux_/is_maybe.hpp b/boost/parameter/aux_/is_maybe.hpp index b875852847..0069eddc14 100644 --- a/boost/parameter/aux_/is_maybe.hpp +++ b/boost/parameter/aux_/is_maybe.hpp @@ -1,26 +1,52 @@ -// Copyright Daniel Wallin, David Abrahams 2010. 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 2010. +// 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_MAYBE_050329_HPP #define BOOST_PARAMETER_IS_MAYBE_050329_HPP -#include <boost/type_traits/is_base_and_derived.hpp> +namespace boost { namespace parameter { namespace aux { -namespace boost { -namespace parameter { -namespace aux { + struct maybe_base + { + }; +}}} // namespace boost::parameter::aux -struct maybe_base {}; +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <type_traits> -template <class T> -struct is_maybe - : is_base_and_derived<maybe_base, T> -{}; +namespace boost { namespace parameter { namespace aux { -} // namespace aux -} // namespace parameter -} // namespace boost + template <typename T> + using is_maybe = ::std::is_base_of< + ::boost::parameter::aux::maybe_base + , typename ::std::remove_const<T>::type + >; +}}} // namespace boost::parameter::aux + +#else // !defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <boost/mpl/bool.hpp> +#include <boost/mpl/if.hpp> +#include <boost/type_traits/is_base_of.hpp> +#include <boost/type_traits/remove_const.hpp> + +namespace boost { namespace parameter { namespace aux { + + template <typename T> + struct is_maybe + : ::boost::mpl::if_< + ::boost::is_base_of< + ::boost::parameter::aux::maybe_base + , typename ::boost::remove_const<T>::type + > + , ::boost::mpl::true_ + , ::boost::mpl::false_ + >::type + { + }; +}}} // namespace boost::parameter::aux + +#endif // BOOST_PARAMETER_CAN_USE_MP11 +#endif // include guard -#endif // BOOST_PARAMETER_IS_MAYBE_050329_HPP diff --git a/boost/parameter/aux_/is_placeholder.hpp b/boost/parameter/aux_/is_placeholder.hpp new file mode 100644 index 0000000000..2ed46d86af --- /dev/null +++ b/boost/parameter/aux_/is_placeholder.hpp @@ -0,0 +1,64 @@ +// Copyright Cromwell D. Enage 2019. +// 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_AUX_IS_PLACEHOLDER_HPP +#define BOOST_PARAMETER_AUX_IS_PLACEHOLDER_HPP + +#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_mpl_placeholder +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + : ::boost::mp11::mp_false +#else + : ::boost::mpl::false_ +#endif + { + }; +}}} // namespace boost::parameter::aux + +#include <boost/mpl/arg_fwd.hpp> + +namespace boost { namespace parameter { namespace aux { + + template <int I> + struct is_mpl_placeholder< ::boost::mpl::arg<I> > +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + : ::boost::mp11::mp_true +#else + : ::boost::mpl::true_ +#endif + { + }; +}}} // namespace boost::parameter::aux + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <boost/mp11/bind.hpp> + +namespace boost { namespace parameter { namespace aux { + + template <typename T> + struct is_mp11_placeholder : ::boost::mp11::mp_false + { + }; + + template < ::std::size_t I> + struct is_mp11_placeholder< ::boost::mp11::mp_arg<I> > + : ::boost::mp11::mp_true + { + }; +}}} // namespace boost::parameter::aux + +#endif // BOOST_PARAMETER_CAN_USE_MP11 +#endif // include guard + diff --git a/boost/parameter/aux_/is_tagged_argument.hpp b/boost/parameter/aux_/is_tagged_argument.hpp new file mode 100644 index 0000000000..fa1b53d8cf --- /dev/null +++ b/boost/parameter/aux_/is_tagged_argument.hpp @@ -0,0 +1,95 @@ +// 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_IS_TAGGED_ARGUMENT_HPP +#define BOOST_PARAMETER_IS_TAGGED_ARGUMENT_HPP + +namespace boost { namespace parameter { namespace aux { + + struct tagged_argument_base + { + }; +}}} // namespace boost::parameter::aux + +#include <boost/parameter/config.hpp> +#include <boost/mpl/bool.hpp> +#include <boost/mpl/if.hpp> + +#if defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING) || \ + (0 < BOOST_PARAMETER_EXPONENTIAL_OVERLOAD_THRESHOLD_ARITY) +#include <boost/type_traits/is_base_of.hpp> +#include <boost/type_traits/remove_const.hpp> +#include <boost/type_traits/remove_reference.hpp> + +namespace boost { namespace parameter { namespace aux { + + // This metafunction identifies tagged_argument specializations + // and their derived classes. + template <typename T> + struct is_tagged_argument + : ::boost::mpl::if_< + // Cannot use is_convertible<> to check if T is derived from + // tagged_argument_base. -- Cromwell D. Enage + ::boost::is_base_of< + ::boost::parameter::aux::tagged_argument_base + , typename ::boost::remove_const< + typename ::boost::remove_reference<T>::type + >::type + > + , ::boost::mpl::true_ + , ::boost::mpl::false_ + >::type + { + }; +}}} // namespace boost::parameter::aux + +#else // no perfect forwarding support and no exponential overloads +#include <boost/type_traits/is_convertible.hpp> +#include <boost/type_traits/is_lvalue_reference.hpp> + +namespace boost { namespace parameter { namespace aux { + + template <typename T> + struct is_tagged_argument_aux + : ::boost::is_convertible< + T* + , ::boost::parameter::aux::tagged_argument_base const* + > + { + }; + + // This metafunction identifies tagged_argument specializations + // and their derived classes. + template <typename T> + struct is_tagged_argument + : ::boost::mpl::if_< + ::boost::is_lvalue_reference<T> + , ::boost::mpl::false_ + , ::boost::parameter::aux::is_tagged_argument_aux<T> + >::type + { + }; +}}} // namespace boost::parameter::aux + +#endif // perfect forwarding support, or exponential overloads + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <type_traits> + +namespace boost { namespace parameter { namespace aux { + + template <typename T> + using is_tagged_argument_mp11 = ::std::is_base_of< + ::boost::parameter::aux::tagged_argument_base + , typename ::std::remove_const< + typename ::std::remove_reference<T>::type + >::type + >; +}}} // namespace boost::parameter::aux + +#endif // BOOST_PARAMETER_CAN_USE_MP11 +#endif // include guard + diff --git a/boost/parameter/aux_/lambda_tag.hpp b/boost/parameter/aux_/lambda_tag.hpp new file mode 100644 index 0000000000..77759a2e7d --- /dev/null +++ b/boost/parameter/aux_/lambda_tag.hpp @@ -0,0 +1,16 @@ +// 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_AUX_LAMBDA_TAG_HPP +#define BOOST_PARAMETER_AUX_LAMBDA_TAG_HPP + +namespace boost { namespace parameter { namespace aux { + + // Tag type passed to MPL lambda. + struct lambda_tag; +}}} // namespace boost::parameter::aux + +#endif // include guard + diff --git a/boost/parameter/aux_/maybe.hpp b/boost/parameter/aux_/maybe.hpp index 55e083e5b4..74273fcf3d 100644 --- a/boost/parameter/aux_/maybe.hpp +++ b/boost/parameter/aux_/maybe.hpp @@ -1,120 +1,151 @@ -// Copyright Daniel Wallin 2006. Use, modification and distribution is -// subject to the Boost Software License, Version 1.0. (See accompanying -// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +// Copyright Daniel Wallin 2006. +// 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) // // 2009.10.21 TDS remove depenency on boost::python::detail::referent_storage // #ifndef BOOST_PARAMETER_MAYBE_091021_HPP -# define BOOST_PARAMETER_MAYBE_091021_HPP - -# include <boost/mpl/if.hpp> -# include <boost/mpl/identity.hpp> -# include <boost/type_traits/is_reference.hpp> -# include <boost/type_traits/add_reference.hpp> -# include <boost/optional.hpp> -# include <boost/aligned_storage.hpp> -# include <boost/type_traits/remove_cv.hpp> -# include <boost/type_traits/add_const.hpp> -# include <boost/parameter/aux_/is_maybe.hpp> +#define BOOST_PARAMETER_MAYBE_091021_HPP namespace boost { namespace parameter { namespace aux { -template <class T> struct referent_size; - -template <class T> -struct referent_size<T&> -{ - BOOST_STATIC_CONSTANT(std::size_t, value = sizeof(T)); -}; - -// A metafunction returning a POD type which can store U, where T == -// U&. If T is not a reference type, returns a POD which can store T. -template <class T> -struct referent_storage -{ - typedef typename boost::aligned_storage< - referent_size<T>::value - >::type type; -}; - -template <class T> -struct maybe : maybe_base -{ - typedef typename add_reference< -# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) - T const -# else - typename add_const<T>::type -# endif - >::type reference; - - typedef typename remove_cv< - BOOST_DEDUCED_TYPENAME remove_reference<reference>::type - >::type non_cv_value; - - explicit maybe(T value_) - : value(value_) - , constructed(false) - {} - - maybe() - : constructed(false) - {} - - ~maybe() - { - if (constructed) - this->destroy(); - } + template <typename T> + struct referent_size; +}}} // namespace boost::parameter::aux - reference construct(reference value_) const - { - return value_; - } +#include <boost/parameter/config.hpp> - template <class U> - reference construct2(U const& value_) const - { - new (m_storage.address()) non_cv_value(value_); - constructed = true; - return *(non_cv_value*)m_storage.address(); - } - - template <class U> - reference construct(U const& value_) const - { - return this->construct2(value_); - } +namespace boost { namespace parameter { namespace aux { - void destroy() + template <typename T> + struct referent_size<T&> { - ((non_cv_value*)m_storage.address())->~non_cv_value(); - } + BOOST_STATIC_CONSTANT(::std::size_t, value = sizeof(T)); + }; +}}} // namespace boost::parameter::aux - typedef reference(maybe<T>::*safe_bool)() const; +#include <boost/type_traits/aligned_storage.hpp> - operator safe_bool() const - { - return value ? &maybe<T>::get : 0 ; - } +namespace boost { namespace parameter { namespace aux { - reference get() const + // A metafunction returning a POD type which can store U, where T == U&. + // If T is not a reference type, returns a POD which can store T. + template <typename T> + struct referent_storage + : ::boost::aligned_storage< + ::boost::parameter::aux::referent_size<T>::value + > { - return value.get(); - } + }; +}}} // namespace boost::parameter::aux -private: - boost::optional<T> value; - mutable bool constructed; +#include <boost/parameter/aux_/is_maybe.hpp> +#include <boost/optional/optional.hpp> +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <type_traits> +#else // !defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <boost/type_traits/add_lvalue_reference.hpp> +#include <boost/type_traits/remove_cv.hpp> +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +#include <boost/type_traits/add_const.hpp> +#endif +#endif // BOOST_PARAMETER_CAN_USE_MP11 - mutable typename referent_storage< - reference - >::type m_storage; -}; +namespace boost { namespace parameter { namespace aux { + template <typename T> + struct maybe : ::boost::parameter::aux::maybe_base + { +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + typedef typename ::std::add_lvalue_reference< + typename ::std::add_const<T>::type +#else // !defined(BOOST_PARAMETER_CAN_USE_MP11) + typedef typename ::boost::add_lvalue_reference< +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) + T const +#else + typename ::boost::add_const<T>::type +#endif +#endif // BOOST_PARAMETER_CAN_USE_MP11 + >::type reference; + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + typedef typename ::std::remove_cv< + typename ::std::remove_reference<reference>::type +#else + typedef typename ::boost::remove_cv< + BOOST_DEDUCED_TYPENAME ::boost::remove_reference<reference>::type +#endif + >::type non_cv_value; + + inline explicit maybe(T value_) : value(value_), constructed(false) + { + } + + inline maybe() : value(), constructed(false) + { + } + + ~maybe() + { + if (this->constructed) + { + this->destroy(); + } + } + + inline reference construct(reference value_) const + { + return value_; + } + + template <typename U> + reference construct2(U const& value_) const + { + new (this->m_storage.address()) non_cv_value(value_); + this->constructed = true; + return *reinterpret_cast<non_cv_value*>( + this->m_storage.address() + ); + } + + template <typename U> + inline reference construct(U const& value_) const + { + return this->construct2(value_); + } + + void destroy() + { + reinterpret_cast<non_cv_value*>( + this->m_storage.address() + )->~non_cv_value(); + } + + typedef reference( + ::boost::parameter::aux::maybe<T>::*safe_bool + )() const; + + inline operator safe_bool() const + { + return this->value ? &::boost::parameter::aux::maybe<T>::get : 0; + } + + inline reference get() const + { + return this->value.get(); + } + + private: + ::boost::optional<T> value; + mutable bool constructed; + mutable typename ::boost::parameter::aux + ::referent_storage<reference>::type m_storage; + }; }}} // namespace boost::parameter::aux -#endif // BOOST_PARAMETER_MAYBE_060211_HPP +#endif // include guard diff --git a/boost/parameter/aux_/name.hpp b/boost/parameter/aux_/name.hpp new file mode 100644 index 0000000000..8d623bcabf --- /dev/null +++ b/boost/parameter/aux_/name.hpp @@ -0,0 +1,93 @@ +// Copyright Daniel Wallin 2006. +// 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_AUX_NAME_HPP +#define BOOST_PARAMETER_AUX_NAME_HPP + +namespace boost { namespace parameter { namespace aux { + + struct name_tag_base + { + }; + + template <typename Tag> + struct name_tag + { + }; +}}} // namespace boost::parameter::aux + +#include <boost/mpl/bool.hpp> + +namespace boost { namespace parameter { namespace aux { + + template <typename T> + struct is_name_tag : ::boost::mpl::false_ + { + }; +}}} // namespace boost::parameter::aux + +#include <boost/parameter/value_type.hpp> +#include <boost/mpl/placeholders.hpp> +#include <boost/config.hpp> +#include <boost/config/workaround.hpp> + +#if !defined(BOOST_NO_SFINAE) && \ + !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592)) +#include <boost/parameter/aux_/lambda_tag.hpp> +#include <boost/mpl/lambda.hpp> +#include <boost/mpl/bind.hpp> +#include <boost/mpl/quote.hpp> +#include <boost/core/enable_if.hpp> + +namespace boost { namespace mpl { + + template <typename T> + struct lambda< + T + , typename ::boost::enable_if< + ::boost::parameter::aux::is_name_tag<T> + , ::boost::parameter::aux::lambda_tag + >::type + > + { + typedef ::boost::mpl::true_ is_le; + typedef ::boost::mpl::bind3< + ::boost::mpl::quote3< ::boost::parameter::value_type> + , ::boost::mpl::arg<2> + , T + , void + > result_; + typedef result_ type; + }; +}} // namespace boost::mpl + +#endif // SFINAE enabled, not Borland. + +#include <boost/parameter/aux_/void.hpp> + +#define BOOST_PARAMETER_TAG_PLACEHOLDER_TYPE(tag) \ + ::boost::parameter::value_type< \ + ::boost::mpl::_2,tag,::boost::parameter::void_ \ + > +/**/ + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#define BOOST_PARAMETER_TAG_MP11_PLACEHOLDER_VALUE(name, tag) \ + template <typename ArgumentPack> \ + using name = typename ::boost::parameter \ + ::value_type<ArgumentPack,tag,::boost::parameter::void_>::type +/**/ + +#include <boost/parameter/binding.hpp> + +#define BOOST_PARAMETER_TAG_MP11_PLACEHOLDER_BINDING(name, tag) \ + template <typename ArgumentPack> \ + using name = typename ::boost::parameter \ + ::binding<ArgumentPack,tag,::boost::parameter::void_>::type +/**/ + +#endif // BOOST_PARAMETER_CAN_USE_MP11 +#endif // include guard + diff --git a/boost/parameter/aux_/overloads.hpp b/boost/parameter/aux_/overloads.hpp deleted file mode 100644 index dcc92d4d75..0000000000 --- a/boost/parameter/aux_/overloads.hpp +++ /dev/null @@ -1,88 +0,0 @@ -// Copyright David Abrahams, Daniel Wallin 2003. Use, modification and -// distribution is subject to the Boost Software License, Version 1.0. -// (See accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) - -// This file generates overloads in this format: -// -// template<class A0, class A1> -// typename mpl::apply_wrap1< -// aux::make_arg_list< -// PS0,A0 -// , aux::make_arg_list< -// PS1,A1 -// , mpl::identity<aux::empty_arg_list> -// > -// > -// , unnamed_list -// >::type -// operator()(A0 const& a0, A1 const& a1) const -// { -// typedef typename mpl::apply_wrap1< -// aux::make_arg_list< -// PS0,A0 -// , aux::make_arg_list< -// PS1,A1 -// , mpl::identity<aux::empty_arg_list> -// > -// > -// >::type arg_tuple; -// -// return arg_tuple( -// a0 -// , a1 -// , aux::void_() -// ... -// ); -// } -// - -#if !defined(BOOST_PP_IS_ITERATING) -# error Boost.Parameters - do not include this file! -#endif - -#define N BOOST_PP_ITERATION() - -#define BOOST_PARAMETER_open_list(z, n, text) \ - aux::item< \ - BOOST_PP_CAT(PS, n), BOOST_PP_CAT(A, n) - -#define BOOST_PARAMETER_close_list(z, n, text) > - -#define BOOST_PARAMETER_arg_list(n) \ - aux::make_arg_list< \ - BOOST_PP_ENUM(N, BOOST_PARAMETER_open_list, _) \ - , void_ \ - BOOST_PP_REPEAT(N, BOOST_PARAMETER_close_list, _) \ - , deduced_list \ - , aux::tag_keyword_arg \ - > - -#define BOOST_PARAMETER_arg_pack_init(z, n, limit) \ - BOOST_PP_CAT(a, BOOST_PP_SUB(limit,n)) - -template<BOOST_PP_ENUM_PARAMS(N, class A)> -typename mpl::first< - typename BOOST_PARAMETER_arg_list(N)::type ->::type -operator()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, & a)) const -{ - typedef typename BOOST_PARAMETER_arg_list(N)::type result; - - typedef typename mpl::first<result>::type result_type; - typedef typename mpl::second<result>::type error; - error(); - - return result_type( - BOOST_PP_ENUM(N, BOOST_PARAMETER_arg_pack_init, BOOST_PP_DEC(N)) - BOOST_PP_ENUM_TRAILING_PARAMS( - BOOST_PP_SUB(BOOST_PARAMETER_MAX_ARITY, N) - , aux::void_reference() BOOST_PP_INTERCEPT - )); -} - -#undef BOOST_PARAMETER_arg_list -#undef BOOST_PARAMETER_open_list -#undef BOOST_PARAMETER_close_list -#undef N - diff --git a/boost/parameter/aux_/pack/as_parameter_requirements.hpp b/boost/parameter/aux_/pack/as_parameter_requirements.hpp new file mode 100644 index 0000000000..65fae4c7ee --- /dev/null +++ b/boost/parameter/aux_/pack/as_parameter_requirements.hpp @@ -0,0 +1,32 @@ +// 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_AUX_PACK_AS_PARAMETER_REQUIREMENTS_HPP +#define BOOST_PARAMETER_AUX_PACK_AS_PARAMETER_REQUIREMENTS_HPP + +#include <boost/parameter/aux_/pack/parameter_requirements.hpp> +#include <boost/parameter/aux_/pack/tag_type.hpp> +#include <boost/parameter/aux_/pack/predicate.hpp> +#include <boost/parameter/deduced.hpp> + +namespace boost { namespace parameter { namespace aux { + + // Converts a ParameterSpec into a specialization of + // parameter_requirements. We need to do this in order to get the + // tag_type into the type in a way that can be conveniently matched + // by a satisfies(...) member function in arg_list. + template <typename ParameterSpec> + struct as_parameter_requirements + { + typedef ::boost::parameter::aux::parameter_requirements< + typename ::boost::parameter::aux::tag_type<ParameterSpec>::type + , typename ::boost::parameter::aux::predicate<ParameterSpec>::type + , ::boost::parameter::aux::has_default<ParameterSpec> + > type; + }; +}}} // namespace boost::parameter::aux + +#endif // include guard + diff --git a/boost/parameter/aux_/pack/deduce_tag.hpp b/boost/parameter/aux_/pack/deduce_tag.hpp new file mode 100644 index 0000000000..12ad563f53 --- /dev/null +++ b/boost/parameter/aux_/pack/deduce_tag.hpp @@ -0,0 +1,217 @@ +// 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_AUX_PACK_DEDUCE_TAG_HPP +#define BOOST_PARAMETER_AUX_PACK_DEDUCE_TAG_HPP + +namespace boost { namespace parameter { namespace aux { + + template < + typename Argument + , typename ArgumentPack + , typename DeducedArgs + , typename UsedArgs + , typename TagFn + , typename EmitsErrors + > + struct deduce_tag; +}}} // namespace boost::parameter::aux + +#include <boost/parameter/aux_/lambda_tag.hpp> +#include <boost/parameter/config.hpp> +#include <boost/mpl/apply_wrap.hpp> +#include <boost/mpl/lambda.hpp> + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + +namespace boost { namespace parameter { namespace aux { + + template <typename Predicate, typename Argument, typename ArgumentPack> + struct deduce_tag_condition_mpl + : ::boost::mpl::apply_wrap2< + typename ::boost::mpl::lambda< + Predicate + , ::boost::parameter::aux::lambda_tag + >::type + , Argument + , ArgumentPack + > + { + }; +}}} // namespace boost::parameter::aux + +#include <boost/parameter/aux_/has_nested_template_fn.hpp> +#include <boost/mp11/list.hpp> +#include <boost/mp11/utility.hpp> + +namespace boost { namespace parameter { namespace aux { + + template <typename Predicate, typename Argument, typename ArgumentPack> + struct deduce_tag_condition_mp11 + { + using type = ::boost::mp11::mp_apply_q< + Predicate + , ::boost::mp11::mp_list<Argument,ArgumentPack> + >; + }; + + template <typename Predicate, typename Argument, typename ArgumentPack> + using deduce_tag_condition = ::boost::mp11::mp_if< + ::boost::parameter::aux::has_nested_template_fn<Predicate> + , ::boost::parameter::aux + ::deduce_tag_condition_mp11<Predicate,Argument,ArgumentPack> + , ::boost::parameter::aux + ::deduce_tag_condition_mpl<Predicate,Argument,ArgumentPack> + >; +}}} // namespace boost::parameter::aux + +#else +#include <boost/mpl/bool.hpp> +#include <boost/mpl/if.hpp> +#include <boost/mpl/eval_if.hpp> +#include <boost/mpl/assert.hpp> +#endif // BOOST_PARAMETER_CAN_USE_MP11 + +#include <boost/parameter/aux_/set.hpp> +#include <boost/parameter/aux_/pack/tag_type.hpp> +#include <boost/parameter/aux_/pack/tag_deduced.hpp> + +namespace boost { namespace parameter { namespace aux { + + // Helper for deduce_tag<...>, below. + template < + typename Argument + , typename ArgumentPack + , typename DeducedArgs + , typename UsedArgs + , typename TagFn + , typename EmitsErrors + > + class deduce_tag0 + { + typedef typename DeducedArgs::spec _spec; + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + typedef typename ::boost::parameter::aux::deduce_tag_condition< + typename _spec::predicate +#else + typedef typename ::boost::mpl::apply_wrap2< + typename ::boost::mpl::lambda< + typename _spec::predicate + , ::boost::parameter::aux::lambda_tag + >::type +#endif + , Argument + , ArgumentPack + >::type _condition; + +#if !defined(BOOST_PARAMETER_CAN_USE_MP11) + // Deduced parameter matches several arguments. + BOOST_MPL_ASSERT(( + typename ::boost::mpl::eval_if< + typename ::boost::parameter::aux::has_key_< + UsedArgs + , typename ::boost::parameter::aux::tag_type<_spec>::type + >::type + , ::boost::mpl::eval_if< + _condition + , ::boost::mpl::if_< + EmitsErrors + , ::boost::mpl::false_ + , ::boost::mpl::true_ + > + , ::boost::mpl::true_ + > + , ::boost::mpl::true_ + >::type + )); +#endif // BOOST_PARAMETER_CAN_USE_MP11 + + public: +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using type = typename ::boost::mp11::mp_if< +#else + typedef typename ::boost::mpl::eval_if< +#endif + _condition + , ::boost::parameter::aux + ::tag_deduced<UsedArgs,_spec,Argument,TagFn> + , ::boost::parameter::aux::deduce_tag< + Argument + , ArgumentPack + , typename DeducedArgs::tail + , UsedArgs + , TagFn + , EmitsErrors + > +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + >::type; +#else + >::type type; +#endif + }; +}}} // namespace boost::parameter::aux + +#include <boost/parameter/aux_/void.hpp> + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <type_traits> +#else +#include <boost/mpl/pair.hpp> +#include <boost/type_traits/is_same.hpp> +#endif + +namespace boost { namespace parameter { namespace aux { + + // Tries to deduced a keyword tag for a given Argument. + // Returns an mpl::pair<> consisting of the tagged_argument<>, + // and an mpl::set<> where the new tag has been inserted. + // + // Argument: The argument type to be tagged. + // + // ArgumentPack: The ArgumentPack built so far. + // + // DeducedArgs: A specialization of deduced_item<> (see below). + // A list containing only the deduced ParameterSpecs. + // + // UsedArgs: An mpl::set<> containing the keyword tags used so far. + // + // TagFn: A metafunction class used to tag positional or deduced + // arguments with a keyword tag. + template < + typename Argument + , typename ArgumentPack + , typename DeducedArgs + , typename UsedArgs + , typename TagFn + , typename EmitsErrors + > + struct deduce_tag +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + : ::boost::mp11::mp_if< + ::std::is_same<DeducedArgs,::boost::parameter::void_> + , ::boost::mp11::mp_identity< + ::boost::mp11::mp_list< ::boost::parameter::void_,UsedArgs> + > +#else + : ::boost::mpl::eval_if< + ::boost::is_same<DeducedArgs,::boost::parameter::void_> + , ::boost::mpl::pair< ::boost::parameter::void_,UsedArgs> +#endif + , ::boost::parameter::aux::deduce_tag0< + Argument + , ArgumentPack + , DeducedArgs + , UsedArgs + , TagFn + , EmitsErrors + > + > + { + }; +}}} // namespace boost::parameter::aux + +#endif // include guard + diff --git a/boost/parameter/aux_/pack/deduced_item.hpp b/boost/parameter/aux_/pack/deduced_item.hpp new file mode 100644 index 0000000000..280e6eac6a --- /dev/null +++ b/boost/parameter/aux_/pack/deduced_item.hpp @@ -0,0 +1,34 @@ +// 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_AUX_PACK_DEDUCED_ITEM_HPP +#define BOOST_PARAMETER_AUX_PACK_DEDUCED_ITEM_HPP + +#include <boost/parameter/aux_/void.hpp> + +namespace boost { namespace parameter { namespace aux { + + // A typelist that stored deduced parameter specs. + template < + typename ParameterSpec + , typename Tail = ::boost::parameter::void_ + > + struct deduced_item + { + typedef ParameterSpec spec; + typedef Tail tail; + }; + + // Evaluate Tail and construct deduced_item list. + template <typename Spec, typename Tail> + struct make_deduced_item + { + typedef ::boost::parameter::aux + ::deduced_item<Spec,typename Tail::type> type; + }; +}}} // namespace boost::parameter::aux + +#endif // include guard + diff --git a/boost/parameter/aux_/pack/insert_tagged.hpp b/boost/parameter/aux_/pack/insert_tagged.hpp new file mode 100644 index 0000000000..bef47b14db --- /dev/null +++ b/boost/parameter/aux_/pack/insert_tagged.hpp @@ -0,0 +1,23 @@ +// 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_AUX_PACK_INSERT_TAGGED_HPP +#define BOOST_PARAMETER_AUX_PACK_INSERT_TAGGED_HPP + +#include <boost/parameter/aux_/set.hpp> + +namespace boost { namespace parameter { namespace aux { + + // Inserts Tagged::key_type into the UserArgs set. + // Extra indirection to lazily evaluate Tagged::key_type. + template <typename UsedArgs, typename Tagged> + struct insert_tagged + : ::boost::parameter::aux::insert_<UsedArgs,typename Tagged::key_type> + { + }; +}}} // namespace boost::parameter::aux + +#endif // include guard + diff --git a/boost/parameter/aux_/pack/is_named_argument.hpp b/boost/parameter/aux_/pack/is_named_argument.hpp new file mode 100644 index 0000000000..8b93f61c25 --- /dev/null +++ b/boost/parameter/aux_/pack/is_named_argument.hpp @@ -0,0 +1,43 @@ +// 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_AUX_PACK_IS_NAMED_ARGUMENT_HPP +#define BOOST_PARAMETER_AUX_PACK_IS_NAMED_ARGUMENT_HPP + +#include <boost/parameter/aux_/template_keyword.hpp> +#include <boost/parameter/aux_/is_tagged_argument.hpp> +#include <boost/parameter/config.hpp> + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <boost/mp11/integral.hpp> +#include <boost/mp11/utility.hpp> +#else +#include <boost/mpl/bool.hpp> +#include <boost/mpl/if.hpp> +#endif + +namespace boost { namespace parameter { namespace aux { + + template <typename T> +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using is_named_argument = ::boost::mp11::mp_if< + ::boost::parameter::aux::is_template_keyword<T> + , ::boost::mp11::mp_true + , ::boost::parameter::aux::is_tagged_argument_mp11<T> + >; +#else + struct is_named_argument + : ::boost::mpl::if_< + ::boost::parameter::aux::is_template_keyword<T> + , ::boost::mpl::true_ + , ::boost::parameter::aux::is_tagged_argument<T> + >::type + { + }; +#endif +}}} // namespace boost::parameter::aux + +#endif // include guard + diff --git a/boost/parameter/aux_/pack/item.hpp b/boost/parameter/aux_/pack/item.hpp new file mode 100644 index 0000000000..b408051bad --- /dev/null +++ b/boost/parameter/aux_/pack/item.hpp @@ -0,0 +1,47 @@ +// 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_AUX_PACK_ITEM_HPP +#define BOOST_PARAMETER_AUX_PACK_ITEM_HPP + +#include <boost/parameter/aux_/void.hpp> +#include <boost/config.hpp> +#include <boost/config/workaround.hpp> + +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +#include <boost/type_traits/is_const.hpp> +#include <boost/type_traits/remove_reference.hpp> +#endif + +namespace boost { namespace parameter { namespace aux { + + // A parameter spec item typelist. + template < + typename Spec + , typename Arg + , typename Tail = ::boost::parameter::void_ + > + struct item + { + typedef Spec spec; +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) + typedef ::boost::is_const< + typename ::boost::remove_reference<Arg>::type + > is_arg_const; +#endif + typedef Arg arg; + typedef Tail tail; + }; + + template <typename Spec, typename Arg, typename Tail> + struct make_item + { + typedef boost::parameter::aux + ::item<Spec,Arg,typename Tail::type> type; + }; +}}} // namespace boost::parameter::aux + +#endif // include guard + diff --git a/boost/parameter/aux_/pack/make_arg_list.hpp b/boost/parameter/aux_/pack/make_arg_list.hpp new file mode 100644 index 0000000000..c43ac5c42e --- /dev/null +++ b/boost/parameter/aux_/pack/make_arg_list.hpp @@ -0,0 +1,438 @@ +// Copyright David Abrahams, Daniel Wallin 2003. +// 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_AUX_PACK_MAKE_ARG_LIST_HPP +#define BOOST_PARAMETER_AUX_PACK_MAKE_ARG_LIST_HPP + +namespace boost { namespace parameter { namespace aux { + + template < + typename List + , typename DeducedArgs + , typename TagFn + , typename IsPositional + , typename UsedArgs + , typename ArgumentPack + , typename Error + , typename EmitsErrors + > + struct make_arg_list_aux; +}}} // namespace boost::parameter::aux + +#include <boost/parameter/aux_/arg_list.hpp> +#include <boost/parameter/aux_/void.hpp> +#include <boost/parameter/aux_/pack/unmatched_argument.hpp> +#include <boost/parameter/aux_/pack/tag_type.hpp> +#include <boost/parameter/aux_/pack/is_named_argument.hpp> +#include <boost/parameter/aux_/pack/insert_tagged.hpp> +#include <boost/parameter/aux_/pack/deduce_tag.hpp> +#include <boost/parameter/deduced.hpp> +#include <boost/parameter/config.hpp> + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <boost/mp11/integral.hpp> +#include <boost/mp11/list.hpp> +#include <boost/mp11/utility.hpp> +#include <type_traits> +#else +#include <boost/mpl/bool.hpp> +#include <boost/mpl/pair.hpp> +#include <boost/mpl/if.hpp> +#include <boost/mpl/eval_if.hpp> +#include <boost/mpl/apply_wrap.hpp> +#include <boost/mpl/identity.hpp> +#include <boost/type_traits/is_same.hpp> +#include <boost/type_traits/remove_const.hpp> +#include <boost/type_traits/remove_reference.hpp> +#endif + +namespace boost { namespace parameter { namespace aux { + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + template <typename ArgumentPack, typename TaggedArg, typename EmitsErrors> + struct append_to_make_arg_list + { + using type = ::boost::mp11::mp_push_front< + ArgumentPack + , ::boost::parameter::aux::flat_like_arg_tuple< + typename TaggedArg::key_type + , TaggedArg + , EmitsErrors + > + >; + }; +#endif + + // Borland needs the insane extra-indirection workaround below so that + // it doesn't magically drop the const qualifier from the argument type. + template < + typename List + , typename DeducedArgs + , typename TagFn + , typename IsPositional + , typename UsedArgs + , typename ArgumentPack +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) + , typename _argument +#endif + , typename Error + , typename EmitsErrors + > +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) + class make_arg_list00 +#else + class make_arg_list0 +#endif + { +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) + typedef typename List::arg _argument; +#endif +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using _arg_type = typename ::std::remove_const< + typename ::std::remove_reference<_argument>::type + >::type; + using _is_tagged = ::boost::parameter::aux + ::is_named_argument<_argument>; +#else + typedef typename ::boost::remove_const< + typename ::boost::remove_reference<_argument>::type + >::type _arg_type; + typedef ::boost::parameter::aux + ::is_named_argument<_argument> _is_tagged; +#endif + typedef typename List::spec _parameter_spec; + typedef typename ::boost::parameter::aux + ::tag_type<_parameter_spec>::type _tag; + + // If this argument is either explicitly tagged or a deduced + // parameter, then turn off positional matching. +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using _is_positional = ::boost::mp11::mp_if< + IsPositional + , ::boost::mp11::mp_if< + ::boost::parameter::aux::is_deduced<_parameter_spec> + , ::boost::mp11::mp_false + , ::boost::mp11::mp_if< + _is_tagged + , ::boost::mp11::mp_false + , ::boost::mp11::mp_true + > + > + , ::boost::mp11::mp_false + >; +#else // !defined(BOOST_PARAMETER_CAN_USE_MP11) + typedef typename ::boost::mpl::eval_if< + IsPositional + , ::boost::mpl::eval_if< + ::boost::parameter::aux::is_deduced<_parameter_spec> + , ::boost::mpl::false_ + , ::boost::mpl::if_< + _is_tagged + , ::boost::mpl::false_ + , ::boost::mpl::true_ + > + > + , ::boost::mpl::false_ + >::type _is_positional; +#endif // BOOST_PARAMETER_CAN_USE_MP11 + + // If this parameter is explicitly tagged, then add it to the + // used-parmeters set. We only really need to add parameters + // that are deduced, but we would need a way to check if + // a given tag corresponds to a deduced parameter spec. +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using _used_args = typename ::boost::mp11::mp_if< + _is_tagged + , ::boost::parameter::aux::insert_tagged<UsedArgs,_arg_type> + , ::boost::mp11::mp_identity<UsedArgs> + >::type; +#else + typedef typename ::boost::mpl::eval_if< + _is_tagged + , ::boost::parameter::aux::insert_tagged<UsedArgs,_arg_type> + , ::boost::mpl::identity<UsedArgs> + >::type _used_args; +#endif + + // If this parameter is neither explicitly tagged nor positionally + // matched, then deduce the tag from the deduced parameter specs. +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using _deduced_data = typename ::boost::mp11::mp_if< + ::boost::mp11::mp_if< + _is_tagged + , ::boost::mp11::mp_true + , _is_positional + > + , ::boost::mp11::mp_identity< + ::boost::mp11::mp_list< ::boost::parameter::void_,_used_args> + > +#else + typedef typename ::boost::mpl::eval_if< + typename ::boost::mpl::if_< + _is_tagged + , ::boost::mpl::true_ + , _is_positional + >::type + , ::boost::mpl::pair< ::boost::parameter::void_,_used_args> +#endif + , ::boost::parameter::aux::deduce_tag< + _argument + , ArgumentPack + , DeducedArgs + , _used_args + , TagFn + , EmitsErrors + > +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + >::type; +#else + >::type _deduced_data; +#endif + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + // If this parameter is explicitly tagged ... + using _tagged = ::boost::mp11::mp_if< + _is_tagged + // ... just use it + , _arg_type + // ... else ... + , ::boost::mp11::mp_if< + // if positional matching is turned on ... + _is_positional + // ... tag it positionally + , ::boost::mp11::mp_apply_q< + TagFn + , ::boost::mp11::mp_list<_tag,_argument> + > + // ... else, use the deduced tag + , ::boost::mp11::mp_at_c<_deduced_data,0> + > + >; +#else // !defined(BOOST_PARAMETER_CAN_USE_MP11) + // If this parameter is explicitly tagged ... + typedef typename ::boost::mpl::eval_if< + _is_tagged + // ... just use it + , ::boost::mpl::identity<_arg_type> + // ... else ... + , ::boost::mpl::eval_if< + // if positional matching is turned on ... + _is_positional + // ... tag it positionally + , ::boost::mpl::apply_wrap2<TagFn,_tag,_argument> + // ... else, use the deduced tag + , ::boost::mpl::first<_deduced_data> + > + >::type _tagged; +#endif // BOOST_PARAMETER_CAN_USE_MP11 + + // Build the arg_list incrementally, prepending new nodes. +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using _error = ::boost::mp11::mp_if< + ::boost::mp11::mp_if< + ::std::is_same<Error,::boost::parameter::void_> + , ::std::is_same<_tagged,::boost::parameter::void_> + , ::boost::mp11::mp_false + > +#else + typedef typename ::boost::mpl::if_< + typename ::boost::mpl::if_< + ::boost::is_same<Error,::boost::parameter::void_> + , ::boost::is_same<_tagged,::boost::parameter::void_> + , ::boost::mpl::false_ + >::type +#endif + , ::boost::parameter::aux::unmatched_argument<_argument> + , ::boost::parameter::void_ +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + >; +#else + >::type _error; +#endif + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using _argument_pack = typename ::boost::mp11::mp_if< + ::std::is_same<_tagged,::boost::parameter::void_> + , ::boost::mp11::mp_identity<ArgumentPack> + , ::boost::parameter::aux + ::append_to_make_arg_list<ArgumentPack,_tagged,EmitsErrors> + >::type; +#else // !defined(BOOST_PARAMETER_CAN_USE_MP11) + typedef typename ::boost::mpl::if_< + ::boost::is_same<_tagged,::boost::parameter::void_> + , ArgumentPack +#if defined(BOOST_NO_SFINAE) || BOOST_WORKAROUND(BOOST_MSVC, < 1800) + , ::boost::parameter::aux::arg_list<_tagged,ArgumentPack> +#else + , ::boost::parameter::aux + ::arg_list<_tagged,ArgumentPack,EmitsErrors> +#endif + >::type _argument_pack; +#endif // BOOST_PARAMETER_CAN_USE_MP11 + + public: + typedef typename ::boost::parameter::aux::make_arg_list_aux< + typename List::tail + , DeducedArgs + , TagFn + , _is_positional +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + , ::boost::mp11::mp_at_c<_deduced_data,1> +#else + , typename _deduced_data::second +#endif + , _argument_pack + , _error + , EmitsErrors + >::type type; + }; + +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) + template < + typename List + , typename DeducedArgs + , typename TagFn + , typename IsPositional + , typename UsedArgs + , typename ArgumentPack + , typename Error + , typename EmitsErrors + > + struct make_arg_list0 + { + typedef typename ::boost::mpl::eval_if< + typename List::is_arg_const + , ::boost::parameter::aux::make_arg_list00< + List + , DeducedArgs + , TagFn + , IsPositional + , UsedArgs + , ArgumentPack + , typename List::arg const + , Error + , EmitsErrors + > + , ::boost::parameter::aux::make_arg_list00< + List + , DeducedArgs + , TagFn + , IsPositional + , UsedArgs + , ArgumentPack + , typename List::arg + , Error + , EmitsErrors + > + >::type type; + }; +#endif // Borland workarounds needed. + + // Returns an ArgumentPack where the list of arguments has been tagged + // with keyword tags. + // + // List: A specialization of item<> (see below). Contains both + // the ordered ParameterSpecs, and the given arguments. + // + // DeducedArgs: A specialization of deduced_item<> (see below). + // A list containing only the deduced ParameterSpecs. + // + // TagFn: A metafunction class used to tag positional or deduced + // arguments with a keyword tag. + // + // IsPositional: An mpl::bool_<> specialization indicating if positional + // matching is to be performed. + // + // DeducedSet: An mpl::set<> containing the keyword tags used so far. + // + // ArgumentPack: The ArgumentPack built so far. This is initially an + // empty_arg_list and is built incrementally. + template < + typename List + , typename DeducedArgs + , typename TagFn + , typename IsPositional + , typename DeducedSet + , typename ArgumentPack + , typename Error + , typename EmitsErrors + > + struct make_arg_list_aux +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + : ::boost::mp11::mp_if< + ::std::is_same<List,::boost::parameter::void_> + , ::boost::mp11::mp_identity< + ::boost::mp11::mp_list<ArgumentPack,Error> + > +#else + : ::boost::mpl::eval_if< + ::boost::is_same<List,::boost::parameter::void_> + , ::boost::mpl::identity< ::boost::mpl::pair<ArgumentPack,Error> > +#endif + , ::boost::parameter::aux::make_arg_list0< + List + , DeducedArgs + , TagFn + , IsPositional + , DeducedSet + , ArgumentPack + , Error + , EmitsErrors + > + > + { + }; +}}} // namespace boost::parameter::aux + +#include <boost/parameter/aux_/set.hpp> + +namespace boost { namespace parameter { namespace aux { + + // VC6.5 was choking on the default parameters for make_arg_list_aux, + // so this just forwards to that adding in the defaults. + template < + typename List + , typename DeducedArgs + , typename TagFn +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + , typename EmitsErrors = ::boost::mp11::mp_true +#else + , typename EmitsErrors = ::boost::mpl::true_ +#endif + > +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using make_arg_list = ::boost::parameter::aux::make_arg_list_aux< +#else + struct make_arg_list + : ::boost::parameter::aux::make_arg_list_aux< +#endif + List + , DeducedArgs + , TagFn +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + , ::boost::mp11::mp_true +#else + , ::boost::mpl::true_ +#endif + , ::boost::parameter::aux::set0 +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + , ::boost::parameter::aux::flat_like_arg_list<> +#else + , ::boost::parameter::aux::empty_arg_list +#endif + , ::boost::parameter::void_ + , EmitsErrors +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + >; +#else + > + { + }; +#endif +}}} // namespace boost::parameter::aux + +#endif // include guard + diff --git a/boost/parameter/aux_/pack/make_deduced_items.hpp b/boost/parameter/aux_/pack/make_deduced_items.hpp new file mode 100644 index 0000000000..3bc34332f0 --- /dev/null +++ b/boost/parameter/aux_/pack/make_deduced_items.hpp @@ -0,0 +1,53 @@ +// 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_AUX_PACK_MAKE_DEDUCED_ITEMS_HPP +#define BOOST_PARAMETER_AUX_PACK_MAKE_DEDUCED_ITEMS_HPP + +#include <boost/parameter/aux_/void.hpp> +#include <boost/parameter/aux_/pack/deduced_item.hpp> +#include <boost/parameter/deduced.hpp> +#include <boost/parameter/config.hpp> + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <boost/mp11/utility.hpp> +#include <type_traits> +#else +#include <boost/mpl/eval_if.hpp> +#include <boost/mpl/identity.hpp> +#include <boost/type_traits/is_same.hpp> +#endif + +namespace boost { namespace parameter { namespace aux { + + template <typename Spec, typename Tail> +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using make_deduced_items = ::boost::mp11::mp_if< + ::std::is_same<Spec,::boost::parameter::void_> + , ::boost::mp11::mp_identity< ::boost::parameter::void_> + , ::boost::mp11::mp_if< + ::boost::parameter::aux::is_deduced<Spec> + , ::boost::parameter::aux::make_deduced_item<Spec,Tail> + , Tail + > + >; +#else + struct make_deduced_items + : ::boost::mpl::eval_if< + ::boost::is_same<Spec,::boost::parameter::void_> + , ::boost::mpl::identity< ::boost::parameter::void_> + , ::boost::mpl::eval_if< + ::boost::parameter::aux::is_deduced<Spec> + , ::boost::parameter::aux::make_deduced_item<Spec,Tail> + , Tail + > + > + { + }; +#endif // BOOST_PARAMETER_CAN_USE_MP11 +}}} // namespace boost::parameter::aux + +#endif // include guard + diff --git a/boost/parameter/aux_/pack/make_items.hpp b/boost/parameter/aux_/pack/make_items.hpp new file mode 100644 index 0000000000..ec1554bc64 --- /dev/null +++ b/boost/parameter/aux_/pack/make_items.hpp @@ -0,0 +1,45 @@ +// 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_AUX_PACK_MAKE_ITEMS_HPP +#define BOOST_PARAMETER_AUX_PACK_MAKE_ITEMS_HPP + +#include <boost/parameter/aux_/void.hpp> +#include <boost/parameter/aux_/pack/item.hpp> +#include <boost/parameter/config.hpp> + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <boost/mp11/utility.hpp> +#include <type_traits> +#else +#include <boost/mpl/eval_if.hpp> +#include <boost/mpl/identity.hpp> +#include <boost/type_traits/is_same.hpp> +#endif + +namespace boost { namespace parameter { namespace aux { + + // Creates a item typelist. + template <typename Spec, typename Arg, typename Tail> +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using make_items = ::boost::mp11::mp_if< + ::std::is_same<Arg,::boost::parameter::void_> + , ::boost::mp11::mp_identity< ::boost::parameter::void_> + , ::boost::parameter::aux::make_item<Spec,Arg,Tail> + >; +#else + struct make_items + : ::boost::mpl::eval_if< + ::boost::is_same<Arg,::boost::parameter::void_> + , ::boost::mpl::identity< ::boost::parameter::void_> + , ::boost::parameter::aux::make_item<Spec,Arg,Tail> + > + { + }; +#endif +}}} // namespace boost::parameter::aux + +#endif // include guard + diff --git a/boost/parameter/aux_/pack/make_parameter_spec_items.hpp b/boost/parameter/aux_/pack/make_parameter_spec_items.hpp new file mode 100644 index 0000000000..f13c4b5c16 --- /dev/null +++ b/boost/parameter/aux_/pack/make_parameter_spec_items.hpp @@ -0,0 +1,244 @@ +// 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_AUX_PACK_MAKE_PARAMETER_SPEC_ITEMS_HPP +#define BOOST_PARAMETER_AUX_PACK_MAKE_PARAMETER_SPEC_ITEMS_HPP + +namespace boost { namespace parameter { namespace aux { + + // This recursive metafunction forwards successive elements of + // parameters::parameter_spec to make_deduced_items<>. + // -- Cromwell D. Enage + template <typename SpecSeq> + struct make_deduced_list; + + // Helper for match_parameters_base_cond<...>, below. + template <typename ArgumentPackAndError, typename SpecSeq> + struct match_parameters_base_cond_helper; + + // Helper metafunction for make_parameter_spec_items<...>, below. + template <typename SpecSeq, typename ...Args> + struct make_parameter_spec_items_helper; +}}} // namespace boost::parameter::aux + +#include <boost/parameter/aux_/void.hpp> + +namespace boost { namespace parameter { namespace aux { + + template <typename SpecSeq> + struct make_parameter_spec_items_helper<SpecSeq> + { + typedef ::boost::parameter::void_ type; + }; +}}} // namespace boost::parameter::aux + +#include <boost/parameter/aux_/pack/make_deduced_items.hpp> + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <boost/mp11/list.hpp> +#else +#include <boost/mpl/front.hpp> +#include <boost/mpl/pop_front.hpp> +#endif + +namespace boost { namespace parameter { namespace aux { + + template <typename SpecSeq> + struct make_deduced_list_not_empty + : ::boost::parameter::aux::make_deduced_items< +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + ::boost::mp11::mp_front<SpecSeq> +#else + typename ::boost::mpl::front<SpecSeq>::type +#endif + , ::boost::parameter::aux::make_deduced_list< +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + ::boost::mp11::mp_pop_front<SpecSeq> +#else + typename ::boost::mpl::pop_front<SpecSeq>::type +#endif + > + > + { + }; +}}} // namespace boost::parameter::aux + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <boost/mp11/utility.hpp> +#else +#include <boost/mpl/eval_if.hpp> +#include <boost/mpl/empty.hpp> +#include <boost/mpl/identity.hpp> +#endif + +namespace boost { namespace parameter { namespace aux { + + template <typename SpecSeq> + struct make_deduced_list +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + : ::boost::mp11::mp_if< + ::boost::mp11::mp_empty<SpecSeq> + , ::boost::mp11::mp_identity< ::boost::parameter::void_> +#else + : ::boost::mpl::eval_if< + ::boost::mpl::empty<SpecSeq> + , ::boost::mpl::identity< ::boost::parameter::void_> +#endif + , ::boost::parameter::aux::make_deduced_list_not_empty<SpecSeq> + > + { + }; +}}} // namespace boost::parameter::aux + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <type_traits> +#else +#include <boost/mpl/bool.hpp> +#include <boost/mpl/pair.hpp> +#include <boost/mpl/if.hpp> +#include <boost/type_traits/is_same.hpp> + +namespace boost { namespace parameter { namespace aux { + + template <typename ArgumentPackAndError> + struct is_arg_pack_error_void + : ::boost::mpl::if_< + ::boost::is_same< + typename ::boost::mpl::second<ArgumentPackAndError>::type + , ::boost::parameter::void_ + > + , ::boost::mpl::true_ + , ::boost::mpl::false_ + >::type + { + }; +}}} // namespace boost::parameter::aux + +#endif // BOOST_PARAMETER_CAN_USE_MP11 + +namespace boost { namespace parameter { namespace aux { + + // Checks if the arguments match the criteria of overload resolution. + // If NamedList satisfies the PS0, PS1, ..., this is a metafunction + // returning parameters. Otherwise it has no nested ::type. + template <typename ArgumentPackAndError, typename SpecSeq> +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using match_parameters_base_cond = ::boost::mp11::mp_if< + ::boost::mp11::mp_empty<SpecSeq> + , ::std::is_same< + ::boost::mp11::mp_at_c<ArgumentPackAndError,1> + , ::boost::parameter::void_ + > + , ::boost::parameter::aux::match_parameters_base_cond_helper< + ArgumentPackAndError + , SpecSeq + > + >; +#else + struct match_parameters_base_cond + : ::boost::mpl::eval_if< + ::boost::mpl::empty<SpecSeq> + , ::boost::parameter::aux + ::is_arg_pack_error_void<ArgumentPackAndError> + , ::boost::parameter::aux::match_parameters_base_cond_helper< + ArgumentPackAndError + , SpecSeq + > + > + { + }; +#endif // BOOST_PARAMETER_CAN_USE_MP11 +}}} // namespace boost::parameter::aux + +#include <boost/parameter/aux_/pack/satisfies.hpp> + +namespace boost { namespace parameter { namespace aux { + + template <typename ArgumentPackAndError, typename SpecSeq> + struct match_parameters_base_cond_helper +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + : ::boost::mp11::mp_if< +#else + : ::boost::mpl::eval_if< +#endif + ::boost::parameter::aux::satisfies_requirements_of< +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + ::boost::mp11::mp_at_c<ArgumentPackAndError,0> + , ::boost::mp11::mp_front<SpecSeq> +#else + typename ::boost::mpl::first<ArgumentPackAndError>::type + , typename ::boost::mpl::front<SpecSeq>::type +#endif + > + , ::boost::parameter::aux::match_parameters_base_cond< + ArgumentPackAndError +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + , ::boost::mp11::mp_pop_front<SpecSeq> +#else + , typename ::boost::mpl::pop_front<SpecSeq>::type +#endif + > +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + , ::boost::mp11::mp_false +#else + , ::boost::mpl::false_ +#endif + > + { + }; + + // This parameters item chaining metafunction class does not require + // the lengths of the SpecSeq and of Args parameter pack to match. + // Used by argument_pack to build the items in the resulting arg_list. + // -- Cromwell D. Enage + template <typename SpecSeq, typename ...Args> +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using make_parameter_spec_items = ::boost::mp11::mp_if< + ::boost::mp11::mp_empty<SpecSeq> + , ::boost::mp11::mp_identity< ::boost::parameter::void_> + , ::boost::parameter::aux + ::make_parameter_spec_items_helper<SpecSeq,Args...> + >; +#else + struct make_parameter_spec_items + : ::boost::mpl::eval_if< + ::boost::mpl::empty<SpecSeq> + , ::boost::mpl::identity< ::boost::parameter::void_> + , ::boost::parameter::aux + ::make_parameter_spec_items_helper<SpecSeq,Args...> + > + { + }; +#endif +}}} // namespace boost::parameter::aux + +#include <boost/parameter/aux_/pack/make_items.hpp> + +namespace boost { namespace parameter { namespace aux { + + template <typename SpecSeq, typename A0, typename ...Args> + struct make_parameter_spec_items_helper<SpecSeq,A0,Args...> + : ::boost::parameter::aux::make_items< +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + ::boost::mp11::mp_front<SpecSeq> +#else + typename ::boost::mpl::front<SpecSeq>::type +#endif + , A0 + , ::boost::parameter::aux::make_parameter_spec_items< +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + ::boost::mp11::mp_pop_front<SpecSeq> +#else + typename ::boost::mpl::pop_front<SpecSeq>::type +#endif + , Args... + > + > + { + }; +}}} // namespace boost::parameter::aux + +#endif // include guard + diff --git a/boost/parameter/aux_/pack/parameter_requirements.hpp b/boost/parameter/aux_/pack/parameter_requirements.hpp new file mode 100644 index 0000000000..709da2108b --- /dev/null +++ b/boost/parameter/aux_/pack/parameter_requirements.hpp @@ -0,0 +1,25 @@ +// Copyright Daniel Wallin, David Abrahams 2005. +// 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_AUX_PACK_PARAMETER_REQUIREMENTS_HPP +#define BOOST_PARAMETER_AUX_PACK_PARAMETER_REQUIREMENTS_HPP + +namespace boost { namespace parameter { namespace aux { + + // Used to pass static information about parameter requirements through + // the satisfies() overload set (below). The matched function is never + // invoked, but its type indicates whether a parameter matches at + // compile-time. + template <typename Keyword, typename Predicate, typename HasDefault> + struct parameter_requirements + { + typedef Keyword keyword; + typedef Predicate predicate; + typedef HasDefault has_default; + }; +}}} // namespace boost::parameter::aux + +#endif // include guard + diff --git a/boost/parameter/aux_/pack/predicate.hpp b/boost/parameter/aux_/pack/predicate.hpp new file mode 100644 index 0000000000..752664c60b --- /dev/null +++ b/boost/parameter/aux_/pack/predicate.hpp @@ -0,0 +1,87 @@ +// 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_AUX_PACK_PREDICATE_HPP +#define BOOST_PARAMETER_AUX_PACK_PREDICATE_HPP + +namespace boost { namespace parameter { namespace aux { + + // helper for get_predicate<...>, below + template <typename T> + struct get_predicate_or_default + { + typedef T type; + }; + + // helper for predicate<...>, below + template <typename T> + struct get_predicate + : ::boost::parameter::aux + ::get_predicate_or_default<typename T::predicate> + { + }; +}}} // namespace boost::parameter::aux + +#include <boost/parameter/aux_/use_default.hpp> +#include <boost/parameter/aux_/always_true_predicate.hpp> + +namespace boost { namespace parameter { namespace aux { + + template <> + struct get_predicate_or_default< ::boost::parameter::aux::use_default> + { + typedef ::boost::parameter::aux::always_true_predicate type; + }; +}}} // namespace boost::parameter::aux + +#include <boost/parameter/required.hpp> +#include <boost/parameter/optional.hpp> +#include <boost/parameter/config.hpp> + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <boost/mp11/integral.hpp> +#include <boost/mp11/utility.hpp> +#else +#include <boost/mpl/bool.hpp> +#include <boost/mpl/if.hpp> +#include <boost/mpl/eval_if.hpp> +#include <boost/mpl/identity.hpp> +#endif + +namespace boost { namespace parameter { namespace aux { + + template <typename T> +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using predicate = ::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::get_predicate<T> + , ::boost::mp11::mp_identity< + ::boost::parameter::aux::always_true_predicate + > + >; +#else + struct predicate + : ::boost::mpl::eval_if< + typename ::boost::mpl::if_< + ::boost::parameter::aux::is_optional<T> + , ::boost::mpl::true_ + , ::boost::parameter::aux::is_required<T> + >::type + , ::boost::parameter::aux::get_predicate<T> + , ::boost::mpl::identity< + ::boost::parameter::aux::always_true_predicate + > + > + { + }; +#endif // BOOST_PARAMETER_CAN_USE_MP11 +}}} // namespace boost::parameter::aux + +#endif // include guard + diff --git a/boost/parameter/aux_/pack/satisfies.hpp b/boost/parameter/aux_/pack/satisfies.hpp new file mode 100644 index 0000000000..90c8d21e58 --- /dev/null +++ b/boost/parameter/aux_/pack/satisfies.hpp @@ -0,0 +1,142 @@ +// 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_AUX_PACK_SATISFIES_HPP +#define BOOST_PARAMETER_AUX_PACK_SATISFIES_HPP + +#include <boost/parameter/config.hpp> + +#if BOOST_WORKAROUND(BOOST_MSVC, == 1310) +#include <boost/parameter/aux_/arg_list.hpp> +#include <boost/parameter/aux_/augment_predicate.hpp> +#include <boost/parameter/aux_/void.hpp> +#include <boost/mpl/eval_if.hpp> +#include <boost/mpl/apply_wrap.hpp> +#include <boost/type_traits/is_same.hpp> +#else // !BOOST_WORKAROUND(BOOST_MSVC, == 1310) +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <boost/mp11/integral.hpp> +#else +#include <boost/mpl/bool.hpp> +#endif +#include <boost/parameter/aux_/yesno.hpp> +#include <boost/parameter/aux_/preprocessor/nullptr.hpp> +#endif // MSVC-7.1 workarounds needed + +namespace boost { namespace parameter { namespace aux { + +#if BOOST_WORKAROUND(BOOST_MSVC, == 1310) + template <typename ArgList, typename ParameterRequirements, typename Bound> + struct satisfies_impl + : ::boost::parameter::aux::augment_predicate< + typename ParameterRequirements::predicate + , typename ArgList::reference + , typename ArgList::key_type + , Bound + , ArgList + > + { + }; +#endif + + // Returns mpl::true_ iff the given ParameterRequirements are satisfied by + // ArgList. + template <typename ArgList, typename ParameterRequirements> +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using satisfies = ::boost::mp11::mp_bool< + sizeof( + ::boost::parameter::aux::to_yesno( + ArgList::satisfies( + static_cast<ParameterRequirements*>( + BOOST_PARAMETER_AUX_PP_NULLPTR + ) + , static_cast<ArgList*>(BOOST_PARAMETER_AUX_PP_NULLPTR) + ) + ) + ) == sizeof(::boost::parameter::aux::yes_tag) + >; +#else // !defined(BOOST_PARAMETER_CAN_USE_MP11) + class satisfies + { +#if BOOST_WORKAROUND(BOOST_MSVC, == 1310) + // VC7.1 can't handle the sizeof() implementation below, + // so we use this instead. + typedef typename ::boost::mpl::apply_wrap3< + typename ArgList::binding + , typename ParameterRequirements::keyword + , ::boost::parameter::void_ + , ::boost::mpl::false_ + >::type _bound; + + public: + typedef typename ::boost::mpl::eval_if< + ::boost::is_same<_bound,::boost::parameter::void_> + , typename ParameterRequirements::has_default + , ::boost::mpl::eval_if< + ::boost::is_same< + ArgList + , ::boost::parameter::aux::empty_arg_list + > + , ::boost::mpl::false_ + , ::boost::parameter::aux::satisfies_impl< + ArgList + , ParameterRequirements + , _bound + > + > + >::type type; +#else // !BOOST_WORKAROUND(BOOST_MSVC, == 1310) + BOOST_STATIC_CONSTANT( + bool, _value = ( + sizeof( + ::boost::parameter::aux::to_yesno( + ArgList::satisfies( + static_cast<ParameterRequirements*>( + BOOST_PARAMETER_AUX_PP_NULLPTR + ) + , static_cast<ArgList*>(BOOST_PARAMETER_AUX_PP_NULLPTR) + ) + ) + ) == sizeof(::boost::parameter::aux::yes_tag) + ) + ); + + public: + typedef ::boost::mpl::bool_< + ::boost::parameter::aux + ::satisfies<ArgList,ParameterRequirements>::_value + > type; +#endif // MSVC-7.1 workarounds needed + }; +#endif // BOOST_PARAMETER_CAN_USE_MP11 +}}} // namespace boost::parameter::aux + +#include <boost/parameter/aux_/pack/as_parameter_requirements.hpp> + +namespace boost { namespace parameter { namespace aux { + + // Returns mpl::true_ if the requirements of the given ParameterSpec + // are satisfied by ArgList. + template <typename ArgList, typename ParameterSpec> +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using satisfies_requirements_of = ::boost::parameter::aux::satisfies< + ArgList + , typename ::boost::parameter::aux + ::as_parameter_requirements<ParameterSpec>::type + >; +#else + struct satisfies_requirements_of + : ::boost::parameter::aux::satisfies< + ArgList + , typename ::boost::parameter::aux + ::as_parameter_requirements<ParameterSpec>::type + >::type + { + }; +#endif // BOOST_PARAMETER_CAN_USE_MP11 +}}} // namespace boost::parameter::aux + +#endif // include guard + diff --git a/boost/parameter/aux_/pack/tag_deduced.hpp b/boost/parameter/aux_/pack/tag_deduced.hpp new file mode 100644 index 0000000000..9065ab9558 --- /dev/null +++ b/boost/parameter/aux_/pack/tag_deduced.hpp @@ -0,0 +1,59 @@ +// 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_AUX_PACK_TAG_DEDUCED_HPP +#define BOOST_PARAMETER_AUX_PACK_TAG_DEDUCED_HPP + +#include <boost/parameter/aux_/set.hpp> +#include <boost/parameter/aux_/pack/tag_type.hpp> +#include <boost/parameter/config.hpp> + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <boost/mp11/list.hpp> +#include <boost/mp11/utility.hpp> +#else +#include <boost/mpl/pair.hpp> +#include <boost/mpl/apply_wrap.hpp> +#endif + +namespace boost { namespace parameter { namespace aux { + + // Tags a deduced argument Arg with the keyword tag of Spec using TagFn. + // Returns the tagged argument and the mpl::set<> UsedArgs with the + // tag of Spec inserted. + template <typename UsedArgs, typename Spec, typename Arg, typename TagFn> + struct tag_deduced + { +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using type = ::boost::mp11::mp_list< + ::boost::mp11::mp_apply_q< + TagFn + , ::boost::mp11::mp_list< + typename ::boost::parameter::aux::tag_type<Spec>::type + , Arg + > + > +#else + typedef ::boost::mpl::pair< + typename ::boost::mpl::apply_wrap2< + TagFn + , typename ::boost::parameter::aux::tag_type<Spec>::type + , Arg + >::type +#endif // BOOST_PARAMETER_CAN_USE_MP11 + , typename ::boost::parameter::aux::insert_< + UsedArgs + , typename ::boost::parameter::aux::tag_type<Spec>::type + >::type +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + >; +#else + > type; +#endif + }; +}}} // namespace boost::parameter::aux + +#endif // include guard + diff --git a/boost/parameter/aux_/pack/tag_keyword_arg.hpp b/boost/parameter/aux_/pack/tag_keyword_arg.hpp new file mode 100644 index 0000000000..ae4154e3fd --- /dev/null +++ b/boost/parameter/aux_/pack/tag_keyword_arg.hpp @@ -0,0 +1,30 @@ +// 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_AUX_PACK_TAG_KEYWORD_ARG_HPP +#define BOOST_PARAMETER_AUX_PACK_TAG_KEYWORD_ARG_HPP + +#include <boost/parameter/aux_/tag.hpp> +#include <boost/parameter/config.hpp> + +namespace boost { namespace parameter { namespace aux { + + struct tag_keyword_arg + { + template <typename K, typename T> + struct apply + { + typedef typename ::boost::parameter::aux::tag<K,T>::type type; + }; + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + template <typename K, typename T> + using fn = typename ::boost::parameter::aux::tag<K,T>::type; +#endif + }; +}}} // namespace boost::parameter::aux + +#endif // include guard + diff --git a/boost/parameter/aux_/pack/tag_keyword_arg_ref.hpp b/boost/parameter/aux_/pack/tag_keyword_arg_ref.hpp new file mode 100644 index 0000000000..4d67975ddc --- /dev/null +++ b/boost/parameter/aux_/pack/tag_keyword_arg_ref.hpp @@ -0,0 +1,67 @@ +// 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_AUX_PACK_TAG_KEYWORD_ARG_REF_HPP +#define BOOST_PARAMETER_AUX_PACK_TAG_KEYWORD_ARG_REF_HPP + +#include <boost/parameter/aux_/unwrap_cv_reference.hpp> +#include <boost/parameter/aux_/tagged_argument.hpp> +#include <boost/parameter/config.hpp> + +namespace boost { namespace parameter { namespace aux { + + template < + typename Keyword + , typename ActualArg +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) + , typename = typename ::boost::parameter::aux + ::is_cv_reference_wrapper<ActualArg>::type +#endif + > + struct tag_ref + { + typedef ::boost::parameter::aux::tagged_argument< + Keyword + , typename ::boost::parameter::aux + ::unwrap_cv_reference<ActualArg>::type + > type; + }; +}}} // namespace boost::parameter::aux_ + +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) + +#include <boost/mpl/bool.hpp> + +namespace boost { namespace parameter { namespace aux { + + template <typename Keyword, typename ActualArg> + struct tag_ref<Keyword,ActualArg,::boost::mpl::false_> + { + typedef ::boost::parameter::aux + ::tagged_argument<Keyword,ActualArg> type; + }; +}}} // namespace boost::parameter::aux_ + +#endif // Borland workarounds needed. + +namespace boost { namespace parameter { namespace aux { + + struct tag_keyword_arg_ref + { + template <typename K, typename T> + struct apply + { + typedef typename ::boost::parameter::aux::tag_ref<K,T>::type type; + }; + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + template <typename K, typename T> + using fn = typename ::boost::parameter::aux::tag_ref<K,T>::type; +#endif + }; +}}} // namespace boost::parameter::aux + +#endif // include guard + diff --git a/boost/parameter/aux_/pack/tag_template_keyword_arg.hpp b/boost/parameter/aux_/pack/tag_template_keyword_arg.hpp new file mode 100644 index 0000000000..849966edb9 --- /dev/null +++ b/boost/parameter/aux_/pack/tag_template_keyword_arg.hpp @@ -0,0 +1,30 @@ +// 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_AUX_PACK_TAG_TEMPLATE_KEYWORD_ARG_HPP +#define BOOST_PARAMETER_AUX_PACK_TAG_TEMPLATE_KEYWORD_ARG_HPP + +#include <boost/parameter/template_keyword.hpp> +#include <boost/parameter/config.hpp> + +namespace boost { namespace parameter { namespace aux { + + struct tag_template_keyword_arg + { + template <typename K, typename T> + struct apply + { + typedef ::boost::parameter::template_keyword<K,T> type; + }; + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + template <typename K, typename T> + using fn = ::boost::parameter::template_keyword<K,T>; +#endif + }; +}}} // namespace boost::parameter::aux + +#endif // include guard + diff --git a/boost/parameter/aux_/pack/tag_type.hpp b/boost/parameter/aux_/pack/tag_type.hpp new file mode 100644 index 0000000000..81d1a1476f --- /dev/null +++ b/boost/parameter/aux_/pack/tag_type.hpp @@ -0,0 +1,89 @@ +// 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_AUX_PACK_TAG_TYPE_HPP +#define BOOST_PARAMETER_AUX_PACK_TAG_TYPE_HPP + +namespace boost { namespace parameter { namespace aux { + + // helper for tag_type<...>, below. + template <typename T> + struct get_tag_type0 + { + typedef typename T::key_type type; + }; +}}} // namespace boost::parameter::aux + +#include <boost/parameter/deduced.hpp> +#include <boost/parameter/config.hpp> + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <boost/mp11/utility.hpp> +#else +#include <boost/mpl/eval_if.hpp> +#endif + +namespace boost { namespace parameter { namespace aux { + + template <typename T> + struct get_tag_type +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + : ::boost::mp11::mp_if< +#else + : ::boost::mpl::eval_if< +#endif + ::boost::parameter::aux::is_deduced0<T> + , ::boost::parameter::aux::get_tag_type0<typename T::key_type> + , ::boost::parameter::aux::get_tag_type0<T> + > + { + }; +}}} // namespace boost::parameter::aux + +#include <boost/parameter/required.hpp> +#include <boost/parameter/optional.hpp> + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <boost/mp11/integral.hpp> + +namespace boost { namespace parameter { namespace aux { + + template <typename T> + using tag_type = ::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::get_tag_type<T> + , ::boost::mp11::mp_identity<T> + >; +}}} // namespace boost::parameter::aux + +#else // !defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <boost/mpl/bool.hpp> +#include <boost/mpl/if.hpp> +#include <boost/mpl/identity.hpp> + +namespace boost { namespace parameter { namespace aux { + + template <typename T> + struct tag_type + : ::boost::mpl::eval_if< + typename ::boost::mpl::if_< + ::boost::parameter::aux::is_optional<T> + , ::boost::mpl::true_ + , ::boost::parameter::aux::is_required<T> + >::type + , ::boost::parameter::aux::get_tag_type<T> + , ::boost::mpl::identity<T> + > + { + }; +}}} // namespace boost::parameter::aux + +#endif // BOOST_PARAMETER_CAN_USE_MP11 +#endif // include guard + diff --git a/boost/parameter/aux_/pack/unmatched_argument.hpp b/boost/parameter/aux_/pack/unmatched_argument.hpp new file mode 100644 index 0000000000..72a1bc5f62 --- /dev/null +++ b/boost/parameter/aux_/pack/unmatched_argument.hpp @@ -0,0 +1,41 @@ +// 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_AUX_PACK_UNMATCHED_ARGUMENT_HPP +#define BOOST_PARAMETER_AUX_PACK_UNMATCHED_ARGUMENT_HPP + +#include <boost/parameter/config.hpp> + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <type_traits> +#else +#include <boost/mpl/bool.hpp> +#include <boost/mpl/if.hpp> +#include <boost/mpl/assert.hpp> +#include <boost/type_traits/is_same.hpp> +#endif + +namespace boost { namespace parameter { namespace aux { + + template <typename T> + struct unmatched_argument + { +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + static_assert(::std::is_same<T,void>::value, "T == void"); +#else + BOOST_MPL_ASSERT(( + typename ::boost::mpl::if_< + ::boost::is_same<T,void> + , ::boost::mpl::true_ + , ::boost::mpl::false_ + >::type + )); +#endif + typedef int type; + }; +}}} // namespace boost::parameter::aux + +#endif // include guard + diff --git a/boost/parameter/aux_/parameter_requirements.hpp b/boost/parameter/aux_/parameter_requirements.hpp index ad7a129dd7..d372691e50 100644 --- a/boost/parameter/aux_/parameter_requirements.hpp +++ b/boost/parameter/aux_/parameter_requirements.hpp @@ -1,25 +1,12 @@ -// 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. +// 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 PARAMETER_REQUIREMENTS_050331_HPP #define PARAMETER_REQUIREMENTS_050331_HPP -namespace boost { namespace parameter { namespace aux { +#include <boost/parameter/aux_/pack/parameter_requirements.hpp> -// Used to pass static information about parameter requirements -// through the satisfies() overload set (below). The -// matched function is never invoked, but its type indicates whether -// a parameter matches at compile-time -template <class Keyword, class Predicate, class HasDefault> -struct parameter_requirements -{ - typedef Keyword keyword; - typedef Predicate predicate; - typedef HasDefault has_default; -}; +#endif // include guard -}}} // namespace boost::parameter::aux - -#endif // PARAMETER_REQUIREMENTS_050331_HPP diff --git a/boost/parameter/aux_/parenthesized_type.hpp b/boost/parameter/aux_/parenthesized_type.hpp index 69e7a237d4..863e062e90 100644 --- a/boost/parameter/aux_/parenthesized_type.hpp +++ b/boost/parameter/aux_/parenthesized_type.hpp @@ -1,35 +1,12 @@ -// Copyright David Abrahams 2006. 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_AUX_PARENTHESIZED_TYPE_DWA2006414_HPP -# define BOOST_PARAMETER_AUX_PARENTHESIZED_TYPE_DWA2006414_HPP - -# include <boost/config.hpp> -# include <boost/detail/workaround.hpp> - -namespace boost { namespace parameter { namespace aux { +// Copyright David Abrahams 2006. +// 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) -// A macro that takes a parenthesized C++ type name (T) and transforms -// it into an un-parenthesized type expression equivalent to T. -# define BOOST_PARAMETER_PARENTHESIZED_TYPE(x) \ - boost::parameter::aux::unaryfunptr_arg_type< void(*)x >::type - -// A metafunction that transforms void(*)(T) -> T -template <class UnaryFunctionPointer> -struct unaryfunptr_arg_type; +#ifndef BOOST_PARAMETER_AUX_PARENTHESIZED_TYPE_DWA2006414_HPP +#define BOOST_PARAMETER_AUX_PARENTHESIZED_TYPE_DWA2006414_HPP -template <class Arg> -struct unaryfunptr_arg_type<void(*)(Arg)> -{ - typedef Arg type; -}; +#include <boost/parameter/aux_/preprocessor/impl/parenthesized_type.hpp> -template <> -struct unaryfunptr_arg_type<void(*)(void)> -{ - typedef void type; -}; - -}}} // namespace boost::parameter::aux +#endif // include guard -#endif // BOOST_PARAMETER_AUX_PARENTHESIZED_TYPE_DWA2006414_HPP diff --git a/boost/parameter/aux_/pp_impl/argument_pack.hpp b/boost/parameter/aux_/pp_impl/argument_pack.hpp new file mode 100644 index 0000000000..85bf13f744 --- /dev/null +++ b/boost/parameter/aux_/pp_impl/argument_pack.hpp @@ -0,0 +1,91 @@ +// Copyright Daniel Wallin 2006. +// 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_AUX_PP_IMPL_ARGUMENT_PACK_HPP +#define BOOST_PARAMETER_AUX_PP_IMPL_ARGUMENT_PACK_HPP + +#include <boost/parameter/aux_/pack/tag_keyword_arg.hpp> +#include <boost/parameter/aux_/pack/make_arg_list.hpp> +#include <boost/parameter/config.hpp> + +#if defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING) +#include <boost/parameter/aux_/pack/make_parameter_spec_items.hpp> + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <boost/mp11/integral.hpp> +#include <boost/mp11/list.hpp> +#else +#include <boost/mpl/bool.hpp> +#include <boost/mpl/pair.hpp> +#endif + +namespace boost { namespace parameter { namespace aux { + + template <typename Parameters, typename ...Args> + struct argument_pack + { + typedef typename ::boost::parameter::aux::make_arg_list< + typename ::boost::parameter::aux::make_parameter_spec_items< + typename Parameters::parameter_spec + , Args... + >::type + , typename Parameters::deduced_list + , ::boost::parameter::aux::tag_keyword_arg +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + , ::boost::mp11::mp_false +#else + , ::boost::mpl::false_ +#endif + >::type result; +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using type = ::boost::mp11::mp_at_c<result,0>; +#else + typedef typename ::boost::mpl::first<result>::type type; +#endif + }; +}}} // namespace boost::parameter::aux + +#else // !defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING) +#include <boost/parameter/aux_/void.hpp> +#include <boost/parameter/aux_/pack/make_items.hpp> +#include <boost/parameter/aux_/preprocessor/no_perfect_forwarding_begin.hpp> +#include <boost/preprocessor/facilities/intercept.hpp> +#include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp> +#include <boost/mpl/bool.hpp> +#include <boost/mpl/pair.hpp> + +namespace boost { namespace parameter { namespace aux { + + template < + typename Parameters + BOOST_PP_ENUM_TRAILING_BINARY_PARAMS( + BOOST_PARAMETER_MAX_ARITY + , typename A + , = ::boost::parameter::void_ BOOST_PP_INTERCEPT + ) + > + struct argument_pack + { + typedef typename ::boost::parameter::aux::make_arg_list< + typename BOOST_PARAMETER_build_arg_list( + BOOST_PARAMETER_MAX_ARITY + , ::boost::parameter::aux::make_items + , typename Parameters::parameter_spec + , A + )::type + , typename Parameters::deduced_list + , ::boost::parameter::aux::tag_keyword_arg + , ::boost::mpl::false_ + >::type result; + typedef typename ::boost::mpl::first<result>::type type; + }; +}}} // namespace boost::parameter::aux + +#include <boost/parameter/aux_/preprocessor/no_perfect_forwarding_end.hpp> + +#endif // BOOST_PARAMETER_HAS_PERFECT_FORWARDING +#endif // include guard + diff --git a/boost/parameter/aux_/pp_impl/match.hpp b/boost/parameter/aux_/pp_impl/match.hpp new file mode 100644 index 0000000000..a903975de6 --- /dev/null +++ b/boost/parameter/aux_/pp_impl/match.hpp @@ -0,0 +1,55 @@ +// Copyright Daniel Wallin 2006. +// 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_AUX_PP_IMPL_MATCH_HPP +#define BOOST_PARAMETER_AUX_PP_IMPL_MATCH_HPP + +#include <boost/parameter/config.hpp> + +#if defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING) + +namespace boost { namespace parameter { namespace aux { + + // Recast the ParameterSpec's nested match metafunction + // as a free metafunction. + // + // No more limits set by BOOST_PARAMETER_MAX_ARITY. -- Cromwell D. Enage + template <typename Parameters, typename ...Args> + struct match : Parameters::BOOST_NESTED_TEMPLATE match<Args...> + { + }; +}}} // namespace boost::parameter::aux + +#else + +#include <boost/parameter/aux_/void.hpp> +#include <boost/preprocessor/facilities/intercept.hpp> +#include <boost/preprocessor/repetition/enum_params.hpp> +#include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp> + +namespace boost { namespace parameter { namespace aux { + + // Recast the ParameterSpec's nested match metafunction + // as a free metafunction. + template < + typename Parameters + BOOST_PP_ENUM_TRAILING_BINARY_PARAMS( + BOOST_PARAMETER_MAX_ARITY + , typename A + , = ::boost::parameter::void_ BOOST_PP_INTERCEPT + ) + > + struct match + : Parameters::BOOST_NESTED_TEMPLATE match< + BOOST_PP_ENUM_PARAMS(BOOST_PARAMETER_MAX_ARITY, A) + > + { + }; +}}} // namespace boost::parameter::aux + +#endif // BOOST_PARAMETER_HAS_PERFECT_FORWARDING +#endif // include guard + diff --git a/boost/parameter/aux_/pp_impl/unwrap_predicate.hpp b/boost/parameter/aux_/pp_impl/unwrap_predicate.hpp new file mode 100644 index 0000000000..6141612575 --- /dev/null +++ b/boost/parameter/aux_/pp_impl/unwrap_predicate.hpp @@ -0,0 +1,97 @@ +// Copyright Daniel Wallin 2006. +// 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_AUX_PP_IMPL_UNWRAP_PREDICATE_HPP +#define BOOST_PARAMETER_AUX_PP_IMPL_UNWRAP_PREDICATE_HPP + +namespace boost { namespace parameter { namespace aux { + + // Given Match, which is "void x" where x is an argument matching + // criterion, extract a corresponding MPL predicate. + template <typename Match> + struct unwrap_predicate; +}}} // namespace boost::parameter::aux + +#include <boost/parameter/aux_/always_true_predicate.hpp> + +namespace boost { namespace parameter { namespace aux { + + // Match anything + template <> + struct unwrap_predicate<void*> + { + typedef ::boost::parameter::aux::always_true_predicate type; + }; +}}} // namespace boost::parameter::aux + +#include <boost/parameter/config.hpp> + +#if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x580)) +#include <boost/parameter/aux_/void.hpp> +#endif + +namespace boost { namespace parameter { namespace aux { + + // A matching predicate is explicitly specified. +#if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x580)) + template <typename Predicate> + struct unwrap_predicate< ::boost::parameter::aux::voidstar(Predicate)> + { + typedef Predicate type; + }; +#else + template <typename Predicate> + struct unwrap_predicate<void *(Predicate)> + { + typedef Predicate type; + }; +#endif // SunProCC workarounds needed. +}}} // namespace boost::parameter::aux + +#include <boost/mpl/bool.hpp> +#include <boost/mpl/if.hpp> + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <type_traits> +#else +#include <boost/mpl/placeholders.hpp> +#include <boost/type_traits/is_convertible.hpp> +#endif + +namespace boost { namespace parameter { namespace aux { + + // A type to which the argument is supposed to be convertible is + // specified. + template <typename Target> + struct unwrap_predicate<void (Target)> + { +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + struct type + { + template <typename Argument, typename ArgumentPack> + struct apply + : ::boost::mpl::if_< + ::std::is_convertible<Argument,Target> + , ::boost::mpl::true_ + , ::boost::mpl::false_ + > + { + }; + + template <typename Argument, typename ArgumentPack> + using fn = ::std::is_convertible<Argument,Target>; + }; +#else + typedef ::boost::mpl::if_< + ::boost::is_convertible< ::boost::mpl::_,Target> + , ::boost::mpl::true_ + , ::boost::mpl::false_ + > type; +#endif // BOOST_PARAMETER_CAN_USE_MP11 + }; +}}} // namespace boost::parameter::aux + +#endif // include guard + diff --git a/boost/parameter/aux_/preprocessor/binary_seq_for_each.hpp b/boost/parameter/aux_/preprocessor/binary_seq_for_each.hpp new file mode 100644 index 0000000000..700d918a9d --- /dev/null +++ b/boost/parameter/aux_/preprocessor/binary_seq_for_each.hpp @@ -0,0 +1,1638 @@ +// 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_AUX_PREPROCESSOR_BINARY_SEQ_FOR_EACH_HPP +#define BOOST_PARAMETER_AUX_PREPROCESSOR_BINARY_SEQ_FOR_EACH_HPP + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_0(macro, data) +/**/ + +#include <boost/parameter/aux_/preprocessor/for_each_pred.hpp> +#include <boost/parameter/aux_/preprocessor/binary_seq_for_each_inc.hpp> +#include <boost/preprocessor/repetition/for.hpp> + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_1(macro, data) \ + BOOST_PP_FOR( \ + (data)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_2 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_1_N \ + , macro \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_2(macro, data) \ + BOOST_PP_FOR( \ + (data)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_3 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_1_N \ + , macro \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_3(macro, data) \ + BOOST_PP_FOR( \ + (data)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_4 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_1_N \ + , macro \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_4(macro, data) \ + BOOST_PP_FOR( \ + (data)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_5 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_1_N \ + , macro \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_5(macro, data) \ + BOOST_PP_FOR( \ + (data)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_6 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_1_N \ + , macro \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_6(macro, data) \ + BOOST_PP_FOR( \ + (data)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_7 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_1_N \ + , macro \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_7(macro, data) \ + BOOST_PP_FOR( \ + (data)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_8 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_1_N \ + , macro \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_8(macro, data) \ + BOOST_PP_FOR( \ + (data)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_9 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_2_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_9 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_2_N \ + , macro \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_9(macro, data) \ + BOOST_PP_FOR( \ + (data)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_10 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_3_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_10 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_3_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_10 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_3_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_10 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_3_N \ + , macro \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_10(macro, data) \ + BOOST_PP_FOR( \ + (data)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_11 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_4_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_11 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_4_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_11 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_4_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_11 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_4_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_11 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_4_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_11 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_4_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_11 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_4_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_11 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_4_N \ + , macro \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_11(macro, data) \ + BOOST_PP_FOR( \ + (data)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_12 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_5_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_12 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_5_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_12 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_5_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_12 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_5_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_12 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_5_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_12 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_5_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_12 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_5_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_12 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_5_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_12 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_5_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_12 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_5_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_12 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_5_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_12 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_5_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_12 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_5_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_12 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_5_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_12 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_5_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_12 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_5_N \ + , macro \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_12(macro, data) \ + BOOST_PP_FOR( \ + (data)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_13 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_6_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_13 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_6_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_13 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_6_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_13 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_6_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_13 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_6_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_13 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_6_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_13 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_6_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_13 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_6_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_13 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_6_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_13 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_6_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_13 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_6_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_13 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_6_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_13 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_6_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_13 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_6_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_13 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_6_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_13 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_6_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_13 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_6_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_13 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_6_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_13 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_6_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_13 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_6_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_13 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_6_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_13 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_6_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_13 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_6_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_13 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_6_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_13 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_6_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_13 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_6_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_13 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_6_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_13 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_6_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_13 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_6_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_13 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_6_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_13 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_6_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_13 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_6_N \ + , macro \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_13(macro, data) \ + BOOST_PP_FOR( \ + (data)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(0)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(0)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(0)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(0)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(1)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(1)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(1)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(1)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(0)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(0)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(0)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(0)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(1)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(1)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(1)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(1)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(0)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(0)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(0)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(0)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(1)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(1)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(1)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(1)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(0)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(0)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(0)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(0)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(1)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(1)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(1)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(1)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N \ + , macro \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_14(macro, data) \ + BOOST_PP_FOR( \ + (data)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(0)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(0)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(0)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(0)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(1)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(1)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(1)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(1)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(0)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(0)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(0)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(0)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(1)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(1)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(1)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(1)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(0)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(0)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(0)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(0)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(1)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(1)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(1)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(1)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(0)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(0)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(0)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(0)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(1)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(1)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(1)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(1)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(0)(0)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(0)(0)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(0)(0)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(0)(0)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(1)(0)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(1)(0)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(1)(0)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(1)(0)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(0)(1)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(0)(1)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(0)(1)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(0)(1)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(1)(1)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(1)(1)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(1)(1)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(1)(1)(0)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(0)(0)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(0)(0)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(0)(0)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(0)(0)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(1)(0)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(1)(0)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(1)(0)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(1)(0)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(0)(1)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(0)(1)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(0)(1)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(0)(1)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(1)(1)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(1)(1)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(1)(1)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(1)(1)(1)(0)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(0)(0)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(0)(0)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(0)(0)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(0)(0)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(1)(0)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(1)(0)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(1)(0)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(1)(0)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(0)(1)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(0)(1)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(0)(1)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(0)(1)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(1)(1)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(1)(1)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(1)(1)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(1)(1)(0)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(0)(0)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(0)(0)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(0)(0)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(0)(0)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(1)(0)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(1)(0)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(1)(0)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(1)(0)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(0)(1)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(0)(1)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(0)(1)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(0)(1)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(0)(1)(1)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(0)(1)(1)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(0)(1)(1)(1)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) \ + BOOST_PP_FOR( \ + (data)(1)(1)(1)(1)(1)(1)(1)(0)(0)(0)(0)(0)(0)(0) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15 \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N \ + , macro \ + ) +/**/ + +#include <boost/preprocessor/seq/elem.hpp> +#include <boost/preprocessor/cat.hpp> + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH(n, seq) \ + BOOST_PP_CAT(BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_, n)( \ + BOOST_PP_SEQ_ELEM(0, seq), BOOST_PP_SEQ_ELEM(1, seq) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_Z(z, n, seq) \ + BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH(n, seq) +/**/ + +#endif // include guard + diff --git a/boost/parameter/aux_/preprocessor/binary_seq_for_each_inc.hpp b/boost/parameter/aux_/preprocessor/binary_seq_for_each_inc.hpp new file mode 100644 index 0000000000..7e97546739 --- /dev/null +++ b/boost/parameter/aux_/preprocessor/binary_seq_for_each_inc.hpp @@ -0,0 +1,1796 @@ +// 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_AUX_PREPROCESSOR_BINARY_SEQ_FOR_EACH_INC_HPP +#define BOOST_PARAMETER_AUX_PREPROCESSOR_BINARY_SEQ_FOR_EACH_INC_HPP + +#include <boost/parameter/aux_/preprocessor/inc_binary_seq.hpp> +#include <boost/preprocessor/seq/seq.hpp> +#include <boost/preprocessor/seq/push_front.hpp> + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_1_N(r, seq) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_TAIL(seq)) \ + , BOOST_PP_SEQ_HEAD(seq) \ + ) +/**/ + +#include <boost/parameter/aux_/preprocessor/seq_merge.hpp> +#include <boost/preprocessor/seq/first_n.hpp> +#include <boost/preprocessor/seq/rest_n.hpp> + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_2_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(2, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(2, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_3_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(3, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(3, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_4_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(4, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(4, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_5_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(5, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(5, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_6_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(6, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(6, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_7_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(7, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(7, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_8_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(8, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(8, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_9_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(9, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(9, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_10_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(10, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(10, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_11_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(11, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(11, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_12_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(12, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(12, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_13_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(13, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(13, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_14_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(14, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(14, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_15_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(15, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(15, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_16_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(16, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(16, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_17_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(17, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(17, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_18_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(18, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(18, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_19_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(19, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(19, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_20_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(20, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(20, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_21_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(21, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(21, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_22_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(22, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(22, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_23_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(23, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(23, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_24_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(24, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(24, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_25_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(25, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(25, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_26_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(26, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(26, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_27_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(27, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(27, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_28_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(28, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(28, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_29_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(29, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(29, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_30_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(30, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(30, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_31_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(31, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(31, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_32_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(32, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(32, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_33_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(33, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(33, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_34_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(34, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(34, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_35_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(35, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(35, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_36_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(36, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(36, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_37_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(37, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(37, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_38_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(38, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(38, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_39_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(39, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(39, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_40_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(40, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(40, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_41_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(41, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(41, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_42_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(42, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(42, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_43_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(43, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(43, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_44_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(44, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(44, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_45_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(45, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(45, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_46_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(46, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(46, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_47_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(47, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(47, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_48_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(48, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(48, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_49_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(49, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(49, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_50_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(50, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(50, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_51_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(51, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(51, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_52_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(52, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(52, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_53_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(53, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(53, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_54_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(54, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(54, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_55_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(55, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(55, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_56_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(56, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(56, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_57_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(57, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(57, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_58_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(58, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(58, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_59_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(59, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(59, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_60_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(60, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(60, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_61_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(61, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(61, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_62_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(62, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(62, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_63_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(63, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(63, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_64_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(64, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(64, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_65_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(65, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(65, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_66_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(66, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(66, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_67_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(67, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(67, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_68_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(68, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(68, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_69_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(69, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(69, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_70_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(70, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(70, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_71_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(71, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(71, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_72_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(72, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(72, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_73_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(73, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(73, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_74_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(74, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(74, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_75_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(75, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(75, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_76_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(76, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(76, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_77_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(77, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(77, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_78_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(78, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(78, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_79_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(79, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(79, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_80_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(80, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(80, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_81_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(81, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(81, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_82_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(82, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(82, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_83_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(83, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(83, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_84_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(84, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(84, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_85_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(85, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(85, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_86_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(86, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(86, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_87_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(87, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(87, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_88_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(88, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(88, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_89_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(89, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(89, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_90_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(90, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(90, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_91_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(91, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(91, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_92_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(92, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(92, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_93_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(93, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(93, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_94_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(94, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(94, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_95_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(95, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(95, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_96_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(96, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(96, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_97_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(97, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(97, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_98_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(98, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(98, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_99_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(99, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(99, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_100_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(100, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(100, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_101_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(101, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(101, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_102_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(102, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(102, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_103_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(103, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(103, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_104_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(104, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(104, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_105_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(105, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(105, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_106_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(106, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(106, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_107_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(107, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(107, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_108_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(108, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(108, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_109_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(109, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(109, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_110_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(110, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(110, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_111_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(111, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(111, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_112_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(112, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(112, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_113_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(113, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(113, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_114_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(114, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(114, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_115_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(115, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(115, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_116_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(116, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(116, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_117_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(117, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(117, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_118_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(118, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(118, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_119_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(119, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(119, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_120_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(120, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(120, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_121_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(121, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(121, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_122_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(122, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(122, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_123_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(123, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(123, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_124_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(124, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(124, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_125_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(125, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(125, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_126_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(126, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(126, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_127_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(127, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(127, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_128_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(128, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(128, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_129_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(129, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(129, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_130_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(130, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(130, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_131_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(131, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(131, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_132_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(132, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(132, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_133_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(133, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(133, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_134_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(134, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(134, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_135_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(135, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(135, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_136_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(136, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(136, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_137_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(137, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(137, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_138_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(138, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(138, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_139_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(139, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(139, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_140_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(140, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(140, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_141_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(11, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(141, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_142_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(142, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(142, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_143_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(143, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(143, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_144_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(144, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(144, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_145_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(145, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(145, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_146_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(146, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(146, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_147_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(147, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(147, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_148_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(148, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(148, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_149_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(149, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(149, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_150_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(150, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(150, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_151_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(151, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(151, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_152_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(152, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(152, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_153_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(153, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(153, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_154_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(154, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(154, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_155_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(155, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(155, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_156_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(156, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(156, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_157_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(157, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(157, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_158_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(158, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(158, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_159_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(159, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(159, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_160_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(160, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(160, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_161_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(161, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(161, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_162_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(162, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(162, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_163_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(163, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(163, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_164_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(164, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(164, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_165_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(165, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(165, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_166_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(166, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(166, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_167_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(167, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(167, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_168_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(168, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(168, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_169_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(169, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(169, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_170_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(170, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(170, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_171_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(171, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(171, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_172_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(172, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(172, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_173_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(173, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(173, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_174_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(174, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(174, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_175_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(175, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(175, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_176_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(176, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(176, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_177_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(177, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(177, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_178_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(178, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(178, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_179_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(179, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(179, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_180_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(180, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(180, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_181_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(181, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(181, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_182_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(182, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(182, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_183_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(183, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(183, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_184_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(184, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(184, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_185_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(185, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(185, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_186_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(186, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(186, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_187_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(187, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(187, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_188_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(188, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(188, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_189_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(189, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(189, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_190_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(190, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(190, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_191_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(191, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(191, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_192_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(192, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(192, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_193_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(193, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(193, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_194_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(194, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(194, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_195_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(195, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(195, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_196_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(196, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(196, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_197_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(197, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(197, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_198_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(198, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(198, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_199_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(199, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(199, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_200_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(200, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(200, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_201_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(201, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(201, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_202_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(202, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(202, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_203_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(203, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(203, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_204_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(204, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(204, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_205_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(205, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(205, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_206_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(206, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(206, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_207_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(207, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(207, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_208_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(208, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(208, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_209_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(209, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(209, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_210_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(210, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(210, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_211_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(211, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(211, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_212_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(212, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(212, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_213_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(213, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(213, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_214_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(214, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(214, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_215_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(215, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(215, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_216_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(216, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(216, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_217_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(217, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(217, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_218_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(218, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(218, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_219_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(219, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(219, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_220_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(220, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(220, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_221_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(221, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(221, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_222_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(222, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(222, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_223_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(223, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(223, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_224_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(224, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(224, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_225_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(225, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(225, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_226_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(226, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(226, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_227_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(227, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(227, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_228_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(228, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(228, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_229_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(229, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(229, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_230_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(230, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(230, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_231_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(231, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(231, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_232_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(232, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(232, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_233_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(233, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(233, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_234_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(234, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(234, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_235_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(235, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(235, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_236_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(236, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(236, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_237_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(237, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(237, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_238_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(238, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(238, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_239_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(239, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(239, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_240_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(240, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(240, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_241_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(241, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(241, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_242_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(242, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(242, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_243_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(243, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(243, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_244_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(244, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(244, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_245_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(245, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(245, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_246_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(246, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(246, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_247_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(247, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(247, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_248_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(248, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(248, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_249_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(249, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(249, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_250_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(250, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(250, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_251_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(251, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(251, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_252_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(252, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(252, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_253_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(253, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(253, seq)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_INC_254_N(r, seq) \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE( \ + BOOST_PP_SEQ_FIRST_N(254, seq) \ + , BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(BOOST_PP_SEQ_REST_N(254, seq)) \ + ) +/**/ + +#endif // include guard + diff --git a/boost/parameter/aux_/preprocessor/binary_seq_to_args.hpp b/boost/parameter/aux_/preprocessor/binary_seq_to_args.hpp new file mode 100644 index 0000000000..4b4ca6290a --- /dev/null +++ b/boost/parameter/aux_/preprocessor/binary_seq_to_args.hpp @@ -0,0 +1,65 @@ +// 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_AUX_PREPROCESSOR_BINARY_SEQ_TO_ARGS_HPP +#define BOOST_PARAMETER_AUX_PREPROCESSOR_BINARY_SEQ_TO_ARGS_HPP + +#include <boost/preprocessor/seq/elem.hpp> +#include <boost/preprocessor/cat.hpp> + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_TO_ARG_0_1(n, prefix_seq) \ + BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(0, prefix_seq), n) const& +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_TO_ARG_1_1(n, prefix_seq) \ + BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(0, prefix_seq), n)& +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_TO_ARG_0_2(n, prefix_seq) \ + BOOST_PARAMETER_AUX_PP_BINARY_SEQ_TO_ARG_0_1(n, prefix_seq) \ + BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(1, prefix_seq), n) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_TO_ARG_1_2(n, prefix_seq) \ + BOOST_PARAMETER_AUX_PP_BINARY_SEQ_TO_ARG_1_1(n, prefix_seq) \ + BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(1, prefix_seq), n) +/**/ + +#include <boost/preprocessor/seq/size.hpp> + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_TO_ARG_0(prefix_seq) \ + BOOST_PP_CAT( \ + BOOST_PARAMETER_AUX_PP_BINARY_SEQ_TO_ARG_0_ \ + , BOOST_PP_SEQ_SIZE(prefix_seq) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_TO_ARG_1(prefix_seq) \ + BOOST_PP_CAT( \ + BOOST_PARAMETER_AUX_PP_BINARY_SEQ_TO_ARG_1_ \ + , BOOST_PP_SEQ_SIZE(prefix_seq) \ + ) +/**/ + +#include <boost/parameter/aux_/preprocessor/convert_binary_seq.hpp> + +// This macro converts the specified Boost.Preprocessor sequence of 1s and 0s +// into a formal function parameter list. +// +// Example: +// BOOST_PARAMETER_AUX_PP_BINARY_SEQ_TO_ARGS((1)(0)(1)(0), (P)(p)) +// expands to +// P0 & p0, P1 const& p1, P2 & p2, P3 const& p3 +#define BOOST_PARAMETER_AUX_PP_BINARY_SEQ_TO_ARGS(binary_seq, prefix_seq) \ + BOOST_PARAMETER_AUX_PP_CONVERT_BINARY_SEQ( \ + binary_seq \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_TO_ARG_0(prefix_seq) \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_TO_ARG_1(prefix_seq) \ + , prefix_seq \ + ) +/**/ + +#endif // include guard + diff --git a/boost/parameter/aux_/preprocessor/convert_binary_seq.hpp b/boost/parameter/aux_/preprocessor/convert_binary_seq.hpp new file mode 100644 index 0000000000..64832b3d4b --- /dev/null +++ b/boost/parameter/aux_/preprocessor/convert_binary_seq.hpp @@ -0,0 +1,57 @@ +// Copyright Cromwell D. Enage 2013. +// 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_AUX_PREPROCESSOR_CONVERT_BINARY_SEQ_HPP +#define BOOST_PARAMETER_AUX_PREPROCESSOR_CONVERT_BINARY_SEQ_HPP + +#include <boost/preprocessor/seq/size.hpp> +#include <boost/preprocessor/seq/push_back.hpp> + +#define BOOST_PARAMETER_AUX_PP_AUGMENT_BINARY_SEQ_INDEX_FOLD_OP(s, seq, idx) \ + BOOST_PP_SEQ_PUSH_BACK(seq, (idx, BOOST_PP_SEQ_SIZE(seq))) +/**/ + +#include <boost/preprocessor/control/iif.hpp> +#include <boost/preprocessor/seq/elem.hpp> +#include <boost/preprocessor/tuple/elem.hpp> + +#define BOOST_PARAMETER_AUX_PP_CONVERT_BINARY_SEQ_FOLD_OP(s, seq, elem) \ + ( \ + BOOST_PP_SEQ_PUSH_BACK( \ + BOOST_PP_SEQ_ELEM(0, seq) \ + , BOOST_PP_IIF( \ + BOOST_PP_TUPLE_ELEM(2, 0, elem) \ + , BOOST_PP_SEQ_ELEM(2, seq) \ + , BOOST_PP_SEQ_ELEM(1, seq) \ + )(BOOST_PP_TUPLE_ELEM(2, 1, elem), BOOST_PP_SEQ_ELEM(3, seq)) \ + ) \ + )(BOOST_PP_SEQ_ELEM(1, seq))(BOOST_PP_SEQ_ELEM(2, seq)) \ + (BOOST_PP_SEQ_ELEM(3, seq)) +/**/ + +#include <boost/parameter/aux_/preprocessor/seq_enum.hpp> +#include <boost/preprocessor/facilities/empty.hpp> +#include <boost/preprocessor/seq/seq.hpp> +#include <boost/preprocessor/seq/fold_left.hpp> + +#define BOOST_PARAMETER_AUX_PP_CONVERT_BINARY_SEQ(seq, macro0, macro1, data) \ + BOOST_PARAMETER_SEQ_ENUM( \ + BOOST_PP_SEQ_ELEM( \ + 0 \ + , BOOST_PP_SEQ_FOLD_LEFT( \ + BOOST_PARAMETER_AUX_PP_CONVERT_BINARY_SEQ_FOLD_OP \ + , (BOOST_PP_SEQ_NIL)(macro0)(macro1)(data) \ + , BOOST_PP_SEQ_FOLD_LEFT( \ + BOOST_PARAMETER_AUX_PP_AUGMENT_BINARY_SEQ_INDEX_FOLD_OP \ + , BOOST_PP_EMPTY() \ + , seq \ + ) \ + ) \ + ) \ + ) +/**/ + +#endif // include guard + diff --git a/boost/parameter/aux_/preprocessor/flatten.hpp b/boost/parameter/aux_/preprocessor/flatten.hpp index 5d7615e3f3..876a928bfd 100644 --- a/boost/parameter/aux_/preprocessor/flatten.hpp +++ b/boost/parameter/aux_/preprocessor/flatten.hpp @@ -1,115 +1,12 @@ -// Copyright Daniel Wallin 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 http://www.boost.org/LICENSE_1_0.txt) +// Copyright Daniel Wallin 2005. +// 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_FLATTEN_051217_HPP -# define BOOST_PARAMETER_FLATTEN_051217_HPP +#define BOOST_PARAMETER_FLATTEN_051217_HPP -# include <boost/preprocessor/tuple/elem.hpp> -# include <boost/preprocessor/tuple/rem.hpp> -# include <boost/preprocessor/cat.hpp> -# include <boost/preprocessor/seq/for_each.hpp> -# include <boost/preprocessor/seq/for_each_i.hpp> -# include <boost/preprocessor/identity.hpp> -# include <boost/preprocessor/selection/max.hpp> -# include <boost/preprocessor/arithmetic/sub.hpp> -# include <boost/preprocessor/repetition/enum_trailing.hpp> -# include <boost/parameter/aux_/preprocessor/for_each.hpp> +#include <boost/parameter/aux_/preprocessor/impl/flatten.hpp> -# define BOOST_PARAMETER_FLATTEN_SPLIT_required required, -# define BOOST_PARAMETER_FLATTEN_SPLIT_optional optional, -# define BOOST_PARAMETER_FLATTEN_SPLIT_deduced deduced, - -# define BOOST_PARAMETER_FLATTEN_SPLIT(sub) \ - BOOST_PP_CAT(BOOST_PARAMETER_FLATTEN_SPLIT_, sub) - -# define BOOST_PARAMETER_FLATTEN_QUALIFIER(sub) \ - BOOST_PP_SPLIT(0, BOOST_PARAMETER_FLATTEN_SPLIT(sub)) - -# define BOOST_PARAMETER_FLATTEN_ARGS(sub) \ - BOOST_PP_SPLIT(1, BOOST_PARAMETER_FLATTEN_SPLIT(sub)) - -# define BOOST_PARAMETER_FLATTEN_ARITY_optional(arities) \ - BOOST_PP_TUPLE_ELEM(3,0,arities) - -# define BOOST_PARAMETER_FLATTEN_ARITY_required(arities) \ - BOOST_PP_TUPLE_ELEM(3,1,arities) - -# define BOOST_PARAMETER_FLATTEN_SPEC0_DUMMY_ELEM(z, n, data) ~ -# define BOOST_PARAMETER_FLATTEN_SPEC0(r, n, elem, data) \ - (( \ - BOOST_PP_TUPLE_ELEM(3,2,data) \ - , BOOST_PP_TUPLE_REM(BOOST_PP_TUPLE_ELEM(3,0,data)) elem \ - BOOST_PP_ENUM_TRAILING( \ - BOOST_PP_SUB( \ - BOOST_PP_TUPLE_ELEM(3,1,data) \ - , BOOST_PP_TUPLE_ELEM(3,0,data) \ - ) \ - , BOOST_PARAMETER_FLATTEN_SPEC0_DUMMY_ELEM \ - , ~ \ - ) \ - )) - -# define BOOST_PARAMETER_FLATTEN_SPEC_AUX(r, arity, max_arity, spec, transform) \ - BOOST_PARAMETER_FOR_EACH_R( \ - r \ - , arity \ - , BOOST_PARAMETER_FLATTEN_ARGS(spec) \ - , (arity, max_arity, transform(BOOST_PARAMETER_FLATTEN_QUALIFIER(spec))) \ - , BOOST_PARAMETER_FLATTEN_SPEC0 \ - ) - -# define BOOST_PARAMETER_FLATTEN_IDENTITY(x) x - -# define BOOST_PARAMETER_FLATTEN_SPEC_optional(r, arities, spec) \ - BOOST_PARAMETER_FLATTEN_SPEC_AUX( \ - r \ - , BOOST_PP_CAT( \ - BOOST_PARAMETER_FLATTEN_ARITY_, BOOST_PARAMETER_FLATTEN_QUALIFIER(spec) \ - )(arities) \ - , BOOST_PP_TUPLE_ELEM(3,2,arities) \ - , spec \ - , BOOST_PARAMETER_FLATTEN_IDENTITY \ - ) - -# define BOOST_PARAMETER_FLATTEN_SPEC_required(r, arities, spec) \ - BOOST_PARAMETER_FLATTEN_SPEC_optional(r, arities, spec) - -# define BOOST_PARAMETER_FLATTEN_SPEC_AS_DEDUCED(x) BOOST_PP_CAT(deduced_,x) - -# define BOOST_PARAMETER_FLATTEN_SPEC_deduced_M(r, arities, n, spec) \ - BOOST_PARAMETER_FLATTEN_SPEC_AUX( \ - r \ - , BOOST_PP_CAT( \ - BOOST_PARAMETER_FLATTEN_ARITY_, BOOST_PARAMETER_FLATTEN_QUALIFIER(spec) \ - )(arities) \ - , BOOST_PP_TUPLE_ELEM(3,2,arities) \ - , spec \ - , BOOST_PARAMETER_FLATTEN_SPEC_AS_DEDUCED \ - ) - -# define BOOST_PARAMETER_FLATTEN_SPEC_deduced(r, arities, spec) \ - BOOST_PP_SEQ_FOR_EACH_I_R( \ - r \ - , BOOST_PARAMETER_FLATTEN_SPEC_deduced_M \ - , arities \ - , BOOST_PARAMETER_FLATTEN_ARGS(spec) \ - ) - -# define BOOST_PARAMETER_FLATTEN_SPEC(r, arities, spec) \ - BOOST_PP_CAT( \ - BOOST_PARAMETER_FLATTEN_SPEC_, BOOST_PARAMETER_FLATTEN_QUALIFIER(spec) \ - )(r, arities, spec) - -# define BOOST_PARAMETER_FLATTEN(optional_arity, required_arity, wanted_arity, specs) \ - BOOST_PP_SEQ_FOR_EACH( \ - BOOST_PARAMETER_FLATTEN_SPEC \ - , ( \ - optional_arity, required_arity \ - , wanted_arity \ - ) \ - , specs \ - ) - -#endif // BOOST_PARAMETER_FLATTEN_051217_HPP +#endif // include guard diff --git a/boost/parameter/aux_/preprocessor/for_each.hpp b/boost/parameter/aux_/preprocessor/for_each.hpp index 0eb1f702db..221f45a785 100644 --- a/boost/parameter/aux_/preprocessor/for_each.hpp +++ b/boost/parameter/aux_/preprocessor/for_each.hpp @@ -1,103 +1,12 @@ -// Copyright Daniel Wallin 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 http://www.boost.org/LICENSE_1_0.txt) +// Copyright Daniel Wallin 2005. +// 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_FOR_EACH_051217_HPP -# define BOOST_PARAMETER_FOR_EACH_051217_HPP +#define BOOST_PARAMETER_FOR_EACH_051217_HPP -# include <boost/preprocessor/cat.hpp> -# include <boost/preprocessor/detail/split.hpp> -# include <boost/preprocessor/logical/not.hpp> -# include <boost/preprocessor/facilities/is_empty.hpp> -# include <boost/preprocessor/tuple/eat.hpp> -# include <boost/preprocessor/arithmetic/inc.hpp> -# include <boost/preprocessor/repeat.hpp> -# include <boost/preprocessor/punctuation/comma_if.hpp> -# include <boost/preprocessor/for.hpp> -# include <boost/preprocessor/repetition/deduce_r.hpp> +#include <boost/parameter/aux_/preprocessor/impl/for_each.hpp> -# define BOOST_PARAMETER_FOR_EACH_head_aux2(x,y) (x,y), ~ -# define BOOST_PARAMETER_FOR_EACH_head_aux3(x,y,z) (x,y,z), ~ -# define BOOST_PARAMETER_FOR_EACH_head_aux4(x,y,z,u) (x,y,z,u), ~ -# define BOOST_PARAMETER_FOR_EACH_head(n,x) \ - BOOST_PP_SPLIT(0, BOOST_PP_CAT(BOOST_PARAMETER_FOR_EACH_head_aux,n) x) - -# define BOOST_PARAMETER_FOR_EACH_pred_aux_BOOST_PARAMETER_FOR_EACH_END_SENTINEL -# define BOOST_PARAMETER_FOR_EACH_pred_aux_check(x) \ - BOOST_PP_NOT(BOOST_PP_IS_EMPTY( \ - BOOST_PP_CAT(BOOST_PARAMETER_FOR_EACH_pred_aux_, x) \ - )), ~ - -# define BOOST_PARAMETER_FOR_EACH_pred_aux2(x,y) \ - BOOST_PARAMETER_FOR_EACH_pred_aux_check(x) -# define BOOST_PARAMETER_FOR_EACH_pred_aux3(x,y,z) \ - BOOST_PARAMETER_FOR_EACH_pred_aux_check(x) -# define BOOST_PARAMETER_FOR_EACH_pred_aux4(x,y,z,u) \ - BOOST_PARAMETER_FOR_EACH_pred_aux_check(x) - -# define BOOST_PARAMETER_FOR_EACH_pred_aux0(n,x) \ - BOOST_PP_CAT(BOOST_PARAMETER_FOR_EACH_pred_aux,n) x - -# if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() -# define BOOST_PARAMETER_FOR_EACH_pred_SPLIT_FIRST(x) \ - BOOST_PP_SPLIT(0, x) - -# define BOOST_PARAMETER_FOR_EACH_pred(r, state) \ - BOOST_PARAMETER_FOR_EACH_pred_SPLIT_FIRST( \ - BOOST_PARAMETER_FOR_EACH_pred_aux0( \ - BOOST_PP_TUPLE_ELEM(5,3,state) \ - , BOOST_PP_TUPLE_ELEM(5,0,state) \ - ) \ - ) -# else -# define BOOST_PARAMETER_FOR_EACH_pred(r, state) \ - BOOST_PP_SPLIT( \ - 0 \ - , BOOST_PARAMETER_FOR_EACH_pred_aux0( \ - BOOST_PP_TUPLE_ELEM(5,3,state) \ - , BOOST_PP_TUPLE_ELEM(5,0,state) \ - ) \ - ) -# endif - -# define BOOST_PARAMETER_FOR_EACH_op(r, state) \ - ( \ - BOOST_PP_TUPLE_EAT(BOOST_PP_TUPLE_ELEM(5,3,state)) \ - BOOST_PP_TUPLE_ELEM(5,0,state) \ - , BOOST_PP_TUPLE_ELEM(5,1,state) \ - , BOOST_PP_TUPLE_ELEM(5,2,state) \ - , BOOST_PP_TUPLE_ELEM(5,3,state) \ - , BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(5,4,state)) \ - ) - -# define BOOST_PARAMETER_FOR_EACH_macro(r, state) \ - BOOST_PP_TUPLE_ELEM(5,2,state)( \ - r \ - , BOOST_PP_TUPLE_ELEM(5,4,state) \ - , BOOST_PARAMETER_FOR_EACH_head( \ - BOOST_PP_TUPLE_ELEM(5,3,state) \ - , BOOST_PP_TUPLE_ELEM(5,0,state) \ - ) \ - , BOOST_PP_TUPLE_ELEM(5,1,state) \ - ) - -# define BOOST_PARAMETER_FOR_EACH_build_end_sentinel(z,n,text) \ - BOOST_PP_COMMA_IF(n) BOOST_PARAMETER_FOR_EACH_END_SENTINEL -# define BOOST_PARAMETER_FOR_EACH_build_end_sentinel_tuple(arity) \ - ( \ - BOOST_PP_REPEAT(arity, BOOST_PARAMETER_FOR_EACH_build_end_sentinel, _) \ - ) - -# define BOOST_PARAMETER_FOR_EACH_R(r, arity, list, data, macro) \ - BOOST_PP_CAT(BOOST_PP_FOR_, r)( \ - (list BOOST_PARAMETER_FOR_EACH_build_end_sentinel_tuple(arity), data, macro, arity, 0) \ - , BOOST_PARAMETER_FOR_EACH_pred \ - , BOOST_PARAMETER_FOR_EACH_op \ - , BOOST_PARAMETER_FOR_EACH_macro \ - ) - -# define BOOST_PARAMETER_FOR_EACH(arity, list, data, macro) \ - BOOST_PARAMETER_FOR_EACH_R(BOOST_PP_DEDUCE_R(), arity, list, data, macro) - -#endif // BOOST_PARAMETER_FOR_EACH_051217_HPP +#endif // include guard diff --git a/boost/parameter/aux_/preprocessor/for_each_pred.hpp b/boost/parameter/aux_/preprocessor/for_each_pred.hpp new file mode 100644 index 0000000000..7d4c6368e6 --- /dev/null +++ b/boost/parameter/aux_/preprocessor/for_each_pred.hpp @@ -0,0 +1,1029 @@ +// 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_AUX_PREPROCESSOR_FOR_EACH_PRED_HPP +#define BOOST_PARAMETER_AUX_PREPROCESSOR_FOR_EACH_PRED_HPP + +#include <boost/preprocessor/comparison/not_equal.hpp> +#include <boost/preprocessor/seq/size.hpp> + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_1(r, seq) \ + BOOST_PP_NOT_EQUAL(2, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_2(r, seq) \ + BOOST_PP_NOT_EQUAL(3, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_3(r, seq) \ + BOOST_PP_NOT_EQUAL(4, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_4(r, seq) \ + BOOST_PP_NOT_EQUAL(5, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_5(r, seq) \ + BOOST_PP_NOT_EQUAL(6, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_6(r, seq) \ + BOOST_PP_NOT_EQUAL(7, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_7(r, seq) \ + BOOST_PP_NOT_EQUAL(8, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_8(r, seq) \ + BOOST_PP_NOT_EQUAL(9, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_9(r, seq) \ + BOOST_PP_NOT_EQUAL(10, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_10(r, seq) \ + BOOST_PP_NOT_EQUAL(11, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_11(r, seq) \ + BOOST_PP_NOT_EQUAL(12, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_12(r, seq) \ + BOOST_PP_NOT_EQUAL(13, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_13(r, seq) \ + BOOST_PP_NOT_EQUAL(14, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_14(r, seq) \ + BOOST_PP_NOT_EQUAL(15, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_15(r, seq) \ + BOOST_PP_NOT_EQUAL(16, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_16(r, seq) \ + BOOST_PP_NOT_EQUAL(17, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_17(r, seq) \ + BOOST_PP_NOT_EQUAL(18, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_18(r, seq) \ + BOOST_PP_NOT_EQUAL(19, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_19(r, seq) \ + BOOST_PP_NOT_EQUAL(20, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_20(r, seq) \ + BOOST_PP_NOT_EQUAL(21, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_21(r, seq) \ + BOOST_PP_NOT_EQUAL(22, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_22(r, seq) \ + BOOST_PP_NOT_EQUAL(23, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_23(r, seq) \ + BOOST_PP_NOT_EQUAL(24, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_24(r, seq) \ + BOOST_PP_NOT_EQUAL(25, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_25(r, seq) \ + BOOST_PP_NOT_EQUAL(26, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_26(r, seq) \ + BOOST_PP_NOT_EQUAL(27, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_27(r, seq) \ + BOOST_PP_NOT_EQUAL(28, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_28(r, seq) \ + BOOST_PP_NOT_EQUAL(29, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_29(r, seq) \ + BOOST_PP_NOT_EQUAL(30, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_30(r, seq) \ + BOOST_PP_NOT_EQUAL(31, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_31(r, seq) \ + BOOST_PP_NOT_EQUAL(32, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_32(r, seq) \ + BOOST_PP_NOT_EQUAL(33, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_33(r, seq) \ + BOOST_PP_NOT_EQUAL(34, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_34(r, seq) \ + BOOST_PP_NOT_EQUAL(35, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_35(r, seq) \ + BOOST_PP_NOT_EQUAL(36, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_36(r, seq) \ + BOOST_PP_NOT_EQUAL(37, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_37(r, seq) \ + BOOST_PP_NOT_EQUAL(38, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_38(r, seq) \ + BOOST_PP_NOT_EQUAL(39, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_39(r, seq) \ + BOOST_PP_NOT_EQUAL(40, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_40(r, seq) \ + BOOST_PP_NOT_EQUAL(41, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_41(r, seq) \ + BOOST_PP_NOT_EQUAL(42, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_42(r, seq) \ + BOOST_PP_NOT_EQUAL(43, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_43(r, seq) \ + BOOST_PP_NOT_EQUAL(44, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_44(r, seq) \ + BOOST_PP_NOT_EQUAL(45, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_45(r, seq) \ + BOOST_PP_NOT_EQUAL(46, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_46(r, seq) \ + BOOST_PP_NOT_EQUAL(47, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_47(r, seq) \ + BOOST_PP_NOT_EQUAL(48, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_48(r, seq) \ + BOOST_PP_NOT_EQUAL(49, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_49(r, seq) \ + BOOST_PP_NOT_EQUAL(50, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_50(r, seq) \ + BOOST_PP_NOT_EQUAL(51, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_51(r, seq) \ + BOOST_PP_NOT_EQUAL(52, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_52(r, seq) \ + BOOST_PP_NOT_EQUAL(53, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_53(r, seq) \ + BOOST_PP_NOT_EQUAL(54, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_54(r, seq) \ + BOOST_PP_NOT_EQUAL(55, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_55(r, seq) \ + BOOST_PP_NOT_EQUAL(56, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_56(r, seq) \ + BOOST_PP_NOT_EQUAL(57, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_57(r, seq) \ + BOOST_PP_NOT_EQUAL(58, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_58(r, seq) \ + BOOST_PP_NOT_EQUAL(59, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_59(r, seq) \ + BOOST_PP_NOT_EQUAL(60, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_60(r, seq) \ + BOOST_PP_NOT_EQUAL(61, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_61(r, seq) \ + BOOST_PP_NOT_EQUAL(62, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_62(r, seq) \ + BOOST_PP_NOT_EQUAL(63, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_63(r, seq) \ + BOOST_PP_NOT_EQUAL(64, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_64(r, seq) \ + BOOST_PP_NOT_EQUAL(65, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_65(r, seq) \ + BOOST_PP_NOT_EQUAL(66, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_66(r, seq) \ + BOOST_PP_NOT_EQUAL(67, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_67(r, seq) \ + BOOST_PP_NOT_EQUAL(68, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_68(r, seq) \ + BOOST_PP_NOT_EQUAL(69, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_69(r, seq) \ + BOOST_PP_NOT_EQUAL(70, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_70(r, seq) \ + BOOST_PP_NOT_EQUAL(71, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_71(r, seq) \ + BOOST_PP_NOT_EQUAL(72, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_72(r, seq) \ + BOOST_PP_NOT_EQUAL(73, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_73(r, seq) \ + BOOST_PP_NOT_EQUAL(74, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_74(r, seq) \ + BOOST_PP_NOT_EQUAL(75, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_75(r, seq) \ + BOOST_PP_NOT_EQUAL(76, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_76(r, seq) \ + BOOST_PP_NOT_EQUAL(77, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_77(r, seq) \ + BOOST_PP_NOT_EQUAL(78, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_78(r, seq) \ + BOOST_PP_NOT_EQUAL(79, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_79(r, seq) \ + BOOST_PP_NOT_EQUAL(80, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_80(r, seq) \ + BOOST_PP_NOT_EQUAL(81, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_81(r, seq) \ + BOOST_PP_NOT_EQUAL(82, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_82(r, seq) \ + BOOST_PP_NOT_EQUAL(83, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_83(r, seq) \ + BOOST_PP_NOT_EQUAL(84, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_84(r, seq) \ + BOOST_PP_NOT_EQUAL(85, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_85(r, seq) \ + BOOST_PP_NOT_EQUAL(86, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_86(r, seq) \ + BOOST_PP_NOT_EQUAL(87, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_87(r, seq) \ + BOOST_PP_NOT_EQUAL(88, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_88(r, seq) \ + BOOST_PP_NOT_EQUAL(89, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_89(r, seq) \ + BOOST_PP_NOT_EQUAL(90, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_90(r, seq) \ + BOOST_PP_NOT_EQUAL(91, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_91(r, seq) \ + BOOST_PP_NOT_EQUAL(92, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_92(r, seq) \ + BOOST_PP_NOT_EQUAL(93, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_93(r, seq) \ + BOOST_PP_NOT_EQUAL(94, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_94(r, seq) \ + BOOST_PP_NOT_EQUAL(95, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_95(r, seq) \ + BOOST_PP_NOT_EQUAL(96, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_96(r, seq) \ + BOOST_PP_NOT_EQUAL(97, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_97(r, seq) \ + BOOST_PP_NOT_EQUAL(98, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_98(r, seq) \ + BOOST_PP_NOT_EQUAL(99, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_99(r, seq) \ + BOOST_PP_NOT_EQUAL(100, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_100(r, seq) \ + BOOST_PP_NOT_EQUAL(101, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_101(r, seq) \ + BOOST_PP_NOT_EQUAL(102, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_102(r, seq) \ + BOOST_PP_NOT_EQUAL(103, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_103(r, seq) \ + BOOST_PP_NOT_EQUAL(104, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_104(r, seq) \ + BOOST_PP_NOT_EQUAL(105, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_105(r, seq) \ + BOOST_PP_NOT_EQUAL(106, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_106(r, seq) \ + BOOST_PP_NOT_EQUAL(107, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_107(r, seq) \ + BOOST_PP_NOT_EQUAL(108, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_108(r, seq) \ + BOOST_PP_NOT_EQUAL(109, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_109(r, seq) \ + BOOST_PP_NOT_EQUAL(110, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_110(r, seq) \ + BOOST_PP_NOT_EQUAL(111, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_111(r, seq) \ + BOOST_PP_NOT_EQUAL(112, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_112(r, seq) \ + BOOST_PP_NOT_EQUAL(113, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_113(r, seq) \ + BOOST_PP_NOT_EQUAL(114, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_114(r, seq) \ + BOOST_PP_NOT_EQUAL(115, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_115(r, seq) \ + BOOST_PP_NOT_EQUAL(116, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_116(r, seq) \ + BOOST_PP_NOT_EQUAL(117, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_117(r, seq) \ + BOOST_PP_NOT_EQUAL(118, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_118(r, seq) \ + BOOST_PP_NOT_EQUAL(119, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_119(r, seq) \ + BOOST_PP_NOT_EQUAL(120, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_120(r, seq) \ + BOOST_PP_NOT_EQUAL(121, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_121(r, seq) \ + BOOST_PP_NOT_EQUAL(122, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_122(r, seq) \ + BOOST_PP_NOT_EQUAL(123, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_123(r, seq) \ + BOOST_PP_NOT_EQUAL(124, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_124(r, seq) \ + BOOST_PP_NOT_EQUAL(125, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_125(r, seq) \ + BOOST_PP_NOT_EQUAL(126, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_126(r, seq) \ + BOOST_PP_NOT_EQUAL(127, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_127(r, seq) \ + BOOST_PP_NOT_EQUAL(128, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_128(r, seq) \ + BOOST_PP_NOT_EQUAL(129, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_129(r, seq) \ + BOOST_PP_NOT_EQUAL(130, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_130(r, seq) \ + BOOST_PP_NOT_EQUAL(131, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_131(r, seq) \ + BOOST_PP_NOT_EQUAL(132, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_132(r, seq) \ + BOOST_PP_NOT_EQUAL(133, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_133(r, seq) \ + BOOST_PP_NOT_EQUAL(134, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_134(r, seq) \ + BOOST_PP_NOT_EQUAL(135, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_135(r, seq) \ + BOOST_PP_NOT_EQUAL(136, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_136(r, seq) \ + BOOST_PP_NOT_EQUAL(137, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_137(r, seq) \ + BOOST_PP_NOT_EQUAL(138, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_138(r, seq) \ + BOOST_PP_NOT_EQUAL(139, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_139(r, seq) \ + BOOST_PP_NOT_EQUAL(140, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_140(r, seq) \ + BOOST_PP_NOT_EQUAL(141, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_141(r, seq) \ + BOOST_PP_NOT_EQUAL(142, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_142(r, seq) \ + BOOST_PP_NOT_EQUAL(143, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_143(r, seq) \ + BOOST_PP_NOT_EQUAL(144, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_144(r, seq) \ + BOOST_PP_NOT_EQUAL(145, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_145(r, seq) \ + BOOST_PP_NOT_EQUAL(146, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_146(r, seq) \ + BOOST_PP_NOT_EQUAL(147, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_147(r, seq) \ + BOOST_PP_NOT_EQUAL(148, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_148(r, seq) \ + BOOST_PP_NOT_EQUAL(149, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_149(r, seq) \ + BOOST_PP_NOT_EQUAL(150, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_150(r, seq) \ + BOOST_PP_NOT_EQUAL(151, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_151(r, seq) \ + BOOST_PP_NOT_EQUAL(152, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_152(r, seq) \ + BOOST_PP_NOT_EQUAL(153, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_153(r, seq) \ + BOOST_PP_NOT_EQUAL(154, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_154(r, seq) \ + BOOST_PP_NOT_EQUAL(155, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_155(r, seq) \ + BOOST_PP_NOT_EQUAL(156, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_156(r, seq) \ + BOOST_PP_NOT_EQUAL(157, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_157(r, seq) \ + BOOST_PP_NOT_EQUAL(158, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_158(r, seq) \ + BOOST_PP_NOT_EQUAL(159, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_159(r, seq) \ + BOOST_PP_NOT_EQUAL(160, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_160(r, seq) \ + BOOST_PP_NOT_EQUAL(161, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_161(r, seq) \ + BOOST_PP_NOT_EQUAL(162, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_162(r, seq) \ + BOOST_PP_NOT_EQUAL(163, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_163(r, seq) \ + BOOST_PP_NOT_EQUAL(164, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_164(r, seq) \ + BOOST_PP_NOT_EQUAL(165, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_165(r, seq) \ + BOOST_PP_NOT_EQUAL(166, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_166(r, seq) \ + BOOST_PP_NOT_EQUAL(167, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_167(r, seq) \ + BOOST_PP_NOT_EQUAL(168, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_168(r, seq) \ + BOOST_PP_NOT_EQUAL(169, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_169(r, seq) \ + BOOST_PP_NOT_EQUAL(170, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_170(r, seq) \ + BOOST_PP_NOT_EQUAL(171, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_171(r, seq) \ + BOOST_PP_NOT_EQUAL(172, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_172(r, seq) \ + BOOST_PP_NOT_EQUAL(173, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_173(r, seq) \ + BOOST_PP_NOT_EQUAL(174, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_174(r, seq) \ + BOOST_PP_NOT_EQUAL(175, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_175(r, seq) \ + BOOST_PP_NOT_EQUAL(176, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_176(r, seq) \ + BOOST_PP_NOT_EQUAL(177, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_177(r, seq) \ + BOOST_PP_NOT_EQUAL(178, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_178(r, seq) \ + BOOST_PP_NOT_EQUAL(179, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_179(r, seq) \ + BOOST_PP_NOT_EQUAL(180, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_180(r, seq) \ + BOOST_PP_NOT_EQUAL(181, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_181(r, seq) \ + BOOST_PP_NOT_EQUAL(182, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_182(r, seq) \ + BOOST_PP_NOT_EQUAL(183, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_183(r, seq) \ + BOOST_PP_NOT_EQUAL(184, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_184(r, seq) \ + BOOST_PP_NOT_EQUAL(185, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_185(r, seq) \ + BOOST_PP_NOT_EQUAL(186, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_186(r, seq) \ + BOOST_PP_NOT_EQUAL(187, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_187(r, seq) \ + BOOST_PP_NOT_EQUAL(188, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_188(r, seq) \ + BOOST_PP_NOT_EQUAL(189, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_189(r, seq) \ + BOOST_PP_NOT_EQUAL(190, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_190(r, seq) \ + BOOST_PP_NOT_EQUAL(191, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_191(r, seq) \ + BOOST_PP_NOT_EQUAL(192, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_192(r, seq) \ + BOOST_PP_NOT_EQUAL(193, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_193(r, seq) \ + BOOST_PP_NOT_EQUAL(194, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_194(r, seq) \ + BOOST_PP_NOT_EQUAL(195, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_195(r, seq) \ + BOOST_PP_NOT_EQUAL(196, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_196(r, seq) \ + BOOST_PP_NOT_EQUAL(197, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_197(r, seq) \ + BOOST_PP_NOT_EQUAL(198, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_198(r, seq) \ + BOOST_PP_NOT_EQUAL(199, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_199(r, seq) \ + BOOST_PP_NOT_EQUAL(200, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_200(r, seq) \ + BOOST_PP_NOT_EQUAL(201, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_201(r, seq) \ + BOOST_PP_NOT_EQUAL(202, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_202(r, seq) \ + BOOST_PP_NOT_EQUAL(203, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_203(r, seq) \ + BOOST_PP_NOT_EQUAL(204, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_204(r, seq) \ + BOOST_PP_NOT_EQUAL(205, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_205(r, seq) \ + BOOST_PP_NOT_EQUAL(206, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_206(r, seq) \ + BOOST_PP_NOT_EQUAL(207, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_207(r, seq) \ + BOOST_PP_NOT_EQUAL(208, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_208(r, seq) \ + BOOST_PP_NOT_EQUAL(209, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_209(r, seq) \ + BOOST_PP_NOT_EQUAL(210, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_210(r, seq) \ + BOOST_PP_NOT_EQUAL(211, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_211(r, seq) \ + BOOST_PP_NOT_EQUAL(212, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_212(r, seq) \ + BOOST_PP_NOT_EQUAL(213, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_213(r, seq) \ + BOOST_PP_NOT_EQUAL(214, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_214(r, seq) \ + BOOST_PP_NOT_EQUAL(215, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_215(r, seq) \ + BOOST_PP_NOT_EQUAL(216, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_216(r, seq) \ + BOOST_PP_NOT_EQUAL(217, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_217(r, seq) \ + BOOST_PP_NOT_EQUAL(218, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_218(r, seq) \ + BOOST_PP_NOT_EQUAL(219, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_219(r, seq) \ + BOOST_PP_NOT_EQUAL(220, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_220(r, seq) \ + BOOST_PP_NOT_EQUAL(221, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_221(r, seq) \ + BOOST_PP_NOT_EQUAL(222, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_222(r, seq) \ + BOOST_PP_NOT_EQUAL(223, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_223(r, seq) \ + BOOST_PP_NOT_EQUAL(224, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_224(r, seq) \ + BOOST_PP_NOT_EQUAL(225, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_225(r, seq) \ + BOOST_PP_NOT_EQUAL(226, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_226(r, seq) \ + BOOST_PP_NOT_EQUAL(227, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_227(r, seq) \ + BOOST_PP_NOT_EQUAL(228, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_228(r, seq) \ + BOOST_PP_NOT_EQUAL(229, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_229(r, seq) \ + BOOST_PP_NOT_EQUAL(230, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_230(r, seq) \ + BOOST_PP_NOT_EQUAL(231, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_231(r, seq) \ + BOOST_PP_NOT_EQUAL(232, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_232(r, seq) \ + BOOST_PP_NOT_EQUAL(233, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_233(r, seq) \ + BOOST_PP_NOT_EQUAL(234, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_234(r, seq) \ + BOOST_PP_NOT_EQUAL(235, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_235(r, seq) \ + BOOST_PP_NOT_EQUAL(236, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_236(r, seq) \ + BOOST_PP_NOT_EQUAL(237, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_237(r, seq) \ + BOOST_PP_NOT_EQUAL(238, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_238(r, seq) \ + BOOST_PP_NOT_EQUAL(239, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_239(r, seq) \ + BOOST_PP_NOT_EQUAL(240, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_240(r, seq) \ + BOOST_PP_NOT_EQUAL(241, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_241(r, seq) \ + BOOST_PP_NOT_EQUAL(242, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_242(r, seq) \ + BOOST_PP_NOT_EQUAL(243, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_243(r, seq) \ + BOOST_PP_NOT_EQUAL(244, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_244(r, seq) \ + BOOST_PP_NOT_EQUAL(245, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_245(r, seq) \ + BOOST_PP_NOT_EQUAL(246, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_246(r, seq) \ + BOOST_PP_NOT_EQUAL(247, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_247(r, seq) \ + BOOST_PP_NOT_EQUAL(248, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_248(r, seq) \ + BOOST_PP_NOT_EQUAL(249, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_249(r, seq) \ + BOOST_PP_NOT_EQUAL(250, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_250(r, seq) \ + BOOST_PP_NOT_EQUAL(251, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_251(r, seq) \ + BOOST_PP_NOT_EQUAL(252, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_252(r, seq) \ + BOOST_PP_NOT_EQUAL(253, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_253(r, seq) \ + BOOST_PP_NOT_EQUAL(254, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_PRED_254(r, seq) \ + BOOST_PP_NOT_EQUAL(255, BOOST_PP_SEQ_SIZE(seq)) +/**/ + +#endif // include guard + diff --git a/boost/parameter/aux_/preprocessor/impl/argument_specs.hpp b/boost/parameter/aux_/preprocessor/impl/argument_specs.hpp new file mode 100644 index 0000000000..1efce38864 --- /dev/null +++ b/boost/parameter/aux_/preprocessor/impl/argument_specs.hpp @@ -0,0 +1,24 @@ +// Copyright Daniel Wallin 2006. +// 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_AUX_PREPROCESSOR_IMPL_ARGUMENT_SPECS_HPP +#define BOOST_PARAMETER_AUX_PREPROCESSOR_IMPL_ARGUMENT_SPECS_HPP + +#include <boost/preprocessor/tuple/elem.hpp> + +// Accessor macros for the argument specs tuple. +#define BOOST_PARAMETER_FN_ARG_QUALIFIER(x) BOOST_PP_TUPLE_ELEM(4, 0, x) +#define BOOST_PARAMETER_FN_ARG_KEYWORD(x) BOOST_PP_TUPLE_ELEM(4, 1, x) +#define BOOST_PARAMETER_FN_ARG_PRED(x) BOOST_PP_TUPLE_ELEM(4, 2, x) +#define BOOST_PARAMETER_FN_ARG_DEFAULT(x) BOOST_PP_TUPLE_ELEM(4, 3, x) + +#include <boost/parameter/aux_/preprocessor/qualifier.hpp> + +#define BOOST_PARAMETER_FN_ARG_NAME(x) \ + BOOST_PARAMETER_UNQUALIFIED(BOOST_PARAMETER_FN_ARG_KEYWORD(x)) +/**/ + +#endif // include guard + diff --git a/boost/parameter/aux_/preprocessor/impl/arity_range.hpp b/boost/parameter/aux_/preprocessor/impl/arity_range.hpp new file mode 100644 index 0000000000..848648e4cc --- /dev/null +++ b/boost/parameter/aux_/preprocessor/impl/arity_range.hpp @@ -0,0 +1,42 @@ +// Copyright Daniel Wallin 2006. +// 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_AUX_PREPROCESSOR_IMPL_ARITY_RANGE_HPP +#define BOOST_PARAMETER_AUX_PREPROCESSOR_IMPL_ARITY_RANGE_HPP + +// Helper macros for BOOST_PARAMETER_ARITY_RANGE. +#define BOOST_PARAMETER_ARITY_RANGE_M_optional(state) state +#define BOOST_PARAMETER_ARITY_RANGE_M_deduced_optional(state) state + +#include <boost/preprocessor/arithmetic/inc.hpp> + +#define BOOST_PARAMETER_ARITY_RANGE_M_required(state) BOOST_PP_INC(state) +#define BOOST_PARAMETER_ARITY_RANGE_M_deduced_required(state) \ + BOOST_PP_INC(state) +/**/ + +#include <boost/parameter/aux_/preprocessor/impl/argument_specs.hpp> +#include <boost/preprocessor/cat.hpp> + +#define BOOST_PARAMETER_ARITY_RANGE_M(s, state, x) \ + BOOST_PP_CAT( \ + BOOST_PARAMETER_ARITY_RANGE_M_ \ + , BOOST_PARAMETER_FN_ARG_QUALIFIER(x) \ + )(state) +/**/ + +#include <boost/preprocessor/seq/fold_left.hpp> +#include <boost/preprocessor/seq/size.hpp> + +// Calculates [begin, end) arity range. +#define BOOST_PARAMETER_ARITY_RANGE(args) \ + ( \ + BOOST_PP_SEQ_FOLD_LEFT(BOOST_PARAMETER_ARITY_RANGE_M, 0, args) \ + , BOOST_PP_INC(BOOST_PP_SEQ_SIZE(args)) \ + ) +/**/ + +#endif // include guard + diff --git a/boost/parameter/aux_/preprocessor/impl/flatten.hpp b/boost/parameter/aux_/preprocessor/impl/flatten.hpp new file mode 100644 index 0000000000..0d23a0c3b3 --- /dev/null +++ b/boost/parameter/aux_/preprocessor/impl/flatten.hpp @@ -0,0 +1,143 @@ +// Copyright Daniel Wallin 2005. +// 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_AUX_PREPROCESSOR_IMPL_FLATTEN_HPP +#define BOOST_PARAMETER_AUX_PREPROCESSOR_IMPL_FLATTEN_HPP + +#define BOOST_PARAMETER_AUX_PP_FLATTEN_SPLIT_required required, +#define BOOST_PARAMETER_AUX_PP_FLATTEN_SPLIT_optional optional, +#define BOOST_PARAMETER_AUX_PP_FLATTEN_SPLIT_deduced deduced, +#define BOOST_PARAMETER_AUX_PP_FLATTEN_IDENTITY(x) x +#define BOOST_PARAMETER_AUX_PP_FLATTEN_SPEC0_DUMMY_ELEM(z, n, data) ~ + +#include <boost/preprocessor/cat.hpp> + +#define BOOST_PARAMETER_AUX_PP_FLATTEN_SPLIT(sub) \ + BOOST_PP_CAT(BOOST_PARAMETER_AUX_PP_FLATTEN_SPLIT_, sub) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FLATTEN_SPEC_AS_DEDUCED(x) \ + BOOST_PP_CAT(deduced_, x) +/**/ + +#include <boost/preprocessor/detail/split.hpp> + +#define BOOST_PARAMETER_AUX_PP_FLATTEN_QUALIFIER(sub) \ + BOOST_PP_SPLIT(0, BOOST_PARAMETER_AUX_PP_FLATTEN_SPLIT(sub)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FLATTEN_ARGS(sub) \ + BOOST_PP_SPLIT(1, BOOST_PARAMETER_AUX_PP_FLATTEN_SPLIT(sub)) +/**/ + +#include <boost/preprocessor/tuple/elem.hpp> + +#define BOOST_PARAMETER_AUX_PP_FLATTEN_ARITY_optional(arities) \ + BOOST_PP_TUPLE_ELEM(3, 0, arities) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FLATTEN_ARITY_required(arities) \ + BOOST_PP_TUPLE_ELEM(3, 1, arities) +/**/ + +#include <boost/preprocessor/arithmetic/sub.hpp> +#include <boost/preprocessor/repetition/enum_trailing.hpp> +#include <boost/preprocessor/tuple/rem.hpp> + +#define BOOST_PARAMETER_AUX_PP_FLATTEN_SPEC0(r, n, elem, data) \ + (( \ + BOOST_PP_TUPLE_ELEM(3, 2, data) \ + , BOOST_PP_TUPLE_REM(BOOST_PP_TUPLE_ELEM(3, 0, data)) elem \ + BOOST_PP_ENUM_TRAILING( \ + BOOST_PP_SUB( \ + BOOST_PP_TUPLE_ELEM(3, 1, data) \ + , BOOST_PP_TUPLE_ELEM(3, 0, data) \ + ) \ + , BOOST_PARAMETER_AUX_PP_FLATTEN_SPEC0_DUMMY_ELEM \ + , ~ \ + ) \ + )) +/**/ + +#include <boost/parameter/aux_/preprocessor/impl/for_each.hpp> + +#define BOOST_PARAMETER_AUX_PP_FLATTEN_SPEC_AUX( \ + r, arity, max_arity, spec, xform \ +) \ + BOOST_PARAMETER_AUX_PP_FOR_EACH_R( \ + r \ + , arity \ + , BOOST_PARAMETER_AUX_PP_FLATTEN_ARGS(spec) \ + , ( \ + arity \ + , max_arity \ + , xform(BOOST_PARAMETER_AUX_PP_FLATTEN_QUALIFIER(spec)) \ + ) \ + , BOOST_PARAMETER_AUX_PP_FLATTEN_SPEC0 \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FLATTEN_SPEC_optional(r, arities, spec) \ + BOOST_PARAMETER_AUX_PP_FLATTEN_SPEC_AUX( \ + r \ + , BOOST_PP_CAT( \ + BOOST_PARAMETER_AUX_PP_FLATTEN_ARITY_ \ + , BOOST_PARAMETER_AUX_PP_FLATTEN_QUALIFIER(spec) \ + )(arities) \ + , BOOST_PP_TUPLE_ELEM(3, 2, arities) \ + , spec \ + , BOOST_PARAMETER_AUX_PP_FLATTEN_IDENTITY \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FLATTEN_SPEC_required(r, arities, spec) \ + BOOST_PARAMETER_AUX_PP_FLATTEN_SPEC_optional(r, arities, spec) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FLATTEN_SPEC_deduced_M(r, arities, n, spec) \ + BOOST_PARAMETER_AUX_PP_FLATTEN_SPEC_AUX( \ + r \ + , BOOST_PP_CAT( \ + BOOST_PARAMETER_AUX_PP_FLATTEN_ARITY_ \ + , BOOST_PARAMETER_AUX_PP_FLATTEN_QUALIFIER(spec) \ + )(arities) \ + , BOOST_PP_TUPLE_ELEM(3, 2, arities) \ + , spec \ + , BOOST_PARAMETER_AUX_PP_FLATTEN_SPEC_AS_DEDUCED \ + ) +/**/ + +#include <boost/preprocessor/seq/for_each_i.hpp> + +#define BOOST_PARAMETER_AUX_PP_FLATTEN_SPEC_deduced(r, arities, spec) \ + BOOST_PP_SEQ_FOR_EACH_I_R( \ + r \ + , BOOST_PARAMETER_AUX_PP_FLATTEN_SPEC_deduced_M \ + , arities \ + , BOOST_PARAMETER_AUX_PP_FLATTEN_ARGS(spec) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FLATTEN_SPEC(r, arities, spec) \ + BOOST_PP_CAT( \ + BOOST_PARAMETER_AUX_PP_FLATTEN_SPEC_ \ + , BOOST_PARAMETER_AUX_PP_FLATTEN_QUALIFIER(spec) \ + )(r, arities, spec) +/**/ + +#include <boost/preprocessor/seq/for_each.hpp> + +#define BOOST_PARAMETER_AUX_PP_FLATTEN( \ + opt_arity, req_arity, wanted_arity, specs \ +) \ + BOOST_PP_SEQ_FOR_EACH( \ + BOOST_PARAMETER_AUX_PP_FLATTEN_SPEC \ + , (opt_arity, req_arity, wanted_arity) \ + , specs \ + ) +/**/ + +#endif // include guard + diff --git a/boost/parameter/aux_/preprocessor/impl/for_each.hpp b/boost/parameter/aux_/preprocessor/impl/for_each.hpp new file mode 100644 index 0000000000..b6ece207f2 --- /dev/null +++ b/boost/parameter/aux_/preprocessor/impl/for_each.hpp @@ -0,0 +1,152 @@ +// Copyright Daniel Wallin 2005. +// 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_AUX_PREPROCESSOR_IMPL_FOR_EACH_HPP +#define BOOST_PARAMETER_AUX_PREPROCESSOR_IMPL_FOR_EACH_HPP + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_head_aux2(x, y) (x, y), ~ +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_head_aux3(x, y, z) (x, y, z), ~ +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_head_aux4(x, y, z, u) (x, y, z, u), ~ + +#define \ +BOOST_PARAMETER_AUX_PP_FOR_EACH_pred_aux_BOOST_PARAMETER_AUX_PP_FOR_EACH_END_S +/**/ + +#include <boost/preprocessor/detail/split.hpp> + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_pred_SPLIT_FIRST(x) \ + BOOST_PP_SPLIT(0, x) +/**/ + +#include <boost/preprocessor/cat.hpp> + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_head(n, x) \ + BOOST_PP_SPLIT( \ + 0 \ + , BOOST_PP_CAT(BOOST_PARAMETER_AUX_PP_FOR_EACH_head_aux, n) x \ + ) +/**/ + +#include <boost/preprocessor/facilities/is_empty.hpp> +#include <boost/preprocessor/logical/not.hpp> + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_pred_aux_check(x) \ + BOOST_PP_NOT(BOOST_PP_IS_EMPTY( \ + BOOST_PP_CAT(BOOST_PARAMETER_AUX_PP_FOR_EACH_pred_aux_, x) \ + )), ~ +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_pred_aux2(x, y) \ + BOOST_PARAMETER_AUX_PP_FOR_EACH_pred_aux_check(x) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_pred_aux3(x, y, z) \ + BOOST_PARAMETER_AUX_PP_FOR_EACH_pred_aux_check(x) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_pred_aux4(x, y, z, u) \ + BOOST_PARAMETER_AUX_PP_FOR_EACH_pred_aux_check(x) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_pred_aux0(n, x) \ + BOOST_PP_CAT(BOOST_PARAMETER_AUX_PP_FOR_EACH_pred_aux, n) x +/**/ + +#include <boost/preprocessor/tuple/elem.hpp> + +#if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_pred(r, state) \ + BOOST_PARAMETER_AUX_PP_FOR_EACH_pred_SPLIT_FIRST( \ + BOOST_PARAMETER_AUX_PP_FOR_EACH_pred_aux0( \ + BOOST_PP_TUPLE_ELEM(5, 3, state) \ + , BOOST_PP_TUPLE_ELEM(5, 0, state) \ + ) \ + ) +/**/ + +#else // !(BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC()) + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_pred(r, state) \ + BOOST_PP_SPLIT( \ + 0 \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_pred_aux0( \ + BOOST_PP_TUPLE_ELEM(5, 3, state) \ + , BOOST_PP_TUPLE_ELEM(5, 0, state) \ + ) \ + ) +/**/ + +#endif // BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() + +#include <boost/preprocessor/arithmetic/inc.hpp> +#include <boost/preprocessor/tuple/eat.hpp> + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_op(r, state) \ + ( \ + BOOST_PP_TUPLE_EAT(BOOST_PP_TUPLE_ELEM(5, 3, state)) \ + BOOST_PP_TUPLE_ELEM(5, 0, state) \ + , BOOST_PP_TUPLE_ELEM(5, 1, state) \ + , BOOST_PP_TUPLE_ELEM(5, 2, state) \ + , BOOST_PP_TUPLE_ELEM(5, 3, state) \ + , BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(5, 4, state)) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_macro(r, state) \ + BOOST_PP_TUPLE_ELEM(5, 2, state)( \ + r \ + , BOOST_PP_TUPLE_ELEM(5, 4, state) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_head( \ + BOOST_PP_TUPLE_ELEM(5, 3, state) \ + , BOOST_PP_TUPLE_ELEM(5, 0, state) \ + ) \ + , BOOST_PP_TUPLE_ELEM(5, 1, state) \ + ) +/**/ + +#include <boost/preprocessor/punctuation/comma_if.hpp> + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_build_end_sentinel(z, n, text) \ + BOOST_PP_COMMA_IF(n) BOOST_PARAMETER_AUX_PP_FOR_EACH_END_S +/**/ + +#include <boost/preprocessor/repetition/repeat.hpp> + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_build_end_sentinel_tuple(arity) \ + ( \ + BOOST_PP_REPEAT( \ + arity, BOOST_PARAMETER_AUX_PP_FOR_EACH_build_end_sentinel, _ \ + ) \ + ) +/**/ + +#include <boost/preprocessor/repetition/for.hpp> + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH_R(r, arity, list, data, macro) \ + BOOST_PP_CAT(BOOST_PP_FOR_, r)( \ + (list \ + BOOST_PARAMETER_AUX_PP_FOR_EACH_build_end_sentinel_tuple(arity) \ + , data \ + , macro \ + , arity \ + , 0 \ + ) \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_pred \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_op \ + , BOOST_PARAMETER_AUX_PP_FOR_EACH_macro \ + ) +/**/ + +#include <boost/preprocessor/repetition/deduce_r.hpp> + +#define BOOST_PARAMETER_AUX_PP_FOR_EACH(arity, list, data, macro) \ + BOOST_PARAMETER_AUX_PP_FOR_EACH_R( \ + BOOST_PP_DEDUCE_R(), arity, list, data, macro \ + ) +/**/ + +#endif // include guard + diff --git a/boost/parameter/aux_/preprocessor/impl/forwarding_overloads.hpp b/boost/parameter/aux_/preprocessor/impl/forwarding_overloads.hpp new file mode 100644 index 0000000000..f5eb7ab797 --- /dev/null +++ b/boost/parameter/aux_/preprocessor/impl/forwarding_overloads.hpp @@ -0,0 +1,509 @@ +// Copyright Daniel Wallin 2006. +// 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_AUX_PREPROCESSOR_IMPL_FORWARDING_OVERLOADS_HPP +#define BOOST_PARAMETER_AUX_PREPROCESSOR_IMPL_FORWARDING_OVERLOADS_HPP + +#include <boost/parameter/config.hpp> + +#if defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING) + +#include <boost/preprocessor/cat.hpp> + +// Expands to a forwarding parameter for a constructor or forwarding function. +#define BOOST_PARAMETER_FUNCTION_ARG_TYPE_Z(z, n, type_prefix) \ + BOOST_PP_CAT(type_prefix, n)&& +/**/ + +#include <utility> + +// Expands to an argument passed from a forwarding function to the front-end +// implementation function, or from a constructor to its delegate. +#define BOOST_PARAMETER_FUNCTION_FORWARD_PARAM_Z(z, n, type_prefix) \ + ::std::forward<BOOST_PP_CAT(type_prefix, n)>(BOOST_PP_CAT(a, n)) +/**/ + +#include <boost/parameter/aux_/preprocessor/impl/parenthesized_type.hpp> +#include <boost/preprocessor/tuple/elem.hpp> + +// Expands to the default constructor, whose job is to pass an empty back to +// the delegate constructor of the base class. +#define BOOST_PARAMETER_CONSTRUCTOR_OVERLOAD_0_Z(z, n, data) \ + inline BOOST_PP_TUPLE_ELEM(2, 0, data)() \ + : BOOST_PARAMETER_PARENTHESIZED_TYPE(BOOST_PP_TUPLE_ELEM(2, 1, data))( \ + BOOST_PP_CAT(constructor_parameters, __LINE__)()() \ + ) \ + { \ + } +/**/ + +#include <boost/parameter/aux_/pp_impl/argument_pack.hpp> +#include <boost/parameter/aux_/preprocessor/impl/function_name.hpp> +#include <boost/preprocessor/control/expr_if.hpp> + +// Expands to a 0-arity forwarding function, whose job is to pass an empty +// pack to the front-end implementation function. +#define BOOST_PARAMETER_FUNCTION_FORWARD_OVERLOAD_0_Z(z, n, data) \ + BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(BOOST_PP_TUPLE_ELEM(4, 1, data)) \ + inline BOOST_PARAMETER_FUNCTION_RESULT_NAME( \ + BOOST_PP_TUPLE_ELEM(4, 1, data) \ + , BOOST_PP_TUPLE_ELEM(4, 3, data) \ + )< \ + ::boost::parameter::aux::argument_pack< \ + BOOST_PARAMETER_FUNCTION_SPECIFICATION_NAME( \ + BOOST_PP_TUPLE_ELEM(4, 1, data) \ + , BOOST_PP_TUPLE_ELEM(4, 3, data) \ + ) \ + >::type \ + >::type \ + BOOST_PARAMETER_MEMBER_FUNCTION_NAME(BOOST_PP_TUPLE_ELEM(3, 0, data))() \ + BOOST_PP_EXPR_IF(BOOST_PP_TUPLE_ELEM(4, 3, data), const) \ + { \ + return BOOST_PP_EXPR_IF(BOOST_PP_TUPLE_ELEM(4, 2, data), this->) \ + BOOST_PARAMETER_FUNCTION_IMPL_NAME( \ + BOOST_PP_TUPLE_ELEM(4, 1, data) \ + , BOOST_PP_TUPLE_ELEM(4, 3, data) \ + )( \ + BOOST_PARAMETER_FUNCTION_SPECIFICATION_NAME( \ + BOOST_PP_TUPLE_ELEM(4, 1, data) \ + , BOOST_PP_TUPLE_ELEM(4, 3, data) \ + )()() \ + ); \ + } +/**/ + +#include <boost/parameter/aux_/preprocessor/impl/function_forward_match.hpp> +#include <boost/preprocessor/repetition/enum.hpp> +#include <boost/preprocessor/repetition/enum_params.hpp> +#include <boost/preprocessor/repetition/enum_binary_params.hpp> + +// Expands to a forwarding function, whose job is to consolidate its arguments +// into a pack for the front-end implementation function to take in. +#define BOOST_PARAMETER_FUNCTION_FORWARD_OVERLOAD_1_Z(z, n, data) \ + template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename ParameterArgumentType)> \ + BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(BOOST_PP_TUPLE_ELEM(4, 1, data)) \ + inline typename BOOST_PARAMETER_FUNCTION_RESULT_NAME( \ + BOOST_PP_TUPLE_ELEM(4, 1, data) \ + , BOOST_PP_TUPLE_ELEM(4, 3, data) \ + )< \ + typename ::boost::parameter::aux::argument_pack< \ + BOOST_PARAMETER_FUNCTION_SPECIFICATION_NAME( \ + BOOST_PP_TUPLE_ELEM(4, 1, data) \ + , BOOST_PP_TUPLE_ELEM(4, 3, data) \ + ) \ + , BOOST_PP_CAT(BOOST_PP_ENUM_, z)( \ + n \ + , BOOST_PARAMETER_FUNCTION_ARG_TYPE_Z \ + , ParameterArgumentType \ + ) \ + >::type \ + >::type \ + BOOST_PARAMETER_MEMBER_FUNCTION_NAME(BOOST_PP_TUPLE_ELEM(4, 0, data))( \ + BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, ParameterArgumentType, && a) \ + BOOST_PARAMETER_FUNCTION_FORWARD_MATCH_Z( \ + z \ + , BOOST_PARAMETER_FUNCTION_SPECIFICATION_NAME( \ + BOOST_PP_TUPLE_ELEM(4, 1, data) \ + , BOOST_PP_TUPLE_ELEM(4, 3, data) \ + ) \ + , n \ + , ParameterArgumentType \ + ) \ + ) BOOST_PP_EXPR_IF(BOOST_PP_TUPLE_ELEM(4, 3, data), const) \ + { \ + return BOOST_PP_EXPR_IF(BOOST_PP_TUPLE_ELEM(4, 2, data), this->) \ + BOOST_PARAMETER_FUNCTION_IMPL_NAME( \ + BOOST_PP_TUPLE_ELEM(4, 1, data) \ + , BOOST_PP_TUPLE_ELEM(4, 3, data) \ + )( \ + BOOST_PARAMETER_FUNCTION_SPECIFICATION_NAME( \ + BOOST_PP_TUPLE_ELEM(4, 1, data) \ + , BOOST_PP_TUPLE_ELEM(4, 3, data) \ + )()( \ + BOOST_PP_CAT(BOOST_PP_ENUM_, z)( \ + n \ + , BOOST_PARAMETER_FUNCTION_FORWARD_PARAM_Z \ + , ParameterArgumentType \ + ) \ + ) \ + ); \ + } +/**/ + +#include <boost/preprocessor/comparison/equal.hpp> + +// Expands to a constructor whose job is to consolidate its arguments into a +// pack for the delegate constructor of the base class to take in. +#define BOOST_PARAMETER_CONSTRUCTOR_OVERLOAD_1_Z(z, n, data) \ + template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename ParameterArgumentType)> \ + BOOST_PP_EXPR_IF(BOOST_PP_EQUAL(n, 1), explicit) \ + inline BOOST_PP_TUPLE_ELEM(2, 0, data)( \ + BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, ParameterArgumentType, && a) \ + BOOST_PARAMETER_FUNCTION_FORWARD_MATCH_Z( \ + z \ + , BOOST_PP_CAT(constructor_parameters, __LINE__) \ + , n \ + , ParameterArgumentType \ + ) \ + ) : BOOST_PARAMETER_PARENTHESIZED_TYPE(BOOST_PP_TUPLE_ELEM(2, 1, data))( \ + BOOST_PP_CAT(constructor_parameters, __LINE__)()( \ + BOOST_PP_CAT(BOOST_PP_ENUM_, z)( \ + n \ + , BOOST_PARAMETER_FUNCTION_FORWARD_PARAM_Z \ + , ParameterArgumentType \ + ) \ + ) \ + ) \ + { \ + } +/**/ + +#include <boost/preprocessor/control/if.hpp> + +#define BOOST_PARAMETER_FUNCTION_FORWARD_OVERLOAD_Z(z, n, data) \ + BOOST_PP_IF( \ + n \ + , BOOST_PARAMETER_FUNCTION_FORWARD_OVERLOAD_1_Z \ + , BOOST_PARAMETER_FUNCTION_FORWARD_OVERLOAD_0_Z \ + )(z, n, data) +/**/ + +#define BOOST_PARAMETER_CONSTRUCTOR_OVERLOAD_Z(z, n, data) \ + BOOST_PP_IF( \ + n \ + , BOOST_PARAMETER_CONSTRUCTOR_OVERLOAD_1_Z \ + , BOOST_PARAMETER_CONSTRUCTOR_OVERLOAD_0_Z \ + )(z, n, data) +/**/ + +#include <boost/preprocessor/repetition/repeat_from_to.hpp> + +// Helper macro for BOOST_PARAMETER_FUNCTION_FORWARD_OVERLOADS. +#define BOOST_PARAMETER_FUNCTION_FORWARD_OVERLOADS_AUX(nm, impl, r, is_m, c) \ + BOOST_PP_REPEAT_FROM_TO( \ + BOOST_PP_TUPLE_ELEM(2, 0, r) \ + , BOOST_PP_TUPLE_ELEM(2, 1, r) \ + , BOOST_PARAMETER_FUNCTION_FORWARD_OVERLOAD_Z \ + , ( \ + nm \ + , impl \ + , BOOST_PP_IF( \ + BOOST_PARAMETER_MEMBER_FUNCTION_IS_STATIC(nm) \ + , 0 \ + , is_m \ + ) \ + , c \ + ) \ + ) +/**/ + +// Helper macro for BOOST_PARAMETER_CONSTRUCTOR_OVERLOADS. +#define BOOST_PARAMETER_CONSTRUCTOR_OVERLOADS_AUX(class_, base, range) \ + BOOST_PP_REPEAT_FROM_TO( \ + BOOST_PP_TUPLE_ELEM(2, 0, range) \ + , BOOST_PP_TUPLE_ELEM(2, 1, range) \ + , BOOST_PARAMETER_CONSTRUCTOR_OVERLOAD_Z \ + , (class_, base) \ + ) +/**/ + +#include <boost/parameter/aux_/preprocessor/impl/arity_range.hpp> + +// Expands to the layer of forwarding functions for the function with the +// specified name, whose arguments determine the range of arities. +#define BOOST_PARAMETER_FUNCTION_FORWARD_OVERLOADS(name, impl, a, is_m, c) \ + BOOST_PARAMETER_FUNCTION_FORWARD_OVERLOADS_AUX( \ + name, impl, BOOST_PARAMETER_ARITY_RANGE(a), is_m, c \ + ) +/**/ + +// Expands to the layer of forwarding functions for the constructor in the +// specified class, whose arguments determine the range of arities. +#define BOOST_PARAMETER_CONSTRUCTOR_OVERLOADS(class_, base, args) \ + BOOST_PARAMETER_CONSTRUCTOR_OVERLOADS_AUX( \ + class_, base, BOOST_PARAMETER_ARITY_RANGE(args) \ + ) +/**/ + +#else // !defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING) + +#include <boost/parameter/aux_/preprocessor/impl/parenthesized_type.hpp> +#include <boost/preprocessor/seq/seq.hpp> +#include <boost/preprocessor/tuple/elem.hpp> +#include <boost/preprocessor/cat.hpp> + +// Expands to the default constructor, whose job is to pass an empty argument +// pack back to the delegate constructor of the base class. +#define BOOST_PARAMETER_DEFAULT_CONSTRUCTOR(z, n, seq) \ + inline \ + BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_TAIL(seq)))() \ + : BOOST_PARAMETER_PARENTHESIZED_TYPE( \ + BOOST_PP_TUPLE_ELEM( \ + 2, 1, BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_TAIL(seq)) \ + ) \ + )(BOOST_PP_CAT(constructor_parameters, __LINE__)()()) \ + { \ + } +/**/ + +#include <boost/parameter/aux_/pp_impl/argument_pack.hpp> +#include <boost/parameter/aux_/preprocessor/impl/function_name.hpp> +#include <boost/preprocessor/control/expr_if.hpp> + +// Expands to a 0-arity forwarding function, whose job is to pass an empty +// argument pack to the front-end implementation function. +#define BOOST_PARAMETER_FUNCTION_FORWARD_OVERLOAD_0_ARITY(z, n, seq) \ + BOOST_PARAMETER_MEMBER_FUNCTION_STATIC( \ + BOOST_PP_TUPLE_ELEM( \ + 4, 1, BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_TAIL(seq)) \ + ) \ + ) \ + inline BOOST_PARAMETER_FUNCTION_RESULT_NAME( \ + BOOST_PP_TUPLE_ELEM( \ + 4, 1, BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_TAIL(seq)) \ + ) \ + , BOOST_PP_TUPLE_ELEM( \ + 4, 3, BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_TAIL(seq)) \ + ) \ + )< \ + ::boost::parameter::aux::argument_pack< \ + BOOST_PARAMETER_FUNCTION_SPECIFICATION_NAME( \ + BOOST_PP_TUPLE_ELEM( \ + 4, 1, BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_TAIL(seq)) \ + ) \ + , BOOST_PP_TUPLE_ELEM( \ + 4, 3, BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_TAIL(seq)) \ + ) \ + ) \ + >::type \ + >::type \ + BOOST_PARAMETER_MEMBER_FUNCTION_NAME( \ + BOOST_PP_TUPLE_ELEM( \ + 4, 0, BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_TAIL(seq)) \ + ) \ + )() BOOST_PP_EXPR_IF( \ + BOOST_PP_TUPLE_ELEM( \ + 4, 3, BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_TAIL(seq)) \ + ) \ + , const \ + ) \ + { \ + return BOOST_PP_EXPR_IF( \ + BOOST_PP_TUPLE_ELEM( \ + 4, 2, BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_TAIL(seq)) \ + ) \ + , this-> \ + ) BOOST_PARAMETER_FUNCTION_IMPL_NAME( \ + BOOST_PP_TUPLE_ELEM( \ + 4, 1, BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_TAIL(seq)) \ + ) \ + , BOOST_PP_TUPLE_ELEM( \ + 4, 3, BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_TAIL(seq)) \ + ) \ + )( \ + BOOST_PARAMETER_FUNCTION_SPECIFICATION_NAME( \ + BOOST_PP_TUPLE_ELEM( \ + 4, 1, BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_TAIL(seq)) \ + ) \ + , BOOST_PP_TUPLE_ELEM( \ + 4, 3, BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_TAIL(seq)) \ + ) \ + )()() \ + ); \ + } +/**/ + +#include <boost/parameter/aux_/preprocessor/binary_seq_to_args.hpp> +#include <boost/parameter/aux_/preprocessor/impl/function_forward_match.hpp> +#include <boost/preprocessor/comparison/equal.hpp> +#include <boost/preprocessor/repetition/enum_params.hpp> +#include <boost/preprocessor/seq/size.hpp> + +// Expands to a constructor whose job is to consolidate its arguments into a +// pack for the delegate constructor of the base class to take in. Each +// element in BOOST_PP_SEQ_TAIL(seq) determines the const-ness of the +// corresponding argument. +#define BOOST_PARAMETER_CONSTRUCTOR_OVERLOAD_R(r, seq) \ + template < \ + BOOST_PP_ENUM_PARAMS( \ + BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_TAIL(seq)) \ + , typename ParameterArgumentType \ + ) \ + > \ + BOOST_PP_EXPR_IF( \ + BOOST_PP_EQUAL(BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_TAIL(seq)), 1) \ + , explicit \ + ) \ + inline BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_SEQ_HEAD(seq))( \ + BOOST_PARAMETER_AUX_PP_BINARY_SEQ_TO_ARGS( \ + BOOST_PP_SEQ_TAIL(seq), (ParameterArgumentType)(a) \ + ) \ + BOOST_PARAMETER_FUNCTION_FORWARD_MATCH( \ + BOOST_PP_CAT(constructor_parameters, __LINE__) \ + , BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_TAIL(seq)) \ + , ParameterArgumentType \ + ) \ + ) : BOOST_PARAMETER_PARENTHESIZED_TYPE( \ + BOOST_PP_TUPLE_ELEM(2, 1, BOOST_PP_SEQ_HEAD(seq)) \ + )( \ + BOOST_PP_CAT(constructor_parameters, __LINE__)()( \ + BOOST_PP_ENUM_PARAMS( \ + BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_TAIL(seq)), a \ + ) \ + ) \ + ) \ + { \ + } +/**/ + +// Expands to a forwarding function, whose job is to consolidate its arguments +// into a pack for the front-end implementation function to take in. Each +// element in BOOST_PP_SEQ_TAIL(seq) determines the const-ness of the +// corresponding argument. +#define BOOST_PARAMETER_FUNCTION_FORWARD_OVERLOAD_R(r, seq) \ + template < \ + BOOST_PP_ENUM_PARAMS( \ + BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_TAIL(seq)) \ + , typename ParameterArgumentType \ + ) \ + > \ + BOOST_PARAMETER_MEMBER_FUNCTION_STATIC( \ + BOOST_PP_TUPLE_ELEM(4, 1, BOOST_PP_SEQ_HEAD(seq)) \ + ) \ + inline typename BOOST_PARAMETER_FUNCTION_RESULT_NAME( \ + BOOST_PP_TUPLE_ELEM(4, 1, BOOST_PP_SEQ_HEAD(seq)) \ + , BOOST_PP_TUPLE_ELEM(4, 3, BOOST_PP_SEQ_HEAD(seq)) \ + )< \ + typename ::boost::parameter::aux::argument_pack< \ + BOOST_PARAMETER_FUNCTION_SPECIFICATION_NAME( \ + BOOST_PP_TUPLE_ELEM(4, 1, BOOST_PP_SEQ_HEAD(seq)) \ + , BOOST_PP_TUPLE_ELEM(4, 3, BOOST_PP_SEQ_HEAD(seq)) \ + ) \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_TO_ARGS( \ + BOOST_PP_SEQ_TAIL(seq), (ParameterArgumentType) \ + ) \ + >::type \ + >::type \ + BOOST_PARAMETER_MEMBER_FUNCTION_NAME( \ + BOOST_PP_TUPLE_ELEM(4, 0, BOOST_PP_SEQ_HEAD(seq)) \ + )( \ + BOOST_PARAMETER_AUX_PP_BINARY_SEQ_TO_ARGS( \ + BOOST_PP_SEQ_TAIL(seq), (ParameterArgumentType)(a) \ + ) \ + BOOST_PARAMETER_FUNCTION_FORWARD_MATCH( \ + BOOST_PARAMETER_FUNCTION_SPECIFICATION_NAME( \ + BOOST_PP_TUPLE_ELEM(4, 1, BOOST_PP_SEQ_HEAD(seq)) \ + , BOOST_PP_TUPLE_ELEM(4, 3, BOOST_PP_SEQ_HEAD(seq)) \ + ) \ + , BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_TAIL(seq)) \ + , ParameterArgumentType \ + ) \ + ) BOOST_PP_EXPR_IF( \ + BOOST_PP_TUPLE_ELEM(4, 3, BOOST_PP_SEQ_HEAD(seq)), const \ + ) \ + { \ + return BOOST_PP_EXPR_IF( \ + BOOST_PP_TUPLE_ELEM(4, 2, BOOST_PP_SEQ_HEAD(seq)) \ + , this-> \ + ) BOOST_PARAMETER_FUNCTION_IMPL_NAME( \ + BOOST_PP_TUPLE_ELEM(4, 1, BOOST_PP_SEQ_HEAD(seq)) \ + , BOOST_PP_TUPLE_ELEM(4, 3, BOOST_PP_SEQ_HEAD(seq)) \ + )( \ + BOOST_PARAMETER_FUNCTION_SPECIFICATION_NAME( \ + BOOST_PP_TUPLE_ELEM(4, 1, BOOST_PP_SEQ_HEAD(seq)) \ + , BOOST_PP_TUPLE_ELEM(4, 3, BOOST_PP_SEQ_HEAD(seq)) \ + )()( \ + BOOST_PP_ENUM_PARAMS( \ + BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_TAIL(seq)), a \ + ) \ + ) \ + ); \ + } +/**/ + +#include <boost/parameter/aux_/preprocessor/binary_seq_for_each.hpp> +#include <boost/preprocessor/control/if.hpp> + +// Expands to all constructors that take in n arguments. Enables +// BOOST_PARAMETER_CONSTRUCTOR_OVERLOADS_AUX to use +// BOOST_PARAMETER_CONSTRUCTOR_OVERLOAD_Z within BOOST_PP_REPEAT_FROM_TO. +#define BOOST_PARAMETER_CONSTRUCTOR_OVERLOAD_Z(z, n, data) \ + BOOST_PP_IF( \ + n \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_Z \ + , BOOST_PARAMETER_DEFAULT_CONSTRUCTOR \ + )(z, n, (BOOST_PARAMETER_CONSTRUCTOR_OVERLOAD_R)(data)) +/**/ + +// Expands to all forwarding functions that take in n arguments. Enables +// BOOST_PARAMETER_FUNCTION_FORWARD_OVERLOADS_AUX to use +// BOOST_PARAMETER_FUNCTION_FORWARD_OVERLOAD_Z within BOOST_PP_REPEAT_FROM_TO. +#define BOOST_PARAMETER_FUNCTION_FORWARD_OVERLOAD_Z(z, n, data) \ + BOOST_PP_IF( \ + n \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_Z \ + , BOOST_PARAMETER_FUNCTION_FORWARD_OVERLOAD_0_ARITY \ + )(z, n, (BOOST_PARAMETER_FUNCTION_FORWARD_OVERLOAD_R)(data)) +/**/ + +#include <boost/preprocessor/repetition/repeat_from_to.hpp> + +// Helper macro for BOOST_PARAMETER_CONSTRUCTOR_OVERLOADS. +#define BOOST_PARAMETER_CONSTRUCTOR_OVERLOADS_AUX(class_, base, range) \ + BOOST_PP_REPEAT_FROM_TO( \ + BOOST_PP_TUPLE_ELEM(2, 0, range) \ + , BOOST_PP_TUPLE_ELEM(2, 1, range) \ + , BOOST_PARAMETER_CONSTRUCTOR_OVERLOAD_Z \ + , (class_, base) \ + ) +/**/ + +// Helper macro for BOOST_PARAMETER_FUNCTION_FORWARD_OVERLOADS. +#define BOOST_PARAMETER_FUNCTION_FORWARD_OVERLOADS_AUX(nm, impl, r, is_m, c) \ + BOOST_PP_REPEAT_FROM_TO( \ + BOOST_PP_TUPLE_ELEM(2, 0, r) \ + , BOOST_PP_TUPLE_ELEM(2, 1, r) \ + , BOOST_PARAMETER_FUNCTION_FORWARD_OVERLOAD_Z \ + , ( \ + nm \ + , impl \ + , BOOST_PP_IF( \ + BOOST_PARAMETER_MEMBER_FUNCTION_IS_STATIC(impl) \ + , 0 \ + , is_m \ + ) \ + , c \ + ) \ + ) +/**/ + +#include <boost/parameter/aux_/preprocessor/impl/arity_range.hpp> + +// Expands to the layer of forwarding functions for the constructor in the +// specified class, whose arguments determine the range of arities. +#define BOOST_PARAMETER_CONSTRUCTOR_OVERLOADS(class_, base, args) \ + BOOST_PARAMETER_CONSTRUCTOR_OVERLOADS_AUX( \ + class_ \ + , base \ + , BOOST_PARAMETER_ARITY_RANGE(args) \ + ) +/**/ + +// Expands to the layer of forwarding functions for the function with the +// specified name, whose arguments determine the range of arities. +#define BOOST_PARAMETER_FUNCTION_FORWARD_OVERLOADS(name, impl, a, is_m, c) \ + BOOST_PARAMETER_FUNCTION_FORWARD_OVERLOADS_AUX( \ + name \ + , impl \ + , BOOST_PARAMETER_ARITY_RANGE(a) \ + , is_m \ + , c \ + ) +/**/ + +#endif // BOOST_PARAMETER_HAS_PERFECT_FORWARDING +#endif // include guard + diff --git a/boost/parameter/aux_/preprocessor/impl/function_cast.hpp b/boost/parameter/aux_/preprocessor/impl/function_cast.hpp new file mode 100644 index 0000000000..2c40a25798 --- /dev/null +++ b/boost/parameter/aux_/preprocessor/impl/function_cast.hpp @@ -0,0 +1,730 @@ +// Copyright Daniel Wallin 2006. +// 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_AUX_PREPROCESSOR_IMPL_FUNCTION_CAST_HPP +#define BOOST_PARAMETER_AUX_PREPROCESSOR_IMPL_FUNCTION_CAST_HPP + +#include <boost/parameter/config.hpp> + +#if defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING) + +namespace boost { namespace parameter { namespace aux { + + // Handles possible implicit casts. Used by preprocessor.hpp + // to normalize user input. + // + // cast<void*>::execute() is identity + // cast<void*(X)>::execute() is identity + // cast<void(X)>::execute() casts to X + // + // preprocessor.hpp uses this like this: + // + // #define X(value, predicate) + // cast<void predicate>::execute(value) + // + // X(something, *) + // X(something, *(predicate)) + // X(something, (int)) + template <typename VoidExpr, typename Args> + struct cast; +}}} // namespace boost::parameter::aux + +#include <boost/parameter/aux_/use_default_tag.hpp> + +namespace boost { namespace parameter { namespace aux { + + template <typename T, typename B> + inline ::boost::parameter::aux::use_default_tag + forward(::boost::parameter::aux::use_default_tag) + { + return ::boost::parameter::aux::use_default_tag(); + } +}}} // namespace boost::parameter::aux + +#include <boost/mpl/bool.hpp> +#include <boost/mpl/if.hpp> + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <boost/mp11/integral.hpp> +#include <boost/mp11/utility.hpp> +#endif + +namespace boost { namespace parameter { namespace aux { + + template <typename Args> + struct cast<void*,Args> + { + template <typename T, typename B> + struct apply + { + typedef typename ::boost::mpl + ::if_<B,T,::boost::mpl::true_>::type type; + }; + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + template <typename T, typename B> + using fn = ::boost::mp11::mp_if<B,T,::boost::mp11::mp_true>; +#endif + }; +}}} // namespace boost::parameter::aux + +#include <boost/parameter/aux_/void.hpp> + +namespace boost { namespace parameter { namespace aux { + + template <typename Predicate, typename Args> + struct cast<void*(Predicate),Args> + : ::boost::parameter::aux::cast<void*,Args> + { + }; +}}} // namespace boost::parameter::aux + +#include <boost/mpl/placeholders.hpp> + +namespace boost { namespace parameter { namespace aux { + + // This is a hack used in cast<> to turn the user supplied type, + // which may or may not be a placeholder expression, into one, + // so that it will be properly evaluated by mpl::apply. + template <typename T, typename Dummy = ::boost::mpl::_1> + struct as_placeholder_expr + { + typedef T type; + }; +}}} // namespace boost::parameter::aux + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <boost/mp11/list.hpp> + +namespace boost { namespace parameter { namespace aux { + + template <typename Target, typename Source, typename Args> + struct apply_target_fn + { + using type = ::boost::mp11 + ::mp_apply_q<Target,::boost::mp11::mp_list<Source,Args> >; + }; +}}} // namespace boost::parameter::aux + +#endif + +#include <boost/mpl/apply.hpp> + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <boost/parameter/aux_/has_nested_template_fn.hpp> +#include <type_traits> +#else +#include <boost/type_traits/is_same.hpp> +#include <boost/type_traits/remove_const.hpp> +#include <boost/type_traits/remove_reference.hpp> +#endif + +namespace boost { namespace parameter { namespace aux { + + template <typename Target, typename Source, typename Args> +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using is_target_same_as_source = ::std::is_same< + typename ::std::remove_const< + typename ::std::remove_reference< + typename ::boost::mp11::mp_if< + ::boost::parameter::aux::has_nested_template_fn<Target> + , ::boost::parameter::aux + ::apply_target_fn<Target,Source,Args> + , ::boost::mpl::apply2< + ::boost::parameter::aux::as_placeholder_expr<Target> + , Source + , Args + > + >::type + >::type + >::type + , typename ::std::remove_const<Source>::type + >; +#else // !defined(BOOST_PARAMETER_CAN_USE_MP11) + struct is_target_same_as_source + : ::boost::mpl::if_< + ::boost::is_same< + typename ::boost::remove_const< + typename ::boost::remove_reference< + typename ::boost::mpl::apply2< + ::boost::parameter::aux + ::as_placeholder_expr<Target> + , Source + , Args + >::type + >::type + >::type + , typename ::boost::remove_const<Source>::type + > + , ::boost::mpl::true_ + , ::boost::mpl::false_ + >::type + { + }; +#endif // BOOST_PARAMETER_CAN_USE_MP11 +}}} // namespace boost::parameter::aux + +#if !defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <boost/type_traits/add_const.hpp> +#include <boost/type_traits/is_const.hpp> +#endif + +namespace boost { namespace parameter { namespace aux { + + // Covers the case where is_convertible<Source,Target> but not + // is_same<Source,Target>. Use cases are covered + // by test/normalize_argument_types.cpp + template <typename Source, typename Target> + class cast_convert + { + typedef ::boost::parameter::aux::cast_convert<Source,Target> _self; + + public: +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using type = typename ::boost::mp11::mp_if< + ::std::is_const<Source> + , ::std::add_const<Target> + , ::std::remove_const<Target> + >::type; +#else + typedef typename boost::mpl::eval_if< + ::boost::is_const<Source> + , ::boost::add_const<Target> + , ::boost::remove_const<Target> + >::type type; +#endif + + private: + inline static typename _self::type +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + _copy(typename ::std::remove_const<Target>::type value) +#else + _copy(typename ::boost::remove_const<Target>::type value) +#endif + { + return value; + } + + public: + inline static typename _self::type evaluate(Source&& source) + { + return _self::_copy(source); + } + }; + + template <typename Target, typename Source, typename Args> +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using cast_impl = ::std::remove_reference< + typename ::boost::mp11::mp_if< + ::boost::parameter::aux::has_nested_template_fn<Target> + , ::boost::parameter::aux + ::is_target_same_as_source<Target,Source,Args> + , ::boost::mpl::apply2< + ::boost::parameter::aux::as_placeholder_expr<Target> + , Source + , Args + > + >::type + >; +#else + struct cast_impl + : ::boost::remove_reference< + typename ::boost::mpl::apply2< + ::boost::parameter::aux::as_placeholder_expr<Target> + , Source + , Args + >::type + > + { + }; +#endif // BOOST_PARAMETER_CAN_USE_MP11 +}}} // namespace boost::parameter::aux + +#include <boost/mpl/eval_if.hpp> +#include <boost/mpl/identity.hpp> + +namespace boost { namespace parameter { namespace aux { + + template <typename Target, typename Args> + struct cast<void(Target),Args> + { + template <typename T, typename B> + struct apply + { + typedef typename ::boost::mpl::eval_if< + B + , ::boost::mpl::eval_if< + ::boost::parameter::aux + ::is_target_same_as_source<Target,T,Args> + , ::boost::mpl::identity<T> + , ::boost::parameter::aux::cast_impl<Target,T,Args> + > + , ::boost::parameter::aux + ::is_target_same_as_source<Target,T,Args> + >::type type; + }; + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + template <typename T, typename B> + using fn = typename ::boost::mp11::mp_if< + B + , ::boost::mp11::mp_if< + ::boost::parameter::aux + ::is_target_same_as_source<Target,T,Args> + , ::boost::mp11::mp_identity<T> + , ::boost::parameter::aux::cast_impl<Target,T,Args> + > + , ::boost::parameter::aux + ::is_target_same_as_source<Target,T,Args> + >::type; +#endif + }; +}}} // namespace boost::parameter::aux + +#include <boost/parameter/value_type.hpp> + +#if !defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <boost/mpl/apply_wrap.hpp> +#endif + +// Expands to the target type of the argument as indicated by the predicate. +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#define BOOST_PARAMETER_FUNCTION_CAST_T(tag, predicate, args) \ + ::boost::mp11::mp_apply_q< \ + ::boost::parameter::aux::cast<void predicate, args> \ + , ::boost::mp11::mp_list< \ + typename ::boost::parameter::value_type< \ + args \ + , tag \ + , ::boost::parameter::aux::use_default_tag \ + >::type \ + , ::boost::mp11::mp_true \ + > \ + > +/**/ +#else // !defined(BOOST_PARAMETER_CAN_USE_MP11) +#define BOOST_PARAMETER_FUNCTION_CAST_T(tag, predicate, args) \ + typename ::boost::mpl::apply_wrap2< \ + ::boost::parameter::aux::cast<void predicate, args> \ + , typename ::boost::parameter::value_type< \ + args \ + , tag \ + , ::boost::parameter::aux::use_default_tag \ + >::type \ + , ::boost::mpl::true_ \ + >::type +/**/ +#endif // BOOST_PARAMETER_CAN_USE_MP11 + +// Expands to boost::mpl::true_ if and only if the argument's source and +// target types are the same. +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#define BOOST_PARAMETER_FUNCTION_CAST_B(tag, predicate, args) \ + ::boost::mp11::mp_apply_q< \ + ::boost::parameter::aux::cast<void predicate, args> \ + , ::boost::mp11::mp_list< \ + typename ::boost::parameter::value_type< \ + args \ + , tag \ + , ::boost::parameter::aux::use_default_tag \ + >::type \ + , ::boost::mp11::mp_false \ + > \ + > +/**/ +#else // !defined(BOOST_PARAMETER_CAN_USE_MP11) +#define BOOST_PARAMETER_FUNCTION_CAST_B(tag, predicate, args) \ + typename ::boost::mpl::apply_wrap2< \ + ::boost::parameter::aux::cast<void predicate, args> \ + , typename ::boost::parameter::value_type< \ + args \ + , tag \ + , ::boost::parameter::aux::use_default_tag \ + >::type \ + , ::boost::mpl::false_ \ + >::type +/**/ +#endif // BOOST_PARAMETER_CAN_USE_MP11 + +#include <boost/core/enable_if.hpp> +#include <utility> + +namespace boost { namespace parameter { namespace aux { + + // If the source and target types are not the same, + // then perform an implicit conversion. + template <typename Target, typename B, typename Source> + inline typename ::boost::lazy_disable_if< + B + , ::boost::parameter::aux::cast_convert<Source,Target> + >::type + forward(Source&& source) + { + return ::boost::parameter::aux::cast_convert<Source,Target> + ::evaluate(::std::forward<Source>(source)); + } + + // If the source and target types are the same, + // then simply forward the argument. + // However, treat rvalue references to scalars as const lvalue references. + template <typename T, typename B> + inline typename ::boost::enable_if<B,T const&>::type forward(T const& t) + { + return t; + } + + template <typename T, typename B> + inline typename ::boost::enable_if< +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + ::boost::mp11::mp_if< + B + , ::boost::mp11::mp_if< + ::std::is_const<T> + , ::boost::mp11::mp_false + , ::boost::mp11::mp_true + > + , ::boost::mp11::mp_false + > +#else + typename ::boost::mpl::eval_if< + B + , ::boost::mpl::if_< + ::boost::is_const<T> + , ::boost::mpl::false_ + , ::boost::mpl::true_ + > + , ::boost::mpl::false_ + >::type +#endif // BOOST_PARAMETER_CAN_USE_MP11 + , T& + >::type + forward(T& t) + { + return t; + } +}}} // namespace boost::parameter::aux + +#include <boost/type_traits/is_scalar.hpp> + +namespace boost { namespace parameter { namespace aux { + + template <typename T, typename B> + inline typename ::boost::enable_if< +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + ::boost::mp11::mp_if< + B + , ::boost::mp11::mp_if< + ::std::is_scalar<T> + , ::boost::mp11::mp_false + , ::boost::mp11::mp_true + > + , ::boost::mp11::mp_false + > +#else + typename ::boost::mpl::eval_if< + B + , ::boost::mpl::if_< + ::boost::is_scalar<T> + , ::boost::mpl::false_ + , ::boost::mpl::true_ + > + , ::boost::mpl::false_ + >::type +#endif // BOOST_PARAMETER_CAN_USE_MP11 + , T const&& + >::type + forward(T const&& t) + { + return static_cast<T const&&>(t); + } + + template <typename T, typename B> + inline typename ::boost::enable_if< +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + ::boost::mp11::mp_if< + B + , ::boost::mp11::mp_if< + ::std::is_scalar<T> + , ::boost::mp11::mp_false + , ::boost::mp11::mp_true + > + , ::boost::mp11::mp_false + > +#else + typename ::boost::mpl::eval_if< + B + , ::boost::mpl::if_< + ::boost::is_scalar<T> + , ::boost::mpl::false_ + , ::boost::mpl::true_ + > + , ::boost::mpl::false_ + >::type +#endif // BOOST_PARAMETER_CAN_USE_MP11 + , T&& + >::type + forward(T&& t) + { + return ::std::forward<T>(t); + } +}}} // namespace boost::parameter::aux + +#elif BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +#define BOOST_PARAMETER_FUNCTION_CAST_T(value_t, predicate, args) value_t +#define BOOST_PARAMETER_FUNCTION_CAST_B(value, predicate, args) value +#else // no perfect forwarding support and no Borland workarounds needed + +namespace boost { namespace parameter { namespace aux { + + // Handles possible implicit casts. Used by preprocessor.hpp + // to normalize user input. + // + // cast<void*>::execute() is identity + // cast<void*(X)>::execute() is identity + // cast<void(X)>::execute() casts to X + // + // preprocessor.hpp uses this like this: + // + // #define X(value, predicate) + // cast<void predicate>::execute(value) + // + // X(something, *) + // X(something, *(predicate)) + // X(something, (int)) + template <typename VoidExpr, typename Args> + struct cast; +}}} // namespace boost::parameter::aux + +#include <boost/parameter/aux_/use_default_tag.hpp> +#include <boost/mpl/bool.hpp> +#include <boost/mpl/if.hpp> + +namespace boost { namespace parameter { namespace aux { + + template <typename Args> + struct cast<void*,Args> + { + template <typename T> + struct apply + { + typedef T& type; + }; + + inline static ::boost::parameter::aux::use_default_tag + execute(::boost::parameter::aux::use_default_tag) + { + return ::boost::parameter::aux::use_default_tag(); + } + + template <typename U> + inline static U& execute(U& value) + { + return value; + } + }; +}}} // namespace boost::parameter::aux + +#include <boost/parameter/aux_/void.hpp> + +namespace boost { namespace parameter { namespace aux { + + template <typename Predicate, typename Args> +#if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x580)) + struct cast< ::boost::parameter::aux::voidstar(Predicate),Args> +#else + struct cast<void*(Predicate),Args> +#endif + : ::boost::parameter::aux::cast<void*,Args> + { + }; +}}} // namespace boost::parameter::aux + +#include <boost/mpl/placeholders.hpp> + +namespace boost { namespace parameter { namespace aux { + + // This is a hack used in cast<> to turn the user supplied type, + // which may or may not be a placeholder expression, into one, + // so that it will be properly evaluated by mpl::apply. + template <typename T, typename Dummy = ::boost::mpl::_1> + struct as_placeholder_expr + { + typedef T type; + }; +}}} // namespace boost::parameter::aux + +#include <boost/mpl/apply.hpp> +#include <boost/type_traits/is_same.hpp> +#include <boost/type_traits/remove_const.hpp> +#include <boost/type_traits/remove_reference.hpp> + +namespace boost { namespace parameter { namespace aux { + + template <typename Target, typename Source, typename Args> + struct is_target_same_as_source + : ::boost::mpl::if_< + ::boost::is_same< + typename ::boost::remove_const< + typename ::boost::remove_reference< + typename ::boost::mpl::apply2< + ::boost::parameter::aux + ::as_placeholder_expr<Target> + , Source + , Args + >::type + >::type + >::type + , typename ::boost::remove_const<Source>::type + > + , ::boost::mpl::true_ + , ::boost::mpl::false_ + >::type + { + }; + + template < + typename Target + , typename Source + , typename Args + , typename Enable = ::boost::parameter::aux + ::is_target_same_as_source<Target,Source,Args> + > + struct cast_impl + { + typedef Source& type; + + inline static Source& evaluate(Source& value) + { + return value; + } + }; +}}} // namespace boost::parameter::aux + +#include <boost/type_traits/add_const.hpp> +#include <boost/type_traits/add_lvalue_reference.hpp> + +namespace boost { namespace parameter { namespace aux { + + // Covers the case where is_convertible<Source,Target> but not + // is_same<Source,Target>. Use cases are covered + // by test/normalize_argument_types.cpp + template <typename Source, typename Target> + class cast_convert + { + typedef ::boost::parameter::aux::cast_convert<Source,Target> _self; + + public: + typedef typename ::boost::add_lvalue_reference< + typename ::boost::add_const<Target>::type + >::type type; + + private: + template <typename U> + inline static typename _self::type _mod_const(U const& u) + { + return u; + } + + inline static Target _copy(Target value) + { + return value; + } + + public: + inline static typename _self::type evaluate(Source& source) + { + return _self::_mod_const(_self::_copy(source)); + } + }; + + template <typename Target, typename Source, typename Args> + struct cast_impl<Target,Source,Args,::boost::mpl::false_> + : ::boost::parameter::aux::cast_convert< + Source, + typename ::boost::mpl::apply2< + ::boost::parameter::aux::as_placeholder_expr<Target> + , Source + , Args + >::type + > + { + }; +}}} // namespace boost::parameter::aux + +#include <boost/mpl/eval_if.hpp> + +namespace boost { namespace parameter { namespace aux { + + template <typename Target, typename Args> + struct cast<void(Target),Args> + { + template <typename T> + struct apply + { + typedef typename ::boost::mpl::eval_if< + ::boost::parameter::aux + ::is_target_same_as_source<Target,T,Args> + , ::boost::add_lvalue_reference<T> + , ::boost::parameter::aux::cast_impl< + Target + , T + , Args + , ::boost::mpl::false_ + > + >::type type; + }; + + inline static ::boost::parameter::aux::use_default_tag + execute(::boost::parameter::aux::use_default_tag) + { + return ::boost::parameter::aux::use_default_tag(); + } + + template <typename U> + inline static typename ::boost::parameter::aux + ::cast_impl<Target,U const,Args>::type + execute(U const& value) + { + return ::boost::parameter::aux + ::cast_impl<Target,U const,Args>::evaluate(value); + } + + template <typename U> + inline static typename ::boost::parameter::aux + ::cast_impl<Target,U,Args>::type + execute(U& value) + { + return ::boost::parameter::aux + ::cast_impl<Target,U,Args>::evaluate(value); + } + }; +}}} // namespace boost::parameter::aux + +#include <boost/mpl/apply_wrap.hpp> +#include <boost/parameter/value_type.hpp> + +// Expands to the reference-qualified target type of the argument +// as indicated by the predicate. +#define BOOST_PARAMETER_FUNCTION_CAST_T(tag, predicate, args) \ + typename ::boost::mpl::apply_wrap1< \ + ::boost::parameter::aux::cast<void predicate, args> \ + , typename ::boost::parameter::value_type< \ + args \ + , tag \ + , ::boost::parameter::aux::use_default_tag \ + >::type \ + >::type +/**/ + +// Expands to the converted or passed-through value +// as indicated by the predicate. +#define BOOST_PARAMETER_FUNCTION_CAST_B(value, predicate, args) \ + ::boost::parameter::aux::cast<void predicate, args>::execute(value) +/**/ + +#endif // perfect forwarding support, or Borland workarounds needed +#endif // include guard + diff --git a/boost/parameter/aux_/preprocessor/impl/function_dispatch_layer.hpp b/boost/parameter/aux_/preprocessor/impl/function_dispatch_layer.hpp new file mode 100644 index 0000000000..3c240d527c --- /dev/null +++ b/boost/parameter/aux_/preprocessor/impl/function_dispatch_layer.hpp @@ -0,0 +1,474 @@ +// Copyright Daniel Wallin 2006. +// 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_AUX_PREPROCESSOR_IMPL_FUNCTION_DISPATCH_LAYER_HPP +#define BOOST_PARAMETER_AUX_PREPROCESSOR_IMPL_FUNCTION_DISPATCH_LAYER_HPP + +#include <boost/preprocessor/cat.hpp> + +// Expands to keyword_tag_type for some keyword_tag. +#define BOOST_PARAMETER_FUNCTION_DISPATCH_ARG_TYPE(keyword_tag) \ + BOOST_PP_CAT(keyword_tag, _type) +/**/ + +// Expands to a template parameter for each dispatch function. +#define BOOST_PARAMETER_FUNCTION_DISPATCH_TEMPLATE_ARG(r, macro, arg) \ + , typename BOOST_PARAMETER_FUNCTION_DISPATCH_ARG_TYPE(macro(arg)) +/**/ + +#include <boost/parameter/config.hpp> + +#if defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING) + +// Expands to a forwarding parameter for a dispatch function. +#define BOOST_PARAMETER_FUNCTION_DISPATCH_ARG_DEFN(r, macro, arg) \ + , BOOST_PARAMETER_FUNCTION_DISPATCH_ARG_TYPE(macro(arg))&& macro(arg) +/**/ + +#include <utility> + +// Expands to an argument passed from one dispatch function to the next. +#define BOOST_PARAMETER_FUNCTION_DISPATCH_ARG_FWD(r, macro, arg) \ + , ::std::forward< \ + BOOST_PARAMETER_FUNCTION_DISPATCH_ARG_TYPE(macro(arg)) \ + >(macro(arg)) +/**/ + +#else // !defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING) + +// Expands to a forwarding parameter for a dispatch function. The parameter +// type stores its const-ness. +#define BOOST_PARAMETER_FUNCTION_DISPATCH_ARG_DEFN(r, macro, arg) \ + , BOOST_PARAMETER_FUNCTION_DISPATCH_ARG_TYPE(macro(arg))& macro(arg) +/**/ + +#include <boost/parameter/aux_/as_lvalue.hpp> + +// Expands to an argument passed from one dispatch function to the next. +// Explicit forwarding takes the form of forcing the argument to be an lvalue. +#define BOOST_PARAMETER_FUNCTION_DISPATCH_ARG_FWD(r, macro, arg) \ + , ::boost::parameter::aux::as_lvalue(macro(arg)) +/**/ + +#endif // BOOST_PARAMETER_HAS_PERFECT_FORWARDING + +#include <boost/parameter/aux_/preprocessor/impl/argument_specs.hpp> +#include <boost/parameter/aux_/preprocessor/impl/split_args.hpp> +#include <boost/preprocessor/seq/for_each.hpp> +#include <boost/preprocessor/seq/first_n.hpp> + +// Iterates through all required arguments and the first n optional arguments, +// passing each argument to the specified macro. +#define BOOST_PARAMETER_FUNCTION_DISPATCH_ARG_REPEAT(macro, n, split_args) \ + BOOST_PP_SEQ_FOR_EACH( \ + macro \ + , BOOST_PARAMETER_FN_ARG_NAME \ + , BOOST_PARAMETER_SPLIT_ARG_REQ_SEQ(split_args) \ + ) \ + BOOST_PP_SEQ_FOR_EACH( \ + macro \ + , BOOST_PARAMETER_FN_ARG_NAME \ + , BOOST_PP_SEQ_FIRST_N( \ + n, BOOST_PARAMETER_SPLIT_ARG_OPT_SEQ(split_args) \ + ) \ + ) +/**/ + +#include <boost/parameter/aux_/preprocessor/impl/function_dispatch_tuple.hpp> +#include <boost/parameter/aux_/preprocessor/impl/function_name.hpp> +#include <boost/preprocessor/control/if.hpp> + +// Produces a name for the dispatch functions. +#define BOOST_PARAMETER_FUNCTION_DISPATCH_NAME(x, n) \ + BOOST_PP_CAT( \ + BOOST_PP_CAT( \ + BOOST_PP_IF( \ + BOOST_PARAMETER_FUNCTION_DISPATCH_IS_CONST(x) \ + , boost_param_dispatch_const_ \ + , boost_param_dispatch_ \ + ) \ + , BOOST_PP_CAT(BOOST_PP_CAT(n, boost_), __LINE__) \ + ) \ + , BOOST_PARAMETER_MEMBER_FUNCTION_NAME( \ + BOOST_PARAMETER_FUNCTION_DISPATCH_BASE_NAME(x) \ + ) \ + ) +/**/ + +// Expands to the template parameter list of the dispatch function with all +// required and first n optional parameters; also extracts the static keyword +// if present. +#define BOOST_PARAMETER_FUNCTION_DISPATCH_HEAD_TPL(n, x) \ + template < \ + typename ResultType, typename Args \ + BOOST_PARAMETER_FUNCTION_DISPATCH_ARG_REPEAT( \ + BOOST_PARAMETER_FUNCTION_DISPATCH_TEMPLATE_ARG \ + , n \ + , BOOST_PARAMETER_FUNCTION_DISPATCH_SPLIT_ARGS(x) \ + ) \ + > BOOST_PARAMETER_MEMBER_FUNCTION_STATIC( \ + BOOST_PARAMETER_FUNCTION_DISPATCH_BASE_NAME(x) \ + ) +/**/ + +#include <boost/parameter/aux_/use_default_tag.hpp> +#include <boost/preprocessor/control/expr_if.hpp> +#include <boost/preprocessor/punctuation/comma_if.hpp> + +// Expands to the result type, name, parenthesized list of all required and +// n optional parameters, and const-ness of the dispatch function; the bit +// value b determines whether or not this dispatch function takes in +// boost::parameter::aux::use_default_tag as its last parameter. +#define BOOST_PARAMETER_FUNCTION_DISPATCH_HEAD_PRN(n, x, b1, b2) \ + ResultType BOOST_PARAMETER_FUNCTION_DISPATCH_NAME(x, b1)( \ + ResultType(*)(), Args const& args, long \ + BOOST_PARAMETER_FUNCTION_DISPATCH_ARG_REPEAT( \ + BOOST_PARAMETER_FUNCTION_DISPATCH_ARG_DEFN \ + , n \ + , BOOST_PARAMETER_FUNCTION_DISPATCH_SPLIT_ARGS(x) \ + ) \ + BOOST_PP_COMMA_IF(b2) \ + BOOST_PP_EXPR_IF(b2, ::boost::parameter::aux::use_default_tag) \ + ) BOOST_PP_EXPR_IF(BOOST_PARAMETER_FUNCTION_DISPATCH_IS_CONST(x), const) +/**/ + +// Expands to a forward declaration of the dispatch function that takes in +// all required and the first n optional parameters, but not +// boost::parameter::aux::use_default_tag. +#define BOOST_PARAMETER_FUNCTION_DISPATCH_FWD_DECL_0_Z(z, n, x) \ + BOOST_PARAMETER_FUNCTION_DISPATCH_HEAD_TPL(n, x) \ + BOOST_PARAMETER_FUNCTION_DISPATCH_HEAD_PRN(n, x, 0, 0); +/**/ + +// Expands to a forward declaration of the dispatch function that takes in +// all required parameters, the first n optional parameters, and +// boost::parameter::aux::use_default_tag. +#define BOOST_PARAMETER_FUNCTION_DISPATCH_FWD_DECL_1_Z(z, n, x) \ + BOOST_PARAMETER_FUNCTION_DISPATCH_HEAD_TPL(n, x) \ + BOOST_PARAMETER_FUNCTION_DISPATCH_HEAD_PRN(n, x, 0, 1); +/**/ + +#include <boost/preprocessor/seq/elem.hpp> + +// Expands to the default value of the (n + 1)th optional parameter. +#define BOOST_PARAMETER_FUNCTION_DISPATCH_DEFAULT_AUX(n, s_args) \ + BOOST_PARAMETER_FN_ARG_DEFAULT( \ + BOOST_PP_SEQ_ELEM(n, BOOST_PARAMETER_SPLIT_ARG_OPT_SEQ(s_args)) \ + ) +/**/ + +#include <boost/parameter/keyword.hpp> + +// Expands to the assignment portion which binds the default value to the +// (n + 1)th optional parameter before composing it with the argument-pack +// parameter passed in to the n-th dispatch function. +#define BOOST_PARAMETER_FUNCTION_DISPATCH_DEFAULT(n, s_args, tag_ns) \ + ::boost::parameter::keyword< \ + tag_ns::BOOST_PARAMETER_FN_ARG_NAME( \ + BOOST_PP_SEQ_ELEM(n, BOOST_PARAMETER_SPLIT_ARG_OPT_SEQ(s_args)) \ + ) \ + >::instance = BOOST_PARAMETER_FUNCTION_DISPATCH_DEFAULT_AUX(n, s_args) +/**/ + +#include <boost/parameter/aux_/preprocessor/impl/function_cast.hpp> + +// Takes in the arg tuple (name, pred) and the tag namespace. +// Extracts the corresponding required argument from the pack. +// This form enables BOOST_PARAMETER_FUNCTION_DISPATCH_LAYER to use it +// from within BOOST_PP_SEQ_FOR_EACH. +#if defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING) +// The boost::parameter::aux::forward wrapper is necessary to transmit the +// target type to the next dispatch function. Otherwise, the argument will +// retain its original type. -- Cromwell D. Enage +#define BOOST_PARAMETER_FUNCTION_DISPATCH_ARG_CAST_R(r, tag_ns, arg) \ + , ::boost::parameter::aux::forward< \ + BOOST_PARAMETER_FUNCTION_CAST_T( \ + tag_ns::BOOST_PARAMETER_FN_ARG_NAME(arg) \ + , BOOST_PARAMETER_FN_ARG_PRED(arg) \ + , Args \ + ) \ + , BOOST_PARAMETER_FUNCTION_CAST_B( \ + tag_ns::BOOST_PARAMETER_FN_ARG_NAME(arg) \ + , BOOST_PARAMETER_FN_ARG_PRED(arg) \ + , Args \ + ) \ + >( \ + args[ \ + ::boost::parameter::keyword< \ + tag_ns::BOOST_PARAMETER_FN_ARG_NAME(arg) \ + >::instance \ + ] \ + ) +/**/ +#else // !defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING) +// The explicit type cast is necessary to transmit the target type to the next +// dispatch function. Otherwise, the argument will retain its original type. +// -- Cromwell D. Enage +#define BOOST_PARAMETER_FUNCTION_DISPATCH_ARG_CAST_R(r, tag_ns, arg) \ + , BOOST_PARAMETER_FUNCTION_CAST_T( \ + tag_ns::BOOST_PARAMETER_FN_ARG_NAME(arg) \ + , BOOST_PARAMETER_FN_ARG_PRED(arg) \ + , Args \ + )( \ + args[ \ + ::boost::parameter::keyword< \ + tag_ns::BOOST_PARAMETER_FN_ARG_NAME(arg) \ + >::instance \ + ] \ + ) +/**/ +#endif // BOOST_PARAMETER_HAS_PERFECT_FORWARDING + +// Takes in the arg tuple (name, pred, default) and the tag namespace. +// Extracts the corresponding optional argument from the pack if specified, +// otherwise temporarily passes use_default_tag() to the dispatch functions. +#if defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING) +// The boost::parameter::aux::forward wrapper is necessary to transmit the +// target type to the next dispatch function. Otherwise, the argument will +// retain its original type. -- Cromwell D. Enage +#define BOOST_PARAMETER_FUNCTION_DISPATCH_OPT_ARG_CAST(arg, tag_ns) \ + ::boost::parameter::aux::forward< \ + BOOST_PARAMETER_FUNCTION_CAST_T( \ + tag_ns::BOOST_PARAMETER_FN_ARG_NAME(arg) \ + , BOOST_PARAMETER_FN_ARG_PRED(arg) \ + , Args \ + ) \ + , BOOST_PARAMETER_FUNCTION_CAST_B( \ + tag_ns::BOOST_PARAMETER_FN_ARG_NAME(arg) \ + , BOOST_PARAMETER_FN_ARG_PRED(arg) \ + , Args \ + ) \ + >( \ + args[ \ + ::boost::parameter::keyword< \ + tag_ns::BOOST_PARAMETER_FN_ARG_NAME(arg) \ + >::instance || ::boost::parameter::aux::use_default_tag() \ + ] \ + ) +/**/ +#else // !defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING) +#define BOOST_PARAMETER_FUNCTION_DISPATCH_OPT_ARG_CAST(arg, tag_ns) \ + BOOST_PARAMETER_FUNCTION_CAST_B( \ + args[ \ + ::boost::parameter::keyword< \ + tag_ns::BOOST_PARAMETER_FN_ARG_NAME(arg) \ + >::instance || ::boost::parameter::aux::use_default_tag() \ + ] \ + , BOOST_PARAMETER_FN_ARG_PRED(arg) \ + , Args \ + ) +/**/ +#endif // BOOST_PARAMETER_HAS_PERFECT_FORWARDING + +#include <boost/parameter/aux_/preprocessor/nullptr.hpp> + +// Expands to three dispatch functions that take in all required parameters +// and the first n optional parameters. The third dispatch function bears +// the same name as the first but takes in use_default_tag as the last +// parameter. The second dispatch function bears a different name from the +// other two. +// +// x is a tuple: +// +// (name, split_args, is_const, tag_namespace) +// +// Where name is the base name of the functions, and split_args is a tuple: +// +// (required_count, required_args, optional_count, required_args) +// +// The first dispatch function queries args if it has bound the (n + 1)th +// optional parameter to a user-defined argument. If so, then it forwards +// its own arguments followed by the user-defined argument to the dispatch +// function that takes in all required parameters and the first (n + 1) +// optional parameters, but not use_default_tag. Otherwise, it forwards +// its own arguments to the third dispatch function. +// +// The third dispatch function appends the default value of the (n + 1)th +// optional parameter to its copy of args. Then it forwards this copy, all +// required parameters, and the first n (not n + 1) optional parameters to +// the second dispatch function. +// +// The second dispatch function forwards its arguments, then the (n + 1)th +// optional parameter that it extracts from args, to the other-named dispatch +// function that takes in all required parameters and the first (n + 1) +// optional parameters, but not use_default_tag. +#define BOOST_PARAMETER_FUNCTION_DISPATCH_OVERLOAD_Z(z, n, x) \ + BOOST_PARAMETER_FUNCTION_DISPATCH_HEAD_TPL(n, x) \ + inline BOOST_PARAMETER_FUNCTION_DISPATCH_HEAD_PRN(n, x, 0, 0) \ + { \ + return BOOST_PP_EXPR_IF( \ + BOOST_PARAMETER_FUNCTION_DISPATCH_IS_MEMBER(x) \ + , this-> \ + ) BOOST_PARAMETER_FUNCTION_DISPATCH_NAME(x, 0)( \ + static_cast<ResultType(*)()>(BOOST_PARAMETER_AUX_PP_NULLPTR) \ + , args \ + , 0L \ + BOOST_PARAMETER_FUNCTION_DISPATCH_ARG_REPEAT( \ + BOOST_PARAMETER_FUNCTION_DISPATCH_ARG_FWD \ + , n \ + , BOOST_PARAMETER_FUNCTION_DISPATCH_SPLIT_ARGS(x) \ + ) \ + , BOOST_PARAMETER_FUNCTION_DISPATCH_OPT_ARG_CAST( \ + BOOST_PP_SEQ_ELEM( \ + n \ + , BOOST_PARAMETER_SPLIT_ARG_OPT_SEQ( \ + BOOST_PARAMETER_FUNCTION_DISPATCH_SPLIT_ARGS(x) \ + ) \ + ) \ + , BOOST_PARAMETER_FUNCTION_DISPATCH_TAG_NAMESPACE(x) \ + ) \ + ); \ + } \ + BOOST_PARAMETER_FUNCTION_DISPATCH_HEAD_TPL(n, x) \ + inline BOOST_PARAMETER_FUNCTION_DISPATCH_HEAD_PRN(n, x, 1, 0) \ + { \ + return BOOST_PP_EXPR_IF( \ + BOOST_PARAMETER_FUNCTION_DISPATCH_IS_MEMBER(x) \ + , this-> \ + ) BOOST_PARAMETER_FUNCTION_DISPATCH_NAME(x, 0)( \ + static_cast<ResultType(*)()>(BOOST_PARAMETER_AUX_PP_NULLPTR) \ + , args \ + , 0L \ + BOOST_PARAMETER_FUNCTION_DISPATCH_ARG_REPEAT( \ + BOOST_PARAMETER_FUNCTION_DISPATCH_ARG_FWD \ + , n \ + , BOOST_PARAMETER_FUNCTION_DISPATCH_SPLIT_ARGS(x) \ + ) \ + , args[ \ + ::boost::parameter::keyword< \ + BOOST_PARAMETER_FUNCTION_DISPATCH_TAG_NAMESPACE(x):: \ + BOOST_PARAMETER_FN_ARG_NAME( \ + BOOST_PP_SEQ_ELEM( \ + n \ + , BOOST_PARAMETER_SPLIT_ARG_OPT_SEQ( \ + BOOST_PARAMETER_FUNCTION_DISPATCH_SPLIT_ARGS(x) \ + ) \ + ) \ + ) \ + >::instance \ + ] \ + ); \ + } \ + BOOST_PARAMETER_FUNCTION_DISPATCH_HEAD_TPL(n, x) \ + inline BOOST_PARAMETER_FUNCTION_DISPATCH_HEAD_PRN(n, x, 0, 1) \ + { \ + return BOOST_PP_EXPR_IF( \ + BOOST_PARAMETER_FUNCTION_DISPATCH_IS_MEMBER(x) \ + , this-> \ + ) BOOST_PARAMETER_FUNCTION_DISPATCH_NAME(x, 1)( \ + static_cast<ResultType(*)()>(BOOST_PARAMETER_AUX_PP_NULLPTR) \ + , (args \ + , BOOST_PARAMETER_FUNCTION_DISPATCH_DEFAULT( \ + n \ + , BOOST_PARAMETER_FUNCTION_DISPATCH_SPLIT_ARGS(x) \ + , BOOST_PARAMETER_FUNCTION_DISPATCH_TAG_NAMESPACE(x) \ + ) \ + ) \ + , 0L \ + BOOST_PARAMETER_FUNCTION_DISPATCH_ARG_REPEAT( \ + BOOST_PARAMETER_FUNCTION_DISPATCH_ARG_FWD \ + , n \ + , BOOST_PARAMETER_FUNCTION_DISPATCH_SPLIT_ARGS(x) \ + ) \ + ); \ + } +/**/ + +#include <boost/preprocessor/arithmetic/inc.hpp> +#include <boost/preprocessor/control/if.hpp> +#include <boost/preprocessor/repetition/repeat_from_to.hpp> +#include <boost/preprocessor/tuple/eat.hpp> + +// x is a tuple: +// +// (base_name, split_args, is_member, is_const, tag_namespace) +// +// Generates all dispatch functions for the function named base_name. Each +// dispatch function that takes in n optional parameters passes the default +// value of the (n + 1)th optional parameter to the next dispatch function. +// The last dispatch function is the back-end implementation, so only the +// header is generated: the user is expected to supply the body. +// +// Also generates the front-end implementation function, which uses +// BOOST_PARAMETER_FUNCTION_CAST to extract each argument from the argument +// pack. +#define BOOST_PARAMETER_FUNCTION_DISPATCH_LAYER(fwd_decl, x) \ + BOOST_PP_IF(fwd_decl, BOOST_PP_REPEAT_FROM_TO, BOOST_PP_TUPLE_EAT(4))( \ + 0 \ + , BOOST_PP_INC( \ + BOOST_PARAMETER_SPLIT_ARG_OPT_COUNT( \ + BOOST_PARAMETER_FUNCTION_DISPATCH_SPLIT_ARGS(x) \ + ) \ + ) \ + , BOOST_PARAMETER_FUNCTION_DISPATCH_FWD_DECL_0_Z \ + , x \ + ) \ + BOOST_PP_IF(fwd_decl, BOOST_PP_REPEAT_FROM_TO, BOOST_PP_TUPLE_EAT(4))( \ + 0 \ + , BOOST_PARAMETER_SPLIT_ARG_OPT_COUNT( \ + BOOST_PARAMETER_FUNCTION_DISPATCH_SPLIT_ARGS(x) \ + ) \ + , BOOST_PARAMETER_FUNCTION_DISPATCH_FWD_DECL_1_Z \ + , x \ + ) \ + template <typename Args> BOOST_PARAMETER_MEMBER_FUNCTION_STATIC( \ + BOOST_PARAMETER_FUNCTION_DISPATCH_BASE_NAME(x) \ + ) inline typename BOOST_PARAMETER_FUNCTION_RESULT_NAME( \ + BOOST_PARAMETER_FUNCTION_DISPATCH_BASE_NAME(x) \ + , BOOST_PARAMETER_FUNCTION_DISPATCH_IS_CONST(x) \ + )<Args>::type BOOST_PARAMETER_FUNCTION_IMPL_NAME( \ + BOOST_PARAMETER_FUNCTION_DISPATCH_BASE_NAME(x) \ + , BOOST_PARAMETER_FUNCTION_DISPATCH_IS_CONST(x) \ + )(Args const& args) \ + BOOST_PP_EXPR_IF(BOOST_PARAMETER_FUNCTION_DISPATCH_IS_CONST(x), const) \ + { \ + return BOOST_PP_EXPR_IF( \ + BOOST_PARAMETER_FUNCTION_DISPATCH_IS_MEMBER(x) \ + , this-> \ + ) BOOST_PARAMETER_FUNCTION_DISPATCH_NAME(x, 0)( \ + static_cast< \ + typename BOOST_PARAMETER_FUNCTION_RESULT_NAME( \ + BOOST_PARAMETER_FUNCTION_DISPATCH_BASE_NAME(x) \ + , BOOST_PARAMETER_FUNCTION_DISPATCH_IS_CONST(x) \ + )<Args>::type(*)() \ + >(BOOST_PARAMETER_AUX_PP_NULLPTR) \ + , args \ + , 0L \ + BOOST_PP_SEQ_FOR_EACH( \ + BOOST_PARAMETER_FUNCTION_DISPATCH_ARG_CAST_R \ + , BOOST_PARAMETER_FUNCTION_DISPATCH_TAG_NAMESPACE(x) \ + , BOOST_PARAMETER_SPLIT_ARG_REQ_SEQ( \ + BOOST_PARAMETER_FUNCTION_DISPATCH_SPLIT_ARGS(x) \ + ) \ + ) \ + ); \ + } \ + BOOST_PP_REPEAT_FROM_TO( \ + 0 \ + , BOOST_PARAMETER_SPLIT_ARG_OPT_COUNT( \ + BOOST_PARAMETER_FUNCTION_DISPATCH_SPLIT_ARGS(x) \ + ) \ + , BOOST_PARAMETER_FUNCTION_DISPATCH_OVERLOAD_Z \ + , x \ + ) \ + BOOST_PARAMETER_FUNCTION_DISPATCH_HEAD_TPL( \ + BOOST_PARAMETER_SPLIT_ARG_OPT_COUNT( \ + BOOST_PARAMETER_FUNCTION_DISPATCH_SPLIT_ARGS(x) \ + ) \ + , x \ + ) \ + inline BOOST_PARAMETER_FUNCTION_DISPATCH_HEAD_PRN( \ + BOOST_PARAMETER_SPLIT_ARG_OPT_COUNT( \ + BOOST_PARAMETER_FUNCTION_DISPATCH_SPLIT_ARGS(x) \ + ) \ + , x \ + , 0 \ + , 0 \ + ) +/**/ + +#endif // include guard + diff --git a/boost/parameter/aux_/preprocessor/impl/function_dispatch_tuple.hpp b/boost/parameter/aux_/preprocessor/impl/function_dispatch_tuple.hpp new file mode 100644 index 0000000000..b24c898e69 --- /dev/null +++ b/boost/parameter/aux_/preprocessor/impl/function_dispatch_tuple.hpp @@ -0,0 +1,33 @@ +// Copyright Daniel Wallin 2006. +// 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_AUX_PREPROCESSOR_IMPL_FUNCTION_DISPATCH_TUPLE_HPP +#define BOOST_PARAMETER_AUX_PREPROCESSOR_IMPL_FUNCTION_DISPATCH_TUPLE_HPP + +#include <boost/preprocessor/tuple/elem.hpp> + +// Accessor macros for the input tuple to the dispatch macros. +#define BOOST_PARAMETER_FUNCTION_DISPATCH_BASE_NAME(x) \ + BOOST_PP_TUPLE_ELEM(5, 0, x) +/**/ + +#define BOOST_PARAMETER_FUNCTION_DISPATCH_SPLIT_ARGS(x) \ + BOOST_PP_TUPLE_ELEM(5, 1, x) +/**/ + +#define BOOST_PARAMETER_FUNCTION_DISPATCH_IS_MEMBER(x) \ + BOOST_PP_TUPLE_ELEM(5, 2, x) +/**/ + +#define BOOST_PARAMETER_FUNCTION_DISPATCH_IS_CONST(x) \ + BOOST_PP_TUPLE_ELEM(5, 3, x) +/**/ + +#define BOOST_PARAMETER_FUNCTION_DISPATCH_TAG_NAMESPACE(x) \ + BOOST_PP_TUPLE_ELEM(5, 4, x) +/**/ + +#endif // include guard + diff --git a/boost/parameter/aux_/preprocessor/impl/function_forward_match.hpp b/boost/parameter/aux_/preprocessor/impl/function_forward_match.hpp new file mode 100644 index 0000000000..3b452ed960 --- /dev/null +++ b/boost/parameter/aux_/preprocessor/impl/function_forward_match.hpp @@ -0,0 +1,43 @@ +// Copyright Daniel Wallin 2006. +// 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_AUX_PREPROCESSOR_IMPL_FUNCTION_FORWARD_MATCH_HPP +#define BOOST_PARAMETER_AUX_PREPROCESSOR_IMPL_FUNCTION_FORWARD_MATCH_HPP + +#include <boost/parameter/config.hpp> + +#if !defined(BOOST_NO_SFINAE) && \ + !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592)) + +#include <boost/parameter/aux_/pp_impl/match.hpp> +#include <boost/preprocessor/repetition/enum_trailing_params.hpp> + +// Expands to an extra argument that is well-formed +// iff all Args... satisfy the requirements set by params. +#define BOOST_PARAMETER_FUNCTION_FORWARD_MATCH(params, n, prefix) \ + , typename ::boost::parameter::aux::match< \ + params BOOST_PP_ENUM_TRAILING_PARAMS(n, prefix) \ + >::type = params() +/**/ + +#define BOOST_PARAMETER_FUNCTION_FORWARD_MATCH_Z(z, params, n, prefix) \ + , typename ::boost::parameter::aux::match< \ + params BOOST_PP_ENUM_TRAILING_PARAMS_Z(z, n, prefix) \ + >::type = params() +/**/ + +#else // SFINAE/Borland workarounds needed. + +#define BOOST_PARAMETER_FUNCTION_FORWARD_MATCH(params, n, prefix) \ + , params = params() +/**/ + +#define BOOST_PARAMETER_FUNCTION_FORWARD_MATCH_Z(z, params, n, prefix) \ + , params = params() +/**/ + +#endif +#endif // include guard + diff --git a/boost/parameter/aux_/preprocessor/impl/function_name.hpp b/boost/parameter/aux_/preprocessor/impl/function_name.hpp new file mode 100644 index 0000000000..af5d194c49 --- /dev/null +++ b/boost/parameter/aux_/preprocessor/impl/function_name.hpp @@ -0,0 +1,152 @@ +// Copyright Daniel Wallin 2006. +// 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_AUX_PREPROCESSOR_IMPL_FUNCTION_NAME_HPP +#define BOOST_PARAMETER_AUX_PREPROCESSOR_IMPL_FUNCTION_NAME_HPP + +#define BOOST_PARAMETER_MEMBER_FUNCTION_CHECK_STATIC_static () +/**/ + +#include <boost/parameter/aux_/preprocessor/is_nullary.hpp> +#include <boost/preprocessor/cat.hpp> + +#define BOOST_PARAMETER_MEMBER_FUNCTION_IS_STATIC(name) \ + BOOST_PARAMETER_IS_NULLARY( \ + BOOST_PP_CAT(BOOST_PARAMETER_MEMBER_FUNCTION_CHECK_STATIC_, name) \ + ) +/**/ + +#include <boost/preprocessor/seq/seq.hpp> +#include <boost/config.hpp> + +#if defined(BOOST_MSVC) + +// Workaround for MSVC preprocessor. +// +// When stripping static from "static f", msvc will produce " f". The leading +// whitespace doesn't go away when pasting the token with something else, so +// this thing is a hack to strip the whitespace. +#define BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC_static ( +/**/ + +#define BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC_AUX(name) \ + BOOST_PP_CAT(BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC_, name)) +/**/ + +#define BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC(name) \ + BOOST_PP_SEQ_HEAD( \ + BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC_AUX(name) \ + ) +/**/ + +#else + +#define BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC_static +/**/ + +#define BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC(name) \ + BOOST_PP_CAT(BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC_, name) +/**/ + +#endif // MSVC workarounds needed + +#include <boost/preprocessor/control/expr_if.hpp> + +#define BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(name) \ + BOOST_PP_EXPR_IF( \ + BOOST_PARAMETER_MEMBER_FUNCTION_IS_STATIC(name), static \ + ) +/**/ + +#include <boost/preprocessor/control/if.hpp> +#include <boost/preprocessor/tuple/eat.hpp> + +#define BOOST_PARAMETER_MEMBER_FUNCTION_NAME(name) \ + BOOST_PP_IF( \ + BOOST_PARAMETER_MEMBER_FUNCTION_IS_STATIC(name) \ + , BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC \ + , name BOOST_PP_TUPLE_EAT(1) \ + )(name) +/**/ + +// Produces a name for a parameter specification for the function named base. +#define BOOST_PARAMETER_FUNCTION_SPECIFICATION_NAME(base, is_const) \ + BOOST_PP_CAT( \ + BOOST_PP_CAT( \ + BOOST_PP_IF( \ + is_const \ + , boost_param_parameters_const_ \ + , boost_param_parameters_ \ + ) \ + , __LINE__ \ + ) \ + , BOOST_PARAMETER_MEMBER_FUNCTION_NAME(base) \ + ) +/**/ + +// Produces a name for a result type metafunction for the no-spec function +// named base. +#define BOOST_PARAMETER_NO_SPEC_FUNCTION_RESULT_NAME(base, is_const) \ + BOOST_PP_CAT( \ + BOOST_PP_CAT( \ + BOOST_PP_IF( \ + is_const \ + , boost_param_no_spec_result_const_ \ + , boost_param_no_spec_result_ \ + ) \ + , __LINE__ \ + ) \ + , BOOST_PARAMETER_MEMBER_FUNCTION_NAME(base) \ + ) +/**/ + +// Produces a name for a result type metafunction for the function named base. +#define BOOST_PARAMETER_FUNCTION_RESULT_NAME(base, is_const) \ + BOOST_PP_CAT( \ + BOOST_PP_CAT( \ + BOOST_PP_IF( \ + is_const \ + , boost_param_result_const_ \ + , boost_param_result_ \ + ) \ + , __LINE__ \ + ) \ + , BOOST_PARAMETER_MEMBER_FUNCTION_NAME(base) \ + ) +/**/ + +// Produces a name for the implementation function to which the no-spec +// function named base forwards its result type and argument pack. +#define BOOST_PARAMETER_NO_SPEC_FUNCTION_IMPL_NAME(base, is_const) \ + BOOST_PP_CAT( \ + BOOST_PP_CAT( \ + BOOST_PP_IF( \ + is_const \ + , boost_param_no_spec_impl_const \ + , boost_param_no_spec_impl \ + ) \ + , __LINE__ \ + ) \ + , BOOST_PARAMETER_MEMBER_FUNCTION_NAME(base) \ + ) +/**/ + +// Can't do boost_param_impl_ ## basee +// because base might start with an underscore. +// daniel: what? how is that relevant? the reason for using CAT() +// is to make sure base is expanded. i'm not sure we need to here, +// but it's more stable to do it. +#define BOOST_PARAMETER_FUNCTION_IMPL_NAME(base, is_const) \ + BOOST_PP_CAT( \ + BOOST_PP_CAT( \ + BOOST_PP_IF(is_const, boost_param_impl_const, boost_param_impl) \ + , __LINE__ \ + ) \ + , BOOST_PARAMETER_MEMBER_FUNCTION_NAME(base) \ + ) +/**/ + +#endif // include guard + diff --git a/boost/parameter/aux_/preprocessor/impl/no_spec_overloads.hpp b/boost/parameter/aux_/preprocessor/impl/no_spec_overloads.hpp new file mode 100644 index 0000000000..345e408dd4 --- /dev/null +++ b/boost/parameter/aux_/preprocessor/impl/no_spec_overloads.hpp @@ -0,0 +1,331 @@ +// 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_AUX_PREPROCESSOR_IMPL_NO_SPEC_OVERLOADS_HPP +#define BOOST_PARAMETER_AUX_PREPROCESSOR_IMPL_NO_SPEC_OVERLOADS_HPP + +#include <boost/parameter/aux_/preprocessor/impl/function_name.hpp> + +// Defines the no-spec implementation function header. +#define BOOST_PARAMETER_NO_SPEC_FUNCTION_IMPL_HEAD(name, is_const) \ + template <typename ResultType, typename Args> \ + BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(name) ResultType \ + BOOST_PARAMETER_NO_SPEC_FUNCTION_IMPL_NAME( \ + name, is_const \ + )(ResultType(*)(), Args const& args) +/**/ + +#include <boost/parameter/config.hpp> + +#if defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING) + +#include <boost/parameter/aux_/preprocessor/impl/parenthesized_return_type.hpp> + +// Expands to the result metafunction for the specified no-spec function. +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#define BOOST_PARAMETER_NO_SPEC_FUNCTION_HEAD(result, name, is_const) \ + template <typename TaggedArg0, typename ...TaggedArgs> \ + using BOOST_PARAMETER_NO_SPEC_FUNCTION_RESULT_NAME(name, is_const) \ + = typename BOOST_PARAMETER_PARENTHESIZED_RETURN_TYPE(result); +/**/ +#else +#define BOOST_PARAMETER_NO_SPEC_FUNCTION_HEAD(result, name, is_const) \ + template <typename TaggedArg0, typename ...TaggedArgs> \ + struct BOOST_PARAMETER_NO_SPEC_FUNCTION_RESULT_NAME(name, is_const) \ + : BOOST_PARAMETER_PARENTHESIZED_RETURN_TYPE(result) \ + { \ + }; +/**/ +#endif // BOOST_PARAMETER_CAN_USE_MP11 + +#include <boost/parameter/compose.hpp> +#include <boost/parameter/are_tagged_arguments.hpp> +#include <boost/parameter/aux_/preprocessor/impl/parenthesized_type.hpp> +#include <boost/core/enable_if.hpp> + +// Exapnds to a variadic constructor that is enabled if and only if all its +// arguments are tagged arguments. The enclosing class must inherit from the +// specified base class, which in turn must implement a constructor that takes +// in the argument pack that this one passes on. +#define BOOST_PARAMETER_NO_SPEC_CONSTRUCTOR(class_, base) \ + template < \ + typename TaggedArg0 \ + , typename ...TaggedArgs \ + , typename = typename ::boost::enable_if< \ + ::boost::parameter \ + ::are_tagged_arguments<TaggedArg0,TaggedArgs...> \ + >::type \ + > inline explicit \ + class_(TaggedArg0 const& arg0, TaggedArgs const&... args) \ + : BOOST_PARAMETER_PARENTHESIZED_TYPE(base)( \ + ::boost::parameter::compose(arg0, args...) \ + ) \ + { \ + } +/**/ + +// Exapnds to a variadic constructor that is enabled if and only if all its +// arguments are tagged arguments. The specified function must be able to +// take in the argument pack that this constructor passes on. +#define BOOST_PARAMETER_NO_SPEC_NO_BASE_CONSTRUCTOR(class_, func) \ + template < \ + typename TaggedArg0 \ + , typename ...TaggedArgs \ + , typename = typename ::boost::enable_if< \ + ::boost::parameter \ + ::are_tagged_arguments<TaggedArg0,TaggedArgs...> \ + >::type \ + > inline explicit \ + class_(TaggedArg0 const& arg0, TaggedArgs const&... args) \ + { \ + func(::boost::parameter::compose(arg0, args...)); \ + } +/**/ + +#include <boost/parameter/aux_/preprocessor/nullptr.hpp> +#include <boost/preprocessor/control/expr_if.hpp> + +// Exapnds to a variadic function that is enabled if and only if +// all its arguments are tagged arguments. +#define BOOST_PARAMETER_NO_SPEC_FUNCTION_OVERLOAD(name, impl, is_m, c) \ + template <typename TaggedArg0, typename ...TaggedArgs> \ + BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(impl) \ + inline typename ::boost::lazy_enable_if< \ + ::boost::parameter \ + ::are_tagged_arguments<TaggedArg0,TaggedArgs...> \ + , BOOST_PARAMETER_NO_SPEC_FUNCTION_RESULT_NAME( \ + impl, c \ + )<TaggedArg0,TaggedArgs...> \ + >::type BOOST_PARAMETER_MEMBER_FUNCTION_NAME(name) \ + (TaggedArg0 const& arg0, TaggedArgs const&... args) \ + BOOST_PP_EXPR_IF(c, const) \ + { \ + return BOOST_PP_EXPR_IF(is_m, this->) \ + BOOST_PARAMETER_NO_SPEC_FUNCTION_IMPL_NAME(impl, c)( \ + static_cast< \ + typename BOOST_PARAMETER_NO_SPEC_FUNCTION_RESULT_NAME( \ + impl, c \ + )<TaggedArg0,TaggedArgs...>::type(*)() \ + >(BOOST_PARAMETER_AUX_PP_NULLPTR) \ + , ::boost::parameter::compose(arg0, args...) \ + ); \ + } +/**/ + +#else // !defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING) + +#include <boost/parameter/aux_/void.hpp> +#include <boost/parameter/aux_/preprocessor/impl/parenthesized_return_type.hpp> +#include <boost/preprocessor/facilities/intercept.hpp> +#include <boost/preprocessor/repetition/enum_binary_params.hpp> + +// Expands to the result metafunction for the specified no-spec function. +#define BOOST_PARAMETER_NO_SPEC_FUNCTION_HEAD(result, name, is_const) \ + template < \ + BOOST_PP_ENUM_BINARY_PARAMS( \ + BOOST_PARAMETER_COMPOSE_MAX_ARITY \ + , typename TaggedArg \ + , = ::boost::parameter::void_ BOOST_PP_INTERCEPT \ + ) \ + > \ + struct BOOST_PARAMETER_NO_SPEC_FUNCTION_RESULT_NAME(name, is_const) \ + : BOOST_PARAMETER_PARENTHESIZED_RETURN_TYPE(result) \ + { \ + }; +/**/ + +#include <boost/parameter/compose.hpp> +#include <boost/parameter/aux_/preprocessor/impl/parenthesized_type.hpp> +#include <boost/preprocessor/comparison/equal.hpp> +#include <boost/preprocessor/control/expr_if.hpp> +#include <boost/preprocessor/repetition/enum_params.hpp> +#include <boost/preprocessor/tuple/elem.hpp> + +#if defined(BOOST_NO_SFINAE) + +// Exapnds to a tagged-argument constructor overload that passes the argument +// pack to the base class delegate constructor. +#define BOOST_PARAMETER_NO_SPEC_CONSTRUCTOR_OVERLOAD_Z(z, n, data) \ + template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename TaggedArg)> \ + BOOST_PP_EXPR_IF(BOOST_PP_EQUAL(n, 1), explicit) inline \ + BOOST_PP_TUPLE_ELEM(2, 0, data)( \ + BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, TaggedArg, const& arg) \ + ) : BOOST_PARAMETER_PARENTHESIZED_TYPE(BOOST_PP_TUPLE_ELEM(2, 1, data))( \ + ::boost::parameter::compose(BOOST_PP_ENUM_PARAMS_Z(z, n, arg)) \ + ) \ + { \ + } +/**/ + +// Exapnds to a tagged-argument constructor overload that passes the argument +// pack to the delegate function. +#define BOOST_PARAMETER_NO_SPEC_NO_BASE_CONSTRUCTOR_OVERLOAD_Z(z, n, data) \ + template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename TaggedArg)> \ + BOOST_PP_EXPR_IF(BOOST_PP_EQUAL(n, 1), explicit) inline \ + BOOST_PP_TUPLE_ELEM(2, 0, data)( \ + BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, TaggedArg, const& a) \ + ) \ + { \ + BOOST_PP_TUPLE_ELEM(2, 1, data)( \ + ::boost::parameter::compose(BOOST_PP_ENUM_PARAMS_Z(z, n, a)) \ + ); \ + } +/**/ + +#include <boost/parameter/aux_/preprocessor/nullptr.hpp> + +// Exapnds to a tagged-argument function overload. +#define BOOST_PARAMETER_NO_SPEC_FUNCTION_OVERLOAD_Z(z, n, data) \ + template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename TaggedArg)> \ + BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(BOOST_PP_TUPLE_ELEM(4, 1, data)) \ + inline typename BOOST_PARAMETER_NO_SPEC_FUNCTION_RESULT_NAME( \ + BOOST_PP_TUPLE_ELEM(4, 1, data) \ + , BOOST_PP_TUPLE_ELEM(4, 3, data) \ + )<BOOST_PP_ENUM_PARAMS_Z(z, n, TaggedArg)>::type \ + BOOST_PARAMETER_MEMBER_FUNCTION_NAME( \ + BOOST_PP_TUPLE_ELEM(4, 0, data) \ + )(BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, TaggedArg, const& arg)) \ + BOOST_PP_EXPR_IF(BOOST_PP_TUPLE_ELEM(4, 3, data), const) \ + { \ + return BOOST_PP_EXPR_IF(BOOST_PP_TUPLE_ELEM(4, 2, data), this->) \ + BOOST_PARAMETER_NO_SPEC_FUNCTION_IMPL_NAME( \ + BOOST_PP_TUPLE_ELEM(4, 1, data) \ + , BOOST_PP_TUPLE_ELEM(4, 3, data) \ + )( \ + static_cast< \ + typename BOOST_PARAMETER_NO_SPEC_FUNCTION_RESULT_NAME( \ + BOOST_PP_TUPLE_ELEM(4, 1, data) \ + , BOOST_PP_TUPLE_ELEM(4, 3, data) \ + )<BOOST_PP_ENUM_PARAMS_Z(z, n, TaggedArg)>::type(*)() \ + >(BOOST_PARAMETER_AUX_PP_NULLPTR) \ + , ::boost::parameter::compose(BOOST_PP_ENUM_PARAMS_Z(z, n, arg)) \ + ); \ + } +/**/ + +#else // !defined(BOOST_NO_SFINAE) + +#include <boost/parameter/are_tagged_arguments.hpp> +#include <boost/parameter/aux_/preprocessor/nullptr.hpp> +#include <boost/core/enable_if.hpp> + +// Exapnds to a tagged-argument constructor overload that passes the argument +// pack to the base class delegate constructor. This constructor is enabled +// if and only if all its arguments are tagged arguments. +#define BOOST_PARAMETER_NO_SPEC_CONSTRUCTOR_OVERLOAD_Z(z, n, data) \ + template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename TaggedArg)> \ + BOOST_PP_EXPR_IF(BOOST_PP_EQUAL(n, 1), explicit) inline \ + BOOST_PP_TUPLE_ELEM(2, 0, data)( \ + BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, TaggedArg, const& arg) \ + , typename ::boost::enable_if< \ + ::boost::parameter::are_tagged_arguments< \ + BOOST_PP_ENUM_PARAMS_Z(z, n, TaggedArg) \ + > \ + >::type* = BOOST_PARAMETER_AUX_PP_NULLPTR \ + ) : BOOST_PARAMETER_PARENTHESIZED_TYPE(BOOST_PP_TUPLE_ELEM(2, 1, data))( \ + ::boost::parameter::compose(BOOST_PP_ENUM_PARAMS_Z(z, n, arg)) \ + ) \ + { \ + } +/**/ + +// Exapnds to a tagged-argument constructor overload that passes the argument +// pack to the delegate function. This constructor is enabled if and only if +// all its arguments are tagged arguments. +#define BOOST_PARAMETER_NO_SPEC_NO_BASE_CONSTRUCTOR_OVERLOAD_Z(z, n, data) \ + template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename TaggedArg)> \ + BOOST_PP_EXPR_IF(BOOST_PP_EQUAL(n, 1), explicit) inline \ + BOOST_PP_TUPLE_ELEM(2, 0, data)( \ + BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, TaggedArg, const& a) \ + , typename ::boost::enable_if< \ + ::boost::parameter::are_tagged_arguments< \ + BOOST_PP_ENUM_PARAMS_Z(z, n, TaggedArg) \ + > \ + >::type* = BOOST_PARAMETER_AUX_PP_NULLPTR \ + ) \ + { \ + BOOST_PP_TUPLE_ELEM(2, 1, data)( \ + ::boost::parameter::compose(BOOST_PP_ENUM_PARAMS_Z(z, n, a)) \ + ); \ + } +/**/ + +// Exapnds to a function overload that is enabled if and only if +// all its arguments are tagged arguments. +#define BOOST_PARAMETER_NO_SPEC_FUNCTION_OVERLOAD_Z(z, n, data) \ + template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename TaggedArg)> \ + BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(BOOST_PP_TUPLE_ELEM(4, 1, data)) \ + inline typename ::boost::lazy_enable_if< \ + ::boost::parameter \ + ::are_tagged_arguments<BOOST_PP_ENUM_PARAMS_Z(z, n, TaggedArg)> \ + , BOOST_PARAMETER_NO_SPEC_FUNCTION_RESULT_NAME( \ + BOOST_PP_TUPLE_ELEM(4, 1, data) \ + , BOOST_PP_TUPLE_ELEM(4, 3, data) \ + )<BOOST_PP_ENUM_PARAMS_Z(z, n, TaggedArg)> \ + >::type BOOST_PARAMETER_MEMBER_FUNCTION_NAME( \ + BOOST_PP_TUPLE_ELEM(4, 0, data) \ + )(BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, TaggedArg, const& arg)) \ + BOOST_PP_EXPR_IF(BOOST_PP_TUPLE_ELEM(4, 3, data), const) \ + { \ + return BOOST_PP_EXPR_IF(BOOST_PP_TUPLE_ELEM(4, 2, data), this->) \ + BOOST_PARAMETER_NO_SPEC_FUNCTION_IMPL_NAME( \ + BOOST_PP_TUPLE_ELEM(4, 1, data) \ + , BOOST_PP_TUPLE_ELEM(4, 3, data) \ + )( \ + static_cast< \ + typename BOOST_PARAMETER_NO_SPEC_FUNCTION_RESULT_NAME( \ + BOOST_PP_TUPLE_ELEM(4, 1, data) \ + , BOOST_PP_TUPLE_ELEM(4, 3, data) \ + )<BOOST_PP_ENUM_PARAMS_Z(z, n, TaggedArg)>::type(*)() \ + >(BOOST_PARAMETER_AUX_PP_NULLPTR) \ + , ::boost::parameter::compose(BOOST_PP_ENUM_PARAMS_Z(z, n, arg)) \ + ); \ + } +/**/ + +#endif // BOOST_NO_SFINAE + +#include <boost/preprocessor/arithmetic/inc.hpp> +#include <boost/preprocessor/repetition/repeat_from_to.hpp> + +// Emulates a variadic constructor that is enabled if and only if all its +// arguments are tagged arguments. The enclosing class must inherit from the +// specified base class, which in turn must implement a constructor that takes +// in the argument pack that this one passes on. +#define BOOST_PARAMETER_NO_SPEC_CONSTRUCTOR(class_, base) \ + BOOST_PP_REPEAT_FROM_TO( \ + 1 \ + , BOOST_PP_INC(BOOST_PARAMETER_COMPOSE_MAX_ARITY) \ + , BOOST_PARAMETER_NO_SPEC_CONSTRUCTOR_OVERLOAD_Z \ + , (class_, base) \ + ) +/**/ + +// Emulates a variadic constructor that is enabled if and only if all its +// arguments are tagged arguments. The specified function must be able to +// take in the argument pack that this constructor passes on. +#define BOOST_PARAMETER_NO_SPEC_NO_BASE_CONSTRUCTOR(class_, func) \ + BOOST_PP_REPEAT_FROM_TO( \ + 1 \ + , BOOST_PP_INC(BOOST_PARAMETER_COMPOSE_MAX_ARITY) \ + , BOOST_PARAMETER_NO_SPEC_NO_BASE_CONSTRUCTOR_OVERLOAD_Z \ + , (class_, func) \ + ) +/**/ + +// Emulates a variadic function that is enabled if and only if +// all its arguments are tagged arguments. +#define BOOST_PARAMETER_NO_SPEC_FUNCTION_OVERLOAD(name, impl, is_m, c) \ + BOOST_PP_REPEAT_FROM_TO( \ + 1 \ + , BOOST_PP_INC(BOOST_PARAMETER_COMPOSE_MAX_ARITY) \ + , BOOST_PARAMETER_NO_SPEC_FUNCTION_OVERLOAD_Z \ + , (name, impl, is_m, c) \ + ) +/**/ + +#endif // BOOST_PARAMETER_HAS_PERFECT_FORWARDING +#endif // include guard + diff --git a/boost/parameter/aux_/preprocessor/impl/parenthesized_return_type.hpp b/boost/parameter/aux_/preprocessor/impl/parenthesized_return_type.hpp new file mode 100644 index 0000000000..6bd8a62951 --- /dev/null +++ b/boost/parameter/aux_/preprocessor/impl/parenthesized_return_type.hpp @@ -0,0 +1,122 @@ +// Copyright Cromwell D. Enage 2019. +// 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_AUX_PREPROCESSOR_IMPL_PARENTHESIZED_RETURN_TYPE_HPP +#define BOOST_PARAMETER_AUX_PREPROCESSOR_IMPL_PARENTHESIZED_RETURN_TYPE_HPP + +namespace boost { namespace parameter { namespace aux { + + // A metafunction that transforms void(*)(T) -> identity<T> + template <typename UnaryFunctionPointer> + struct unaryfunptr_return_type; +}}} // namespace boost::parameter::aux + +#include <boost/parameter/config.hpp> + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <boost/mp11/utility.hpp> +#else +#include <boost/mpl/identity.hpp> +#endif + +namespace boost { namespace parameter { namespace aux { + + template <typename Arg> + struct unaryfunptr_return_type<void(*)(Arg)> + { +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using type = ::boost::mp11::mp_identity<Arg>; +#else + typedef ::boost::mpl::identity<Arg> type; +#endif + }; + + template <> + struct unaryfunptr_return_type<void(*)(void)> + { +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using type = ::boost::mp11::mp_identity<void>; +#else + typedef ::boost::mpl::identity<void> type; +#endif + }; +}}} // namespace boost::parameter::aux + +#if !defined(BOOST_NO_SFINAE) +#include <boost/core/enable_if.hpp> + +namespace boost { namespace parameter { namespace aux { + + template <typename Pred, typename Ret> + struct unaryfunptr_return_type<void(*)(::boost::enable_if<Pred,Ret>)> + { + typedef ::boost::enable_if<Pred,Ret> type; + }; + + template <bool b, typename Ret> + struct unaryfunptr_return_type<void(*)(::boost::enable_if_c<b,Ret>)> + { + typedef ::boost::enable_if_c<b,Ret> type; + }; + + template <typename Pred, typename Ret> + struct unaryfunptr_return_type<void(*)(::boost::lazy_enable_if<Pred,Ret>)> + { + typedef ::boost::lazy_enable_if<Pred,Ret> type; + }; + + template <bool b, typename Ret> + struct unaryfunptr_return_type<void(*)(::boost::lazy_enable_if_c<b,Ret>)> + { + typedef ::boost::lazy_enable_if_c<b,Ret> type; + }; + + template <typename Pred, typename Ret> + struct unaryfunptr_return_type<void(*)(::boost::disable_if<Pred,Ret>)> + { + typedef ::boost::disable_if<Pred,Ret> type; + }; + + template <bool b, typename Ret> + struct unaryfunptr_return_type<void(*)(::boost::disable_if_c<b,Ret>)> + { + typedef ::boost::disable_if_c<b,Ret> type; + }; + + template <typename B, typename Ret> + struct unaryfunptr_return_type<void(*)(::boost::lazy_disable_if<B,Ret>)> + { + typedef ::boost::lazy_disable_if<B,Ret> type; + }; + + template <bool b, typename Ret> + struct unaryfunptr_return_type<void(*)(::boost::lazy_disable_if_c<b,Ret>)> + { + typedef ::boost::lazy_disable_if_c<b,Ret> type; + }; +}}} // namespace boost::parameter::aux + +#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS) +#include <type_traits> + +namespace boost { namespace parameter { namespace aux { + + template <bool b, typename Ret> + struct unaryfunptr_return_type<void(*)(::std::enable_if<b,Ret>)> + { + typedef ::std::enable_if<b,Ret> type; + }; +}}} // namespace boost::parameter::aux + +#endif // BOOST_NO_CXX11_HDR_TYPE_TRAITS +#endif // BOOST_NO_SFINAE + +// A macro that takes a parenthesized C++ type name (T) and transforms it +// into an un-parenthesized type expression equivalent to identity<T>. +#define BOOST_PARAMETER_PARENTHESIZED_RETURN_TYPE(x) \ + ::boost::parameter::aux::unaryfunptr_return_type< void(*)x >::type + +#endif // include guard + diff --git a/boost/parameter/aux_/preprocessor/impl/parenthesized_type.hpp b/boost/parameter/aux_/preprocessor/impl/parenthesized_type.hpp new file mode 100644 index 0000000000..f3d9ed9a90 --- /dev/null +++ b/boost/parameter/aux_/preprocessor/impl/parenthesized_type.hpp @@ -0,0 +1,34 @@ +// Copyright David Abrahams 2006. +// 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_AUX_PREPROCESSOR_IMPL_PARENTHESIZED_TYPE_HPP +#define BOOST_PARAMETER_AUX_PREPROCESSOR_IMPL_PARENTHESIZED_TYPE_HPP + +namespace boost { namespace parameter { namespace aux { + + // A metafunction that transforms void(*)(T) -> T + template <typename UnaryFunctionPointer> + struct unaryfunptr_arg_type; + + template <typename Arg> + struct unaryfunptr_arg_type<void(*)(Arg)> + { + typedef Arg type; + }; + + template <> + struct unaryfunptr_arg_type<void(*)(void)> + { + typedef void type; + }; +}}} // namespace boost::parameter::aux + +// A macro that takes a parenthesized C++ type name (T) and transforms it +// into an un-parenthesized type expression equivalent to T. +#define BOOST_PARAMETER_PARENTHESIZED_TYPE(x) \ + ::boost::parameter::aux::unaryfunptr_arg_type< void(*)x >::type + +#endif // include guard + diff --git a/boost/parameter/aux_/preprocessor/impl/specification.hpp b/boost/parameter/aux_/preprocessor/impl/specification.hpp new file mode 100644 index 0000000000..d2a4638a83 --- /dev/null +++ b/boost/parameter/aux_/preprocessor/impl/specification.hpp @@ -0,0 +1,109 @@ +// Copyright Daniel Wallin 2006. +// 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_AUX_PREPROCESSOR_IMPL_SPECIFICATION_HPP +#define BOOST_PARAMETER_AUX_PREPROCESSOR_IMPL_SPECIFICATION_HPP + +#include <boost/parameter/optional.hpp> + +// Helper macros for BOOST_PARAMETER_SPECIFICATION_ELEM_R. +#define BOOST_PARAMETER_QUALIFIED_TAG_optional(tag) \ + optional<tag +/**/ + +#include <boost/parameter/required.hpp> + +#define BOOST_PARAMETER_QUALIFIED_TAG_required(tag) \ + required<tag +/**/ + +#include <boost/parameter/deduced.hpp> + +#define BOOST_PARAMETER_QUALIFIED_TAG_deduced_optional(tag) \ + optional< ::boost::parameter::deduced<tag> +/**/ + +#define BOOST_PARAMETER_QUALIFIED_TAG_deduced_required(tag) \ + required< ::boost::parameter::deduced<tag> +/**/ + +#include <boost/parameter/aux_/preprocessor/impl/argument_specs.hpp> +#include <boost/parameter/config.hpp> +#include <boost/preprocessor/punctuation/comma_if.hpp> +#include <boost/preprocessor/cat.hpp> + +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) + +#include <boost/parameter/aux_/use_default.hpp> + +#define BOOST_PARAMETER_SPECIFICATION_ELEM_R(r, tag_namespace, i, elem) \ + BOOST_PP_COMMA_IF(i) ::boost::parameter::BOOST_PP_CAT( \ + BOOST_PARAMETER_QUALIFIED_TAG_ \ + , BOOST_PARAMETER_FN_ARG_QUALIFIER(elem) \ + )(tag_namespace::BOOST_PARAMETER_FN_ARG_NAME(elem)) \ + , ::boost::parameter::aux::use_default \ + > +/**/ + +#else // !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) + +#include <boost/parameter/aux_/pp_impl/unwrap_predicate.hpp> + +// Expands to each boost::parameter::parameters<> element type. +#define BOOST_PARAMETER_SPECIFICATION_ELEM_R(r, tag_namespace, i, elem) \ + BOOST_PP_COMMA_IF(i) ::boost::parameter::BOOST_PP_CAT( \ + BOOST_PARAMETER_QUALIFIED_TAG_ \ + , BOOST_PARAMETER_FN_ARG_QUALIFIER(elem) \ + )(tag_namespace::BOOST_PARAMETER_FN_ARG_NAME(elem)) \ + , typename ::boost::parameter::aux::unwrap_predicate< \ + void BOOST_PARAMETER_FN_ARG_PRED(elem) \ + >::type \ + > +/**/ + +#endif // Borland workarounds needed. + +#include <boost/parameter/parameters.hpp> +#include <boost/parameter/aux_/preprocessor/impl/function_name.hpp> +#include <boost/preprocessor/control/if.hpp> +#include <boost/preprocessor/seq/for_each_i.hpp> + +// Expands to a boost::parameter::parameters<> specialization for the +// function named base. Used by BOOST_PARAMETER_CONSTRUCTOR_AUX and +// BOOST_PARAMETER_FUNCTION_HEAD for their respective ParameterSpec models. +#define BOOST_PARAMETER_SPECIFICATION(tag_ns, base, split_args, is_const) \ + template <typename BoostParameterDummy> \ + struct BOOST_PP_CAT( \ + BOOST_PP_CAT( \ + BOOST_PP_IF( \ + is_const \ + , boost_param_params_const_ \ + , boost_param_params_ \ + ) \ + , __LINE__ \ + ) \ + , BOOST_PARAMETER_MEMBER_FUNCTION_NAME(base) \ + ) : ::boost::parameter::parameters< \ + BOOST_PP_SEQ_FOR_EACH_I( \ + BOOST_PARAMETER_SPECIFICATION_ELEM_R, tag_ns, split_args \ + ) \ + > \ + { \ + }; \ + typedef BOOST_PP_CAT( \ + BOOST_PP_CAT( \ + BOOST_PP_IF( \ + is_const \ + , boost_param_params_const_ \ + , boost_param_params_ \ + ) \ + , __LINE__ \ + ) \ + , BOOST_PARAMETER_MEMBER_FUNCTION_NAME(base) \ + )<int> +/**/ + +#endif // include guard + diff --git a/boost/parameter/aux_/preprocessor/impl/split_args.hpp b/boost/parameter/aux_/preprocessor/impl/split_args.hpp new file mode 100644 index 0000000000..bfda33b393 --- /dev/null +++ b/boost/parameter/aux_/preprocessor/impl/split_args.hpp @@ -0,0 +1,71 @@ +// Copyright Daniel Wallin 2006. +// 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_AUX_PREPROCESSOR_IMPL_SPLIT_ARGS_HPP +#define BOOST_PARAMETER_AUX_PREPROCESSOR_IMPL_SPLIT_ARGS_HPP + +#include <boost/preprocessor/tuple/elem.hpp> + +// Accessor macros for the split_args tuple. +#define BOOST_PARAMETER_SPLIT_ARG_REQ_COUNT(x) BOOST_PP_TUPLE_ELEM(4, 0, x) +#define BOOST_PARAMETER_SPLIT_ARG_REQ_SEQ(x) BOOST_PP_TUPLE_ELEM(4, 1, x) +#define BOOST_PARAMETER_SPLIT_ARG_OPT_COUNT(x) BOOST_PP_TUPLE_ELEM(4, 2, x) +#define BOOST_PARAMETER_SPLIT_ARG_OPT_SEQ(x) BOOST_PP_TUPLE_ELEM(4, 3, x) + +#include <boost/preprocessor/arithmetic/inc.hpp> +#include <boost/preprocessor/seq/push_back.hpp> + +// Helper macros for BOOST_PARAMETER_FUNCTION_SPLIT_ARGS. +#define BOOST_PARAMETER_FUNCTION_SPLIT_ARG_required(s_a, arg) \ + ( \ + BOOST_PP_INC(BOOST_PARAMETER_SPLIT_ARG_REQ_COUNT(s_a)) \ + , BOOST_PP_SEQ_PUSH_BACK(BOOST_PARAMETER_SPLIT_ARG_REQ_SEQ(s_a), arg) \ + , BOOST_PARAMETER_SPLIT_ARG_OPT_COUNT(s_a) \ + , BOOST_PARAMETER_SPLIT_ARG_OPT_SEQ(s_a) \ + ) +/**/ + +#define BOOST_PARAMETER_FUNCTION_SPLIT_ARG_deduced_required(split_args, arg) \ + BOOST_PARAMETER_FUNCTION_SPLIT_ARG_required(split_args, arg) +/**/ + +#define BOOST_PARAMETER_FUNCTION_SPLIT_ARG_optional(s_a, arg) \ + ( \ + BOOST_PARAMETER_SPLIT_ARG_REQ_COUNT(s_a) \ + , BOOST_PARAMETER_SPLIT_ARG_REQ_SEQ(s_a) \ + , BOOST_PP_INC(BOOST_PARAMETER_SPLIT_ARG_OPT_COUNT(s_a)) \ + , BOOST_PP_SEQ_PUSH_BACK(BOOST_PARAMETER_SPLIT_ARG_OPT_SEQ(s_a), arg) \ + ) +/**/ + +#define BOOST_PARAMETER_FUNCTION_SPLIT_ARG_deduced_optional(split_args, arg) \ + BOOST_PARAMETER_FUNCTION_SPLIT_ARG_optional(split_args, arg) +/**/ + +#include <boost/parameter/aux_/preprocessor/impl/argument_specs.hpp> +#include <boost/preprocessor/cat.hpp> + +#define BOOST_PARAMETER_FUNCTION_SPLIT_ARG(s, split_args, arg) \ + BOOST_PP_CAT( \ + BOOST_PARAMETER_FUNCTION_SPLIT_ARG_ \ + , BOOST_PARAMETER_FN_ARG_QUALIFIER(arg) \ + )(split_args, arg) +/**/ + +#include <boost/preprocessor/seq/fold_left.hpp> +#include <boost/preprocessor/seq/seq.hpp> + +// Expands from the flattened BOOST_PARAMETER_FUNCTION et. al. arg sequence to +// the tuple (required_count, required_args, optional_count, optional_args). +#define BOOST_PARAMETER_FUNCTION_SPLIT_ARGS(args) \ + BOOST_PP_SEQ_FOLD_LEFT( \ + BOOST_PARAMETER_FUNCTION_SPLIT_ARG \ + , (0, BOOST_PP_SEQ_NIL, 0, BOOST_PP_SEQ_NIL) \ + , args \ + ) +/**/ + +#endif // include guard + diff --git a/boost/parameter/aux_/preprocessor/inc_binary_seq.hpp b/boost/parameter/aux_/preprocessor/inc_binary_seq.hpp new file mode 100644 index 0000000000..9796e336a1 --- /dev/null +++ b/boost/parameter/aux_/preprocessor/inc_binary_seq.hpp @@ -0,0 +1,78 @@ +// Copyright Cromwell D. Enage 2013. +// 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_AUX_PREPROCESSOR_INC_BINARY_SEQ_HPP +#define BOOST_PARAMETER_AUX_PREPROCESSOR_INC_BINARY_SEQ_HPP + +#include <boost/preprocessor/seq/push_back.hpp> + +// This macro keeps the rest of the sequence if carry == 0. +#define BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ_0(seq, element) \ + (BOOST_PP_SEQ_PUSH_BACK(seq, element), 0) +/**/ + +#include <boost/preprocessor/control/iif.hpp> + +// This macro updates the rest of the sequence if carry == 1. +#define BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ_1(seq, element) \ + (BOOST_PP_SEQ_PUSH_BACK(seq, BOOST_PP_IIF(element, 0, 1)), element) +/**/ + +#include <boost/preprocessor/tuple/elem.hpp> +#include <boost/preprocessor/cat.hpp> + +// This macro maintains a tuple (seq, carry), where seq is the intermediate +// result and carry is a flag that will unset upon finding an element == 0. +#define BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ_OP(s, result_tuple, element) \ + BOOST_PP_CAT( \ + BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ_ \ + , BOOST_PP_TUPLE_ELEM(2, 1, result_tuple) \ + )(BOOST_PP_TUPLE_ELEM(2, 0, result_tuple), element) +/**/ + +// This macro keeps the sequence at its original length if carry == 0. +#define BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ_IMPL_0(seq) seq +/**/ + +// This macro appends a zero to seq if carry == 1. +#define BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ_IMPL_1(seq) \ + BOOST_PP_SEQ_PUSH_BACK(seq, 0) +/**/ + +// This macro takes in the tuple (seq, carry), with carry indicating whether +// or not seq originally contained all 1s. If so, then seq now contains all +// 0s, and this macro pushes an extra 0 before expanding to the new sequence. +// Otherwise, this macro expands to seq as is. +#define BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ_IMPL(seq_and_carry) \ + BOOST_PP_CAT( \ + BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ_IMPL_ \ + , BOOST_PP_TUPLE_ELEM(2, 1, seq_and_carry) \ + )(BOOST_PP_TUPLE_ELEM(2, 0, seq_and_carry)) +/**/ + +#include <boost/preprocessor/seq/seq.hpp> +#include <boost/preprocessor/seq/fold_left.hpp> + +// This macro treats the specified sequence of 1s and 0s like a binary number +// in reverse and expands to a sequence representing the next value up. +// However, if the input sequence contains all 1s, then the output sequence +// will contain one more element but all 0s. +// +// Examples: +// seq = (1)(0)(1)(0) --> return (0)(1)(1)(0) +// seq = (1)(1)(1)(0) --> return (0)(0)(0)(1) +// seq = (1)(1)(1)(1) --> return (0)(0)(0)(0)(0) +#define BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ(seq) \ + BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ_IMPL( \ + BOOST_PP_SEQ_FOLD_LEFT( \ + BOOST_PARAMETER_AUX_PP_INC_BINARY_SEQ_OP \ + , (BOOST_PP_SEQ_NIL, 1) \ + , seq \ + ) \ + ) +/**/ + +#endif // include guard + diff --git a/boost/parameter/aux_/preprocessor/is_binary.hpp b/boost/parameter/aux_/preprocessor/is_binary.hpp new file mode 100644 index 0000000000..a8f3c67afb --- /dev/null +++ b/boost/parameter/aux_/preprocessor/is_binary.hpp @@ -0,0 +1,31 @@ +// Copyright Daniel Wallin 2006. +// 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_AUX_PREPROCESSOR_IS_BINARY_HPP +#define BOOST_PARAMETER_AUX_PREPROCESSOR_IS_BINARY_HPP + +#include <boost/config.hpp> +#include <boost/config/workaround.hpp> + +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +// From Paul Mensonides +#include <boost/preprocessor/punctuation/comma.hpp> +#include <boost/preprocessor/detail/split.hpp> +#define BOOST_PARAMETER_IS_BINARY(x) \ + BOOST_PP_SPLIT(1, BOOST_PARAMETER_IS_BINARY_C x BOOST_PP_COMMA() 0) +/**/ +#include <boost/preprocessor/punctuation/paren.hpp> +#include <boost/preprocessor/tuple/eat.hpp> +#define BOOST_PARAMETER_IS_BINARY_C(x,y) \ + ~, 1 BOOST_PP_RPAREN() \ + BOOST_PP_TUPLE_EAT(2) BOOST_PP_LPAREN() ~ +/**/ +#else +#include <boost/preprocessor/detail/is_binary.hpp> +#define BOOST_PARAMETER_IS_BINARY(x) BOOST_PP_IS_BINARY(x) +#endif + +#endif // include guard + diff --git a/boost/parameter/aux_/preprocessor/is_nullary.hpp b/boost/parameter/aux_/preprocessor/is_nullary.hpp new file mode 100644 index 0000000000..5d8e59c538 --- /dev/null +++ b/boost/parameter/aux_/preprocessor/is_nullary.hpp @@ -0,0 +1,32 @@ +// Copyright Daniel Wallin 2006. +// 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_AUX_PREPROCESSOR_IS_NULLARY_HPP +#define BOOST_PARAMETER_AUX_PREPROCESSOR_IS_NULLARY_HPP + +#include <boost/config.hpp> +#include <boost/config/workaround.hpp> + +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +// From Paul Mensonides +#include <boost/preprocessor/punctuation/comma.hpp> +#include <boost/preprocessor/detail/split.hpp> +#define BOOST_PARAMETER_IS_NULLARY(x) \ + BOOST_PP_SPLIT(1, BOOST_PARAMETER_IS_NULLARY_C x BOOST_PP_COMMA() 0) +/**/ +#include <boost/preprocessor/punctuation/paren.hpp> +#include <boost/preprocessor/tuple/eat.hpp> +#define BOOST_PARAMETER_IS_NULLARY_C() \ + ~, 1 BOOST_PP_RPAREN() \ + BOOST_PP_TUPLE_EAT(2) BOOST_PP_LPAREN() ~ +/**/ +#else +#include <boost/preprocessor/detail/is_nullary.hpp> +#define BOOST_PARAMETER_IS_NULLARY(x) BOOST_PP_IS_NULLARY(x) +/**/ +#endif + +#endif // include guard + diff --git a/boost/parameter/aux_/preprocessor/no_perfect_forwarding_begin.hpp b/boost/parameter/aux_/preprocessor/no_perfect_forwarding_begin.hpp new file mode 100644 index 0000000000..9ade7adcd1 --- /dev/null +++ b/boost/parameter/aux_/preprocessor/no_perfect_forwarding_begin.hpp @@ -0,0 +1,165 @@ +// Copyright David Abrahams, Daniel Wallin 2003. +// 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) + +// No include guard. This file is intended for multiple inclusion. + +#define BOOST_PARAMETER_right_angle(z, n, _) > +/**/ + +#define BOOST_PARAMETER_satisfies_end(z, n, false_t) ,false_t> +/**/ + +#include <boost/preprocessor/seq/elem.hpp> +#include <boost/preprocessor/cat.hpp> + +// Generates: +// +// make< +// parameter_spec##0, argument_type##0 +// , make< +// parameter_spec##1, argument_type##1 +// , ... boost::mpl::identity<boost::parameter::aux::empty_arg_list> +// ...> +// > +#define BOOST_PARAMETER_make_arg_list(z, n, names) \ + BOOST_PP_SEQ_ELEM(0, names)< \ + BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(1, names), n), \ + BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(2, names), n), +/**/ + +#include <boost/parameter/aux_/void.hpp> +#include <boost/mpl/identity.hpp> +#include <boost/preprocessor/repetition/repeat.hpp> + +#define BOOST_PARAMETER_build_arg_list(n, make, param_spec, arg_type) \ + BOOST_PP_REPEAT( \ + n, BOOST_PARAMETER_make_arg_list, (make)(param_spec)(arg_type) \ + ) \ + ::boost::mpl::identity< ::boost::parameter::void_> \ + BOOST_PP_REPEAT(n, BOOST_PARAMETER_right_angle, _) +/**/ + +#define BOOST_PARAMETER_make_deduced_list(z, n, names) \ + BOOST_PP_SEQ_ELEM(0, names)<BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(1, names), n), +/**/ + +#define BOOST_PARAMETER_build_deduced_list(n, make, parameter_spec) \ + BOOST_PP_REPEAT( \ + n, BOOST_PARAMETER_make_deduced_list, (make)(parameter_spec) \ + ) \ + ::boost::mpl::identity< ::boost::parameter::void_> \ + BOOST_PP_REPEAT(n, BOOST_PARAMETER_right_angle, _) +/**/ + +#define BOOST_PARAMETER_forward_typedef(z, n, names) \ + typedef BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(0, names), n) \ + BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(1, names), n); +/**/ + +#define BOOST_PARAMETER_template_args(z, n, prefix) \ + typename BOOST_PP_CAT(prefix, n) = ::boost::parameter::void_ +/**/ + +#include <boost/mpl/pair.hpp> + +#if (0 < BOOST_PARAMETER_EXPONENTIAL_OVERLOAD_THRESHOLD_ARITY) + +#include <boost/parameter/aux_/pack/item.hpp> +#include <boost/preprocessor/control/iif.hpp> + +#define BOOST_PARAMETER_make_arg_items_R(r, prefix, i, elem) \ + ::boost::parameter::aux::item<BOOST_PP_CAT(prefix, i), \ + BOOST_PP_CAT(A, i) BOOST_PP_IIF(elem, &, const&), +/**/ + +#include <boost/parameter/aux_/pack/make_arg_list.hpp> +#include <boost/parameter/aux_/pack/tag_keyword_arg.hpp> +#include <boost/preprocessor/seq/for_each_i.hpp> +#include <boost/preprocessor/seq/size.hpp> + +#define BOOST_PARAMETER_function_call_arg_list_R(r, seq) \ + ::boost::parameter::aux::make_arg_list< \ + BOOST_PP_SEQ_FOR_EACH_I_R( \ + r, BOOST_PARAMETER_make_arg_items_R, PS, seq \ + ) \ + ::boost::parameter::void_ \ + BOOST_PP_REPEAT( \ + BOOST_PP_SEQ_SIZE(seq), BOOST_PARAMETER_right_angle, _ \ + ) \ + , deduced_list \ + , ::boost::parameter::aux::tag_keyword_arg \ + > +/**/ + +#include <boost/preprocessor/arithmetic/sub.hpp> + +#define BOOST_PARAMETER_function_call_arg_pack_init(z, n, limit) \ + BOOST_PP_CAT(a, BOOST_PP_SUB(limit, n)) +/**/ + +#include <boost/parameter/aux_/preprocessor/binary_seq_to_args.hpp> +#include <boost/preprocessor/arithmetic/dec.hpp> +#include <boost/preprocessor/facilities/intercept.hpp> +#include <boost/preprocessor/repetition/enum.hpp> +#include <boost/preprocessor/repetition/enum_params.hpp> +#include <boost/preprocessor/repetition/enum_binary_params.hpp> +#include <boost/preprocessor/repetition/enum_trailing_params.hpp> +#include <boost/preprocessor/seq/seq.hpp> + +#define BOOST_PARAMETER_function_call_op_overload_R(r, seq) \ + template < \ + BOOST_PP_ENUM_PARAMS( \ + BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(seq)) \ + , typename A \ + ) \ + > \ + inline typename ::boost::mpl::first< \ + typename BOOST_PARAMETER_function_call_arg_list_R( \ + r, BOOST_PP_SEQ_TAIL(seq) \ + )::type \ + >::type \ + operator()( \ + BOOST_PARAMETER_AUX_PP_BINARY_SEQ_TO_ARGS( \ + BOOST_PP_SEQ_TAIL(seq), (A)(a) \ + ) \ + ) const \ + { \ + typedef typename BOOST_PARAMETER_function_call_arg_list_R( \ + r, BOOST_PP_SEQ_TAIL(seq) \ + )::type result; \ + typedef typename ::boost::mpl::first<result>::type result_type; \ + typedef typename ::boost::mpl::second<result>::type error; \ + error(); \ + return result_type( \ + BOOST_PP_ENUM( \ + BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(seq)) \ + , BOOST_PARAMETER_function_call_arg_pack_init \ + , BOOST_PP_DEC(BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(seq))) \ + ) \ + BOOST_PP_ENUM_TRAILING_PARAMS( \ + BOOST_PP_SUB( \ + BOOST_PARAMETER_COMPOSE_MAX_ARITY \ + , BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(seq)) \ + ) \ + , ::boost::parameter::aux::void_reference() BOOST_PP_INTERCEPT \ + ) \ + ); \ + } +/**/ + +#endif // exponential overloads + +#include <boost/parameter/aux_/pack/satisfies.hpp> +#include <boost/mpl/eval_if.hpp> + +#define BOOST_PARAMETER_satisfies_begin(z, n, prefix) \ + ::boost::mpl::eval_if< \ + ::boost::parameter::aux::satisfies_requirements_of< \ + typename ::boost::mpl::first<ArgumentPackAndError>::type \ + , BOOST_PP_CAT(prefix, n) \ + >, +/**/ + diff --git a/boost/parameter/aux_/preprocessor/no_perfect_forwarding_end.hpp b/boost/parameter/aux_/preprocessor/no_perfect_forwarding_end.hpp new file mode 100644 index 0000000000..71cc596d2c --- /dev/null +++ b/boost/parameter/aux_/preprocessor/no_perfect_forwarding_end.hpp @@ -0,0 +1,24 @@ +// Copyright David Abrahams, Daniel Wallin 2003. +// 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) + +// No include guard. This file is intended for multiple inclusion. + +#undef BOOST_PARAMETER_satisfies_begin +#if (0 < BOOST_PARAMETER_EXPONENTIAL_OVERLOAD_THRESHOLD_ARITY) +#undef BOOST_PARAMETER_function_call_op_overload_R +#undef BOOST_PARAMETER_function_call_arg_pack_init +#undef BOOST_PARAMETER_function_call_arg_list_R +#undef BOOST_PARAMETER_make_arg_items_R +#endif +#undef BOOST_PARAMETER_template_args +#undef BOOST_PARAMETER_forward_typedef +#undef BOOST_PARAMETER_build_deduced_list +#undef BOOST_PARAMETER_make_deduced_list +#undef BOOST_PARAMETER_build_arg_list +#undef BOOST_PARAMETER_make_arg_list +#undef BOOST_PARAMETER_satisfies_end +#undef BOOST_PARAMETER_right_angle + diff --git a/boost/parameter/aux_/preprocessor/nullptr.hpp b/boost/parameter/aux_/preprocessor/nullptr.hpp new file mode 100644 index 0000000000..85ab6cc2da --- /dev/null +++ b/boost/parameter/aux_/preprocessor/nullptr.hpp @@ -0,0 +1,18 @@ +// Copyright Cromwell D. Enage 2019. +// 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_AUX_PREPROCESSOR_NULLPTR_HPP +#define BOOST_PARAMETER_AUX_PREPROCESSOR_NULLPTR_HPP + +#include <boost/config.hpp> + +#if defined(BOOST_NO_CXX11_NULLPTR) +#define BOOST_PARAMETER_AUX_PP_NULLPTR 0 +#else +#define BOOST_PARAMETER_AUX_PP_NULLPTR nullptr +#endif + +#endif // include guard + diff --git a/boost/parameter/aux_/preprocessor/overloads.hpp b/boost/parameter/aux_/preprocessor/overloads.hpp new file mode 100644 index 0000000000..4f2685616d --- /dev/null +++ b/boost/parameter/aux_/preprocessor/overloads.hpp @@ -0,0 +1,92 @@ +// 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) + +// This file generates overloads in this format: +// +// template <typename A0, typename A1> +// typename ::boost::mpl::apply_wrap1< +// ::boost::parameter::aux::make_arg_list< +// PS0,A0 +// , ::boost::parameter::aux::make_arg_list< +// PS1,A1 +// , ::boost::mpl::identity< +// ::boost::parameter::aux::empty_arg_list +// > +// > +// > +// , unnamed_list +// >::type +// operator()(A0 const& a0, A1 const& a1) const +// { +// typedef typename ::boost::mpl::apply_wrap1< +// ::boost::parameter::aux::make_arg_list< +// PS0,A0 +// , ::boost::parameter::aux::make_arg_list< +// PS1,A1 +// , ::boost::mpl::identity< +// ::boost::parameter::aux::empty_arg_list +// > +// > +// > +// >::type arg_tuple; +// +// return arg_tuple( +// a0 +// , a1 +// , ::boost::parameter::aux::void_() +// ... +// ); +// } +// + +#if !defined(BOOST_PP_IS_ITERATING) +# error Boost.Parameters - do not include this file! +#endif + +#define N BOOST_PP_ITERATION() + +#define BOOST_PARAMETER_open_list(z, n, text) \ + ::boost::parameter::aux::item< \ + BOOST_PP_CAT(PS, n), BOOST_PP_CAT(A, n) + +#define BOOST_PARAMETER_close_list(z, n, text) > + +#define BOOST_PARAMETER_arg_list(n) \ + ::boost::parameter::aux::make_arg_list< \ + BOOST_PP_ENUM(N, BOOST_PARAMETER_open_list, _) \ + , ::boost::parameter::void_ \ + BOOST_PP_REPEAT(N, BOOST_PARAMETER_close_list, _) \ + , deduced_list \ + , ::boost::parameter::aux::tag_keyword_arg \ + > + +#define BOOST_PARAMETER_arg_pack_init(z, n, limit) \ + BOOST_PP_CAT(a, BOOST_PP_SUB(limit, n)) + +template <BOOST_PP_ENUM_PARAMS(N, typename A)> +typename ::boost::mpl::first< + typename BOOST_PARAMETER_arg_list(N)::type +>::type + operator()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, & a)) const +{ + typedef typename BOOST_PARAMETER_arg_list(N)::type result; + typedef typename ::boost::mpl::first<result>::type result_type; + typedef typename ::boost::mpl::second<result>::type error; + error(); + + return result_type( + BOOST_PP_ENUM(N, BOOST_PARAMETER_arg_pack_init, BOOST_PP_DEC(N)) + BOOST_PP_ENUM_TRAILING_PARAMS( + BOOST_PP_SUB(BOOST_PARAMETER_COMPOSE_MAX_ARITY, N) + , ::boost::parameter::aux::void_reference() BOOST_PP_INTERCEPT + ) + ); +} + +#undef BOOST_PARAMETER_arg_list +#undef BOOST_PARAMETER_close_list +#undef BOOST_PARAMETER_open_list +#undef N + diff --git a/boost/parameter/aux_/preprocessor/qualifier.hpp b/boost/parameter/aux_/preprocessor/qualifier.hpp new file mode 100644 index 0000000000..b809503b44 --- /dev/null +++ b/boost/parameter/aux_/preprocessor/qualifier.hpp @@ -0,0 +1,88 @@ +// Copyright Daniel Wallin 2006. +// 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_AUX_PREPROCESSOR_QUALIFIER_HPP +#define BOOST_PARAMETER_AUX_PREPROCESSOR_QUALIFIER_HPP + +#define BOOST_PARAMETER_QUALIFIER_EAT_in(x) +#define BOOST_PARAMETER_QUALIFIER_EAT_out(x) +#define BOOST_PARAMETER_QUALIFIER_EAT_in_out(x) +#define BOOST_PARAMETER_QUALIFIER_EAT_consume(x) +#define BOOST_PARAMETER_QUALIFIER_EAT_move_from(x) +#define BOOST_PARAMETER_QUALIFIER_EAT_forward(x) + +#define BOOST_PARAMETER_GET_QUALIFIER_in(x) in_reference +#define BOOST_PARAMETER_GET_QUALIFIER_out(x) out_reference +#define BOOST_PARAMETER_GET_QUALIFIER_in_out(x) in_out_reference +#define BOOST_PARAMETER_GET_QUALIFIER_consume(x) consume_reference +#define BOOST_PARAMETER_GET_QUALIFIER_move_from(x) move_from_reference +#define BOOST_PARAMETER_GET_QUALIFIER_forward(x) forward_reference + +#define BOOST_PARAMETER_STRIP_QUALIFIER_in(x) x +#define BOOST_PARAMETER_STRIP_QUALIFIER_out(x) x +#define BOOST_PARAMETER_STRIP_QUALIFIER_in_out(x) x +#define BOOST_PARAMETER_STRIP_QUALIFIER_consume(x) x +#define BOOST_PARAMETER_STRIP_QUALIFIER_move_from(x) x +#define BOOST_PARAMETER_STRIP_QUALIFIER_forward(x) x + +#include <boost/preprocessor/cat.hpp> + +#define BOOST_PARAMETER_GET_QUALIFIER_GET(x) \ + BOOST_PP_CAT(BOOST_PARAMETER_GET_QUALIFIER_, x) +/**/ + +#define BOOST_PARAMETER_GET_UNQUALIFIED(x) \ + BOOST_PP_CAT(BOOST_PARAMETER_STRIP_QUALIFIER_, x) +/**/ + +#include <boost/preprocessor/facilities/is_empty.hpp> + +// Expands to 1 if x is either "in(k)", "out(k)", "in_out(k)", "consume(k)", +// "move_from(k)", or "forward(k)"; expands to 0 otherwise. +#define BOOST_PARAMETER_IS_QUALIFIER(x) \ + BOOST_PP_IS_EMPTY(BOOST_PP_CAT(BOOST_PARAMETER_QUALIFIER_EAT_, x)) +/**/ + +#include <boost/preprocessor/control/iif.hpp> + +// Expands to the qualifier of x, +// where x is either a keyword qualifier or a keyword. +// +// k => forward_reference +// in(k) => in_reference +// out(k) => out_reference +// in_out(k) => in_out_reference +// forward(k) => forward_reference +// consume(k) => consume_reference +// move_from(k) => move_from_reference +#define BOOST_PARAMETER_GET_QUALIFIER(x) \ + BOOST_PP_IIF( \ + BOOST_PARAMETER_IS_QUALIFIER(x) \ + , BOOST_PARAMETER_GET_QUALIFIER_GET(x) \ + , forward_reference \ + ) +/**/ + +// Expands to the unqualified version of x, +// where x is either a keyword qualifier or a keyword. +// +// k => k +// in(k) => k +// out(k) => k +// in_out(k) => k +// forward(k) => k +// consume(k) => k +// move_from(k) => k +#define BOOST_PARAMETER_UNQUALIFIED(x) \ + BOOST_PP_IIF( \ + BOOST_PARAMETER_IS_QUALIFIER(x) \ + , BOOST_PARAMETER_GET_UNQUALIFIED(x) \ + , x \ + ) +/**/ + +#endif // include guard + diff --git a/boost/parameter/aux_/preprocessor/seq_enum.hpp b/boost/parameter/aux_/preprocessor/seq_enum.hpp new file mode 100644 index 0000000000..1455105d05 --- /dev/null +++ b/boost/parameter/aux_/preprocessor/seq_enum.hpp @@ -0,0 +1,26 @@ +// Copyright David Abrahams 2005. +// 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_AUX_PREPROCESSOR_SEQ_ENUM_HPP +#define BOOST_PARAMETER_AUX_PREPROCESSOR_SEQ_ENUM_HPP + +#include <boost/preprocessor/seq/enum.hpp> +#include <boost/config.hpp> +#include <boost/config/workaround.hpp> + +#if BOOST_WORKAROUND(__MWERKS__, <= 0x3003) +#include <boost/preprocessor/seq/size.hpp> +// Temporary version of BOOST_PP_SEQ_ENUM +// until Paul M. integrates the workaround. +#define BOOST_PARAMETER_SEQ_ENUM_I(size, seq) \ + BOOST_PP_CAT(BOOST_PP_SEQ_ENUM_, size) seq +#define BOOST_PARAMETER_SEQ_ENUM(seq) \ + BOOST_PARAMETER_SEQ_ENUM_I(BOOST_PP_SEQ_SIZE(seq), seq) +#else +#define BOOST_PARAMETER_SEQ_ENUM(seq) BOOST_PP_SEQ_ENUM(seq) +#endif + +#endif // include guard + diff --git a/boost/parameter/aux_/preprocessor/seq_merge.hpp b/boost/parameter/aux_/preprocessor/seq_merge.hpp new file mode 100644 index 0000000000..065375388e --- /dev/null +++ b/boost/parameter/aux_/preprocessor/seq_merge.hpp @@ -0,0 +1,1807 @@ +// 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_AUX_PREPROCESSOR_SEQ_MERGE_HPP +#define BOOST_PARAMETER_AUX_PREPROCESSOR_SEQ_MERGE_HPP + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_0(seq0, seq1) seq1 +/**/ + +#include <boost/preprocessor/seq/seq.hpp> +#include <boost/preprocessor/seq/push_front.hpp> + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_1(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT(seq1, BOOST_PP_SEQ_HEAD(seq0)) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_2(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_1(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_3(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_2(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_4(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_3(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_5(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_4(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_6(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_5(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_7(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_6(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_8(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_7(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_9(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_8(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_10(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_9(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_11(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_10(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_12(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_11(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_13(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_12(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_14(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_13(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_15(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_14(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_16(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_15(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_17(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_16(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_18(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_17(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_19(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_18(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_20(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_19(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_21(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_20(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_22(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_21(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_23(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_22(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_24(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_23(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_25(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_24(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_26(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_25(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_27(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_26(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_28(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_27(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_29(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_28(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_30(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_29(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_31(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_30(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_32(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_31(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_33(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_32(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_34(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_33(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_35(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_34(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_36(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_35(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_37(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_36(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_38(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_37(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_39(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_38(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_40(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_39(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_41(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_40(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_42(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_41(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_43(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_42(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_44(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_43(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_45(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_44(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_46(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_45(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_47(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_46(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_48(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_47(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_49(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_48(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_50(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_49(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_51(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_50(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_52(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_51(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_53(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_52(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_54(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_53(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_55(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_54(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_56(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_55(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_57(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_56(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_58(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_57(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_59(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_58(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_60(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_59(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_61(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_60(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_62(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_61(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_63(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_62(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_64(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_63(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_65(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_64(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_66(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_65(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_67(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_66(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_68(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_67(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_69(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_68(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_70(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_69(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_71(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_70(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_72(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_71(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_73(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_72(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_74(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_73(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_75(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_74(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_76(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_75(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_77(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_76(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_78(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_77(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_79(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_78(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_80(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_79(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_81(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_80(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_82(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_81(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_83(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_82(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_84(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_83(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_85(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_84(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_86(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_85(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_87(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_86(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_88(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_87(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_89(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_88(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_90(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_89(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_91(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_90(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_92(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_91(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_93(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_92(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_94(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_93(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_95(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_94(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_96(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_95(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_97(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_96(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_98(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_97(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_99(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_98(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_100(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_99(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_101(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_100(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_102(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_101(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_103(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_102(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_104(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_103(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_105(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_104(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_106(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_105(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_107(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_106(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_108(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_107(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_109(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_108(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_110(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_109(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_111(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_110(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_112(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_111(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_113(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_112(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_114(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_113(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_115(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_114(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_116(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_115(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_117(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_116(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_118(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_117(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_119(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_118(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_120(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_119(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_121(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_120(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_122(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_121(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_123(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_122(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_124(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_123(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_125(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_124(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_126(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_125(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_127(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_126(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_128(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_127(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_129(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_128(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_130(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_129(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_131(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_130(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_132(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_131(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_133(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_132(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_134(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_133(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_135(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_134(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_136(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_135(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_137(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_136(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_138(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_137(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_139(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_138(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_140(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_139(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_141(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_140(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_142(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_141(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_143(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_142(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_144(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_143(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_145(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_144(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_146(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_145(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_147(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_146(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_148(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_147(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_149(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_148(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_150(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_149(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_151(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_150(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_152(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_151(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_153(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_152(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_154(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_153(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_155(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_154(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_156(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_155(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_157(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_156(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_158(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_157(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_159(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_158(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_160(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_159(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_161(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_160(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_162(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_161(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_163(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_162(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_164(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_163(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_165(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_164(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_166(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_165(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_167(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_166(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_168(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_167(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_169(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_168(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_170(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_169(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_171(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_170(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_172(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_171(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_173(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_172(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_174(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_173(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_175(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_174(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_176(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_175(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_177(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_176(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_178(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_177(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_179(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_178(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_180(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_179(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_181(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_180(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_182(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_181(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_183(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_182(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_184(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_183(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_185(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_184(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_186(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_185(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_187(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_186(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_188(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_187(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_189(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_188(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_190(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_189(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_191(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_190(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_192(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_191(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_193(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_192(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_194(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_193(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_195(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_194(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_196(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_195(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_197(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_196(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_198(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_197(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_199(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_198(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_200(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_199(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_201(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_200(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_202(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_201(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_203(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_202(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_204(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_203(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_205(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_204(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_206(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_205(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_207(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_206(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_208(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_207(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_209(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_208(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_210(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_209(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_211(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_210(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_212(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_211(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_213(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_212(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_214(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_213(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_215(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_214(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_216(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_215(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_217(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_216(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_218(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_217(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_219(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_218(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_220(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_219(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_221(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_220(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_222(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_221(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_223(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_222(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_224(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_223(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_225(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_224(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_226(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_225(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_227(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_226(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_228(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_227(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_229(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_228(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_230(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_229(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_231(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_230(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_232(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_231(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_233(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_232(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_234(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_233(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_235(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_234(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_236(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_235(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_237(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_236(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_238(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_237(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_239(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_238(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_240(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_239(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_241(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_240(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_242(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_241(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_243(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_242(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_244(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_243(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_245(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_244(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_246(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_245(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_247(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_246(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_248(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_247(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_249(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_248(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_250(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_249(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_251(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_250(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_252(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_251(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_253(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_252(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_254(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_253(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE_255(seq0, seq1) \ + BOOST_PP_SEQ_PUSH_FRONT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_254(BOOST_PP_SEQ_TAIL(seq0), seq1) \ + , BOOST_PP_SEQ_HEAD(seq0) \ + ) +/**/ + +#include <boost/preprocessor/seq/size.hpp> +#include <boost/preprocessor/cat.hpp> + +#define BOOST_PARAMETER_AUX_PP_SEQ_MERGE(seq0, seq1) \ + BOOST_PP_CAT( \ + BOOST_PARAMETER_AUX_PP_SEQ_MERGE_, BOOST_PP_SEQ_SIZE(seq0) \ + )(seq0, seq1) +/**/ + +#endif // include guard + diff --git a/boost/parameter/aux_/result_of0.hpp b/boost/parameter/aux_/result_of0.hpp index e0096148b4..f8cbea3c3a 100644 --- a/boost/parameter/aux_/result_of0.hpp +++ b/boost/parameter/aux_/result_of0.hpp @@ -1,36 +1,53 @@ -// Copyright David Abrahams 2005. 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_AUX_RESULT_OF0_DWA2005511_HPP -# define BOOST_PARAMETER_AUX_RESULT_OF0_DWA2005511_HPP - -# include <boost/utility/result_of.hpp> - -// A metafunction returning the result of invoking a nullary function -// object of the given type. +// Copyright David Abrahams 2005. +// 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_NO_RESULT_OF - -# include <boost/utility/result_of.hpp> -namespace boost { namespace parameter { namespace aux { -template <class F> -struct result_of0 : result_of<F()> -{}; +#ifndef BOOST_PARAMETER_AUX_RESULT_OF0_DWA2005511_HPP +#define BOOST_PARAMETER_AUX_RESULT_OF0_DWA2005511_HPP -}}} // namespace boost::parameter::aux_ +#include <boost/parameter/aux_/use_default_tag.hpp> +#include <boost/parameter/config.hpp> +#include <boost/utility/result_of.hpp> +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <boost/mp11/utility.hpp> +#include <type_traits> #else +#include <boost/mpl/if.hpp> +#include <boost/type_traits/is_void.hpp> +#endif + +namespace boost { namespace parameter { namespace aux { + + // A metafunction returning the result of invoking + // a nullary function object of the given type. + template <typename F> + class result_of0 + { +#if defined(BOOST_NO_RESULT_OF) + typedef typename F::result_type result_of_F; +#else + typedef typename ::boost::result_of<F()>::type result_of_F; +#endif -namespace boost { namespace parameter { namespace aux { -template <class F> -struct result_of0 -{ - typedef typename F::result_type type; -}; - -}}} // namespace boost::parameter::aux_ - -#endif + public: +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using type = ::boost::mp11::mp_if< + ::std::is_void<result_of_F> +#else + typedef typename ::boost::mpl::if_< + ::boost::is_void<result_of_F> +#endif + , ::boost::parameter::aux::use_default_tag + , result_of_F +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + >; +#else + >::type type; +#endif + }; +}}} // namespace boost::parameter::aux +#endif // include guard -#endif // BOOST_PARAMETER_AUX_RESULT_OF0_DWA2005511_HPP diff --git a/boost/parameter/aux_/set.hpp b/boost/parameter/aux_/set.hpp index 7ab93dc7bb..418b0b174d 100644 --- a/boost/parameter/aux_/set.hpp +++ b/boost/parameter/aux_/set.hpp @@ -1,66 +1,118 @@ -// Copyright Daniel Wallin 2006. Use, modification and distribution is -// subject to the Boost Software License, Version 1.0. (See accompanying -// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +// Copyright Daniel Wallin 2006. +// 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_SET_060912_HPP -# define BOOST_PARAMETER_SET_060912_HPP +#define BOOST_PARAMETER_SET_060912_HPP -# include <boost/detail/workaround.hpp> +#include <boost/parameter/config.hpp> -# if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) -# include <boost/mpl/insert.hpp> -# include <boost/mpl/set/set0.hpp> -# include <boost/mpl/has_key.hpp> +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <boost/mp11/list.hpp> namespace boost { namespace parameter { namespace aux { -typedef mpl::set0<> set0; + typedef ::boost::mp11::mp_list<> set0; +}}} // namespace boost::parameter::aux + +#include <boost/mp11/algorithm.hpp> + +namespace boost { namespace parameter { namespace aux { + + template <typename S, typename K> + struct insert_ + { + using type = ::boost::mp11::mp_insert_c<S,0,K>; + }; +}}} // namespace boost::parameter::aux + +#include <boost/mp11/integral.hpp> +#include <boost/mp11/utility.hpp> +#include <type_traits> + +namespace boost { namespace parameter { namespace aux { + + template <typename Set, typename K> + struct has_key_ + { + using type = ::boost::mp11::mp_if< + ::boost::mp11::mp_empty<Set> + , ::boost::mp11::mp_false + , ::std::is_same< + ::boost::mp11::mp_find<Set,K> + , ::boost::mp11::mp_size<Set> + > + >; + }; +}}} // namespace boost::parameter::aux + +#elif BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +#include <boost/mpl/list.hpp> + +namespace boost { namespace parameter { namespace aux { + + typedef ::boost::mpl::list0<> set0; +}}} // namespace boost::parameter::aux -template <class Set, class K> -struct insert_ -{ - typedef typename mpl::insert<Set, K>::type type; -}; +#include <boost/mpl/push_front.hpp> -template <class Set, class K> -struct has_key_ -{ - typedef typename mpl::has_key<Set, K>::type type; -}; +namespace boost { namespace parameter { namespace aux { + template <typename Set, typename K> + struct insert_ : ::boost::mpl::push_front<Set,K> + { + }; }}} // namespace boost::parameter::aux -# else +#include <boost/mpl/bool.hpp> +#include <boost/mpl/if.hpp> +#include <boost/mpl/end.hpp> +#include <boost/mpl/find.hpp> +#include <boost/type_traits/is_same.hpp> -# include <boost/mpl/list.hpp> -# include <boost/mpl/end.hpp> -# include <boost/mpl/find.hpp> -# include <boost/mpl/not.hpp> -# include <boost/mpl/push_front.hpp> +namespace boost { namespace parameter { namespace aux { + + template <typename Set, typename K> + struct has_key_ + { + typedef typename ::boost::mpl::find<Set,K>::type iter; + typedef typename ::boost::mpl::if_< + ::boost::is_same<iter,typename ::boost::mpl::end<Set>::type> + , ::boost::mpl::false_ + , ::boost::mpl::true_ + >::type type; + }; +}}} // namespace boost::parameter::aux + +#else // !BOOST_PARAMETER_CAN_USE_MP11 && Borland workarounds not needed +#include <boost/mpl/set/set0.hpp> namespace boost { namespace parameter { namespace aux { -typedef mpl::list0<> set0; + typedef ::boost::mpl::set0<> set0; +}}} // namespace boost::parameter::aux -template <class Set, class K> -struct insert_ -{ - typedef typename mpl::push_front<Set, K>::type type; -}; +#include <boost/mpl/insert.hpp> -template <class Set, class K> -struct has_key_ -{ - typedef typename mpl::find<Set, K>::type iter; - typedef mpl::not_< - is_same<iter, typename mpl::end<Set>::type> - > type; -}; +namespace boost { namespace parameter { namespace aux { + template <typename Set, typename K> + struct insert_ : ::boost::mpl::insert<Set,K> + { + }; }}} // namespace boost::parameter::aux -# endif +#include <boost/mpl/has_key.hpp> +namespace boost { namespace parameter { namespace aux { + + template <typename Set, typename K> + struct has_key_ : ::boost::mpl::has_key<Set,K> + { + }; +}}} // namespace boost::parameter::aux -#endif // BOOST_PARAMETER_SET_060912_HPP +#endif // BOOST_PARAMETER_CAN_USE_MP11 || Borland workarounds needed +#endif // include guard diff --git a/boost/parameter/aux_/tag.hpp b/boost/parameter/aux_/tag.hpp index 475efb9e4a..0cba191d6a 100644 --- a/boost/parameter/aux_/tag.hpp +++ b/boost/parameter/aux_/tag.hpp @@ -1,38 +1,160 @@ -// Copyright David Abrahams 2005. 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) +// Copyright 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_AUX_TAG_DWA2005610_HPP -# define BOOST_PARAMETER_AUX_TAG_DWA2005610_HPP +#define BOOST_PARAMETER_AUX_TAG_DWA2005610_HPP + +#include <boost/parameter/aux_/unwrap_cv_reference.hpp> +#include <boost/parameter/aux_/tagged_argument.hpp> +#include <boost/parameter/config.hpp> + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) && \ + !BOOST_WORKAROUND(BOOST_MSVC, >= 1910) +// MSVC-14.1+ assigns rvalue references to tagged_argument instances +// instead of tagged_argument_rref instances with this code. +#include <boost/mp11/integral.hpp> +#include <boost/mp11/utility.hpp> +#include <type_traits> + +namespace boost { namespace parameter { namespace aux { + + template <typename Keyword, typename Arg> + struct tag_if_lvalue_reference + { + using type = ::boost::parameter::aux::tagged_argument_list_of_1< + ::boost::parameter::aux::tagged_argument< + Keyword + , typename ::boost::parameter::aux + ::unwrap_cv_reference<Arg>::type + > + >; + }; + + template <typename Keyword, typename Arg> + struct tag_if_scalar + { + using type = ::boost::parameter::aux::tagged_argument_list_of_1< + ::boost::parameter::aux + ::tagged_argument<Keyword,typename ::std::add_const<Arg>::type> + >; + }; + + template <typename Keyword, typename Arg> + using tag_if_otherwise = ::boost::mp11::mp_if< + ::std::is_scalar<typename ::std::remove_const<Arg>::type> + , ::boost::parameter::aux::tag_if_scalar<Keyword,Arg> + , ::boost::mp11::mp_identity< + ::boost::parameter::aux::tagged_argument_list_of_1< + ::boost::parameter::aux::tagged_argument_rref<Keyword,Arg> + > + > + >; + + template <typename Keyword, typename Arg> + using tag = ::boost::mp11::mp_if< + ::boost::mp11::mp_if< + ::std::is_lvalue_reference<Arg> + , ::boost::mp11::mp_true + , ::boost::parameter::aux::is_cv_reference_wrapper<Arg> + > + , ::boost::parameter::aux::tag_if_lvalue_reference<Keyword,Arg> + , ::boost::parameter::aux::tag_if_otherwise<Keyword,Arg> + >; +}}} // namespace boost::parameter::aux_ -# include <boost/parameter/aux_/unwrap_cv_reference.hpp> -# include <boost/parameter/aux_/tagged_argument.hpp> +#elif defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING) +#include <boost/mpl/bool.hpp> +#include <boost/mpl/if.hpp> +#include <boost/mpl/eval_if.hpp> +#include <boost/mpl/identity.hpp> +#include <boost/type_traits/add_const.hpp> +#include <boost/type_traits/is_scalar.hpp> +#include <boost/type_traits/is_lvalue_reference.hpp> +#include <boost/type_traits/remove_const.hpp> namespace boost { namespace parameter { namespace aux { -template <class Keyword, class ActualArg + template <typename Keyword, typename ActualArg> + struct tag + { + typedef typename ::boost::parameter::aux + ::unwrap_cv_reference<ActualArg>::type Arg; + typedef typename ::boost::add_const<Arg>::type ConstArg; + typedef typename ::boost::remove_const<Arg>::type MutArg; + typedef typename ::boost::mpl::eval_if< + typename ::boost::mpl::if_< + ::boost::is_lvalue_reference<ActualArg> + , ::boost::mpl::true_ + , ::boost::parameter::aux::is_cv_reference_wrapper<ActualArg> + >::type + , ::boost::mpl::identity< +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + ::boost::parameter::aux::tagged_argument_list_of_1< +#endif + ::boost::parameter::aux::tagged_argument<Keyword,Arg> +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + > +#endif + > + , ::boost::mpl::if_< + ::boost::is_scalar<MutArg> +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + , ::boost::parameter::aux::tagged_argument_list_of_1< + ::boost::parameter::aux::tagged_argument<Keyword,ConstArg> + > + , ::boost::parameter::aux::tagged_argument_list_of_1< + ::boost::parameter::aux::tagged_argument_rref<Keyword,Arg> + > +#else + , ::boost::parameter::aux::tagged_argument<Keyword,ConstArg> + , ::boost::parameter::aux::tagged_argument_rref<Keyword,Arg> +#endif + > + >::type type; + }; +}}} // namespace boost::parameter::aux_ + +#else // !defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING) + +namespace boost { namespace parameter { namespace aux { + + template < + typename Keyword + , typename Arg #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) - , class = typename is_cv_reference_wrapper<ActualArg>::type -#endif - > -struct tag -{ - typedef tagged_argument< - Keyword - , typename unwrap_cv_reference<ActualArg>::type - > type; -}; + , typename = typename ::boost::parameter::aux + ::is_cv_reference_wrapper<Arg>::type +#endif + > + struct tag + { + typedef ::boost::parameter::aux::tagged_argument< + Keyword + , typename ::boost::parameter::aux::unwrap_cv_reference<Arg>::type + > type; + }; +}}} // namespace boost::parameter::aux_ #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) -template <class Keyword, class ActualArg> -struct tag<Keyword,ActualArg,mpl::false_> -{ - typedef tagged_argument< - Keyword - , ActualArg - > type; -}; -#endif +#include <boost/mpl/bool.hpp> +#include <boost/type_traits/remove_reference.hpp> + +namespace boost { namespace parameter { namespace aux { + template <typename Keyword, typename Arg> + struct tag<Keyword,Arg,::boost::mpl::false_> + { + typedef ::boost::parameter::aux::tagged_argument< + Keyword + , typename ::boost::remove_reference<Arg>::type + > type; + }; }}} // namespace boost::parameter::aux_ -#endif // BOOST_PARAMETER_AUX_TAG_DWA2005610_HPP +#endif // Borland workarounds needed. +#endif // MP11 or perfect forwarding support +#endif // include guard + diff --git a/boost/parameter/aux_/tagged_argument.hpp b/boost/parameter/aux_/tagged_argument.hpp index 79d273e418..964dd8fd00 100644 --- a/boost/parameter/aux_/tagged_argument.hpp +++ b/boost/parameter/aux_/tagged_argument.hpp @@ -1,188 +1,894 @@ -// 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_TAGGED_ARGUMENT_050328_HPP -# define BOOST_PARAMETER_TAGGED_ARGUMENT_050328_HPP - -# include <boost/parameter/aux_/void.hpp> -# include <boost/parameter/aux_/arg_list.hpp> -# include <boost/parameter/aux_/result_of0.hpp> -# include <boost/mpl/if.hpp> -# include <boost/mpl/apply_wrap.hpp> -# include <boost/mpl/and.hpp> -# include <boost/mpl/not.hpp> -# include <boost/type_traits/is_same.hpp> -# include <boost/type_traits/is_convertible.hpp> -# include <boost/type_traits/is_reference.hpp> +#define BOOST_PARAMETER_TAGGED_ARGUMENT_050328_HPP namespace boost { namespace parameter { namespace aux { -struct empty_arg_list; -struct arg_list_tag; + struct error_const_lvalue_bound_to_out_parameter; + struct error_lvalue_bound_to_consume_parameter; + struct error_rvalue_bound_to_out_parameter; +}}} // namespace boost::parameter::aux -struct tagged_argument_base {}; +#include <boost/parameter/keyword_fwd.hpp> +#include <boost/parameter/config.hpp> +#include <boost/mpl/eval_if.hpp> +#include <boost/type_traits/is_same.hpp> +#include <boost/type_traits/remove_const.hpp> -// Holds a reference to an argument of type Arg associated with -// keyword Keyword - -template <class Keyword, class Arg> -struct tagged_argument : tagged_argument_base -{ - typedef Keyword key_type; - typedef Arg value_type; - typedef Arg& reference; +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <boost/mp11/integral.hpp> +#include <boost/mp11/utility.hpp> +#include <type_traits> +#endif - tagged_argument(reference x) : value(x) {} +namespace boost { namespace parameter { namespace aux { - // A metafunction class that, given a keyword and a default - // type, returns the appropriate result type for a keyword - // lookup given that default - struct binding + template <typename Keyword, typename Arg> +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using tagged_argument_type = ::boost::mp11::mp_if< + ::boost::mp11::mp_if< + ::std::is_scalar<Arg> + , ::boost::mp11::mp_false + , ::std::is_same< + typename Keyword::qualifier + , ::boost::parameter::consume_reference + > + > + , ::boost::parameter::aux::error_lvalue_bound_to_consume_parameter + , ::boost::mp11::mp_if< + ::std::is_const<Arg> + , ::boost::mp11::mp_if< + ::std::is_same< + typename Keyword::qualifier + , ::boost::parameter::out_reference + > + , ::boost::parameter::aux + ::error_const_lvalue_bound_to_out_parameter + , ::std::remove_const<Arg> + > + , ::boost::mp11::mp_identity<Arg> + > + >; +#else // !defined(BOOST_PARAMETER_CAN_USE_MP11) + struct tagged_argument_type + : ::boost::mpl::eval_if< + ::boost::is_same< + typename Keyword::qualifier + , ::boost::parameter::out_reference + > + , ::boost::parameter::aux::error_const_lvalue_bound_to_out_parameter + , ::boost::remove_const<Arg> + > { - template <class KW, class Default, class Reference> - struct apply - { - typedef typename mpl::eval_if< - boost::is_same<KW, key_type> - , mpl::if_<Reference, reference, value_type> - , mpl::identity<Default> - >::type type; - }; }; +#endif // BOOST_PARAMETER_CAN_USE_MP11 +}}} // namespace boost::parameter::aux - // Comma operator to compose argument list without using parameters<>. - // Useful for argument lists with undetermined length. - template <class Keyword2, class Arg2> - arg_list< - tagged_argument<Keyword, Arg> - , arg_list<tagged_argument<Keyword2, Arg2> > - > - operator,(tagged_argument<Keyword2, Arg2> x) const - { - return arg_list< - tagged_argument<Keyword, Arg> - , arg_list<tagged_argument<Keyword2, Arg2> > - >( - *this - , arg_list<tagged_argument<Keyword2, Arg2> >(x, empty_arg_list()) - ); - } - - reference operator[](keyword<Keyword> const&) const - { - return value; - } +#include <boost/parameter/aux_/tagged_argument_fwd.hpp> +#include <boost/parameter/aux_/is_tagged_argument.hpp> +#include <boost/parameter/aux_/default.hpp> +#include <boost/parameter/aux_/void.hpp> +#include <boost/parameter/aux_/arg_list.hpp> +#include <boost/parameter/aux_/result_of0.hpp> +#include <boost/mpl/bool.hpp> +#include <boost/mpl/if.hpp> +#include <boost/mpl/identity.hpp> +#include <boost/mpl/apply_wrap.hpp> +#include <boost/type_traits/is_const.hpp> +#include <boost/type_traits/is_function.hpp> +#include <boost/type_traits/is_scalar.hpp> +#include <boost/type_traits/remove_reference.hpp> -# if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) - template <class KW, class Default> - Default& get_with_default(default_<KW,Default> const& x, int) const - { - return x.value; - } +#if defined(BOOST_NO_CXX11_HDR_FUNCTIONAL) +#include <boost/function.hpp> +#else +#include <functional> +#endif - template <class Default> - reference get_with_default(default_<key_type,Default> const&, long) const - { - return value; - } +#if defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING) +#include <boost/core/enable_if.hpp> +#include <utility> - template <class KW, class Default> - typename mpl::apply_wrap3<binding, KW, Default&, mpl::true_>::type - operator[](default_<KW,Default> const& x) const - { - return get_with_default(x, 0L); - } +namespace boost { namespace parameter { namespace aux { - template <class KW, class F> - typename result_of0<F>::type - get_with_lazy_default(lazy_default<KW,F> const& x, int) const + // Holds an lvalue reference to an argument of type Arg associated with + // keyword Keyword + template <typename Keyword, typename Arg> + class tagged_argument + : public ::boost::parameter::aux::tagged_argument_base { - return x.compute_default(); - } +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using arg_type = typename ::boost::parameter::aux + ::tagged_argument_type<Keyword,Arg>::type; +#else + typedef typename ::boost::mpl::eval_if< + typename ::boost::mpl::eval_if< + ::boost::is_scalar<Arg> + , ::boost::mpl::false_ + , ::boost::is_same< + typename Keyword::qualifier + , ::boost::parameter::consume_reference + > + >::type + , ::boost::parameter::aux::error_lvalue_bound_to_consume_parameter + , ::boost::mpl::eval_if< + ::boost::is_const<Arg> + , ::boost::parameter::aux::tagged_argument_type<Keyword,Arg> + , ::boost::mpl::identity<Arg> + > + >::type arg_type; +#endif // BOOST_PARAMETER_CAN_USE_MP11 - template <class F> - reference get_with_lazy_default(lazy_default<key_type,F> const&, long) const - { - return value; - } - - template <class KW, class F> - typename mpl::apply_wrap3< - binding,KW - , typename result_of0<F>::type - , mpl::true_ - >::type - operator[](lazy_default<KW,F> const& x) const - { - return get_with_lazy_default(x, 0L); - } -# else - template <class Default> - reference operator[](default_<key_type,Default> const& ) const - { - return value; - } + public: + typedef Keyword key_type; + + // Wrap plain (non-UDT) function objects in either + // a boost::function or a std::function. -- Cromwell D. Enage +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using value_type = ::boost::mp11::mp_if< + ::std::is_function<arg_type> + , ::std::function<arg_type> + , Arg + >; +#else // !defined(BOOST_PARAMETER_CAN_USE_MP11) + typedef typename ::boost::mpl::if_< + ::boost::is_function<arg_type> +#if defined(BOOST_NO_CXX11_HDR_FUNCTIONAL) + , ::boost::function<arg_type> +#else + , ::std::function<arg_type> +#endif + , Arg + >::type value_type; +#endif // BOOST_PARAMETER_CAN_USE_MP11 + + // If Arg is void_, then this type will evaluate to void_&. If the + // supplied argument is a plain function, then this type will evaluate + // to a reference-to-const function wrapper type. If the supplied + // argument is an lvalue, then Arg will be deduced to the lvalue + // reference. -- Cromwell D. Enage +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using reference = ::boost::mp11::mp_if< + ::std::is_function<arg_type> + , value_type const& + , Arg& + >; +#else + typedef typename ::boost::mpl::if_< + ::boost::is_function<arg_type> + , value_type const& + , Arg& + >::type reference; +#endif + + private: + // Store plain functions by value, everything else by reference. + // -- Cromwell D. Enage +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + ::boost::mp11::mp_if< + ::std::is_function<arg_type> + , value_type + , reference + > value; +#else + typename ::boost::mpl::if_< + ::boost::is_function<arg_type> + , value_type + , reference + >::type value; +#endif + + public: + inline explicit BOOST_CONSTEXPR tagged_argument(reference x) + : value(x) + { + } - template <class F> - reference operator[](lazy_default<key_type,F> const& ) const + inline BOOST_CONSTEXPR tagged_argument(tagged_argument const& copy) + : value(copy.value) + { + } + + // A metafunction class that, given a keyword and a default type, + // returns the appropriate result type for a keyword lookup given + // that default. + struct binding + { + template <typename KW, typename Default, typename Reference> + struct apply + : ::boost::mpl::eval_if< + ::boost::is_same<KW,key_type> + , ::boost::mpl::if_<Reference,reference,value_type> + , ::boost::mpl::identity<Default> + > + { + }; + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + template <typename KW, typename Default, typename Reference> + using fn = ::boost::mp11::mp_if< + ::std::is_same<KW,key_type> + , ::boost::mp11::mp_if<Reference,reference,value_type> + , Default + >; +#endif + }; + +#if !defined(BOOST_PARAMETER_CAN_USE_MP11) + // Comma operator to compose argument list without using parameters<>. + // Useful for argument lists with undetermined length. + template <typename Keyword2, typename Arg2> + inline BOOST_CONSTEXPR ::boost::parameter::aux::arg_list< + ::boost::parameter::aux::tagged_argument<Keyword,Arg> + , ::boost::parameter::aux::arg_list< + ::boost::parameter::aux::tagged_argument<Keyword2,Arg2> + > + > + operator,( + ::boost::parameter::aux + ::tagged_argument<Keyword2,Arg2> const& x + ) const + { + return ::boost::parameter::aux::arg_list< + ::boost::parameter::aux::tagged_argument<Keyword,Arg> + , ::boost::parameter::aux::arg_list< + ::boost::parameter::aux::tagged_argument<Keyword2,Arg2> + > + >( + *this + , ::boost::parameter::aux::arg_list< + ::boost::parameter::aux::tagged_argument<Keyword2,Arg2> + >(x, ::boost::parameter::aux::empty_arg_list()) + ); + } + + template <typename Keyword2, typename Arg2> + inline BOOST_CONSTEXPR ::boost::parameter::aux::arg_list< + ::boost::parameter::aux::tagged_argument<Keyword,Arg> + , ::boost::parameter::aux::arg_list< + ::boost::parameter::aux::tagged_argument_rref<Keyword2,Arg2> + > + > + operator,( + ::boost::parameter::aux + ::tagged_argument_rref<Keyword2,Arg2> const& x + ) const + { + return ::boost::parameter::aux::arg_list< + ::boost::parameter::aux::tagged_argument<Keyword,Arg> + , boost::parameter::aux::arg_list< + boost::parameter::aux::tagged_argument_rref<Keyword2,Arg2> + > + >( + *this + , ::boost::parameter::aux::arg_list< + ::boost::parameter::aux + ::tagged_argument_rref<Keyword2,Arg2> + >(x, ::boost::parameter::aux::empty_arg_list()) + ); + } +#endif // BOOST_PARAMETER_CAN_USE_MP11 + + // Accessor interface. + inline BOOST_CONSTEXPR reference get_value() const + { + return this->value; + } + + inline BOOST_CONSTEXPR reference + operator[](::boost::parameter::keyword<Keyword> const&) const + { + return this->get_value(); + } + + template <typename Default> + inline BOOST_CONSTEXPR reference + operator[]( + ::boost::parameter::aux::default_<key_type,Default> const& + ) const + { + return this->get_value(); + } + + template <typename F> + inline BOOST_CONSTEXPR reference + operator[]( + ::boost::parameter::aux::lazy_default<key_type,F> const& + ) const + { + return this->get_value(); + } + + template <typename KW, typename Default> + inline BOOST_CONSTEXPR Default& + operator[]( + ::boost::parameter::aux::default_<KW,Default> const& x + ) const + { + return x.value; + } + + template <typename KW, typename Default> + inline BOOST_CONSTEXPR Default&& + operator[]( + ::boost::parameter::aux::default_r_<KW,Default> const& x + ) const + { + return ::std::forward<Default>(x.value); + } + + template <typename KW, typename F> + inline BOOST_CONSTEXPR + typename ::boost::parameter::aux::result_of0<F>::type + operator[]( + ::boost::parameter::aux::lazy_default<KW,F> const& x + ) const + { + return x.compute_default(); + } + + template <typename ParameterRequirements> + static BOOST_CONSTEXPR typename ParameterRequirements::has_default + satisfies(ParameterRequirements*); + + template <typename HasDefault, typename Predicate> + static BOOST_CONSTEXPR + typename ::boost::mpl::apply_wrap1<Predicate,value_type>::type + satisfies( + ::boost::parameter::aux::parameter_requirements< + key_type + , Predicate + , HasDefault + >* + ); + + // MPL sequence support + // Convenience for users + typedef ::boost::parameter::aux::tagged_argument<Keyword,Arg> type; + // For the benefit of iterators + typedef ::boost::parameter::aux::empty_arg_list tail_type; + // For dispatching to sequence intrinsics + typedef ::boost::parameter::aux::arg_list_tag tag; + }; + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + template <typename Keyword> + using tagged_argument_rref_key = ::boost::mp11::mp_if< + ::std::is_same< + typename Keyword::qualifier + , ::boost::parameter::out_reference + > + , ::boost::parameter::aux::error_rvalue_bound_to_out_parameter + , ::boost::mp11::mp_identity<Keyword> + >; +#endif + + // Holds an rvalue reference to an argument of type Arg associated with + // keyword Keyword + template <typename Keyword, typename Arg> + struct tagged_argument_rref + : ::boost::parameter::aux::tagged_argument_base { - return value; - } +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using key_type = typename ::boost::parameter::aux + ::tagged_argument_rref_key<Keyword>::type; +#else + typedef typename ::boost::mpl::eval_if< + ::boost::is_same< + typename Keyword::qualifier + , ::boost::parameter::out_reference + > + , ::boost::parameter::aux::error_rvalue_bound_to_out_parameter + , ::boost::mpl::identity<Keyword> + >::type key_type; +#endif + typedef Arg value_type; + typedef Arg&& reference; + + private: + reference value; + + public: + inline explicit BOOST_CONSTEXPR tagged_argument_rref(reference x) + : value(::std::forward<Arg>(x)) + { + } + + inline BOOST_CONSTEXPR tagged_argument_rref( + tagged_argument_rref const& copy + ) : value(::std::forward<Arg>(copy.value)) + { + } - template <class KW, class Default> - Default& operator[](default_<KW,Default> const& x) const + // A metafunction class that, given a keyword and a default type, + // returns the appropriate result type for a keyword lookup given + // that default. + struct binding + { + template <typename KW, typename Default, typename Reference> + struct apply + { + typedef typename ::boost::mpl::eval_if< + ::boost::is_same<KW,key_type> + , ::boost::mpl::if_<Reference,reference,value_type> + , ::boost::mpl::identity<Default> + >::type type; + }; + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + template <typename KW, typename Default, typename Reference> + using fn = ::boost::mp11::mp_if< + ::std::is_same<KW,key_type> + , ::boost::mp11::mp_if<Reference,reference,value_type> + , Default + >; +#endif + }; + +#if !defined(BOOST_PARAMETER_CAN_USE_MP11) + // Comma operator to compose argument list without using parameters<>. + // Useful for argument lists with undetermined length. + template <typename Keyword2, typename Arg2> + inline BOOST_CONSTEXPR ::boost::parameter::aux::arg_list< + ::boost::parameter::aux::tagged_argument_rref<Keyword,Arg> + , ::boost::parameter::aux::arg_list< + ::boost::parameter::aux::tagged_argument<Keyword2,Arg2> + > + > + operator,( + ::boost::parameter::aux + ::tagged_argument<Keyword2,Arg2> const& x + ) const + { + return boost::parameter::aux::arg_list< + ::boost::parameter::aux::tagged_argument_rref<Keyword,Arg> + , ::boost::parameter::aux::arg_list< + ::boost::parameter::aux::tagged_argument<Keyword2,Arg2> + > + >( + *this + , ::boost::parameter::aux::arg_list< + ::boost::parameter::aux::tagged_argument<Keyword2,Arg2> + >(x, ::boost::parameter::aux::empty_arg_list()) + ); + } + + template <typename Keyword2, typename Arg2> + inline BOOST_CONSTEXPR ::boost::parameter::aux::arg_list< + ::boost::parameter::aux::tagged_argument_rref<Keyword,Arg> + , ::boost::parameter::aux::arg_list< + ::boost::parameter::aux::tagged_argument_rref<Keyword2,Arg2> + > + > + operator,( + ::boost::parameter::aux + ::tagged_argument_rref<Keyword2,Arg2> const& x + ) const + { + return ::boost::parameter::aux::arg_list< + ::boost::parameter::aux::tagged_argument_rref<Keyword,Arg> + , ::boost::parameter::aux::arg_list< + ::boost::parameter::aux + ::tagged_argument_rref<Keyword2,Arg2> + > + >( + *this + , ::boost::parameter::aux::arg_list< + ::boost::parameter::aux::tagged_argument_rref< + Keyword2 + , Arg2 + > + >(x, ::boost::parameter::aux::empty_arg_list()) + ); + } +#endif // BOOST_PARAMETER_CAN_USE_MP11 + + // Accessor interface. + inline BOOST_CONSTEXPR reference get_value() const + { + return ::std::forward<Arg>(this->value); + } + + inline BOOST_CONSTEXPR reference + operator[](::boost::parameter::keyword<Keyword> const&) const + { + return this->get_value(); + } + + template <typename Default> + inline BOOST_CONSTEXPR reference + operator[]( + ::boost::parameter::aux::default_<key_type,Default> const& + ) const + { + return this->get_value(); + } + + template <typename Default> + inline BOOST_CONSTEXPR reference + operator[]( + ::boost::parameter::aux::default_r_<key_type,Default> const& + ) const + { + return this->get_value(); + } + + template <typename F> + inline BOOST_CONSTEXPR reference + operator[]( + ::boost::parameter::aux::lazy_default<key_type,F> const& + ) const + { + return this->get_value(); + } + + template <typename KW, typename Default> + inline BOOST_CONSTEXPR Default& + operator[]( + ::boost::parameter::aux::default_<KW,Default> const& x + ) const + { + return x.value; + } + + template <typename KW, typename Default> + inline BOOST_CONSTEXPR Default&& + operator[]( + ::boost::parameter::aux::default_r_<KW,Default> const& x + ) const + { + return ::std::forward<Default>(x.value); + } + + template <typename KW, typename F> + inline BOOST_CONSTEXPR + typename ::boost::parameter::aux::result_of0<F>::type + operator[]( + ::boost::parameter::aux::lazy_default<KW,F> const& x + ) const + { + return x.compute_default(); + } + + template <typename ParameterRequirements> + static BOOST_CONSTEXPR typename ParameterRequirements::has_default + satisfies(ParameterRequirements*); + + template <typename HasDefault, typename Predicate> + static BOOST_CONSTEXPR + typename ::boost::mpl::apply_wrap1<Predicate,value_type>::type + satisfies( + ::boost::parameter::aux::parameter_requirements< + key_type + , Predicate + , HasDefault + >* + ); + + // MPL sequence support + // Convenience for users + typedef ::boost::parameter::aux + ::tagged_argument_rref<Keyword,Arg> type; + // For the benefit of iterators + typedef ::boost::parameter::aux::empty_arg_list tail_type; + // For dispatching to sequence intrinsics + typedef ::boost::parameter::aux::arg_list_tag tag; + }; +}}} // namespace boost::parameter::aux + +#else // !defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING) + +namespace boost { namespace parameter { namespace aux { + + // Holds an lvalue reference to an argument of type Arg associated with + // keyword Keyword + template <typename Keyword, typename Arg> + class tagged_argument + : public ::boost::parameter::aux::tagged_argument_base { - return x.value; - } + typedef typename ::boost::remove_const<Arg>::type arg_type; + + public: + typedef Keyword key_type; + + // Wrap plain (non-UDT) function objects in either + // a boost::function or a std::function. -- Cromwell D. Enage + typedef typename ::boost::mpl::if_< + ::boost::is_function<arg_type> +#if defined(BOOST_NO_CXX11_HDR_FUNCTIONAL) + , ::boost::function<arg_type> +#else + , ::std::function<arg_type> +#endif + , Arg + >::type value_type; + + // If Arg is void_, then this type will evaluate to void_&. If the + // supplied argument is a plain function, then this type will evaluate + // to a reference-to-const function wrapper type. If the supplied + // argument is an lvalue, then Arg will be deduced to the lvalue + // reference. -- Cromwell D. Enage + typedef typename ::boost::mpl::if_< + ::boost::is_function<arg_type> + , value_type const& + , Arg& + >::type reference; + + private: + // Store plain functions by value, everything else by reference. + // -- Cromwell D. Enage + typename ::boost::mpl::if_< + ::boost::is_function<arg_type> + , value_type + , reference + >::type value; + + public: + inline explicit BOOST_CONSTEXPR tagged_argument(reference x) + : value(x) + { + } + + inline BOOST_CONSTEXPR tagged_argument(tagged_argument const& copy) + : value(copy.value) + { + } + + // A metafunction class that, given a keyword and a default type, + // returns the appropriate result type for a keyword lookup given + // that default. + struct binding + { + template <typename KW, typename Default, typename Reference> + struct apply + { + typedef typename ::boost::mpl::eval_if< + ::boost::is_same<KW,key_type> + , ::boost::mpl::if_<Reference,reference,value_type> + , ::boost::mpl::identity<Default> + >::type type; + }; + }; + + // Comma operator to compose argument list without using parameters<>. + // Useful for argument lists with undetermined length. + template <typename Keyword2, typename Arg2> + inline ::boost::parameter::aux::arg_list< + ::boost::parameter::aux::tagged_argument<Keyword,Arg> + , ::boost::parameter::aux::arg_list< + ::boost::parameter::aux::tagged_argument<Keyword2,Arg2> + > + > + operator,( + ::boost::parameter::aux + ::tagged_argument<Keyword2,Arg2> const& x + ) const + { + return ::boost::parameter::aux::arg_list< + ::boost::parameter::aux::tagged_argument<Keyword,Arg> + , ::boost::parameter::aux::arg_list< + ::boost::parameter::aux::tagged_argument<Keyword2,Arg2> + > + >( + *this + , ::boost::parameter::aux::arg_list< + ::boost::parameter::aux::tagged_argument<Keyword2,Arg2> + >(x, ::boost::parameter::aux::empty_arg_list()) + ); + } + + // Accessor interface. + inline BOOST_CONSTEXPR reference get_value() const + { + return this->value; + } + + inline BOOST_CONSTEXPR reference + operator[](::boost::parameter::keyword<Keyword> const&) const + { + return this->get_value(); + } + +#if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) || \ + BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) + template <typename KW, typename Default> + inline BOOST_CONSTEXPR Default& + get_with_default( + ::boost::parameter::aux::default_<KW,Default> const& x + , int + ) const + { + return x.value; + } - template <class KW, class F> - typename result_of0<F>::type operator[](lazy_default<KW,F> const& x) const + template <typename Default> + inline BOOST_CONSTEXPR reference + get_with_default( + ::boost::parameter::aux::default_<key_type,Default> const& + , long + ) const + { + return this->get_value(); + } + + template <typename KW, typename Default> + inline BOOST_CONSTEXPR typename ::boost::mpl::apply_wrap3< + binding + , KW + , Default& + , ::boost::mpl::true_ + >::type + operator[]( + ::boost::parameter::aux::default_<KW,Default> const& x + ) const + { + return this->get_with_default(x, 0L); + } + + template <typename KW, typename F> + inline BOOST_CONSTEXPR + typename ::boost::parameter::aux::result_of0<F>::type + get_with_lazy_default( + ::boost::parameter::aux::lazy_default<KW,F> const& x + , int + ) const + { + return x.compute_default(); + } + + template <typename F> + inline BOOST_CONSTEXPR reference + get_with_lazy_default( + ::boost::parameter::aux::lazy_default<key_type,F> const& + , long + ) const + { + return this->get_value(); + } + + template <typename KW, typename F> + inline BOOST_CONSTEXPR typename ::boost::mpl::apply_wrap3< + binding + , KW + , typename ::boost::parameter::aux::result_of0<F>::type + , ::boost::mpl::true_ + >::type + operator[]( + ::boost::parameter::aux::lazy_default<KW,F> const& x + ) const + { + return this->get_with_lazy_default(x, 0L); + } +#else // No function template ordering or Borland workarounds needed. + template <typename Default> + inline BOOST_CONSTEXPR reference + operator[]( + ::boost::parameter::aux::default_<key_type,Default> const& + ) const + { + return this->get_value(); + } + + template <typename F> + inline BOOST_CONSTEXPR reference + operator[]( + ::boost::parameter::aux::lazy_default<key_type,F> const& + ) const + { + return this->get_value(); + } + + template <typename KW, typename Default> + inline BOOST_CONSTEXPR Default& + operator[]( + ::boost::parameter::aux::default_<KW,Default> const& x + ) const + { + return x.value; + } + + template <typename KW, typename F> + inline BOOST_CONSTEXPR + typename ::boost::parameter::aux::result_of0<F>::type + operator[]( + ::boost::parameter::aux::lazy_default<KW,F> const& x + ) const + { + return x.compute_default(); + } + + template <typename ParameterRequirements> + static BOOST_CONSTEXPR typename ParameterRequirements::has_default + satisfies(ParameterRequirements*); + + template <typename HasDefault, typename Predicate> + static BOOST_CONSTEXPR + typename ::boost::mpl::apply_wrap1<Predicate,value_type>::type + satisfies( + ::boost::parameter::aux::parameter_requirements< + key_type + , Predicate + , HasDefault + >* + ); +#endif // Function template ordering, Borland workarounds needed. + + // MPL sequence support + // Convenience for users + typedef ::boost::parameter::aux::tagged_argument<Keyword,Arg> type; + // For the benefit of iterators + typedef ::boost::parameter::aux::empty_arg_list tail_type; + // For dispatching to sequence intrinsics + typedef ::boost::parameter::aux::arg_list_tag tag; + +#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310)) + // warning suppression + private: + void operator=(type const&); +#endif + }; +}}} // namespace boost::parameter::aux + +#endif // BOOST_PARAMETER_HAS_PERFECT_FORWARDING + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + +namespace boost { namespace parameter { namespace aux { + + template <typename TaggedArg> + struct tagged_argument_list_of_1 : public TaggedArg { - return x.compute_default(); - } - - template <class ParameterRequirements> - static typename ParameterRequirements::has_default - satisfies(ParameterRequirements*); - - template <class HasDefault, class Predicate> - static typename mpl::apply1<Predicate, value_type>::type - satisfies( - parameter_requirements<key_type,Predicate,HasDefault>* - ); -# endif - - reference value; -# if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310)) - // warning suppression - private: - void operator=(tagged_argument const&); - public: -# endif - // MPL sequence support - typedef tagged_argument type; // Convenience for users - typedef empty_arg_list tail_type; // For the benefit of iterators - typedef arg_list_tag tag; // For dispatching to sequence intrinsics -}; - -// Defines a metafunction, is_tagged_argument, that identifies -// tagged_argument specializations and their derived classes. -template <class T> -struct is_tagged_argument_aux - : is_convertible<T*,tagged_argument_base const*> -{}; - -template <class T> -struct is_tagged_argument - : mpl::and_< - mpl::not_<is_reference<T> > - , is_tagged_argument_aux<T> - > -{}; + using base_type = TaggedArg; + + inline explicit BOOST_CONSTEXPR tagged_argument_list_of_1( + typename base_type::reference x + ) : base_type(static_cast<typename base_type::reference>(x)) + { + } + + inline BOOST_CONSTEXPR tagged_argument_list_of_1( + tagged_argument_list_of_1 const& copy + ) : base_type(static_cast<base_type const&>(copy)) + { + } + + using base_type::operator[]; + using base_type::satisfies; + template <typename TA2> + inline BOOST_CONSTEXPR ::boost::parameter::aux::flat_like_arg_list< + ::boost::parameter::aux + ::flat_like_arg_tuple<typename TaggedArg::key_type,TaggedArg> + , ::boost::parameter::aux::flat_like_arg_tuple< + typename TA2::base_type::key_type + , typename TA2::base_type + > + > + operator,(TA2 const& x) const + { + return boost::parameter::aux::flat_like_arg_list< + ::boost::parameter::aux + ::flat_like_arg_tuple<typename TaggedArg::key_type,TaggedArg> + , ::boost::parameter::aux::flat_like_arg_tuple< + typename TA2::base_type::key_type + , typename TA2::base_type + > + >( + static_cast<base_type const&>(*this) + , ::boost::parameter::aux::arg_list<typename TA2::base_type>( + static_cast<typename TA2::base_type const&>(x) + , ::boost::parameter::aux::empty_arg_list() + ) + ); + } + }; }}} // namespace boost::parameter::aux -#endif // BOOST_PARAMETER_TAGGED_ARGUMENT_050328_HPP +#endif // BOOST_PARAMETER_CAN_USE_MP11 +#endif // include guard diff --git a/boost/parameter/aux_/tagged_argument_fwd.hpp b/boost/parameter/aux_/tagged_argument_fwd.hpp new file mode 100644 index 0000000000..5f1e5a1074 --- /dev/null +++ b/boost/parameter/aux_/tagged_argument_fwd.hpp @@ -0,0 +1,38 @@ +// 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_TAGGED_ARGUMENT_FWD_HPP +#define BOOST_PARAMETER_TAGGED_ARGUMENT_FWD_HPP + +namespace boost { namespace parameter { namespace aux { + + template <typename Keyword, typename Arg> + class tagged_argument; +}}} // namespace boost::parameter::aux + +#include <boost/parameter/config.hpp> + +#if defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING) + +namespace boost { namespace parameter { namespace aux { + + template <typename Keyword, typename Arg> + struct tagged_argument_rref; +}}} // namespace boost::parameter::aux + +#endif + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + +namespace boost { namespace parameter { namespace aux { + + template <typename TaggedArg> + struct tagged_argument_list_of_1; +}}} // namespace boost::parameter::aux + +#endif +#endif // include guard + diff --git a/boost/parameter/aux_/template_keyword.hpp b/boost/parameter/aux_/template_keyword.hpp index 5a02f008a3..ee563f1aa7 100644 --- a/boost/parameter/aux_/template_keyword.hpp +++ b/boost/parameter/aux_/template_keyword.hpp @@ -1,47 +1,89 @@ -// Copyright Daniel Wallin 2006. Use, modification and distribution is -// subject to the Boost Software License, Version 1.0. (See accompanying -// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +// Copyright Daniel Wallin 2006. +// 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_TEMPLATE_KEYWORD_060203_HPP -# define BOOST_PARAMETER_TEMPLATE_KEYWORD_060203_HPP +#define BOOST_PARAMETER_TEMPLATE_KEYWORD_060203_HPP -# include <boost/mpl/and.hpp> -# include <boost/mpl/not.hpp> -# include <boost/type_traits/is_convertible.hpp> -# include <boost/type_traits/is_reference.hpp> +namespace boost { namespace parameter { namespace aux { -namespace boost { namespace parameter { + struct template_keyword_base + { + }; +}}} // namespace boost::parameter::aux -namespace aux -{ +#include <boost/parameter/config.hpp> - struct template_keyword_tag {}; +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <type_traits> - template <class T, class U> - struct is_pointer_convertible - : is_convertible<T*, U*> - {}; +namespace boost { namespace parameter { namespace aux { - template <class T> - struct is_template_keyword - : mpl::and_< - mpl::not_<is_reference<T> > - , is_pointer_convertible<T, template_keyword_tag> - > - {}; + template <typename T> + using is_template_keyword = ::std::is_base_of< + ::boost::parameter::aux::template_keyword_base + , typename ::std::remove_const< + typename ::std::remove_reference<T>::type + >::type + >; +}}} // namespace boost::parameter::aux -} // namespace aux +#else // !defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <boost/mpl/bool.hpp> +#include <boost/mpl/if.hpp> +#include <boost/type_traits/remove_const.hpp> -template <class Tag, class T> -struct template_keyword - : aux::template_keyword_tag -{ - typedef Tag key_type; - typedef T value_type; - typedef value_type reference; -}; +#if defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING) +#include <boost/type_traits/is_base_of.hpp> +#include <boost/type_traits/remove_reference.hpp> +#else +#include <boost/type_traits/is_convertible.hpp> +#include <boost/type_traits/is_lvalue_reference.hpp> +#endif -}} // namespace boost::parameter +namespace boost { namespace parameter { namespace aux { -#endif // BOOST_PARAMETER_TEMPLATE_KEYWORD_060203_HPP +#if !defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING) + template <typename T> + struct is_template_keyword_aux + : ::boost::mpl::if_< + ::boost::is_convertible< + T* + , ::boost::parameter::aux::template_keyword_base const* + > + , ::boost::mpl::true_ + , ::boost::mpl::false_ + >::type + { + }; +#endif // BOOST_PARAMETER_HAS_PERFECT_FORWARDING + + template <typename T> + struct is_template_keyword + : ::boost::mpl::if_< +#if defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING) + // Cannot use is_convertible<> to check if T is derived from + // template_keyword_base. -- Cromwell D. Enage + ::boost::is_base_of< + ::boost::parameter::aux::template_keyword_base + , typename ::boost::remove_const< + typename ::boost::remove_reference<T>::type + >::type + > + , ::boost::mpl::true_ + , ::boost::mpl::false_ +#else + ::boost::is_lvalue_reference<T> + , ::boost::mpl::false_ + , ::boost::parameter::aux::is_template_keyword_aux<T> +#endif // BOOST_PARAMETER_HAS_PERFECT_FORWARDING + >::type + { + }; +}}} // namespace boost::parameter::aux + +#endif // BOOST_PARAMETER_CAN_USE_MP11 +#endif // include guard diff --git a/boost/parameter/aux_/unwrap_cv_reference.hpp b/boost/parameter/aux_/unwrap_cv_reference.hpp index b6c263f232..af577db008 100644 --- a/boost/parameter/aux_/unwrap_cv_reference.hpp +++ b/boost/parameter/aux_/unwrap_cv_reference.hpp @@ -1,91 +1,174 @@ -// 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 UNWRAP_CV_REFERENCE_050328_HPP #define UNWRAP_CV_REFERENCE_050328_HPP +namespace boost { + + template <typename T> + class reference_wrapper; +} // namespace boost + #include <boost/parameter/aux_/yesno.hpp> -#include <boost/mpl/bool.hpp> -#include <boost/mpl/identity.hpp> -#include <boost/mpl/eval_if.hpp> -namespace boost { template<class T> class reference_wrapper; } +namespace boost { namespace parameter { namespace aux { + + // + // reference_wrapper support -- if perfect forwarding is unsupported, + // then when passing arguments positionally by non-const reference, + // we ask users of named parameter interfaces to use ref(x) to wrap them. + // + + template <typename U> + ::boost::parameter::aux::yes_tag + is_cv_reference_wrapper_check( + ::boost::reference_wrapper<U> const volatile* + ); + + ::boost::parameter::aux::no_tag is_cv_reference_wrapper_check(...); +}}} // namespace boost::parameter::aux + +#include <boost/parameter/config.hpp> + +#if !defined(BOOST_NO_CXX11_HDR_FUNCTIONAL) +#include <functional> namespace boost { namespace parameter { namespace aux { -// -// reference_wrapper support -- because of the forwarding problem, -// when passing arguments positionally by non-const reference, we -// ask users of named parameter interfaces to use ref(x) to wrap -// them. -// - -// is_cv_reference_wrapper returns mpl::true_ if T is of type -// reference_wrapper<U> cv -template <class U> -yes_tag is_cv_reference_wrapper_check(reference_wrapper<U> const volatile*); -no_tag is_cv_reference_wrapper_check(...); - -template <class T> -struct is_cv_reference_wrapper -{ - BOOST_STATIC_CONSTANT( - bool, value = ( - sizeof(is_cv_reference_wrapper_check((T*)0)) == sizeof(yes_tag) - ) - ); - - typedef mpl::bool_< -#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) - is_cv_reference_wrapper:: -#endif - value> type; -}; + // Support for std::ref(x) -- Cromwell D. Enage + template <typename U> + ::boost::parameter::aux::yes_tag + is_cv_reference_wrapper_check( + ::std::reference_wrapper<U> const volatile* + ); +}}} // namespace boost::parameter::aux +#endif -// Needed for unwrap_cv_reference below. T might be const, so -// eval_if might fail because of deriving from T const on EDG. -template <class T> -struct get_type -{ - typedef typename T::type type; -}; +#include <boost/parameter/aux_/preprocessor/nullptr.hpp> -#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) -template <class T, class is_reference_wrapper = typename is_cv_reference_wrapper<T>::type> -struct unwrap_cv_reference -{ - typedef T type; -}; - -template <class T> -struct unwrap_cv_reference<T const, mpl::false_> -{ - typedef T const type; -}; - -template <class T> -struct unwrap_cv_reference<T, mpl::true_> - : T -{}; - -#else -// Produces the unwrapped type to hold a reference to in named<> -// Can't use boost::unwrap_reference<> here because it -// doesn't handle the case where T = reference_wrapper<U> cv -template <class T> -struct unwrap_cv_reference -{ - typedef typename mpl::eval_if< - is_cv_reference_wrapper<T> - , get_type<T> - , mpl::identity<T> - >::type type; -}; +#if defined(BOOST_PARAMETER_CAN_USE_MP11) && !( \ + BOOST_WORKAROUND(BOOST_MSVC, >= 1900) && \ + BOOST_WORKAROUND(BOOST_MSVC, < 1910) \ + ) +#include <boost/mp11/integral.hpp> +#include <boost/mp11/utility.hpp> +#include <type_traits> +#else // !defined(BOOST_PARAMETER_CAN_USE_MP11) || MSVC-14.0 +#include <boost/mpl/bool.hpp> +#include <boost/type_traits/remove_reference.hpp> +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \ + !BOOST_WORKAROUND(BOOST_GCC, < 40000) +#include <boost/mpl/eval_if.hpp> #endif +#endif // BOOST_PARAMETER_CAN_USE_MP11 && not MSVC-14.0 + +namespace boost { namespace parameter { namespace aux { +#if defined(BOOST_PARAMETER_CAN_USE_MP11) && !( \ + BOOST_WORKAROUND(BOOST_MSVC, >= 1900) && \ + BOOST_WORKAROUND(BOOST_MSVC, < 1910) \ + ) + // This metafunction returns mp11::mp_true if T is of type + // reference_wrapper<U> cv. + template <typename T> + using is_cv_reference_wrapper = ::boost::mp11::mp_bool< + sizeof( + ::boost::parameter::aux::is_cv_reference_wrapper_check( + static_cast< + typename ::std::remove_reference<T>::type* + >(BOOST_PARAMETER_AUX_PP_NULLPTR) + ) + ) == sizeof(::boost::parameter::aux::yes_tag) + >; + + // Needed for unwrap_cv_reference below. T might be const, so + // mp_eval_if<> might fail because of deriving from T const on EDG. + template <typename T> + using unwrap_cv_reference_impl = typename ::std::remove_reference<T>::type; + + // Produces the unwrapped type to hold a reference to in + // tagged_argument<>. Can't use boost::unwrap_reference<> here + // because it doesn't handle the case where T = reference_wrapper<U> cv. + template <typename T> + using unwrap_cv_reference = ::boost::mp11::mp_eval_if< + ::boost::parameter::aux::is_cv_reference_wrapper<T> + , ::boost::parameter::aux::unwrap_cv_reference_impl<T> + , ::std::remove_reference + , T + >; +#else // !defined(BOOST_PARAMETER_CAN_USE_MP11) || MSVC-14.0 + // This metafunction returns mpl::true_ if T is of type + // reference_wrapper<U> cv. + template <typename T> + struct is_cv_reference_wrapper + { + BOOST_STATIC_CONSTANT( + bool, value = ( + sizeof( + ::boost::parameter::aux::is_cv_reference_wrapper_check( + static_cast< + typename ::boost::remove_reference<T>::type* + >(BOOST_PARAMETER_AUX_PP_NULLPTR) + ) + ) == sizeof(::boost::parameter::aux::yes_tag) + ) + ); + + typedef boost::mpl::bool_< +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) + is_cv_reference_wrapper:: +#endif + value> type; + }; + +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) || \ + BOOST_WORKAROUND(BOOST_GCC, < 40000) + template < + typename T + , typename = typename ::boost::parameter::aux + ::is_cv_reference_wrapper<T>::type + > + struct unwrap_cv_reference : ::boost::remove_reference<T> + { + }; + + template <typename T> + struct unwrap_cv_reference<T const,::boost::mpl::false_> + { + typedef T const type; + }; + + template <typename T> + struct unwrap_cv_reference<T,::boost::mpl::true_> : T + { + }; +#else // no Borland or GCC 3- workarounds needed + // Needed for unwrap_cv_reference below. T might be const, so + // eval_if<> might fail because of deriving from T const on EDG. + template <typename T> + struct unwrap_cv_reference_impl : ::boost::remove_reference<T>::type + { + }; + + // Produces the unwrapped type to hold a reference to in + // tagged_argument<>. Can't use boost::unwrap_reference<> here + // because it doesn't handle the case where T = reference_wrapper<U> cv. + template <typename T> + struct unwrap_cv_reference + : ::boost::mpl::eval_if< + ::boost::parameter::aux::is_cv_reference_wrapper<T> + , ::boost::parameter::aux::unwrap_cv_reference_impl<T> + , ::boost::remove_reference<T> + > + { + }; +#endif // Borland or GCC 3- workarounds needed +#endif // BOOST_PARAMETER_CAN_USE_MP11 && not MSVC-14.0 }}} // namespace boost::parameter::aux -#endif // UNWRAP_CV_REFERENCE_050328_HPP +#endif // include guard diff --git a/boost/parameter/aux_/use_default.hpp b/boost/parameter/aux_/use_default.hpp new file mode 100644 index 0000000000..ba25a3f3de --- /dev/null +++ b/boost/parameter/aux_/use_default.hpp @@ -0,0 +1,17 @@ +// 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_AUX_USE_DEFAULT_HPP +#define BOOST_PARAMETER_AUX_USE_DEFAULT_HPP + +namespace boost { namespace parameter { namespace aux { + + struct use_default + { + }; +}}} // namespace boost::parameter::aux + +#endif // include guard + diff --git a/boost/parameter/aux_/use_default_tag.hpp b/boost/parameter/aux_/use_default_tag.hpp new file mode 100644 index 0000000000..54db947a90 --- /dev/null +++ b/boost/parameter/aux_/use_default_tag.hpp @@ -0,0 +1,29 @@ +// Copyright Daniel Wallin 2006. +// 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_USE_DEFAULT_TAG_HPP +#define BOOST_PARAMETER_USE_DEFAULT_TAG_HPP + +#include <boost/config.hpp> + +namespace boost { namespace parameter { namespace aux { + + struct use_default_tag + { + inline BOOST_CONSTEXPR BOOST_DEFAULTED_FUNCTION(use_default_tag(), {}) + + inline BOOST_CONSTEXPR BOOST_DEFAULTED_FUNCTION( + use_default_tag(use_default_tag const&), {} + ) + + inline BOOST_CONSTEXPR use_default_tag operator()() const + { + return *this; + } + }; +}}} // namespace boost::parameter::aux + +#endif // include guard + diff --git a/boost/parameter/aux_/void.hpp b/boost/parameter/aux_/void.hpp index 7061a7deb5..2c7103b3e4 100644 --- a/boost/parameter/aux_/void.hpp +++ b/boost/parameter/aux_/void.hpp @@ -1,6 +1,6 @@ -// 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. +// 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_VOID_050329_HPP @@ -8,22 +8,31 @@ namespace boost { namespace parameter { -// A placemarker for "no argument passed." -// MAINTAINER NOTE: Do not make this into a metafunction -struct void_ {}; + // A placemarker for "no argument passed." + // MAINTAINER NOTE: Do not make this into a metafunction + struct void_ + { + }; +}} // namespace boost::parameter -namespace aux -{ +namespace boost { namespace parameter { namespace aux { - inline void_& void_reference() - { - static void_ instance; - return instance; - } + inline ::boost::parameter::void_& void_reference() + { + static ::boost::parameter::void_ instance; + return instance; + } +}}} // namespace boost::parameter::aux -} // namespace aux +#include <boost/config/workaround.hpp> -}} // namespace boost::parameter +#if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x580)) + +namespace boost { namespace parameter { namespace aux { + + typedef void* voidstar; +}}} // namespace boost::parameter::aux -#endif // BOOST_PARAMETER_VOID_050329_HPP +#endif +#endif // include guard diff --git a/boost/parameter/aux_/yesno.hpp b/boost/parameter/aux_/yesno.hpp index 13fa545a68..583c64abbc 100644 --- a/boost/parameter/aux_/yesno.hpp +++ b/boost/parameter/aux_/yesno.hpp @@ -1,26 +1,42 @@ -// 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. +// 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 YESNO_050328_HPP #define YESNO_050328_HPP +namespace boost { namespace parameter { namespace aux { + + // types used with the "sizeof trick" to capture the results of + // overload resolution at compile-time. + typedef char yes_tag; + typedef char (&no_tag)[2]; +}}} // namespace boost::parameter::aux + #include <boost/mpl/bool.hpp> namespace boost { namespace parameter { namespace aux { -// types used with the "sizeof trick" to capture the results of -// overload resolution at compile-time. -typedef char yes_tag; -typedef char (&no_tag)[2]; + // mpl::true_ and mpl::false_ are not distinguishable by sizeof(), + // so we pass them through these functions to get a type that is. + ::boost::parameter::aux::yes_tag to_yesno(::boost::mpl::true_); + ::boost::parameter::aux::no_tag to_yesno(::boost::mpl::false_); +}}} // namespace boost::parameter::aux + +#include <boost/parameter/config.hpp> -// mpl::true_ and mpl::false_ are not distinguishable by sizeof(), -// so we pass them through these functions to get a type that is. -yes_tag to_yesno(mpl::true_); -no_tag to_yesno(mpl::false_); +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <boost/mp11/integral.hpp> + +namespace boost { namespace parameter { namespace aux { + // mp11::mp_true and mp11::mp_false are not distinguishable by sizeof(), + // so we pass them through these functions to get a type that is. + ::boost::parameter::aux::yes_tag to_yesno(::boost::mp11::mp_true); + ::boost::parameter::aux::no_tag to_yesno(::boost::mp11::mp_false); }}} // namespace boost::parameter::aux -#endif // YESNO_050328_HPP +#endif // BOOST_PARAMETER_CAN_USE_MP11 +#endif // include guard diff --git a/boost/parameter/binding.hpp b/boost/parameter/binding.hpp index 778a7b7bac..a1d4e85ce0 100644 --- a/boost/parameter/binding.hpp +++ b/boost/parameter/binding.hpp @@ -1,80 +1,164 @@ -// Copyright David Abrahams 2005. 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) +// Copyright David Abrahams 2005. +// 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_BINDING_DWA200558_HPP -# define BOOST_PARAMETER_BINDING_DWA200558_HPP +#define BOOST_PARAMETER_BINDING_DWA200558_HPP + +#include <boost/parameter/aux_/void.hpp> +#include <boost/parameter/config.hpp> -# include <boost/mpl/apply.hpp> -# include <boost/mpl/assert.hpp> -# include <boost/mpl/and.hpp> -# include <boost/parameter/aux_/result_of0.hpp> -# include <boost/parameter/aux_/void.hpp> -# include <boost/type_traits/is_same.hpp> +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <boost/mp11/integral.hpp> +#include <boost/mp11/list.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/mpl/identity.hpp> +#include <boost/mpl/apply_wrap.hpp> +#include <boost/mpl/assert.hpp> +#include <boost/type_traits/is_same.hpp> +#endif namespace boost { namespace parameter { -// A metafunction that, given an argument pack, returns the type of -// the parameter identified by the given keyword. If no such -// parameter has been specified, returns Default - -# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) -template <class Parameters, class Keyword, class Default> -struct binding0 -{ - typedef typename mpl::apply_wrap3< - typename Parameters::binding,Keyword,Default,mpl::true_ - >::type type; - - BOOST_MPL_ASSERT_NOT(( - mpl::and_< - is_same<Default, void_> - , is_same<type, void_> - > - )); -}; -# endif - -template <class Parameters, class Keyword, class Default = void_> -struct binding -{ -# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) - typedef typename mpl::eval_if< - mpl::is_placeholder<Parameters> - , mpl::identity<int> - , binding0<Parameters,Keyword,Default> - >::type type; -# else - typedef typename mpl::apply_wrap3< - typename Parameters::binding,Keyword,Default,mpl::true_ - >::type type; - - BOOST_MPL_ASSERT_NOT(( - mpl::and_< - is_same<Default, void_> - , is_same<type, void_> + // A metafunction that, given an argument pack, returns the reference type + // of the parameter identified by the given keyword. If no such parameter + // has been specified, returns Default + + template <typename Parameters, typename Keyword, typename Default> + struct binding0 + { +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using type = ::boost::mp11::mp_apply_q< + typename Parameters::binding + , ::boost::mp11::mp_list<Keyword,Default,::boost::mp11::mp_true> + >; + + static_assert( + ::boost::mp11::mp_if< + ::std::is_same<Default,::boost::parameter::void_> + , ::boost::mp11::mp_if< + ::std::is_same<type,::boost::parameter::void_> + , ::boost::mp11::mp_false + , ::boost::mp11::mp_true + > + , ::boost::mp11::mp_true + >::value + , "required parameters must not result in void_ type" + ); +#else // !defined(BOOST_PARAMETER_CAN_USE_MP11) + typedef typename ::boost::mpl::apply_wrap3< + typename Parameters::binding + , Keyword + , Default + , ::boost::mpl::true_ + >::type type; + + BOOST_MPL_ASSERT(( + typename ::boost::mpl::eval_if< + ::boost::is_same<Default,::boost::parameter::void_> + , ::boost::mpl::if_< + ::boost::is_same<type,::boost::parameter::void_> + , ::boost::mpl::false_ + , ::boost::mpl::true_ + > + , ::boost::mpl::true_ + >::type + )); +#endif // BOOST_PARAMETER_CAN_USE_MP11 + }; + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + template <typename Placeholder, typename Keyword, typename Default> + struct binding1 + { + using type = ::boost::mp11::mp_apply_q< + Placeholder + , ::boost::mp11::mp_list<Keyword,Default,::boost::mp11::mp_true> + >; + + static_assert( + ::boost::mp11::mp_if< + ::std::is_same<Default,::boost::parameter::void_> + , ::boost::mp11::mp_if< + ::std::is_same<type,::boost::parameter::void_> + , ::boost::mp11::mp_false + , ::boost::mp11::mp_true + > + , ::boost::mp11::mp_true + >::value + , "required parameters must not result in void_ type" + ); + }; +#endif // BOOST_PARAMETER_CAN_USE_MP11 +}} // namespace boost::parameter + +#include <boost/parameter/aux_/is_placeholder.hpp> + +namespace boost { namespace parameter { + + template < + typename Parameters + , typename Keyword + , typename Default = ::boost::parameter::void_ + > + struct binding +#if !defined(BOOST_PARAMETER_CAN_USE_MP11) + : ::boost::mpl::eval_if< + ::boost::parameter::aux::is_mpl_placeholder<Parameters> + , ::boost::mpl::identity<int> + , ::boost::parameter::binding0<Parameters,Keyword,Default> > - )); -# endif - - BOOST_MPL_AUX_LAMBDA_SUPPORT(3,binding,(Parameters,Keyword,Default)) -}; - -// A metafunction that, given an argument pack, returns the type of -// the parameter identified by the given keyword. If no such -// parameter has been specified, returns the type returned by invoking -// DefaultFn -template <class Parameters, class Keyword, class DefaultFn> -struct lazy_binding -{ - typedef typename mpl::apply_wrap3< - typename Parameters::binding - , Keyword - , typename aux::result_of0<DefaultFn>::type - , mpl::true_ - >::type type; -}; +#endif + { +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using type = typename ::boost::mp11::mp_if< + ::boost::parameter::aux::is_mpl_placeholder<Parameters> + , ::boost::mp11::mp_identity<int> + , ::boost::mp11::mp_if< + ::boost::parameter::aux::is_mp11_placeholder<Parameters> + , ::boost::parameter::binding1<Parameters,Keyword,Default> + , ::boost::parameter::binding0<Parameters,Keyword,Default> + > + >::type; +#endif + }; +}} // namespace boost::parameter + +#include <boost/parameter/aux_/result_of0.hpp> +namespace boost { namespace parameter { + // A metafunction that, given an argument pack, returns the reference type + // of the parameter identified by the given keyword. If no such parameter + // has been specified, returns the type returned by invoking DefaultFn + template <typename Parameters, typename Keyword, typename DefaultFn> + struct lazy_binding + { +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using type = ::boost::mp11::mp_apply_q< + typename Parameters::binding + , ::boost::mp11::mp_list< + Keyword + , typename ::boost::parameter::aux::result_of0<DefaultFn>::type + , ::boost::mp11::mp_true + > + >; +#else + typedef typename ::boost::mpl::apply_wrap3< + typename Parameters::binding + , Keyword + , typename ::boost::parameter::aux::result_of0<DefaultFn>::type + , ::boost::mpl::true_ + >::type type; +#endif // BOOST_PARAMETER_CAN_USE_MP11 + }; }} // namespace boost::parameter -#endif // BOOST_PARAMETER_BINDING_DWA200558_HPP +#endif // include guard + diff --git a/boost/parameter/compose.hpp b/boost/parameter/compose.hpp new file mode 100644 index 0000000000..a1111989ea --- /dev/null +++ b/boost/parameter/compose.hpp @@ -0,0 +1,210 @@ +// Copyright Cromwell D. Enage 2019. +// 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_COMPOSE_HPP +#define BOOST_PARAMETER_COMPOSE_HPP + +#include <boost/parameter/aux_/arg_list.hpp> + +namespace boost { namespace parameter { + + inline BOOST_CONSTEXPR ::boost::parameter::aux::empty_arg_list compose() + { + return ::boost::parameter::aux::empty_arg_list(); + } +}} // namespace boost::parameter + +#include <boost/parameter/config.hpp> + +#if defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING) + +namespace boost { namespace parameter { namespace aux { + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + template <typename ...TaggedArgs> + struct compose_arg_list + { + using type = ::boost::parameter::aux::flat_like_arg_list< + ::boost::parameter::aux::flat_like_arg_tuple< + typename TaggedArgs::base_type::key_type + , typename TaggedArgs::base_type + >... + >; + }; +#else // !defined(BOOST_PARAMETER_CAN_USE_MP11) + template <typename TaggedArg0, typename ...TaggedArgs> + struct compose_arg_list; + + template <typename TaggedArg0> + struct compose_arg_list<TaggedArg0> + { + typedef ::boost::parameter::aux::arg_list<TaggedArg0> type; + }; + + template <typename TaggedArg0, typename ...TaggedArgs> + struct compose_arg_list + { + typedef ::boost::parameter::aux::arg_list< + TaggedArg0 + , typename ::boost::parameter::aux + ::compose_arg_list<TaggedArgs...>::type + > type; + }; +#endif // BOOST_PARAMETER_CAN_USE_MP11 +}}} // namespace boost::parameter::aux + +#include <boost/parameter/are_tagged_arguments.hpp> +#include <boost/core/enable_if.hpp> + +namespace boost { namespace parameter { namespace result_of { + + template <typename ...TaggedArgs> + struct compose + : ::boost::lazy_enable_if< + ::boost::parameter::are_tagged_arguments<TaggedArgs...> + , ::boost::parameter::aux::compose_arg_list<TaggedArgs...> + > + { + }; + + template <> + struct compose<> + { + typedef ::boost::parameter::aux::empty_arg_list type; + }; +}}} // namespace boost::parameter::result_of + +namespace boost { namespace parameter { + + template <typename TaggedArg0, typename ...TaggedArgs> + inline BOOST_CONSTEXPR typename ::boost::parameter::result_of + ::compose<TaggedArg0,TaggedArgs...>::type + compose(TaggedArg0 const& arg0, TaggedArgs const&... args) + { + return typename ::boost::parameter::aux + ::compose_arg_list<TaggedArg0,TaggedArgs...>::type( + ::boost::parameter::aux::value_type_is_not_void() + , arg0 + , args... + ); + } +}} // namespace boost::parameter + +#else // !defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING) + +#define BOOST_PARAMETER_compose_arg_list_type_suffix(z, n, suffix) suffix + +#include <boost/preprocessor/cat.hpp> + +#define BOOST_PARAMETER_compose_arg_list_type_prefix(z, n, prefix) \ + ::boost::parameter::aux::arg_list<BOOST_PP_CAT(prefix, n) +/**/ + +#include <boost/preprocessor/facilities/intercept.hpp> +#include <boost/preprocessor/repetition/enum.hpp> +#include <boost/preprocessor/repetition/repeat.hpp> + +#define BOOST_PARAMETER_compose_arg_list_type(z, n, prefix) \ + BOOST_PP_CAT(BOOST_PP_ENUM_, z)( \ + n, BOOST_PARAMETER_compose_arg_list_type_prefix, prefix \ + ) BOOST_PP_CAT(BOOST_PP_REPEAT_, z)( \ + n, BOOST_PARAMETER_compose_arg_list_type_suffix, > \ + ) +/**/ + +#include <boost/parameter/aux_/void.hpp> +#include <boost/preprocessor/arithmetic/inc.hpp> +#include <boost/preprocessor/arithmetic/sub.hpp> +#include <boost/preprocessor/repetition/enum_params.hpp> +#include <boost/preprocessor/repetition/enum_binary_params.hpp> +#include <boost/preprocessor/repetition/enum_trailing_params.hpp> + +#if defined(BOOST_NO_SFINAE) +#define BOOST_PARAMETER_compose_arg_list_function_overload(z, n, prefix) \ + template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename prefix)> \ + inline BOOST_CONSTEXPR \ + BOOST_PARAMETER_compose_arg_list_type(z, n, prefix) \ + compose(BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, prefix, const& a)) \ + { \ + return BOOST_PARAMETER_compose_arg_list_type(z, n, prefix)( \ + BOOST_PP_ENUM_PARAMS_Z(z, n, a) \ + BOOST_PP_ENUM_TRAILING_PARAMS_Z( \ + z \ + , BOOST_PP_SUB(BOOST_PARAMETER_COMPOSE_MAX_ARITY, n) \ + , ::boost::parameter::aux::void_reference() BOOST_PP_INTERCEPT \ + ) \ + ); \ + } +/**/ +#else // !defined(BOOST_NO_SFINAE) +#include <boost/parameter/are_tagged_arguments.hpp> +#include <boost/core/enable_if.hpp> + +namespace boost { namespace parameter { namespace result_of { + + template < + BOOST_PP_ENUM_BINARY_PARAMS( + BOOST_PP_INC(BOOST_PARAMETER_COMPOSE_MAX_ARITY) + , typename TaggedArg + , = void BOOST_PP_INTERCEPT + ) + > + struct compose; + + template <> + struct compose<> + { + typedef ::boost::parameter::aux::empty_arg_list type; + }; +}}} // namespace boost::parameter::result_of + +#define BOOST_PARAMETER_compose_arg_list_function_overload(z, n, prefix) \ +namespace boost { namespace parameter { namespace result_of { \ + template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename prefix)> \ + struct compose<BOOST_PP_ENUM_PARAMS_Z(z, n, prefix)> \ + : ::boost::enable_if< \ + ::boost::parameter \ + ::are_tagged_arguments<BOOST_PP_ENUM_PARAMS_Z(z, n, prefix)> \ + , BOOST_PARAMETER_compose_arg_list_type(z, n, prefix) \ + > \ + { \ + }; \ +}}} \ +namespace boost { namespace parameter { \ + template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename prefix)> \ + inline BOOST_CONSTEXPR typename ::boost::parameter::result_of \ + ::compose<BOOST_PP_ENUM_PARAMS_Z(z, n, prefix)>::type \ + compose(BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, prefix, const& a)) \ + { \ + return BOOST_PARAMETER_compose_arg_list_type(z, n, prefix)( \ + BOOST_PP_ENUM_PARAMS_Z(z, n, a) \ + BOOST_PP_ENUM_TRAILING_PARAMS_Z( \ + z \ + , BOOST_PP_SUB(BOOST_PARAMETER_COMPOSE_MAX_ARITY, n) \ + , ::boost::parameter::aux::void_reference() BOOST_PP_INTERCEPT \ + ) \ + ); \ + } \ +}} +/**/ +#endif // BOOST_NO_SFINAE + +#include <boost/preprocessor/repetition/repeat_from_to.hpp> + +BOOST_PP_REPEAT_FROM_TO( + 1 + , BOOST_PP_INC(BOOST_PARAMETER_COMPOSE_MAX_ARITY) + , BOOST_PARAMETER_compose_arg_list_function_overload + , TaggedArg +) + +#undef BOOST_PARAMETER_compose_arg_list_function_overload +#undef BOOST_PARAMETER_compose_arg_list_type +#undef BOOST_PARAMETER_compose_arg_list_type_prefix +#undef BOOST_PARAMETER_compose_arg_list_type_suffix + +#endif // BOOST_PARAMETER_HAS_PERFECT_FORWARDING +#endif // include guard + diff --git a/boost/parameter/config.hpp b/boost/parameter/config.hpp index 5710c92c0a..1b738f1fb6 100644 --- a/boost/parameter/config.hpp +++ b/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 diff --git a/boost/parameter/deduced.hpp b/boost/parameter/deduced.hpp new file mode 100644 index 0000000000..518ac799f6 --- /dev/null +++ b/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 + diff --git a/boost/parameter/is_argument_pack.hpp b/boost/parameter/is_argument_pack.hpp new file mode 100644 index 0000000000..3ff0d4d7d9 --- /dev/null +++ b/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 + diff --git a/boost/parameter/keyword.hpp b/boost/parameter/keyword.hpp index 925c772085..ce792f1a79 100644 --- a/boost/parameter/keyword.hpp +++ b/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 -#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 diff --git a/boost/parameter/keyword_fwd.hpp b/boost/parameter/keyword_fwd.hpp new file mode 100644 index 0000000000..d2ba0a78f7 --- /dev/null +++ b/boost/parameter/keyword_fwd.hpp @@ -0,0 +1,23 @@ +// 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_KEYWORD_FWD_HPP +#define BOOST_PARAMETER_KEYWORD_FWD_HPP + +namespace boost { namespace parameter { + + struct in_reference; + struct out_reference; + typedef ::boost::parameter::out_reference in_out_reference; + struct forward_reference; + struct consume_reference; + typedef ::boost::parameter::consume_reference move_from_reference; + + template <typename Tag> + struct keyword; +}} // namespace boost::parameter + +#endif // include guard + diff --git a/boost/parameter/macros.hpp b/boost/parameter/macros.hpp index 83fbfb5a60..5ff20fc232 100644 --- a/boost/parameter/macros.hpp +++ b/boost/parameter/macros.hpp @@ -1,99 +1,232 @@ -// Copyright David Abrahams, Daniel Wallin 2003. 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 David Abrahams, Daniel Wallin 2003. +// 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_MACROS_050412_HPP #define BOOST_PARAMETER_MACROS_050412_HPP -#include <boost/preprocessor/tuple/elem.hpp> -#include <boost/preprocessor/repetition/repeat_from_to.hpp> -#include <boost/preprocessor/arithmetic/inc.hpp> -#include <boost/preprocessor/logical/bool.hpp> -#include <boost/preprocessor/punctuation/comma_if.hpp> -#include <boost/preprocessor/control/expr_if.hpp> +#include <boost/parameter/config.hpp> #include <boost/preprocessor/repetition/enum_params.hpp> + +#if !defined(BOOST_NO_SFINAE) && \ + !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592)) + +#define BOOST_PARAMETER_MATCH_TYPE(n, param) \ + , typename param::match<BOOST_PP_ENUM_PARAMS(n, T)>::type kw = param() +/**/ + +#define BOOST_PARAMETER_MATCH_TYPE_Z(z, n, param) \ + , typename param::match<BOOST_PP_ENUM_PARAMS_Z(z, n, T)>::type kw = param() +/**/ + +#else // SFINAE disbled, or Borland workarounds needed. + +#define BOOST_PARAMETER_MATCH_TYPE(n, param) , param kw = param() +/**/ + +#define BOOST_PARAMETER_MATCH_TYPE_Z(z, n, param) , param kw = param() +/**/ + +#endif // SFINAE enabled, not Borland. + +#include <boost/preprocessor/control/if.hpp> #include <boost/preprocessor/repetition/enum_binary_params.hpp> +#include <boost/preprocessor/tuple/elem.hpp> #include <boost/preprocessor/cat.hpp> -#include <boost/detail/workaround.hpp> - -#define BOOST_PARAMETER_FUN_TEMPLATE_HEAD1(n) \ - template<BOOST_PP_ENUM_PARAMS(n, class T)> - -#define BOOST_PARAMETER_FUN_TEMPLATE_HEAD0(n) - -#if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592)) - -# define BOOST_PARAMETER_MATCH_TYPE(n, param) \ - BOOST_PP_EXPR_IF(n, typename) param::match \ - < \ - BOOST_PP_ENUM_PARAMS(n, T) \ - >::type - -#else - -# define BOOST_PARAMETER_MATCH_TYPE(n, param) param - -#endif - -#define BOOST_PARAMETER_FUN_DECL(z, n, params) \ - \ - BOOST_PP_CAT(BOOST_PARAMETER_FUN_TEMPLATE_HEAD, BOOST_PP_BOOL(n))(n) \ - \ - BOOST_PP_TUPLE_ELEM(3, 0, params) \ - BOOST_PP_TUPLE_ELEM(3, 1, params)( \ - BOOST_PP_ENUM_BINARY_PARAMS(n, T, const& p) \ - BOOST_PP_COMMA_IF(n) \ - BOOST_PARAMETER_MATCH_TYPE(n,BOOST_PP_TUPLE_ELEM(3, 2, params)) \ - kw = BOOST_PP_TUPLE_ELEM(3, 2, params)() \ - ) \ - { \ - return BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3, 1, params), _with_named_params)( \ - kw(BOOST_PP_ENUM_PARAMS(n, p)) \ - ); \ + +#if defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING) + +#define BOOST_PARAMETER_FUN_0(z, n, params) \ + BOOST_PP_TUPLE_ELEM(3, 0, params) BOOST_PP_TUPLE_ELEM(3, 1, params)() \ + { \ + return BOOST_PP_CAT( \ + BOOST_PP_TUPLE_ELEM(3, 1, params) \ + , _with_named_params \ + )(BOOST_PP_TUPLE_ELEM(3, 2, params)()()); \ + } +/**/ + +#include <utility> + +#define BOOST_PARAMETER_FUN_DECL_PARAM(z, n, p) \ + ::std::forward<BOOST_PP_CAT(T, n)>(BOOST_PP_CAT(p, n)) +/**/ + +#include <boost/preprocessor/repetition/enum.hpp> + +#define BOOST_PARAMETER_FUN_DEFN_1(z, n, params) \ + template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename T)> \ + BOOST_PP_TUPLE_ELEM(3, 0, params) \ + BOOST_PP_TUPLE_ELEM(3, 1, params)( \ + BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, T, && p) \ + BOOST_PARAMETER_MATCH_TYPE_Z( \ + z, n, BOOST_PP_TUPLE_ELEM(3, 2, params) \ + ) \ + ) \ + { \ + return BOOST_PP_CAT( \ + BOOST_PP_TUPLE_ELEM(3, 1, params) \ + , _with_named_params \ + )( \ + kw( \ + BOOST_PP_CAT(BOOST_PP_ENUM_, z)( \ + n, BOOST_PARAMETER_FUN_DECL_PARAM, p \ + ) \ + ) \ + ); \ } +/**/ + +#define BOOST_PARAMETER_FUN_DECL(z, n, params) \ + BOOST_PP_IF( \ + n \ + , BOOST_PARAMETER_FUN_DEFN_1 \ + , BOOST_PARAMETER_FUN_0 \ + )(z, n, params) +/**/ + +#else // !defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING) + +#define BOOST_PARAMETER_FUN_DEFN_0(z, n, params) \ + template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename T)> \ + BOOST_PP_TUPLE_ELEM(3, 0, params) \ + BOOST_PP_TUPLE_ELEM(3, 1, params)( \ + BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, T, const& p) \ + BOOST_PARAMETER_MATCH_TYPE_Z( \ + z, n, BOOST_PP_TUPLE_ELEM(3, 2, params) \ + ) \ + ) \ + { \ + return BOOST_PP_CAT( \ + BOOST_PP_TUPLE_ELEM(3, 1, params) \ + , _with_named_params \ + )(kw(BOOST_PP_ENUM_PARAMS_Z(z, n, p))); \ + } +/**/ + +#include <boost/preprocessor/seq/seq.hpp> + +#define BOOST_PARAMETER_FUN_0(z, n, seq) \ + BOOST_PP_TUPLE_ELEM(3, 0, BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_TAIL(seq))) \ + BOOST_PP_TUPLE_ELEM(3, 1, BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_TAIL(seq)))() \ + { \ + return BOOST_PP_CAT( \ + BOOST_PP_TUPLE_ELEM( \ + 3, 1, BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_TAIL(seq)) \ + ) \ + , _with_named_params \ + )( \ + BOOST_PP_TUPLE_ELEM(3, 2, BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_TAIL(seq))) \ + ()() \ + ); \ + } +/**/ + +#include <boost/parameter/aux_/preprocessor/binary_seq_to_args.hpp> +#include <boost/preprocessor/seq/size.hpp> + +#define BOOST_PARAMETER_FUN_DEFN_R(r, seq) \ + template < \ + BOOST_PP_ENUM_PARAMS( \ + BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_TAIL(seq)) \ + , typename T \ + ) \ + > BOOST_PP_TUPLE_ELEM(3, 0, BOOST_PP_SEQ_HEAD(seq)) \ + BOOST_PP_TUPLE_ELEM(3, 1, BOOST_PP_SEQ_HEAD(seq))( \ + BOOST_PARAMETER_AUX_PP_BINARY_SEQ_TO_ARGS( \ + BOOST_PP_SEQ_TAIL(seq), (T)(p) \ + ) \ + BOOST_PARAMETER_MATCH_TYPE( \ + BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_TAIL(seq)) \ + , BOOST_PP_TUPLE_ELEM(3, 2, BOOST_PP_SEQ_HEAD(seq)) \ + ) \ + ) \ + { \ + return BOOST_PP_CAT( \ + BOOST_PP_TUPLE_ELEM(3, 1, BOOST_PP_SEQ_HEAD(seq)) \ + , _with_named_params \ + )( \ + kw( \ + BOOST_PP_ENUM_PARAMS( \ + BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_TAIL(seq)), p \ + ) \ + ) \ + ); \ + } +/**/ + +#include <boost/parameter/aux_/preprocessor/binary_seq_for_each.hpp> +#include <boost/preprocessor/tuple/eat.hpp> + +#define BOOST_PARAMETER_FUN_DEFN_1(z, n, params) \ + BOOST_PP_IF( \ + n \ + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_Z \ + , BOOST_PARAMETER_FUN_0 \ + )(z, n, (BOOST_PARAMETER_FUN_DEFN_R)(params)) +/**/ + +#include <boost/preprocessor/comparison/less.hpp> + +#define BOOST_PARAMETER_FUN_DECL(z, n, params) \ + BOOST_PP_CAT( \ + BOOST_PARAMETER_FUN_DEFN_ \ + , BOOST_PP_LESS( \ + n \ + , BOOST_PARAMETER_EXPONENTIAL_OVERLOAD_THRESHOLD_ARITY \ + ) \ + )(z, n, params) +/**/ + +#endif // BOOST_PARAMETER_HAS_PERFECT_FORWARDING + +#include <boost/preprocessor/arithmetic/inc.hpp> +#include <boost/preprocessor/repetition/repeat_from_to.hpp> // Generates: // -// template<class Params> +// template <typename Params> // ret name ## _with_named_params(Params const&); // -// template<class T0> -// ret name(T0 const& p0, typename parameters::match<T0>::type kw = parameters()) +// template <typename T0> +// ret name( +// T0 && p0 +// , typename parameters::match<T0>::type kw = parameters() +// ) // { // return name ## _with_named_params(kw(p0)); // } // -// template<class T0, ..., class TN> -// ret name(T0 const& p0, ..., TN const& PN -// , typename parameters::match<T0, ..., TN>::type kw = parameters()) +// template <typename T0, ..., typename T ## N> +// ret name( +// T0 && p0, ..., TN && p ## N +// , typename parameters::match<T0, ..., T ## N>::type kw = parameters() +// ) // { -// return name ## _with_named_params(kw(p0, ..., pN)); +// return name ## _with_named_params(kw(p0, ..., p ## N)); // } // -// template<class Params> +// template <typename Params> // ret name ## _with_named_params(Params const&) // -// lo and hi determines the min and max arity of the generated functions. - -#define BOOST_PARAMETER_FUN(ret, name, lo, hi, parameters) \ - \ - template<class Params> \ - ret BOOST_PP_CAT(name, _with_named_params)(Params const& p); \ - \ - BOOST_PP_REPEAT_FROM_TO( \ - lo, BOOST_PP_INC(hi), BOOST_PARAMETER_FUN_DECL, (ret, name, parameters)) \ - \ - template<class Params> \ - ret BOOST_PP_CAT(name, _with_named_params)(Params const& p) +// lo and hi determine the min and max arities of the generated functions. -#define BOOST_PARAMETER_MEMFUN(ret, name, lo, hi, parameters) \ - \ - BOOST_PP_REPEAT_FROM_TO( \ - lo, BOOST_PP_INC(hi), BOOST_PARAMETER_FUN_DECL, (ret, name, parameters)) \ - \ - template<class Params> \ +#define BOOST_PARAMETER_MEMFUN(ret, name, lo, hi, parameters) \ + BOOST_PP_REPEAT_FROM_TO( \ + lo, BOOST_PP_INC(hi), BOOST_PARAMETER_FUN_DECL \ + , (ret, name, parameters) \ + ) \ + template <typename Params> \ ret BOOST_PP_CAT(name, _with_named_params)(Params const& p) +/**/ + +#define BOOST_PARAMETER_FUN(ret, name, lo, hi, parameters) \ + template <typename Params> \ + ret BOOST_PP_CAT(name, _with_named_params)(Params const& p); \ + BOOST_PARAMETER_MEMFUN(ret, name, lo, hi, parameters) +/**/ -#endif // BOOST_PARAMETER_MACROS_050412_HPP +#endif // include guard diff --git a/boost/parameter/match.hpp b/boost/parameter/match.hpp index 2fa3f1750a..edb59f96a5 100644 --- a/boost/parameter/match.hpp +++ b/boost/parameter/match.hpp @@ -1,42 +1,34 @@ -// Copyright David Abrahams 2005. 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_MATCH_DWA2005714_HPP -# define BOOST_PARAMETER_MATCH_DWA2005714_HPP - -# include <boost/detail/workaround.hpp> -# include <boost/preprocessor/seq/enum.hpp> - -# if BOOST_WORKAROUND(__MWERKS__, <= 0x3003) -// Temporary version of BOOST_PP_SEQ_ENUM until Paul M. integrates the workaround. -# define BOOST_PARAMETER_SEQ_ENUM_I(size,seq) BOOST_PP_CAT(BOOST_PP_SEQ_ENUM_, size) seq -# define BOOST_PARAMETER_SEQ_ENUM(seq) BOOST_PARAMETER_SEQ_ENUM_I(BOOST_PP_SEQ_SIZE(seq), seq) -# else -# define BOOST_PARAMETER_SEQ_ENUM(seq) BOOST_PP_SEQ_ENUM(seq) -# endif - -# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) - -# include <boost/parameter/config.hpp> -# include <boost/parameter/aux_/void.hpp> -# include <boost/preprocessor/arithmetic/sub.hpp> -# include <boost/preprocessor/facilities/intercept.hpp> -# include <boost/preprocessor/repetition/enum_trailing_params.hpp> +// Copyright David Abrahams 2005. +// 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) -# define BOOST_PARAMETER_MATCH_DEFAULTS(ArgTypes) \ - BOOST_PP_ENUM_TRAILING_PARAMS( \ - BOOST_PP_SUB( \ - BOOST_PARAMETER_MAX_ARITY \ - , BOOST_PP_SEQ_SIZE(ArgTypes) \ - ) \ - , ::boost::parameter::void_ BOOST_PP_INTERCEPT \ - ) - -# else - -# define BOOST_PARAMETER_MATCH_DEFAULTS(ArgTypes) - -# endif +#ifndef BOOST_PARAMETER_MATCH_DWA2005714_HPP +#define BOOST_PARAMETER_MATCH_DWA2005714_HPP + +#include <boost/parameter/config.hpp> + +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +#include <boost/parameter/aux_/void.hpp> +#include <boost/preprocessor/arithmetic/sub.hpp> +#include <boost/preprocessor/facilities/intercept.hpp> +#include <boost/preprocessor/repetition/enum_trailing_params.hpp> +#include <boost/preprocessor/seq/size.hpp> + +#define BOOST_PARAMETER_MATCH_DEFAULTS(ArgTypes) \ + BOOST_PP_ENUM_TRAILING_PARAMS( \ + BOOST_PP_SUB( \ + BOOST_PARAMETER_MAX_ARITY \ + , BOOST_PP_SEQ_SIZE(ArgTypes) \ + ) \ + , ::boost::parameter::void_ BOOST_PP_INTERCEPT \ + ) +/**/ +#else +#define BOOST_PARAMETER_MATCH_DEFAULTS(ArgTypes) +#endif + +#include <boost/parameter/aux_/preprocessor/seq_enum.hpp> // // Generates, e.g. @@ -45,11 +37,12 @@ // // with workarounds for Borland compatibility. // +#define BOOST_PARAMETER_MATCH(ParameterSpec, ArgTypes, name) \ + typename ParameterSpec::match< \ + BOOST_PARAMETER_SEQ_ENUM(ArgTypes) \ + BOOST_PARAMETER_MATCH_DEFAULTS(ArgTypes) \ + >::type name = ParameterSpec() +/**/ -# define BOOST_PARAMETER_MATCH(ParameterSpec, ArgTypes, name) \ - typename ParameterSpec ::match< \ - BOOST_PARAMETER_SEQ_ENUM(ArgTypes) \ - BOOST_PARAMETER_MATCH_DEFAULTS(ArgTypes) \ - >::type name = ParameterSpec () +#endif // include guard -#endif // BOOST_PARAMETER_MATCH_DWA2005714_HPP diff --git a/boost/parameter/name.hpp b/boost/parameter/name.hpp index f439df416b..3b63fc3e33 100644 --- a/boost/parameter/name.hpp +++ b/boost/parameter/name.hpp @@ -1,146 +1,120 @@ -// Copyright Daniel Wallin 2006. Use, modification and distribution is -// subject to the Boost Software License, Version 1.0. (See accompanying -// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +// Copyright Daniel Wallin 2006. +// 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_NAME_060806_HPP -# define BOOST_PARAMETER_NAME_060806_HPP - -# include <boost/parameter/keyword.hpp> -# include <boost/parameter/value_type.hpp> -# include <boost/detail/workaround.hpp> -# include <boost/preprocessor/cat.hpp> -# include <boost/preprocessor/stringize.hpp> -# include <boost/preprocessor/control/iif.hpp> -# include <boost/preprocessor/tuple/eat.hpp> -# include <boost/preprocessor/tuple/elem.hpp> -# include <boost/mpl/placeholders.hpp> - -# if !defined(BOOST_NO_SFINAE) \ - && !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592)) - -# include <boost/utility/enable_if.hpp> -# include <boost/mpl/lambda.hpp> - -namespace boost { namespace parameter { namespace aux { - -// Tag type passed to MPL lambda. -struct lambda_tag; - -struct name_tag_base -{}; - -template <class Tag> -struct name_tag -{}; - -template <class T> -struct is_name_tag - : mpl::false_ -{}; - -}}} // namespace boost::parameter::aux - -namespace boost { namespace mpl { - -template <class T> -struct lambda< - T - , typename boost::enable_if< - parameter::aux::is_name_tag<T>, parameter::aux::lambda_tag - >::type -> -{ - typedef true_ is_le; - typedef bind3< quote3<parameter::value_type>, arg<2>, T, void> result_; - typedef result_ type; -}; - -}} // namespace boost::mpl - -# endif - -# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) -# include <boost/preprocessor/detail/split.hpp> -// From Paul Mensonides -# define BOOST_PARAMETER_IS_BINARY(x) \ - BOOST_PP_SPLIT(1, BOOST_PARAMETER_IS_BINARY_C x BOOST_PP_COMMA() 0) \ - /**/ -# define BOOST_PARAMETER_IS_BINARY_C(x,y) \ - ~, 1 BOOST_PP_RPAREN() \ - BOOST_PP_TUPLE_EAT(2) BOOST_PP_LPAREN() ~ \ - /**/ -# else -# include <boost/preprocessor/detail/is_binary.hpp> -# define BOOST_PARAMETER_IS_BINARY(x) BOOST_PP_IS_BINARY(x) -# endif - -# define BOOST_PARAMETER_BASIC_NAME(tag_namespace, tag, name) \ - namespace tag_namespace \ - { \ - struct tag \ - { \ - static char const* keyword_name() \ - { \ - return BOOST_PP_STRINGIZE(tag); \ - } \ - \ - typedef boost::parameter::value_type< \ - boost::mpl::_2, tag, boost::parameter::void_ \ - > _; \ - \ - typedef boost::parameter::value_type< \ - boost::mpl::_2, tag, boost::parameter::void_ \ - > _1; \ - }; \ - } \ - namespace \ - { \ - ::boost::parameter::keyword<tag_namespace::tag> const& name \ - = ::boost::parameter::keyword<tag_namespace::tag>::instance; \ +#define BOOST_PARAMETER_NAME_060806_HPP + +#include <boost/parameter/aux_/name.hpp> +#include <boost/preprocessor/stringize.hpp> +#include <boost/config.hpp> + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#define BOOST_PARAMETER_NAME_TAG(tag_namespace, tag, q) \ + namespace tag_namespace \ + { \ + struct tag \ + { \ + static BOOST_CONSTEXPR char const* keyword_name() \ + { \ + return BOOST_PP_STRINGIZE(tag); \ + } \ + using _ = BOOST_PARAMETER_TAG_PLACEHOLDER_TYPE(tag); \ + using _1 = _; \ + BOOST_PARAMETER_TAG_MP11_PLACEHOLDER_BINDING(binding_fn, tag); \ + BOOST_PARAMETER_TAG_MP11_PLACEHOLDER_VALUE(fn, tag); \ + using qualifier = ::boost::parameter::q; \ + }; \ } +/**/ +#else // !defined(BOOST_PARAMETER_CAN_USE_MP11) +#define BOOST_PARAMETER_NAME_TAG(tag_namespace, tag, q) \ + namespace tag_namespace \ + { \ + struct tag \ + { \ + static BOOST_CONSTEXPR char const* keyword_name() \ + { \ + return BOOST_PP_STRINGIZE(tag); \ + } \ + typedef BOOST_PARAMETER_TAG_PLACEHOLDER_TYPE(tag) _; \ + typedef BOOST_PARAMETER_TAG_PLACEHOLDER_TYPE(tag) _1; \ + typedef ::boost::parameter::q qualifier; \ + }; \ + } +/**/ +#endif // BOOST_PARAMETER_CAN_USE_MP11 + +#include <boost/parameter/keyword.hpp> + +#define BOOST_PARAMETER_NAME_KEYWORD(tag_namespace, tag, name) \ + namespace \ + { \ + ::boost::parameter::keyword<tag_namespace::tag> const& name \ + = ::boost::parameter::keyword<tag_namespace::tag>::instance; \ + } +/**/ + +#define BOOST_PARAMETER_BASIC_NAME(tag_namespace, tag, qualifier, name) \ + BOOST_PARAMETER_NAME_TAG(tag_namespace, tag, qualifier) \ + BOOST_PARAMETER_NAME_KEYWORD(tag_namespace, tag, name) +/**/ + +#define BOOST_PARAMETER_COMPLEX_NAME_TUPLE1(object, namespace) \ + (object, namespace), ~ +/**/ -# define BOOST_PARAMETER_COMPLEX_NAME_TUPLE1(tag,namespace) \ - (tag, namespace), ~ +#include <boost/preprocessor/tuple/elem.hpp> -# define BOOST_PARAMETER_COMPLEX_NAME_TUPLE(name) \ +#define BOOST_PARAMETER_COMPLEX_NAME_TUPLE(name) \ BOOST_PP_TUPLE_ELEM(2, 0, (BOOST_PARAMETER_COMPLEX_NAME_TUPLE1 name)) +/**/ -# define BOOST_PARAMETER_COMPLEX_NAME_TAG(name) \ +#define BOOST_PARAMETER_COMPLEX_NAME_OBJECT(name) \ BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PARAMETER_COMPLEX_NAME_TUPLE(name)) +/**/ -# define BOOST_PARAMETER_COMPLEX_NAME_NAMESPACE(name) \ +#define BOOST_PARAMETER_COMPLEX_NAME_NAMESPACE(name) \ BOOST_PP_TUPLE_ELEM(2, 1, BOOST_PARAMETER_COMPLEX_NAME_TUPLE(name)) +/**/ -# define BOOST_PARAMETER_COMPLEX_NAME(name) \ - BOOST_PARAMETER_BASIC_NAME( \ - BOOST_PARAMETER_COMPLEX_NAME_NAMESPACE(name) \ - , BOOST_PP_TUPLE_EAT(2) name \ - , BOOST_PARAMETER_COMPLEX_NAME_TAG(name) \ - ) \ +#include <boost/parameter/aux_/preprocessor/qualifier.hpp> +#include <boost/preprocessor/tuple/eat.hpp> + +#define BOOST_PARAMETER_COMPLEX_NAME(name) \ + BOOST_PARAMETER_BASIC_NAME( \ + BOOST_PARAMETER_COMPLEX_NAME_NAMESPACE(name) \ + , BOOST_PARAMETER_UNQUALIFIED(BOOST_PP_TUPLE_EAT(2) name) \ + , BOOST_PARAMETER_GET_QUALIFIER(BOOST_PP_TUPLE_EAT(2) name) \ + , BOOST_PARAMETER_COMPLEX_NAME_OBJECT(name) \ + ) /**/ -# define BOOST_PARAMETER_SIMPLE_NAME(name) \ - BOOST_PARAMETER_BASIC_NAME(tag, name, BOOST_PP_CAT(_, name)) +#include <boost/preprocessor/cat.hpp> -# define BOOST_PARAMETER_NAME(name) \ - BOOST_PP_IIF( \ - BOOST_PARAMETER_IS_BINARY(name) \ - , BOOST_PARAMETER_COMPLEX_NAME \ - , BOOST_PARAMETER_SIMPLE_NAME \ - )(name) \ +#define BOOST_PARAMETER_SIMPLE_NAME(name) \ + BOOST_PARAMETER_BASIC_NAME( \ + tag \ + , BOOST_PARAMETER_UNQUALIFIED(name) \ + , BOOST_PARAMETER_GET_QUALIFIER(name) \ + , BOOST_PP_CAT(_, BOOST_PARAMETER_UNQUALIFIED(name)) \ + ) /**/ +#include <boost/parameter/aux_/preprocessor/is_binary.hpp> +#include <boost/preprocessor/control/iif.hpp> -# define BOOST_PARAMETER_TEMPLATE_KEYWORD(name) \ - namespace tag \ - { \ - struct name; \ - } \ - template <class T> \ - struct name \ - : boost::parameter::template_keyword<tag::name, T> \ - {}; \ +#define BOOST_PARAMETER_NAME(name) \ + BOOST_PP_IIF( \ + BOOST_PARAMETER_IS_BINARY(name) \ + , BOOST_PARAMETER_COMPLEX_NAME \ + , BOOST_PARAMETER_SIMPLE_NAME \ + )(name) /**/ -#endif // BOOST_PARAMETER_NAME_060806_HPP +#include <boost/parameter/template_keyword.hpp> + +#endif // include guard diff --git a/boost/parameter/nested_keyword.hpp b/boost/parameter/nested_keyword.hpp new file mode 100644 index 0000000000..fc180ecf21 --- /dev/null +++ b/boost/parameter/nested_keyword.hpp @@ -0,0 +1,111 @@ +// Copyright Eric Niebler 2005. +// 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_NESTED_KEYWORD_HPP +#define BOOST_PARAMETER_NESTED_KEYWORD_HPP + +#include <boost/parameter/aux_/name.hpp> +#include <boost/parameter/keyword.hpp> +#include <boost/parameter/config.hpp> +#include <boost/preprocessor/cat.hpp> +#include <boost/preprocessor/stringize.hpp> + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#define BOOST_PARAMETER_NESTED_KEYWORD_AUX(tag_namespace, q, name, alias) \ + namespace tag_namespace \ + { \ + template <int Dummy = 0> \ + struct BOOST_PP_CAT(name, _) \ + { \ + static BOOST_CONSTEXPR char const* keyword_name() \ + { \ + return BOOST_PP_STRINGIZE(name); \ + } \ + using _ = BOOST_PARAMETER_TAG_PLACEHOLDER_TYPE( \ + BOOST_PP_CAT(name, _)<Dummy> \ + ); \ + using _1 = BOOST_PARAMETER_TAG_PLACEHOLDER_TYPE( \ + BOOST_PP_CAT(name, _)<Dummy> \ + ); \ + BOOST_PARAMETER_TAG_MP11_PLACEHOLDER_BINDING( \ + binding_fn \ + , BOOST_PP_CAT(name, _)<Dummy> \ + ); \ + BOOST_PARAMETER_TAG_MP11_PLACEHOLDER_VALUE( \ + fn \ + , BOOST_PP_CAT(name, _)<Dummy> \ + ); \ + using qualifier = ::boost::parameter::q; \ + static ::boost::parameter::keyword< \ + BOOST_PP_CAT(name, _)<Dummy> \ + > const& alias; \ + }; \ + template <int Dummy> \ + ::boost::parameter::keyword< \ + BOOST_PP_CAT(name, _)<Dummy> \ + > const& BOOST_PP_CAT(name, _)<Dummy>::alias \ + = ::boost::parameter::keyword< \ + BOOST_PP_CAT(name, _)<Dummy> \ + >::instance; \ + typedef BOOST_PP_CAT(name, _)<> name; \ + } \ + 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_NESTED_KEYWORD_AUX(tag_namespace, q, name, alias) \ + namespace tag_namespace \ + { \ + template <int Dummy = 0> \ + struct BOOST_PP_CAT(name, _) \ + { \ + static BOOST_CONSTEXPR char const* keyword_name() \ + { \ + return BOOST_PP_STRINGIZE(name); \ + } \ + typedef BOOST_PARAMETER_TAG_PLACEHOLDER_TYPE( \ + BOOST_PP_CAT(name, _)<Dummy> \ + ) _; \ + typedef BOOST_PARAMETER_TAG_PLACEHOLDER_TYPE( \ + BOOST_PP_CAT(name, _)<Dummy> \ + ) _1; \ + typedef ::boost::parameter::q qualifier; \ + static ::boost::parameter::keyword< \ + BOOST_PP_CAT(name, _)<Dummy> \ + > const& alias; \ + }; \ + template <int Dummy> \ + ::boost::parameter::keyword< \ + BOOST_PP_CAT(name, _)<Dummy> \ + > const& BOOST_PP_CAT(name, _)<Dummy>::alias \ + = ::boost::parameter::keyword< \ + BOOST_PP_CAT(name, _)<Dummy> \ + >::instance; \ + typedef BOOST_PP_CAT(name, _)<> name; \ + } \ + namespace \ + { \ + ::boost::parameter::keyword<tag_namespace::name> const& name \ + = ::boost::parameter::keyword<tag_namespace::name>::instance; \ + } +/**/ +#endif // BOOST_PARAMETER_CAN_USE_MP11 + +#include <boost/parameter/aux_/preprocessor/qualifier.hpp> + +#define BOOST_PARAMETER_NESTED_KEYWORD(tag_namespace, name, alias) \ + BOOST_PARAMETER_NESTED_KEYWORD_AUX( \ + tag_namespace \ + , BOOST_PARAMETER_GET_QUALIFIER(name) \ + , BOOST_PARAMETER_UNQUALIFIED(name) \ + , alias \ + ) +/**/ + +#endif // include guard + diff --git a/boost/parameter/optional.hpp b/boost/parameter/optional.hpp new file mode 100644 index 0000000000..c0f94d1007 --- /dev/null +++ b/boost/parameter/optional.hpp @@ -0,0 +1,67 @@ +// 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_OPTIONAL_HPP +#define BOOST_PARAMETER_OPTIONAL_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. In order for + // a treated function to participate in overload resolution: + // + // - The actual argument type matched by every keyword tag + // associated with a predicate must satisfy that predicate + // + // - If a keyword k is specified without an optional<...> or + // required<...> wrapper, it is treated as though + // optional<k> were specified. + template < + typename Tag + , typename Predicate = ::boost::parameter::aux::use_default + > + struct optional + { + typedef Tag key_type; + typedef Predicate predicate; + }; +}} + +#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_optional +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + : ::boost::mp11::mp_false +#else + : ::boost::mpl::false_ +#endif + { + }; + + template <typename Tag, typename Predicate> + struct is_optional< ::boost::parameter::optional<Tag,Predicate> > +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + : ::boost::mp11::mp_true +#else + : ::boost::mpl::true_ +#endif + { + }; +}}} // namespace boost::parameter::aux + +#endif // include guard + diff --git a/boost/parameter/parameters.hpp b/boost/parameter/parameters.hpp index 97e102434e..e3d62b21cd 100644 --- a/boost/parameter/parameters.hpp +++ b/boost/parameter/parameters.hpp @@ -1,931 +1,600 @@ -// Copyright David Abrahams, Daniel Wallin 2003. 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 David Abrahams, Daniel Wallin 2003. +// 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_PARAMETERS_031014_HPP #define BOOST_PARAMETERS_031014_HPP -#include <boost/detail/is_xxx.hpp> +#include <boost/parameter/config.hpp> -#include <boost/type_traits/is_const.hpp> +#if defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING) -#include <boost/mpl/lambda.hpp> -#include <boost/mpl/apply.hpp> -#include <boost/mpl/always.hpp> -#include <boost/mpl/and.hpp> -#include <boost/mpl/or.hpp> -#include <boost/mpl/if.hpp> -#include <boost/mpl/identity.hpp> -#include <boost/mpl/not.hpp> -#include <boost/mpl/eval_if.hpp> -#include <boost/mpl/pair.hpp> +namespace boost { namespace parameter { namespace aux { + + // The make_arg_list<> metafunction produces a reversed arg_list, + // so pass the arguments to the arg_list constructor reversed in turn. + template <typename ArgList, typename ...Args> + struct arg_list_factory; +}}} // namespace boost::parameter::aux +#include <boost/parameter/aux_/arg_list.hpp> +#include <utility> + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <boost/mp11/utility.hpp> +#include <type_traits> +#else +#include <boost/mpl/if.hpp> #include <boost/type_traits/is_same.hpp> -#include <boost/type_traits/remove_reference.hpp> +#endif -#include <boost/preprocessor/repetition/enum.hpp> -#include <boost/preprocessor/repetition/enum_params.hpp> -#include <boost/preprocessor/repetition/enum_trailing_params.hpp> -#include <boost/preprocessor/arithmetic/sub.hpp> -#include <boost/preprocessor/repetition/repeat.hpp> -#include <boost/preprocessor/repetition/enum_shifted.hpp> -#include <boost/preprocessor/repetition/enum_binary_params.hpp> -#include <boost/preprocessor/repetition/enum_shifted_params.hpp> -#include <boost/preprocessor/seq/elem.hpp> -#include <boost/preprocessor/iteration/iterate.hpp> -#include <boost/preprocessor/facilities/intercept.hpp> -#include <boost/preprocessor/cat.hpp> +namespace boost { namespace parameter { namespace aux { + + // TODO: Reduce template code bloat. -- Cromwell D. Enage + template <typename ArgList> + struct arg_list_factory<ArgList> + { + template <typename ...ReversedArgs> + static inline BOOST_CONSTEXPR ArgList + reverse(ReversedArgs&&... reversed_args) + { + return ArgList( +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + ::boost::mp11::mp_if< + ::std::is_same< +#else + typename ::boost::mpl::if_< + ::boost::is_same< +#endif + typename ArgList::tagged_arg::value_type + , ::boost::parameter::void_ + > + , ::boost::parameter::aux::value_type_is_void + , ::boost::parameter::aux::value_type_is_not_void +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + >() +#else + >::type() +#endif + , ::std::forward<ReversedArgs>(reversed_args)... + ); + } + }; + + template <typename ArgList, typename A0, typename ...Args> + struct arg_list_factory<ArgList,A0,Args...> + { + template <typename ...ReversedArgs> + static inline BOOST_CONSTEXPR ArgList + reverse(A0&& a0, Args&&... args, ReversedArgs&&... reversed_args) + { + return ::boost::parameter::aux + ::arg_list_factory<ArgList,Args...>::reverse( + ::std::forward<Args>(args)... + , ::std::forward<A0>(a0) + , ::std::forward<ReversedArgs>(reversed_args)... + ); + } + }; +}}} // namespace boost::parameter::aux -#include <boost/parameter/aux_/arg_list.hpp> -#include <boost/parameter/aux_/yesno.hpp> #include <boost/parameter/aux_/void.hpp> -#include <boost/parameter/aux_/default.hpp> -#include <boost/parameter/aux_/unwrap_cv_reference.hpp> -#include <boost/parameter/aux_/tagged_argument.hpp> -#include <boost/parameter/aux_/tag.hpp> -#include <boost/parameter/aux_/template_keyword.hpp> -#include <boost/parameter/aux_/set.hpp> -#include <boost/parameter/config.hpp> +#include <boost/parameter/aux_/pack/make_arg_list.hpp> +#include <boost/parameter/aux_/pack/make_parameter_spec_items.hpp> +#include <boost/parameter/aux_/pack/tag_keyword_arg.hpp> +#include <boost/parameter/aux_/pack/tag_template_keyword_arg.hpp> + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <boost/mp11/integral.hpp> +#include <boost/mp11/list.hpp> +#else +#include <boost/mpl/bool.hpp> +#include <boost/mpl/pair.hpp> +#include <boost/mpl/identity.hpp> +#endif -namespace parameter_ -{ - template <class T> - struct unmatched_argument - { - BOOST_MPL_ASSERT((boost::is_same<T,void>)); - typedef int type; - }; -} // namespace parameter_ - -namespace boost { - -template<class T> class reference_wrapper; - -namespace parameter { - -namespace aux { struct use_default {}; } - -// These templates 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. In -// order for a treated function to participate in overload resolution: -// -// - all keyword tags wrapped in required<...> must have a matching -// actual argument -// -// - The actual argument type matched by every keyword tag -// associated with a predicate must satisfy that predicate -// -// If a keyword k is specified without an optional<...> or -// required<...>, wrapper, it is treated as though optional<k> were -// specified. -// -// If a keyword k is specified with deduced<...>, that keyword -// will be automatically deduced from the argument list. -// -template <class Tag, class Predicate = aux::use_default> -struct required -{ - typedef Tag key_type; - typedef Predicate predicate; -}; - -template <class Tag, class Predicate = aux::use_default> -struct optional -{ - typedef Tag key_type; - typedef Predicate predicate; -}; - -template <class Tag> -struct deduced -{ - typedef Tag key_type; -}; - -namespace aux -{ - // Defines metafunctions, is_required and is_optional, that - // identify required<...>, optional<...> and deduced<...> specializations. - BOOST_DETAIL_IS_XXX_DEF(required, required, 2) - BOOST_DETAIL_IS_XXX_DEF(optional, optional, 2) - BOOST_DETAIL_IS_XXX_DEF(deduced_aux, deduced, 1) - - template <class S> - struct is_deduced0 - : is_deduced_aux< - typename S::key_type - >::type - {}; - - template <class S> - struct is_deduced - : mpl::eval_if< - mpl::or_< - is_optional<S>, is_required<S> - > - , is_deduced0<S> - , mpl::false_ - >::type - {}; - - // - // key_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<...> - // - - // helper for key_type<...>, below. - template <class T> - struct get_tag_type0 - { - typedef typename T::key_type type; - }; - - template <class T> - struct get_tag_type - : mpl::eval_if< - is_deduced_aux<typename T::key_type> - , get_tag_type0<typename T::key_type> - , mpl::identity<typename T::key_type> - > - {}; - - template <class T> - struct tag_type - : mpl::eval_if< - mpl::or_< - is_optional<T> - , is_required<T> - > - , get_tag_type<T> - , mpl::identity<T> - > - {}; - - template <class T> - struct has_default - : mpl::not_<is_required<T> > - {}; - - // helper for get_predicate<...>, below - template <class T> - struct get_predicate_or_default - { - typedef T type; - }; - - template <> - struct get_predicate_or_default<use_default> - { - typedef mpl::always<mpl::true_> type; - }; - - // helper for predicate<...>, below - template <class T> - struct get_predicate - { - typedef typename - get_predicate_or_default<typename T::predicate>::type - type; - }; - - template <class T> - struct predicate - : mpl::eval_if< - mpl::or_< - is_optional<T> - , is_required<T> - > - , get_predicate<T> - , mpl::identity<mpl::always<mpl::true_> > - > - { - }; - - - // Converts a ParameterSpec into a specialization of - // parameter_requirements. We need to do this in order to get the - // tag_type into the type in a way that can be conveniently matched - // by a satisfies(...) member function in arg_list. - template <class ParameterSpec> - struct as_parameter_requirements - { - typedef parameter_requirements< - typename tag_type<ParameterSpec>::type - , typename predicate<ParameterSpec>::type - , typename has_default<ParameterSpec>::type - > type; - }; - - template <class T> - struct is_named_argument - : mpl::or_< - is_template_keyword<T> - , is_tagged_argument<T> - > - {}; - - // Returns mpl::true_ iff the given ParameterRequirements are - // satisfied by ArgList. - template <class ArgList, class ParameterRequirements> - struct satisfies - { -#if BOOST_WORKAROUND(BOOST_MSVC, == 1310) - // VC7.1 can't handle the sizeof() implementation below, - // so we use this instead. - typedef typename mpl::apply_wrap3< - typename ArgList::binding - , typename ParameterRequirements::keyword - , void_ - , mpl::false_ - >::type bound; - - typedef typename mpl::eval_if< - is_same<bound, void_> - , typename ParameterRequirements::has_default - , mpl::apply_wrap2< - typename mpl::lambda< - typename ParameterRequirements::predicate, lambda_tag - >::type - , bound - , ArgList - > - >::type type; +#if !defined(BOOST_PARAMETER_VARIADIC_MPL_SEQUENCE) +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +//#include <boost/mp11/mpl.hpp> +#define BOOST_PARAMETER_VARIADIC_MPL_SEQUENCE ::boost::mp11::mp_list +#else +#include <boost/fusion/container/list/list_fwd.hpp> + +// Newer versions of MSVC fail on the evaluate_category and +// preprocessor_eval_category test programs when parameters uses +// boost::fusion::list. +// -- Cromwell D. Enage +#if defined(BOOST_FUSION_HAS_VARIADIC_LIST) && ( \ + !defined(BOOST_MSVC) || (BOOST_MSVC < 1800) \ + ) +#include <boost/fusion/container/list.hpp> +#include <boost/fusion/mpl.hpp> +#define BOOST_PARAMETER_VARIADIC_MPL_SEQUENCE ::boost::fusion::list #else - BOOST_STATIC_CONSTANT( - bool, value = ( - sizeof( - aux::to_yesno( - ArgList::satisfies((ParameterRequirements*)0, (ArgList*)0) - ) - ) == sizeof(yes_tag) - ) - ); - - typedef mpl::bool_<satisfies::value> type; +#include <boost/fusion/container/deque/deque_fwd.hpp> + +#if defined(BOOST_FUSION_HAS_VARIADIC_DEQUE) +#include <boost/fusion/container/deque.hpp> +#include <boost/fusion/mpl.hpp> +#define BOOST_PARAMETER_VARIADIC_MPL_SEQUENCE ::boost::fusion::deque +#else +#include <boost/mpl/vector.hpp> +#define BOOST_PARAMETER_VARIADIC_MPL_SEQUENCE ::boost::mpl::vector +#endif // BOOST_FUSION_HAS_VARIADIC_DEQUE +#endif // BOOST_FUSION_HAS_VARIADIC_LIST +#endif // BOOST_PARAMETER_CAN_USE_MP11 +#endif // BOOST_PARAMETER_VARIADIC_MPL_SEQUENCE + +namespace boost { namespace parameter { + + template <typename ...Spec> + struct parameters + { + typedef BOOST_PARAMETER_VARIADIC_MPL_SEQUENCE<Spec...> parameter_spec; + + typedef typename ::boost::parameter::aux + ::make_deduced_list<parameter_spec>::type deduced_list; + + // If the elements of NamedList match the criteria of overload + // resolution, returns a type which can be constructed from + // parameters. Otherwise, this is not a valid metafunction + // (no nested ::type). + template <typename ArgumentPackAndError> + struct match_base +#if !defined(BOOST_PARAMETER_CAN_USE_MP11) + : ::boost::mpl::if_< + typename ::boost::parameter::aux::match_parameters_base_cond< + ArgumentPackAndError + , parameter_spec + >::type + , ::boost::mpl::identity< + ::boost::parameter::parameters<Spec...> + > + , ::boost::parameter::void_ + > #endif - }; - - // Returns mpl::true_ if the requirements of the given ParameterSpec - // are satisfied by ArgList. - template <class ArgList, class ParameterSpec> - struct satisfies_requirements_of - : satisfies< - ArgList - , typename as_parameter_requirements<ParameterSpec>::type - > - {}; - - // Tags a deduced argument Arg with the keyword tag of Spec using TagFn. - // Returns the tagged argument and the mpl::set<> UsedArgs with the - // tag of Spec inserted. - template <class UsedArgs, class Spec, class Arg, class TagFn> - struct tag_deduced - { - typedef mpl::pair< - typename mpl::apply_wrap2<TagFn, typename tag_type<Spec>::type, Arg>::type - , typename aux::insert_<UsedArgs, typename tag_type<Spec>::type>::type - > type; - }; - - template < - class Argument - , class ArgumentPack - , class DeducedArgs - , class UsedArgs - , class TagFn - > - struct deduce_tag; - - // Tag type passed to MPL lambda. - struct lambda_tag; - - // Helper for deduce_tag<> below. - template < - class Argument - , class ArgumentPack - , class DeducedArgs - , class UsedArgs - , class TagFn - > - struct deduce_tag0 - { - typedef typename DeducedArgs::spec spec; - - typedef typename mpl::apply_wrap2< - typename mpl::lambda< - typename spec::predicate, lambda_tag - >::type - , Argument - , ArgumentPack - >::type condition; - - // Deduced parameter matches several arguments. - - BOOST_MPL_ASSERT(( - mpl::not_<mpl::and_< - condition - , aux::has_key_<UsedArgs, typename tag_type<spec>::type> - > > - )); - - typedef typename mpl::eval_if< - condition - , tag_deduced<UsedArgs, spec, Argument, TagFn> - , deduce_tag<Argument, ArgumentPack, typename DeducedArgs::tail, UsedArgs, TagFn> - >::type type; - }; - - // Tries to deduced a keyword tag for a given Argument. - // Returns an mpl::pair<> consisting of the tagged_argument<>, - // and an mpl::set<> where the new tag has been inserted. - // - // Argument: The argument type to be tagged. - // - // ArgumentPack: The ArgumentPack built so far. - // - // DeducedArgs: A specialization of deduced_item<> (see below). - // A list containing only the deduced ParameterSpecs. - // - // UsedArgs: An mpl::set<> containing the keyword tags used so far. - // - // TagFn: A metafunction class used to tag positional or deduced - // arguments with a keyword tag. - - template < - class Argument - , class ArgumentPack - , class DeducedArgs - , class UsedArgs - , class TagFn - > - struct deduce_tag - { - typedef typename mpl::eval_if< - is_same<DeducedArgs, void_> - , mpl::pair<void_, UsedArgs> - , deduce_tag0<Argument, ArgumentPack, DeducedArgs, UsedArgs, TagFn> - >::type type; - }; - - template < - class List - , class DeducedArgs - , class TagFn - , class Positional - , class UsedArgs - , class ArgumentPack - , class Error - > - struct make_arg_list_aux; - - // Inserts Tagged::key_type into the UserArgs set. - // Extra indirection to lazily evaluate Tagged::key_type. - template <class UsedArgs, class Tagged> - struct insert_tagged - { - typedef typename aux::insert_< - UsedArgs, typename Tagged::key_type - >::type type; - }; - - // Borland needs the insane extra-indirection workaround below - // so that it doesn't magically drop the const qualifier from - // the argument type. - - template < - class List - , class DeducedArgs - , class TagFn - , class Positional - , class UsedArgs - , class ArgumentPack -#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) - , class argument + { +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using type = ::boost::mp11::mp_if< + typename ::boost::parameter::aux::match_parameters_base_cond< + ArgumentPackAndError + , parameter_spec + >::type + , ::boost::mp11::mp_identity< + ::boost::parameter::parameters<Spec...> + > + , ::boost::parameter::void_ + >; #endif - , class Error - > -#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) - struct make_arg_list00 + }; + + // Specializations are to be used as an optional argument + // to eliminate overloads via SFINAE. + template <typename ...Args> + struct match + : ::boost::parameter::parameters<Spec...> + ::BOOST_NESTED_TEMPLATE match_base< + typename ::boost::parameter::aux::make_arg_list< + typename ::boost::parameter::aux + ::make_parameter_spec_items<parameter_spec,Args...>::type + , deduced_list + , ::boost::parameter::aux::tag_keyword_arg + // Don't emit errors when doing SFINAE. +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + , ::boost::mp11::mp_false #else - struct make_arg_list0 + , ::boost::mpl::false_ #endif - { -#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) - typedef typename List::arg argument; + >::type + >::type + { + }; + + // Metafunction that returns an ArgumentPack. + template <typename ...Args> + struct bind +#if !defined(BOOST_PARAMETER_CAN_USE_MP11) + : ::boost::mpl::first< + typename ::boost::parameter::aux::make_arg_list< + typename ::boost::parameter::aux + ::make_parameter_spec_items<parameter_spec,Args...>::type + , deduced_list + , ::boost::parameter::aux::tag_template_keyword_arg + >::type + > #endif - typedef typename List::spec parameter_spec; - typedef typename tag_type<parameter_spec>::type tag_; - - typedef is_named_argument<argument> is_tagged; - - // If this argument is either explicitly tagged or a deduced - // parameter, we turn off positional matching. - typedef mpl::and_< - mpl::not_< - mpl::or_<is_deduced<parameter_spec>, is_tagged> - > - , Positional - > positional; - - // If this parameter is explicitly tagged we add it to the - // used-parmeters set. We only really need to add parameters - // that are deduced, but we would need a way to check if - // a given tag corresponds to a deduced parameter spec. - typedef typename mpl::eval_if< - is_tagged - , insert_tagged<UsedArgs, argument> - , mpl::identity<UsedArgs> - >::type used_args; - - // If this parameter is neither explicitly tagged, nor - // positionally matched; deduce the tag from the deduced - // parameter specs. - typedef typename mpl::eval_if< - mpl::or_<is_tagged, positional> - , mpl::pair<void_, used_args> - , deduce_tag<argument, ArgumentPack, DeducedArgs, used_args, TagFn> - >::type deduced_data; - - // If this parameter is explicitly tagged.. - typedef typename mpl::eval_if< - is_tagged - , mpl::identity<argument> // .. just use it - , mpl::eval_if< // .. else, if positional matching is turned on.. - positional - , mpl::apply_wrap2<TagFn, tag_, argument> // .. tag it positionally - , mpl::first<deduced_data> // .. else, use the deduced tag - > - >::type tagged; - - // We build the arg_list incrementally as we go, prepending new - // nodes. - - typedef typename mpl::if_< - mpl::and_< - is_same<Error, void_> - , is_same<tagged, void_> - > - , parameter_::unmatched_argument<argument> - , void_ - >::type error; - - typedef typename mpl::if_< - is_same<tagged, void_> - , ArgumentPack - , arg_list<tagged, ArgumentPack> - >::type argument_pack; - - typedef typename make_arg_list_aux< - typename List::tail - , DeducedArgs - , TagFn - , positional - , typename deduced_data::second - , argument_pack - , error - >::type type; - }; - -#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) - template < - class List - , class DeducedArgs - , class TagFn - , class Positional - , class UsedArgs - , class ArgumentPack - , class Error - > - struct make_arg_list0 - { - typedef typename mpl::eval_if< - typename List::is_arg_const - , make_arg_list00< - List - , DeducedArgs - , TagFn - , Positional - , UsedArgs - , ArgumentPack - , typename List::arg const - , Error - > - , make_arg_list00< - List - , DeducedArgs - , TagFn - , Positional - , UsedArgs - , ArgumentPack - , typename List::arg - , Error - > - >::type type; - }; + { +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using type = ::boost::mp11::mp_at_c< + typename ::boost::parameter::aux::make_arg_list< + typename ::boost::parameter::aux + ::make_parameter_spec_items<parameter_spec,Args...>::type + , deduced_list + , ::boost::parameter::aux::tag_template_keyword_arg + >::type + , 0 + >; #endif + }; + + // The function call operator is used to build an arg_list that + // labels the positional parameters and maintains whatever other + // tags may have been specified by the caller. + inline ::boost::parameter::aux::empty_arg_list operator()() const + { + return ::boost::parameter::aux::empty_arg_list(); + } + + template <typename A0, typename ...Args> +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + inline ::boost::mp11::mp_at_c< +#else + inline typename ::boost::mpl::first< +#endif + typename ::boost::parameter::aux::make_arg_list< + typename ::boost::parameter::aux + ::make_parameter_spec_items<parameter_spec,A0,Args...>::type + , deduced_list + , ::boost::parameter::aux::tag_keyword_arg + >::type +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + , 0 + > +#else + >::type +#endif + operator()(A0&& a0, Args&& ...args) const + { + typedef typename ::boost::parameter::aux::make_arg_list< + typename ::boost::parameter::aux + ::make_parameter_spec_items<parameter_spec,A0,Args...>::type + , deduced_list + , ::boost::parameter::aux::tag_keyword_arg + >::type list_error_pair; - // Returns an ArgumentPack where the list of arguments has - // been tagged with keyword tags. - // - // List: A specialization of item<> (see below). Contains - // both the ordered ParameterSpecs, and the given arguments. - // - // DeducedArgs: A specialization of deduced_item<> (see below). - // A list containing only the deduced ParameterSpecs. - // - // TagFn: A metafunction class used to tag positional or deduced - // arguments with a keyword tag. - // - // Position: An mpl::bool_<> specialization indicating if positional - // matching is to be performed. - // - // DeducedSet: An mpl::set<> containing the keyword tags used so far. - // - // ArgumentPack: The ArgumentPack built so far. This is initially an - // empty_arg_list and is built incrementally. - // - - template < - class List - , class DeducedArgs - , class TagFn - , class Positional - , class DeducedSet - , class ArgumentPack - , class Error - > - struct make_arg_list_aux - { - typedef typename mpl::eval_if< - is_same<List, void_> - , mpl::identity<mpl::pair<ArgumentPack, Error> > - , make_arg_list0<List, DeducedArgs, TagFn, Positional, DeducedSet, ArgumentPack, Error> - >::type type; - }; - - // VC6.5 was choking on the default parameters for make_arg_list_aux, so - // this just forwards to that adding in the defaults. - template < - class List - , class DeducedArgs - , class TagFn - , class EmitErrors = mpl::true_ - > - struct make_arg_list - { - typedef typename make_arg_list_aux< - List, DeducedArgs, TagFn, mpl::true_, aux::set0, empty_arg_list, void_ - >::type type; - }; - - // A parameter spec item typelist. - template <class Spec, class Arg, class Tail = void_> - struct item - { - typedef Spec spec; +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using result_type = ::boost::mp11::mp_at_c<list_error_pair,0>; -#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) - typedef is_const<Arg> is_arg_const; + using error = ::boost::mp11::mp_at_c<list_error_pair,1>; +#else + typedef typename ::boost::mpl + ::first<list_error_pair>::type result_type; + + typedef typename ::boost::mpl + ::second<list_error_pair>::type error; #endif - typedef Arg arg; - typedef Tail tail; - }; - - template <class Spec, class Arg, class Tail> - struct make_item - { - typedef item<Spec, Arg, typename Tail::type> type; - }; - - // Creates a item typelist. - template <class Spec, class Arg, class Tail> - struct make_items - { - typedef typename mpl::eval_if< - is_same<Arg, void_> - , mpl::identity<void_> - , make_item<Spec, Arg, Tail> - >::type type; - }; - - // A typelist that stored deduced parameter specs. - template <class ParameterSpec, class Tail = void_> - struct deduced_item - { - typedef ParameterSpec spec; - typedef Tail tail; - }; - - // Evaluate Tail and construct deduced_item list. - template <class Spec, class Tail> - struct make_deduced_item - { - typedef deduced_item<Spec, typename Tail::type> type; - }; - - template <class Spec, class Tail> - struct make_deduced_items - { - typedef typename mpl::eval_if< - is_same<Spec, void_> - , mpl::identity<void_> - , mpl::eval_if< - is_deduced<Spec> - , make_deduced_item<Spec, Tail> - , Tail - > - >::type type; - }; - - // Generates: - // - // make< - // parameter_spec#0, argument_type#0 - // , make< - // parameter_spec#1, argument_type#1 - // , ... mpl::identity<aux::empty_arg_list> - // ...> - // > -#define BOOST_PARAMETER_make_arg_list(z, n, names) \ - BOOST_PP_SEQ_ELEM(0,names)< \ - BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(1,names), n), \ - BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(2,names), n), - -#define BOOST_PARAMETER_right_angle(z, n, text) > - -#define BOOST_PARAMETER_build_arg_list(n, make, parameter_spec, argument_type) \ - BOOST_PP_REPEAT( \ - n, BOOST_PARAMETER_make_arg_list, (make)(parameter_spec)(argument_type)) \ - mpl::identity<void_> \ - BOOST_PP_REPEAT(n, BOOST_PARAMETER_right_angle, _) - -#define BOOST_PARAMETER_make_deduced_list(z, n, names) \ - BOOST_PP_SEQ_ELEM(0,names)< \ - BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(1,names), n), - -#define BOOST_PARAMETER_build_deduced_list(n, make, parameter_spec) \ - BOOST_PP_REPEAT( \ - n, BOOST_PARAMETER_make_deduced_list, (make)(parameter_spec)) \ - mpl::identity<void_> \ - BOOST_PP_REPEAT(n, BOOST_PARAMETER_right_angle, _) - - struct tag_keyword_arg - { - template <class K, class T> - struct apply - : tag<K,T> - {}; - }; - - struct tag_template_keyword_arg - { - template <class K, class T> - struct apply - { - typedef template_keyword<K,T> type; - }; - }; - -} // namespace aux - -#define BOOST_PARAMETER_FORWARD_TYPEDEF(z, i, names) \ - typedef BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(0,names),i) BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(1,names),i); - -#define BOOST_PARAMETER_FORWARD_TYPEDEFS(n, src, dest) \ - BOOST_PP_REPEAT(n, BOOST_PARAMETER_FORWARD_TYPEDEF, (src)(dest)) - - -#define BOOST_PARAMETER_TEMPLATE_ARGS(z, n, text) class BOOST_PP_CAT(PS, n) = void_ - -template< - class PS0 - , BOOST_PP_ENUM_SHIFTED(BOOST_PARAMETER_MAX_ARITY, BOOST_PARAMETER_TEMPLATE_ARGS, _) -> -struct parameters -{ -#undef BOOST_PARAMETER_TEMPLATE_ARGS - - typedef typename BOOST_PARAMETER_build_deduced_list( - BOOST_PARAMETER_MAX_ARITY, aux::make_deduced_items, PS - )::type deduced_list; - - // if the elements of NamedList match the criteria of overload - // resolution, returns a type which can be constructed from - // parameters. Otherwise, this is not a valid metafunction (no nested - // ::type). - - -#if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592)) - // If NamedList satisfies the PS0, PS1, ..., this is a - // metafunction returning parameters. Otherwise it - // has no nested ::type. - template <class ArgumentPackAndError> - struct match_base - : mpl::if_< - // mpl::and_< - // aux::satisfies_requirements_of<NamedList,PS0> - // , mpl::and_< - // aux::satisfies_requirements_of<NamedList,PS1>... - // ..., mpl::true_ - // ...> > - -# define BOOST_PARAMETER_satisfies(z, n, text) \ - mpl::and_< \ - aux::satisfies_requirements_of< \ - typename mpl::first<ArgumentPackAndError>::type \ - , BOOST_PP_CAT(PS, n)> \ - , - mpl::and_< - is_same<typename mpl::second<ArgumentPackAndError>::type, void_> - , BOOST_PP_REPEAT(BOOST_PARAMETER_MAX_ARITY, BOOST_PARAMETER_satisfies, _) - mpl::true_ - BOOST_PP_REPEAT(BOOST_PARAMETER_MAX_ARITY, BOOST_PARAMETER_right_angle, _) - > + error(); -# undef BOOST_PARAMETER_satisfies + return ::boost::parameter::aux + ::arg_list_factory<result_type,A0,Args...>::reverse( + ::std::forward<A0>(a0) + , ::std::forward<Args>(args)... + ); + } + }; +}} // namespace boost::parameter - , mpl::identity<parameters> - , void_ - > - {}; +#else // !defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING) + +#include <boost/parameter/aux_/void.hpp> +#include <boost/parameter/aux_/arg_list.hpp> +#include <boost/parameter/aux_/pack/make_arg_list.hpp> +#include <boost/parameter/aux_/pack/make_items.hpp> +#include <boost/parameter/aux_/pack/make_deduced_items.hpp> +#include <boost/parameter/aux_/pack/tag_template_keyword_arg.hpp> +#include <boost/parameter/aux_/preprocessor/binary_seq_for_each.hpp> +#include <boost/preprocessor/arithmetic/inc.hpp> +#include <boost/preprocessor/repetition/enum_shifted.hpp> +#include <boost/preprocessor/repetition/repeat.hpp> +#include <boost/preprocessor/selection/min.hpp> + +#if ( \ + BOOST_PARAMETER_EXPONENTIAL_OVERLOAD_THRESHOLD_ARITY < \ + BOOST_PARAMETER_MAX_ARITY \ + ) +#include <boost/parameter/aux_/pack/tag_keyword_arg_ref.hpp> +#include <boost/mpl/pair.hpp> +#include <boost/preprocessor/arithmetic/dec.hpp> +#include <boost/preprocessor/arithmetic/sub.hpp> +#include <boost/preprocessor/facilities/intercept.hpp> +#include <boost/preprocessor/iteration/iterate.hpp> +#include <boost/preprocessor/repetition/enum.hpp> +#include <boost/preprocessor/repetition/enum_trailing_params.hpp> +#endif + +#if !defined(BOOST_NO_SFINAE) && \ + !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592)) +#include <boost/parameter/aux_/pack/tag_keyword_arg.hpp> +#include <boost/mpl/bool.hpp> +#include <boost/mpl/if.hpp> +#include <boost/mpl/identity.hpp> +#include <boost/type_traits/is_same.hpp> #endif - - // Specializations are to be used as an optional argument to - // eliminate overloads via SFINAE - template< + #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) - // Borland simply can't handle default arguments in member - // class templates. People wishing to write portable code can - // explicitly specify BOOST_PARAMETER_MAX_ARITY arguments - BOOST_PP_ENUM_PARAMS(BOOST_PARAMETER_MAX_ARITY, class A) -#else - BOOST_PP_ENUM_BINARY_PARAMS( - BOOST_PARAMETER_MAX_ARITY, class A, = void_ BOOST_PP_INTERCEPT - ) +#include <boost/preprocessor/repetition/enum_params.hpp> +#else +#include <boost/preprocessor/repetition/enum_binary_params.hpp> #endif + +#include <boost/parameter/aux_/preprocessor/no_perfect_forwarding_begin.hpp> + +namespace boost { namespace parameter { + + template < + typename PS0 + , BOOST_PP_ENUM_SHIFTED( + BOOST_PARAMETER_MAX_ARITY + , BOOST_PARAMETER_template_args + , PS + ) > - struct match -# if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592)) - : match_base< - typename aux::make_arg_list< - typename BOOST_PARAMETER_build_arg_list( - BOOST_PARAMETER_MAX_ARITY, aux::make_items, PS, A + struct parameters + { + typedef typename BOOST_PARAMETER_build_deduced_list( + BOOST_PARAMETER_MAX_ARITY + , ::boost::parameter::aux::make_deduced_items + , PS + )::type deduced_list; + + // If the elements of NamedList match the criteria of overload + // resolution, returns a type which can be constructed from + // parameters. Otherwise, this is not a valid metafunction + // (no nested ::type). +#if !defined(BOOST_NO_SFINAE) && \ + !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592)) + // If NamedList satisfies the PS0, PS1, ..., this is a metafunction + // returning parameters. Otherwise it has no nested ::type. + template <typename ArgumentPackAndError> + struct match_base + : ::boost::mpl::if_< + // ::boost::mpl::and_< + // aux::satisfies_requirements_of<NamedList,PS0> + // , ::boost::mpl::and_< + // aux::satisfies_requirements_of<NamedList,PS1>... + // ..., ::boost::mpl::true_ + // ...> > + typename BOOST_PP_REPEAT( + BOOST_PARAMETER_MAX_ARITY + , BOOST_PARAMETER_satisfies_begin + , PS + ) + ::boost::is_same< + typename ::boost::mpl + ::second<ArgumentPackAndError>::type + , ::boost::parameter::void_ + > + BOOST_PP_REPEAT( + BOOST_PARAMETER_MAX_ARITY + , BOOST_PARAMETER_satisfies_end + , ::boost::mpl::false_ )::type - , deduced_list - , aux::tag_keyword_arg - , mpl::false_ // Don't emit errors when doing SFINAE + , ::boost::mpl::identity< + ::boost::parameter::parameters< + BOOST_PP_ENUM_PARAMS(BOOST_PARAMETER_MAX_ARITY, PS) + > + > + , ::boost::parameter::void_ + > + { + }; +#endif // SFINAE enabled, not Borland + + // Specializations are to be used as an optional argument + // to eliminate overloads via SFINAE. + template < +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) + // Borland simply can't handle default arguments in member + // class templates. People wishing to write portable code can + // explicitly specify BOOST_PARAMETER_MAX_ARITY arguments. + BOOST_PP_ENUM_PARAMS(BOOST_PARAMETER_MAX_ARITY, typename A) +#else + BOOST_PP_ENUM_BINARY_PARAMS( + BOOST_PARAMETER_MAX_ARITY + , typename A + , = ::boost::parameter::void_ BOOST_PP_INTERCEPT + ) +#endif + > + struct match +#if !defined(BOOST_NO_SFINAE) && \ + !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592)) + : ::boost::parameter::parameters< + BOOST_PP_ENUM_PARAMS(BOOST_PARAMETER_MAX_ARITY, PS) + >::BOOST_NESTED_TEMPLATE match_base< + typename ::boost::parameter::aux::make_arg_list< + typename BOOST_PARAMETER_build_arg_list( + BOOST_PARAMETER_MAX_ARITY + , ::boost::parameter::aux::make_items + , PS + , A + )::type + , deduced_list + , ::boost::parameter::aux::tag_keyword_arg + // Don't emit errors when doing SFINAE. + , ::boost::mpl::false_ + >::type >::type - >::type - {}; -# else - { - typedef parameters< - BOOST_PP_ENUM_PARAMS(BOOST_PARAMETER_MAX_ARITY, PS) - > type; - }; -# endif + { + }; +#else + { + typedef ::boost::parameter::parameters< + BOOST_PP_ENUM_PARAMS(BOOST_PARAMETER_MAX_ARITY, PS) + > type; + }; +#endif // SFINAE enabled, not Borland - // Metafunction that returns an ArgumentPack. + // Metafunction that returns an ArgumentPack. - // TODO, bind has to instantiate the error type in the result - // of make_arg_list. + // TODO, bind has to instantiate the error type in the result + // of make_arg_list. - template < + template < #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) - // Borland simply can't handle default arguments in member - // class templates. People wishing to write portable code can - // explicitly specify BOOST_PARAMETER_MAX_ARITY arguments - BOOST_PP_ENUM_PARAMS(BOOST_PARAMETER_MAX_ARITY, class A) -#else - BOOST_PP_ENUM_BINARY_PARAMS( - BOOST_PARAMETER_MAX_ARITY, class A, = void_ BOOST_PP_INTERCEPT + // Borland simply can't handle default arguments in member + // class templates. People wishing to write portable code can + // explicitly specify BOOST_PARAMETER_MAX_ARITY arguments. + BOOST_PP_ENUM_PARAMS(BOOST_PARAMETER_MAX_ARITY, typename A) +#else + BOOST_PP_ENUM_BINARY_PARAMS( + BOOST_PARAMETER_MAX_ARITY + , typename A + , = ::boost::parameter::void_ BOOST_PP_INTERCEPT + ) +#endif + > + struct bind + { + typedef typename ::boost::parameter::aux::make_arg_list< + typename BOOST_PARAMETER_build_arg_list( + BOOST_PARAMETER_MAX_ARITY + , ::boost::parameter::aux::make_items + , PS + , A + )::type + , deduced_list + , ::boost::parameter::aux::tag_template_keyword_arg + >::type result; + + typedef typename ::boost::mpl::first<result>::type type; + }; + + BOOST_PP_REPEAT( + BOOST_PARAMETER_MAX_ARITY + , BOOST_PARAMETER_forward_typedef + , (PS)(parameter_spec) ) -#endif - > - struct bind - { - typedef typename aux::make_arg_list< - typename BOOST_PARAMETER_build_arg_list( - BOOST_PARAMETER_MAX_ARITY, aux::make_items, PS, A - )::type - , deduced_list - , aux::tag_template_keyword_arg - >::type result; - - typedef typename mpl::first<result>::type type; - }; - BOOST_PARAMETER_FORWARD_TYPEDEFS(BOOST_PARAMETER_MAX_ARITY, PS, parameter_spec) - - // - // The function call operator is used to build an arg_list that - // labels the positional parameters and maintains whatever other - // tags may have been specified by the caller. - // - // !!!NOTE!!! - // - // The make_arg_list<> produces a reversed arg_list, so - // we need to pass the arguments to its constructor - // reversed. - // - aux::empty_arg_list operator()() const - { - return aux::empty_arg_list(); - } - - template<class A0> - typename mpl::first< - typename aux::make_arg_list< - aux::item< - PS0,A0 - > - , deduced_list - , aux::tag_keyword_arg + // The function call operator is used to build an arg_list that + // labels the positional parameters and maintains whatever other + // tags may have been specified by the caller. + // + // !!!NOTE!!! + // + // The make_arg_list<> metafunction produces a reversed arg_list, + // so pass the arguments to the arg_list constructor reversed in turn. + inline ::boost::parameter::aux::empty_arg_list operator()() const + { + return ::boost::parameter::aux::empty_arg_list(); + } + +#if (0 < BOOST_PARAMETER_EXPONENTIAL_OVERLOAD_THRESHOLD_ARITY) + BOOST_PP_REPEAT( + BOOST_PP_MIN( + BOOST_PP_INC(BOOST_PARAMETER_MAX_ARITY) + , BOOST_PARAMETER_EXPONENTIAL_OVERLOAD_THRESHOLD_ARITY + ) + , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_Z + , (BOOST_PARAMETER_function_call_op_overload_R)(_) + ) +#if ( \ + BOOST_PARAMETER_EXPONENTIAL_OVERLOAD_THRESHOLD_ARITY < \ + BOOST_PARAMETER_MAX_ARITY \ + ) +#define BOOST_PP_ITERATION_PARAMS_1 \ + (3,( \ + BOOST_PARAMETER_EXPONENTIAL_OVERLOAD_THRESHOLD_ARITY \ + , BOOST_PARAMETER_MAX_ARITY \ + , <boost/parameter/aux_/preprocessor/overloads.hpp> \ + )) +#include BOOST_PP_ITERATE() +#endif +#else // (0 == BOOST_PARAMETER_EXPONENTIAL_OVERLOAD_THRESHOLD_ARITY) + template <typename A0> + inline typename ::boost::mpl::first< + typename ::boost::parameter::aux::make_arg_list< + ::boost::parameter::aux::item< + PS0,A0 + > + , deduced_list + , ::boost::parameter::aux::tag_keyword_arg_ref + >::type >::type - >::type - operator()(A0& a0) const - { - typedef typename aux::make_arg_list< - aux::item< - PS0,A0 - > - , deduced_list - , aux::tag_keyword_arg - >::type result; - - typedef typename mpl::first<result>::type result_type; - typedef typename mpl::second<result>::type error; - error(); - - return result_type( - a0 - // , void_(), void_(), void_() ... - BOOST_PP_ENUM_TRAILING_PARAMS( - BOOST_PP_SUB(BOOST_PARAMETER_MAX_ARITY, 1) - , aux::void_reference() BOOST_PP_INTERCEPT) - ); - } - - template<class A0, class A1> - typename mpl::first< - typename aux::make_arg_list< - aux::item< - PS0,A0 - , aux::item< - PS1,A1 + operator()(A0& a0) const + { + typedef typename ::boost::parameter::aux::make_arg_list< + ::boost::parameter::aux::item< + PS0,A0 > - > - , deduced_list - , aux::tag_keyword_arg + , deduced_list + , ::boost::parameter::aux::tag_keyword_arg_ref + >::type result; + + typedef typename ::boost::mpl::first<result>::type result_type; + typedef typename ::boost::mpl::second<result>::type error; + error(); + + return result_type( + a0 + // , void_(), void_(), void_() ... + BOOST_PP_ENUM_TRAILING_PARAMS( + BOOST_PP_SUB(BOOST_PARAMETER_COMPOSE_MAX_ARITY, 1) + , ::boost::parameter::aux::void_reference() BOOST_PP_INTERCEPT + ) + ); + } + + template <typename A0, typename A1> + inline typename ::boost::mpl::first< + typename ::boost::parameter::aux::make_arg_list< + ::boost::parameter::aux::item< + PS0,A0 + , ::boost::parameter::aux::item< + PS1,A1 + > + > + , deduced_list + , ::boost::parameter::aux::tag_keyword_arg_ref + >::type >::type - >::type - operator()(A0& a0, A1& a1) const - { - typedef typename aux::make_arg_list< - aux::item< - PS0,A0 - , aux::item< - PS1,A1 + operator()(A0& a0, A1& a1) const + { + typedef typename ::boost::parameter::aux::make_arg_list< + ::boost::parameter::aux::item< + PS0,A0 + , ::boost::parameter::aux::item< + PS1,A1 + > > - > - , deduced_list - , aux::tag_keyword_arg - >::type result; - - typedef typename mpl::first<result>::type result_type; - typedef typename mpl::second<result>::type error; - error(); - - return result_type( - a1,a0 - // , void_(), void_() ... - BOOST_PP_ENUM_TRAILING_PARAMS( - BOOST_PP_SUB(BOOST_PARAMETER_MAX_ARITY, 2) - , aux::void_reference() BOOST_PP_INTERCEPT) - ); - } - - // Higher arities are handled by the preprocessor -#define BOOST_PP_ITERATION_PARAMS_1 (3,( \ - 3,BOOST_PARAMETER_MAX_ARITY,<boost/parameter/aux_/overloads.hpp> \ + , deduced_list + , ::boost::parameter::aux::tag_keyword_arg + >::type result; + + typedef typename ::boost::mpl::first<result>::type result_type; + typedef typename ::boost::mpl::second<result>::type error; + error(); + + return result_type( + a1 + , a0 + // , void_(), void_() ... + BOOST_PP_ENUM_TRAILING_PARAMS( + BOOST_PP_SUB(BOOST_PARAMETER_COMPOSE_MAX_ARITY, 2) + , ::boost::parameter::aux::void_reference() BOOST_PP_INTERCEPT + ) + ); + } + +#if (2 < BOOST_PARAMETER_MAX_ARITY) + // Higher arities are handled by the preprocessor +#define BOOST_PP_ITERATION_PARAMS_1 \ + (3,( \ + 3 \ + , BOOST_PARAMETER_MAX_ARITY \ + , <boost/parameter/aux_/preprocessor/overloads.hpp> \ )) #include BOOST_PP_ITERATE() +#endif +#endif // exponential overloads + }; +}} // namespace boost::parameter -}; - -} // namespace parameter - -} // namespace boost +#include <boost/parameter/aux_/preprocessor/no_perfect_forwarding_end.hpp> -#endif // BOOST_PARAMETERS_031014_HPP +#endif // BOOST_PARAMETER_HAS_PERFECT_FORWARDING +#endif // include guard diff --git a/boost/parameter/preprocessor.hpp b/boost/parameter/preprocessor.hpp index 8ea370cb4b..c67e18a073 100644 --- a/boost/parameter/preprocessor.hpp +++ b/boost/parameter/preprocessor.hpp @@ -1,1077 +1,217 @@ -// Copyright Daniel Wallin 2006. Use, modification and distribution is -// subject to the Boost Software License, Version 1.0. (See accompanying -// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +// Copyright Daniel Wallin 2006. +// 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_PREPROCESSOR_060206_HPP -# define BOOST_PARAMETER_PREPROCESSOR_060206_HPP +#define BOOST_PARAMETER_PREPROCESSOR_060206_HPP -# include <boost/parameter/parameters.hpp> -# include <boost/parameter/binding.hpp> -# include <boost/parameter/match.hpp> +#include <boost/parameter/aux_/preprocessor/impl/forwarding_overloads.hpp> +#include <boost/parameter/aux_/preprocessor/impl/specification.hpp> +#include <boost/preprocessor/cat.hpp> -# include <boost/parameter/aux_/parenthesized_type.hpp> -# include <boost/parameter/aux_/cast.hpp> -# include <boost/parameter/aux_/preprocessor/flatten.hpp> - -# include <boost/preprocessor/repetition/repeat_from_to.hpp> -# include <boost/preprocessor/comparison/equal.hpp> -# include <boost/preprocessor/control/if.hpp> -# include <boost/preprocessor/control/iif.hpp> -# include <boost/preprocessor/control/expr_if.hpp> -# include <boost/preprocessor/repetition/enum_params.hpp> -# include <boost/preprocessor/repetition/enum_binary_params.hpp> -# include <boost/preprocessor/repetition/enum_trailing.hpp> -# include <boost/preprocessor/seq/first_n.hpp> -# include <boost/preprocessor/seq/for_each_product.hpp> -# include <boost/preprocessor/seq/for_each_i.hpp> -# include <boost/preprocessor/tuple/elem.hpp> -# include <boost/preprocessor/tuple/eat.hpp> -# include <boost/preprocessor/seq/fold_left.hpp> -# include <boost/preprocessor/seq/push_back.hpp> -# include <boost/preprocessor/seq/size.hpp> -# include <boost/preprocessor/seq/enum.hpp> -# include <boost/preprocessor/seq/push_back.hpp> - -# include <boost/preprocessor/detail/is_nullary.hpp> - -# include <boost/mpl/always.hpp> -# include <boost/mpl/apply_wrap.hpp> - -namespace boost { namespace parameter { namespace aux { - -# if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592)) - -// Given Match, which is "void x" where x is an argument matching -// criterion, extract a corresponding MPL predicate. -template <class Match> -struct unwrap_predicate; - -// Match anything -template <> -struct unwrap_predicate<void*> -{ - typedef mpl::always<mpl::true_> type; -}; - -#if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x580)) - -typedef void* voidstar; - -// A matching predicate is explicitly specified -template <class Predicate> -struct unwrap_predicate<voidstar (Predicate)> -{ - typedef Predicate type; -}; - -#else - -// A matching predicate is explicitly specified -template <class Predicate> -struct unwrap_predicate<void *(Predicate)> -{ - typedef Predicate type; -}; - -#endif - - -// A type to which the argument is supposed to be convertible is -// specified -template <class Target> -struct unwrap_predicate<void (Target)> -{ - typedef is_convertible<mpl::_, Target> type; -}; - -// Recast the ParameterSpec's nested match metafunction as a free metafunction -template < - class Parameters - , BOOST_PP_ENUM_BINARY_PARAMS( - BOOST_PARAMETER_MAX_ARITY, class A, = boost::parameter::void_ BOOST_PP_INTERCEPT - ) -> -struct match - : Parameters::template match< - BOOST_PP_ENUM_PARAMS(BOOST_PARAMETER_MAX_ARITY, A) - > -{}; -# endif - -# undef false_ - -template < - class Parameters - , BOOST_PP_ENUM_BINARY_PARAMS( - BOOST_PARAMETER_MAX_ARITY, class A, = boost::parameter::void_ BOOST_PP_INTERCEPT - ) -> -struct argument_pack -{ - typedef typename make_arg_list< - typename BOOST_PARAMETER_build_arg_list( - BOOST_PARAMETER_MAX_ARITY, make_items, typename Parameters::parameter_spec, A - )::type - , typename Parameters::deduced_list - , tag_keyword_arg - , mpl::false_ - >::type result; - typedef typename mpl::first<result>::type type; -}; - -// Works around VC6 problem where it won't accept rvalues. -template <class T> -T& as_lvalue(T& value, long) -{ - return value; -} - -template <class T> -T const& as_lvalue(T const& value, int) -{ - return value; -} - - -# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) - -template <class Predicate, class T, class Args> -struct apply_predicate -{ - BOOST_MPL_ASSERT(( - mpl::and_<mpl::false_,T> - )); - - typedef typename mpl::if_< - typename mpl::apply2<Predicate,T,Args>::type - , char - , int - >::type type; -}; - -template <class P> -struct funptr_predicate -{ - static P p; - - template <class T, class Args, class P0> - static typename apply_predicate<P0,T,Args>::type - check_predicate(type<T>, Args*, void**(*)(P0)); - - template <class T, class Args, class P0> - static typename mpl::if_< - is_convertible<T,P0> - , char - , int - >::type check_predicate(type<T>, Args*, void*(*)(P0)); - - template <class T, class Args> - struct apply - { - BOOST_STATIC_CONSTANT(bool, result = - sizeof(check_predicate(boost::type<T>(), (Args*)0, &p)) == 1 - ); - - typedef mpl::bool_<apply<T,Args>::result> type; - }; -}; - -template <> -struct funptr_predicate<void**> - : mpl::always<mpl::true_> -{}; - -# endif - -}}} // namespace boost::parameter::aux - -# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) -// From Paul Mensonides -# define BOOST_PARAMETER_IS_NULLARY(x) \ - BOOST_PP_SPLIT(1, BOOST_PARAMETER_IS_NULLARY_C x BOOST_PP_COMMA() 0) \ - /**/ -# define BOOST_PARAMETER_IS_NULLARY_C() \ - ~, 1 BOOST_PP_RPAREN() \ - BOOST_PP_TUPLE_EAT(2) BOOST_PP_LPAREN() ~ \ - /**/ -# else -# define BOOST_PARAMETER_IS_NULLARY(x) BOOST_PP_IS_NULLARY(x) -# endif - -# define BOOST_PARAMETER_MEMBER_FUNCTION_CHECK_STATIC_static () -# define BOOST_PARAMETER_MEMBER_FUNCTION_IS_STATIC(name) \ - BOOST_PARAMETER_IS_NULLARY( \ - BOOST_PP_CAT(BOOST_PARAMETER_MEMBER_FUNCTION_CHECK_STATIC_,name) \ - ) - -# if !defined(BOOST_MSVC) -# define BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC_static -# define BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC(name) \ - BOOST_PP_CAT(BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC_, name) -# else -// Workaround for MSVC preprocessor. -// -// When stripping static from "static f", msvc will produce -// " f". The leading whitespace doesn't go away when pasting -// the token with something else, so this thing is a hack to -// strip the whitespace. -# define BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC_static ( -# define BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC_AUX(name) \ - BOOST_PP_CAT(BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC_, name)) -# define BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC(name) \ - BOOST_PP_SEQ_HEAD( \ - BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC_AUX(name) \ - ) -# endif - -# define BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(name) \ - BOOST_PP_EXPR_IF( \ - BOOST_PARAMETER_MEMBER_FUNCTION_IS_STATIC(name) \ - , static \ - ) - -# define BOOST_PARAMETER_MEMBER_FUNCTION_NAME(name) \ - BOOST_PP_IF( \ - BOOST_PARAMETER_MEMBER_FUNCTION_IS_STATIC(name) \ - , BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC \ - , name BOOST_PP_TUPLE_EAT(1) \ - )(name) - -// Calculates [begin, end) arity range. - -# define BOOST_PARAMETER_ARITY_RANGE_M_optional(state) state -# define BOOST_PARAMETER_ARITY_RANGE_M_deduced_optional(state) state -# define BOOST_PARAMETER_ARITY_RANGE_M_required(state) BOOST_PP_INC(state) -# define BOOST_PARAMETER_ARITY_RANGE_M_deduced_required(state) BOOST_PP_INC(state) - -# define BOOST_PARAMETER_ARITY_RANGE_M(s, state, x) \ - BOOST_PP_CAT( \ - BOOST_PARAMETER_ARITY_RANGE_M_ \ - , BOOST_PARAMETER_FN_ARG_QUALIFIER(x) \ - )(state) +// Helper macro for BOOST_PARAMETER_CONSTRUCTOR. +#define BOOST_PARAMETER_CONSTRUCTOR_AUX(class_, base, tag_namespace, args) \ + BOOST_PARAMETER_SPECIFICATION(tag_namespace, ctor, args, 0) \ + BOOST_PP_CAT(constructor_parameters, __LINE__); \ + BOOST_PARAMETER_CONSTRUCTOR_OVERLOADS(class_, base, args) /**/ -# define BOOST_PARAMETER_ARITY_RANGE(args) \ - ( \ - BOOST_PP_SEQ_FOLD_LEFT(BOOST_PARAMETER_ARITY_RANGE_M, 0, args) \ - , BOOST_PP_INC(BOOST_PP_SEQ_SIZE(args)) \ - ) -/**/ +#include <boost/parameter/aux_/preprocessor/impl/function_name.hpp> -// Accessor macros for the argument specs tuple. -# define BOOST_PARAMETER_FN_ARG_QUALIFIER(x) \ - BOOST_PP_TUPLE_ELEM(4,0,x) -/**/ - -# define BOOST_PARAMETER_FN_ARG_NAME(x) \ - BOOST_PP_TUPLE_ELEM(4,1,x) -/**/ - -# define BOOST_PARAMETER_FN_ARG_PRED(x) \ - BOOST_PP_TUPLE_ELEM(4,2,x) -/**/ - -# define BOOST_PARAMETER_FN_ARG_DEFAULT(x) \ - BOOST_PP_TUPLE_ELEM(4,3,x) +// Defines the implementation function header. +#define BOOST_PARAMETER_FUNCTION_IMPL_HEAD(name, is_const) \ + template <typename Args> \ + typename BOOST_PARAMETER_FUNCTION_RESULT_NAME(name, is_const)< \ + Args \ + >::type BOOST_PARAMETER_FUNCTION_IMPL_NAME(name, is_const)( \ + Args const& args \ + ) /**/ -# define BOOST_PARAMETETER_FUNCTION_EAT_KEYWORD_QUALIFIER_out(x) -# define BOOST_PARAMETETER_FUNCTION_EAT_KEYWORD_QUALIFIER_in_out(x) +#include <boost/parameter/aux_/preprocessor/impl/parenthesized_return_type.hpp> +#include <boost/parameter/config.hpp> -// Returns 1 if x is either "out(k)" or "in_out(k)". -# define BOOST_PARAMETER_FUNCTION_IS_KEYWORD_QUALIFIER(x) \ - BOOST_PP_IS_EMPTY( \ - BOOST_PP_CAT(BOOST_PARAMETETER_FUNCTION_EAT_KEYWORD_QUALIFIER_, x) \ - ) \ +// Expands to the result metafunction and the parameters specialization. +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#define BOOST_PARAMETER_FUNCTION_HEAD(result, name, tag_ns, args, is_const) \ + template <typename Args> \ + using BOOST_PARAMETER_FUNCTION_RESULT_NAME(name, is_const) \ + = typename BOOST_PARAMETER_PARENTHESIZED_RETURN_TYPE(result); \ + BOOST_PARAMETER_SPECIFICATION(tag_ns, name, args, is_const) \ + BOOST_PARAMETER_FUNCTION_SPECIFICATION_NAME(name, is_const); /**/ - -# define BOOST_PARAMETETER_FUNCTION_GET_KEYWORD_QUALIFIER_out(x) x -# define BOOST_PARAMETETER_FUNCTION_GET_KEYWORD_QUALIFIER_in_out(x) x -# define BOOST_PARAMETER_FUNCTION_KEYWORD_GET(x) \ - BOOST_PP_CAT(BOOST_PARAMETETER_FUNCTION_GET_KEYWORD_QUALIFIER_, x) +#else +#define BOOST_PARAMETER_FUNCTION_HEAD(result, name, tag_ns, args, is_const) \ + template <typename Args> \ + struct BOOST_PARAMETER_FUNCTION_RESULT_NAME(name, is_const) \ + : BOOST_PARAMETER_PARENTHESIZED_RETURN_TYPE(result) \ + { \ + }; \ + BOOST_PARAMETER_SPECIFICATION(tag_ns, name, args, is_const) \ + BOOST_PARAMETER_FUNCTION_SPECIFICATION_NAME(name, is_const); /**/ +#endif // BOOST_PARAMETER_CAN_USE_MP11 -// Returns the keyword of x, where x is either a keyword qualifier -// or a keyword. -// -// k => k -// out(k) => k -// in_out(k) => k -// -# define BOOST_PARAMETER_FUNCTION_KEYWORD(x) \ - BOOST_PP_IF( \ - BOOST_PARAMETER_FUNCTION_IS_KEYWORD_QUALIFIER(x) \ - , BOOST_PARAMETER_FUNCTION_KEYWORD_GET \ - , x BOOST_PP_TUPLE_EAT(1) \ - )(x) +// Helper macro for BOOST_PARAMETER_BASIC_FUNCTION. +#define BOOST_PARAMETER_BASIC_FUNCTION_AUX(result, name, tag_ns, args) \ + BOOST_PARAMETER_FUNCTION_HEAD(result, name, tag_ns, args, 0) \ + BOOST_PARAMETER_FUNCTION_IMPL_HEAD(name, 0); \ + BOOST_PARAMETER_FUNCTION_FORWARD_OVERLOADS(name, name, args, 0, 0) \ + BOOST_PARAMETER_FUNCTION_IMPL_HEAD(name, 0) /**/ -# define BOOST_PARAMETER_FN_ARG_KEYWORD(x) \ - BOOST_PARAMETER_FUNCTION_KEYWORD( \ - BOOST_PARAMETER_FN_ARG_NAME(x) \ - ) +#include <boost/preprocessor/control/expr_if.hpp> -// Builds forwarding functions. - -# define BOOST_PARAMETER_FUNCTION_FWD_FUNCTION_TEMPLATE_Z(z, n) \ - template<BOOST_PP_ENUM_PARAMS_Z(z, n, class ParameterArgumentType)> +// Helper macro for BOOST_PARAMETER_BASIC_MEMBER_FUNCTION, +// BOOST_PARAMETER_BASIC_CONST_MEMBER_FUNCTION, +// BOOST_PARAMETER_BASIC_FUNCTION_CALL_OPERATOR, and +// BOOST_PARAMETER_BASIC_CONST_FUNCTION_CALL_OPERATOR. +#define BOOST_PARAMETER_BASIC_MEMBER_FUNCTION_AUX(r, n, i, tag_ns, args, c) \ + BOOST_PARAMETER_FUNCTION_HEAD(r, i, tag_ns, args, c) \ + BOOST_PARAMETER_FUNCTION_FORWARD_OVERLOADS(n, i, args, 1, c) \ + BOOST_PARAMETER_FUNCTION_IMPL_HEAD(i, c) BOOST_PP_EXPR_IF(c, const) /**/ -# if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592)) -# define BOOST_PARAMETER_FUNCTION_FWD_MATCH_Z(z, name, parameters, n) \ - , typename boost::parameter::aux::match< \ - parameters, BOOST_PP_ENUM_PARAMS(n, ParameterArgumentType) \ - >::type = parameters() -# else -# define BOOST_PARAMETER_FUNCTION_FWD_MATCH_Z(z, name, parameters, n) -# endif -/**/ +#include <boost/parameter/aux_/preprocessor/impl/flatten.hpp> -# define BOOST_PARAMETER_FUNCTION_PARAMETERS_NAME(base) \ - BOOST_PP_CAT( \ - boost_param_parameters_ \ - , BOOST_PP_CAT(__LINE__, BOOST_PARAMETER_MEMBER_FUNCTION_NAME(base)) \ +// Expands to a Boost.Parameter-enabled constructor header. All arguments are +// accessible via args and keywords only. +#define BOOST_PARAMETER_CONSTRUCTOR(class_, base, tag_namespace, args) \ + BOOST_PARAMETER_CONSTRUCTOR_AUX( \ + class_, base, tag_namespace \ + , BOOST_PARAMETER_AUX_PP_FLATTEN(2, 2, 3, args) \ ) - -// Produce a name for a result type metafunction for the function -// named base -# define BOOST_PARAMETER_FUNCTION_RESULT_NAME(base) \ - BOOST_PP_CAT( \ - boost_param_result_ \ - , BOOST_PP_CAT(__LINE__,BOOST_PARAMETER_MEMBER_FUNCTION_NAME(base)) \ - ) - -// Can't do boost_param_impl_ ## basee because base might start with an underscore -// daniel: what? how is that relevant? the reason for using CAT() is to make sure -// base is expanded. i'm not sure we need to here, but it's more stable to do it. -# define BOOST_PARAMETER_IMPL(base) \ - BOOST_PP_CAT(boost_param_impl,BOOST_PARAMETER_MEMBER_FUNCTION_NAME(base)) - -# define BOOST_PARAMETER_FUNCTION_FWD_FUNCTION00(z, n, r, data, elem) \ - BOOST_PP_IF( \ - n \ - , BOOST_PARAMETER_FUNCTION_FWD_FUNCTION_TEMPLATE_Z, BOOST_PP_TUPLE_EAT(2) \ - )(z,n) \ - BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(BOOST_PP_TUPLE_ELEM(7,3,data)) \ - inline \ - BOOST_PP_EXPR_IF(n, typename) \ - BOOST_PARAMETER_FUNCTION_RESULT_NAME(BOOST_PP_TUPLE_ELEM(7,3,data))< \ - BOOST_PP_EXPR_IF(n, typename) \ - boost::parameter::aux::argument_pack< \ - BOOST_PARAMETER_FUNCTION_PARAMETERS_NAME(BOOST_PP_TUPLE_ELEM(7,3,data)) \ - BOOST_PP_COMMA_IF(n) \ - BOOST_PP_IF( \ - n, BOOST_PP_SEQ_ENUM, BOOST_PP_TUPLE_EAT(1) \ - )(elem) \ - >::type \ - >::type \ - BOOST_PARAMETER_MEMBER_FUNCTION_NAME(BOOST_PP_TUPLE_ELEM(7,3,data))( \ - BOOST_PP_IF( \ - n \ - , BOOST_PP_SEQ_FOR_EACH_I_R \ - , BOOST_PP_TUPLE_EAT(4) \ - )( \ - r \ - , BOOST_PARAMETER_FUNCTION_ARGUMENT \ - , ~ \ - , elem \ - ) \ - BOOST_PP_IF(n, BOOST_PARAMETER_FUNCTION_FWD_MATCH_Z, BOOST_PP_TUPLE_EAT(4))( \ - z \ - , BOOST_PP_TUPLE_ELEM(7,3,data) \ - , BOOST_PARAMETER_FUNCTION_PARAMETERS_NAME(BOOST_PP_TUPLE_ELEM(7,3,data)) \ - , n \ - ) \ - ) BOOST_PP_EXPR_IF(BOOST_PP_TUPLE_ELEM(7,4,data), const) \ - { \ - return BOOST_PARAMETER_IMPL(BOOST_PP_TUPLE_ELEM(7,3,data))( \ - BOOST_PARAMETER_FUNCTION_PARAMETERS_NAME(BOOST_PP_TUPLE_ELEM(7,3,data))()( \ - BOOST_PP_ENUM_PARAMS_Z(z, n, a) \ - ) \ - ); \ - } /**/ -# define BOOST_PARAMETER_FUNCTION_FWD_FUNCTION0(r, data, elem) \ - BOOST_PARAMETER_FUNCTION_FWD_FUNCTION00( \ - BOOST_PP_TUPLE_ELEM(7,0,data) \ - , BOOST_PP_TUPLE_ELEM(7,1,data) \ - , r \ - , data \ - , elem \ +// Expands to a Boost.Parameter-enabled function header. All arguments are +// accessible via args and keywords only. +#define BOOST_PARAMETER_BASIC_FUNCTION(result, name, tag_namespace, args) \ + BOOST_PARAMETER_BASIC_FUNCTION_AUX( \ + result, name, tag_namespace \ + , BOOST_PARAMETER_AUX_PP_FLATTEN(2, 2, 3, args) \ ) /**/ -# define BOOST_PARAMETER_FUNCTION_FWD_FUNCTION_ARITY_0(z, n, data) \ - BOOST_PARAMETER_FUNCTION_FWD_FUNCTION00( \ - z, n, BOOST_PP_DEDUCE_R() \ - , (z, n, BOOST_PP_TUPLE_REM(5) data) \ - , ~ \ +// Expands to a Boost.Parameter-enabled member function header. All arguments +// are accessible via args and keywords only. +#define BOOST_PARAMETER_BASIC_MEMBER_FUNCTION(result, name, tag_ns, args) \ + BOOST_PARAMETER_BASIC_MEMBER_FUNCTION_AUX( \ + result, name, name, tag_ns \ + , BOOST_PARAMETER_AUX_PP_FLATTEN(2, 2, 3, args), 0 \ ) /**/ -# define BOOST_PARAMETER_FUNCTION_FWD_FUNCTION_ARITY_N(z, n, data) \ - BOOST_PP_SEQ_FOR_EACH( \ - BOOST_PARAMETER_FUNCTION_FWD_FUNCTION0 \ - , (z, n, BOOST_PP_TUPLE_REM(5) data) \ - , BOOST_PP_SEQ_FOR_EACH_PRODUCT( \ - BOOST_PARAMETER_FUNCTION_FWD_PRODUCT \ - , BOOST_PP_SEQ_FIRST_N( \ - n, BOOST_PP_TUPLE_ELEM(5,3,data) \ - ) \ - ) \ +// Expands to a Boost.Parameter-enabled const-qualified member function +// header. All arguments are accessible via args and keywords only. +#define BOOST_PARAMETER_BASIC_CONST_MEMBER_FUNCTION(r, name, tag_ns, args) \ + BOOST_PARAMETER_BASIC_MEMBER_FUNCTION_AUX( \ + r, name, name, tag_ns \ + , BOOST_PARAMETER_AUX_PP_FLATTEN(2, 2, 3, args), 1 \ ) /**/ -# define BOOST_PARAMETER_FUNCTION_FWD_FUNCTION(z, n, data) \ - BOOST_PP_IF( \ - n \ - , BOOST_PARAMETER_FUNCTION_FWD_FUNCTION_ARITY_N \ - , BOOST_PARAMETER_FUNCTION_FWD_FUNCTION_ARITY_0 \ - )(z,n,data) \ -/**/ - -# define BOOST_PARAMETER_FUNCTION_FWD_FUNCTIONS0( \ - result,name,args,const_,combinations,range \ -) \ - BOOST_PP_REPEAT_FROM_TO( \ - BOOST_PP_TUPLE_ELEM(2,0,range), BOOST_PP_TUPLE_ELEM(2,1,range) \ - , BOOST_PARAMETER_FUNCTION_FWD_FUNCTION \ - , (result,name,const_,combinations,BOOST_PP_TUPLE_ELEM(2,1,range)) \ +// Expands to a Boost.Parameter-enabled function call operator header. All +// arguments are accessible via args and keywords only. +#define BOOST_PARAMETER_BASIC_FUNCTION_CALL_OPERATOR(result, tag_ns, args) \ + BOOST_PARAMETER_BASIC_MEMBER_FUNCTION_AUX( \ + result, operator(), operator, tag_ns \ + , BOOST_PARAMETER_AUX_PP_FLATTEN(2, 2, 3, args), 0 \ ) /**/ -# define BOOST_PARAMETER_FUNCTION_FWD_FUNCTIONS(result,name,args, const_, combinations) \ - BOOST_PARAMETER_FUNCTION_FWD_FUNCTIONS0( \ - result, name, args, const_, combinations, BOOST_PARAMETER_ARITY_RANGE(args) \ +// Expands to a Boost.Parameter-enabled const-qualified function call +// operator header. All arguments are accessible via args and keywords only. +#define BOOST_PARAMETER_BASIC_CONST_FUNCTION_CALL_OPERATOR(r, tag_ns, args) \ + BOOST_PARAMETER_BASIC_MEMBER_FUNCTION_AUX( \ + r, operator(), operator, tag_ns \ + , BOOST_PARAMETER_AUX_PP_FLATTEN(2, 2, 3, args), 1 \ ) /**/ -// Builds boost::parameter::parameters<> specialization -# define BOOST_PARAMETER_FUNCTION_PARAMETERS_QUALIFIER_optional(tag) \ - optional<tag - -# define BOOST_PARAMETER_FUNCTION_PARAMETERS_QUALIFIER_required(tag) \ - required<tag - -# define BOOST_PARAMETER_FUNCTION_PARAMETERS_QUALIFIER_deduced_optional(tag) \ - optional<boost::parameter::deduced<tag> - -# define BOOST_PARAMETER_FUNCTION_PARAMETERS_QUALIFIER_deduced_required(tag) \ - required<boost::parameter::deduced<tag> +#include <boost/parameter/aux_/preprocessor/impl/function_dispatch_layer.hpp> -# if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) - -# define BOOST_PARAMETER_FUNCTION_PARAMETERS_M(r,tag_namespace,i,elem) \ - BOOST_PP_COMMA_IF(i) \ - boost::parameter::BOOST_PP_CAT( \ - BOOST_PARAMETER_FUNCTION_PARAMETERS_QUALIFIER_ \ - , BOOST_PARAMETER_FN_ARG_QUALIFIER(elem) \ - )( \ - tag_namespace::BOOST_PARAMETER_FUNCTION_KEYWORD( \ - BOOST_PARAMETER_FN_ARG_KEYWORD(elem) \ - ) \ - ) \ - , typename boost::parameter::aux::unwrap_predicate< \ - void BOOST_PARAMETER_FN_ARG_PRED(elem) \ - >::type \ - > -# elif BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) -# define BOOST_PARAMETER_FUNCTION_PARAMETERS_M(r,tag_namespace,i,elem) \ - BOOST_PP_COMMA_IF(i) \ - boost::parameter::BOOST_PP_CAT( \ - BOOST_PARAMETER_FUNCTION_PARAMETERS_QUALIFIER_ \ - , BOOST_PARAMETER_FN_ARG_QUALIFIER(elem) \ - )( \ - tag_namespace::BOOST_PARAMETER_FUNCTION_KEYWORD( \ - BOOST_PARAMETER_FN_ARG_KEYWORD(elem) \ - ) \ - ) \ - , boost::mpl::always<boost::mpl::true_> \ - > -# endif - -# define BOOST_PARAMETER_FUNCTION_PARAMETERS(tag_namespace, base, args) \ - template <class BoostParameterDummy> \ - struct BOOST_PP_CAT( \ - BOOST_PP_CAT(boost_param_params_, __LINE__) \ - , BOOST_PARAMETER_MEMBER_FUNCTION_NAME(base) \ - ) : boost::parameter::parameters< \ - BOOST_PP_SEQ_FOR_EACH_I( \ - BOOST_PARAMETER_FUNCTION_PARAMETERS_M, tag_namespace, args \ - ) \ - > \ - {}; \ - \ - typedef BOOST_PP_CAT( \ - BOOST_PP_CAT(boost_param_params_, __LINE__) \ - , BOOST_PARAMETER_MEMBER_FUNCTION_NAME(base) \ - )<int> - -// Defines result type metafunction -# define BOOST_PARAMETER_FUNCTION_RESULT_ARG(z, _, i, x) \ - BOOST_PP_COMMA_IF(i) class BOOST_PP_TUPLE_ELEM(3,1,x) -/**/ - -# define BOOST_PARAMETER_FUNCTION_RESULT_(result, name, args) \ - template <class Args> \ - struct BOOST_PARAMETER_FUNCTION_RESULT_NAME(name) \ - { \ - typedef typename BOOST_PARAMETER_PARENTHESIZED_TYPE(result) type; \ - }; - -// Defines implementation function -# define BOOST_PARAMETER_FUNCTION_IMPL_HEAD(name) \ - template <class Args> \ - typename BOOST_PARAMETER_FUNCTION_RESULT_NAME(name)< \ - Args \ - >::type BOOST_PARAMETER_IMPL(name)(Args const& args) - -# define BOOST_PARAMETER_FUNCTION_IMPL_FWD(name) \ - BOOST_PARAMETER_FUNCTION_IMPL_HEAD(name); -/**/ - -# define BOOST_PARAMETER_FUNCTION_SPLIT_ARG_required(state, arg) \ - ( \ - BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(4, 0, state)) \ - , BOOST_PP_SEQ_PUSH_BACK(BOOST_PP_TUPLE_ELEM(4, 1, state), arg) \ - , BOOST_PP_TUPLE_ELEM(4, 2, state) \ - , BOOST_PP_TUPLE_ELEM(4, 3, state) \ - ) - -# define BOOST_PARAMETER_FUNCTION_SPLIT_ARG_deduced_required(state, arg) \ - BOOST_PARAMETER_FUNCTION_SPLIT_ARG_required(state, arg) - -# define BOOST_PARAMETER_FUNCTION_SPLIT_ARG_optional(state, arg) \ - ( \ - BOOST_PP_TUPLE_ELEM(4, 0, state) \ - , BOOST_PP_TUPLE_ELEM(4, 1, state) \ - , BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(4, 2, state)) \ - , BOOST_PP_SEQ_PUSH_BACK(BOOST_PP_TUPLE_ELEM(4, 3, state), arg) \ - ) - -# define BOOST_PARAMETER_FUNCTION_SPLIT_ARG_deduced_optional(state, arg) \ - BOOST_PARAMETER_FUNCTION_SPLIT_ARG_optional(state, arg) - -# define BOOST_PARAMETER_FUNCTION_SPLIT_ARG(s, state, arg) \ - BOOST_PP_CAT( \ - BOOST_PARAMETER_FUNCTION_SPLIT_ARG_ \ - , BOOST_PARAMETER_FN_ARG_QUALIFIER(arg) \ - )(state, arg) - -// Returns (required_count, required, optional_count, optionals) tuple -# define BOOST_PARAMETER_FUNCTION_SPLIT_ARGS(args) \ - BOOST_PP_SEQ_FOLD_LEFT( \ - BOOST_PARAMETER_FUNCTION_SPLIT_ARG \ - , (0,BOOST_PP_SEQ_NIL, 0,BOOST_PP_SEQ_NIL) \ - , args \ - ) - -# define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG_NAME(keyword) \ - BOOST_PP_CAT(BOOST_PP_CAT(keyword,_),type) - -// Helpers used as parameters to BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS. -# define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_TEMPLATE_ARG(r, _, arg) \ - , class BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG_NAME( \ - BOOST_PARAMETER_FN_ARG_KEYWORD(arg) \ - ) - -# define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG(r, _, arg) \ - , BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG_NAME( \ - BOOST_PARAMETER_FN_ARG_KEYWORD(arg) \ - )& BOOST_PARAMETER_FN_ARG_KEYWORD(arg) - -# define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_PARAMETER(r, _, arg) \ - , BOOST_PARAMETER_FN_ARG_KEYWORD(arg) - -// Produces a name for the dispatch functions. -# define BOOST_PARAMETER_FUNCTION_DEFAULT_NAME(name) \ - BOOST_PP_CAT( \ - boost_param_default_ \ - , BOOST_PP_CAT(__LINE__, BOOST_PARAMETER_MEMBER_FUNCTION_NAME(name)) \ - ) - -// Helper macro used below to produce lists based on the keyword argument -// names. macro is applied to every element. n is the number of -// optional arguments that should be included. -# define BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS(macro, n, split_args) \ - BOOST_PP_SEQ_FOR_EACH( \ - macro \ - , ~ \ - , BOOST_PP_TUPLE_ELEM(4,1,split_args) \ - ) \ - BOOST_PP_SEQ_FOR_EACH( \ - macro \ - , ~ \ - , BOOST_PP_SEQ_FIRST_N( \ - BOOST_PP_SUB(BOOST_PP_TUPLE_ELEM(4,2,split_args), n) \ - , BOOST_PP_TUPLE_ELEM(4,3,split_args) \ - ) \ - ) - -// Generates a keyword | default expression. -# define BOOST_PARAMETER_FUNCTION_DEFAULT_EVAL_DEFAULT(arg, tag_namespace) \ - boost::parameter::keyword< \ - tag_namespace::BOOST_PARAMETER_FN_ARG_KEYWORD(arg) \ - >::instance | boost::parameter::aux::use_default_tag() - -# define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_GET_ARG(arg, tag_ns) \ - BOOST_PARAMETER_FUNCTION_CAST( \ - args[ \ - BOOST_PARAMETER_FUNCTION_DEFAULT_EVAL_DEFAULT( \ - arg, tag_ns \ - ) \ - ] \ - , BOOST_PARAMETER_FN_ARG_PRED(arg) \ - , Args \ - ) - -# define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_BODY(name, n, split_args, tag_namespace) \ - { \ - return BOOST_PARAMETER_FUNCTION_DEFAULT_NAME(name)( \ - (ResultType(*)())0 \ - , args \ - , 0L \ - BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \ - BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_PARAMETER \ - , n \ - , split_args \ - ) \ - , BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_GET_ARG( \ - BOOST_PP_SEQ_ELEM( \ - BOOST_PP_SUB(BOOST_PP_TUPLE_ELEM(4,2,split_args), n) \ - , BOOST_PP_TUPLE_ELEM(4,3,split_args) \ - ) \ - , tag_namespace \ - ) \ - ); \ - } - -# define BOOST_PARAMETER_FUNCTION_DEFAULT_EVAL_ACTUAL_DEFAULT(arg) \ - BOOST_PARAMETER_FUNCTION_CAST( \ - boost::parameter::aux::as_lvalue(BOOST_PARAMETER_FN_ARG_DEFAULT(arg), 0L) \ - , BOOST_PARAMETER_FN_ARG_PRED(arg) \ - , Args \ - ) - -# define BOOST_PARAMETER_FUNCTION_DEFAULT_EVAL_DEFAULT_BODY(name, n, split_args, tag_ns, const_) \ - template < \ - class ResultType \ - , class Args \ - BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \ - BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_TEMPLATE_ARG \ - , BOOST_PP_INC(n) \ - , split_args \ - ) \ - > \ - BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(name) \ - ResultType BOOST_PARAMETER_FUNCTION_DEFAULT_NAME(name)( \ - ResultType(*)() \ - , Args const& args \ - , long \ - BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \ - BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG \ - , BOOST_PP_INC(n) \ - , split_args \ - ) \ - , boost::parameter::aux::use_default_tag \ - ) BOOST_PP_EXPR_IF(const_, const) \ - { \ - return BOOST_PARAMETER_FUNCTION_DEFAULT_NAME(name)( \ - (ResultType(*)())0 \ - , args \ - , 0L \ - BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \ - BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_PARAMETER \ - , BOOST_PP_INC(n) \ - , split_args \ - ) \ - , BOOST_PARAMETER_FUNCTION_DEFAULT_EVAL_ACTUAL_DEFAULT( \ - BOOST_PP_SEQ_ELEM( \ - BOOST_PP_SUB(BOOST_PP_TUPLE_ELEM(4,2,split_args), BOOST_PP_INC(n)) \ - , BOOST_PP_TUPLE_ELEM(4,3,split_args) \ - ) \ - ) \ - ); \ - } - -// Produces a forwarding layer in the default evaluation machine. -// -// data is a tuple: -// -// (name, split_args) -// -// Where name is the base name of the function, and split_args is a tuple: -// -// (required_count, required_args, optional_count, required_args) -// - - -// defines the actual function body for BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION below. -# define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION0(z, n, data) \ - template < \ - class ResultType \ - , class Args \ - BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \ - BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_TEMPLATE_ARG \ - , n \ - , BOOST_PP_TUPLE_ELEM(5,1,data) \ - ) \ - > \ - BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(BOOST_PP_TUPLE_ELEM(5,0,data)) \ - ResultType BOOST_PARAMETER_FUNCTION_DEFAULT_NAME(BOOST_PP_TUPLE_ELEM(5,0,data))( \ - ResultType(*)() \ - , Args const& args \ - , int \ - BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \ - BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG \ - , n \ - , BOOST_PP_TUPLE_ELEM(5,1,data) \ - ) \ - ) BOOST_PP_EXPR_IF(BOOST_PP_TUPLE_ELEM(5,2,data), const) \ - BOOST_PP_IF( \ - n \ - , BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_BODY \ - , ; BOOST_PP_TUPLE_EAT(4) \ - )( \ - BOOST_PP_TUPLE_ELEM(5,0,data) \ - , n \ - , BOOST_PP_TUPLE_ELEM(5,1,data) \ - , BOOST_PP_TUPLE_ELEM(5,3,data) \ - ) - -# define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION(z, n, data) \ - BOOST_PP_IF( \ - BOOST_PP_AND( \ - BOOST_PP_NOT(n) \ - , BOOST_PP_TUPLE_ELEM(5,4,data) \ - ) \ - , BOOST_PP_TUPLE_EAT(3) \ - , BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION0 \ - )(z, n, data) \ - BOOST_PP_IF( \ - BOOST_PP_EQUAL(n, BOOST_PP_TUPLE_ELEM(4,2,BOOST_PP_TUPLE_ELEM(5,1,data))) \ - , BOOST_PP_TUPLE_EAT(5) \ - , BOOST_PARAMETER_FUNCTION_DEFAULT_EVAL_DEFAULT_BODY \ - )( \ - BOOST_PP_TUPLE_ELEM(5,0,data) \ - , n \ - , BOOST_PP_TUPLE_ELEM(5,1,data) \ - , BOOST_PP_TUPLE_ELEM(5,3,data) \ - , BOOST_PP_TUPLE_ELEM(5,2,data) \ - ) - -# define BOOST_PARAMETER_FUNCTION_DEFAULT_GET_ARG(r, tag_ns, arg) \ - , BOOST_PARAMETER_FUNCTION_CAST( \ - args[ \ - boost::parameter::keyword<tag_ns::BOOST_PARAMETER_FN_ARG_KEYWORD(arg)>::instance \ - ] \ - , BOOST_PARAMETER_FN_ARG_PRED(arg) \ - , Args \ - ) - -// Generates the function template that recives a ArgumentPack, and then -// goes on to call the layers of overloads generated by -// BOOST_PARAMETER_FUNCTION_DEFAULT_LAYER. -# define BOOST_PARAMETER_FUNCTION_INITIAL_DISPATCH_FUNCTION(name, split_args, const_, tag_ns) \ - template <class Args> \ - typename BOOST_PARAMETER_FUNCTION_RESULT_NAME(name)<Args>::type \ - BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(name) \ - BOOST_PARAMETER_IMPL(name)(Args const& args) BOOST_PP_EXPR_IF(const_, const) \ - { \ - return BOOST_PARAMETER_FUNCTION_DEFAULT_NAME(name)( \ - (typename BOOST_PARAMETER_FUNCTION_RESULT_NAME(name)<Args>::type(*)())0 \ - , args \ - , 0L \ - \ - BOOST_PP_SEQ_FOR_EACH( \ - BOOST_PARAMETER_FUNCTION_DEFAULT_GET_ARG \ - , tag_ns \ - , BOOST_PP_TUPLE_ELEM(4,1,split_args) \ - ) \ - \ - ); \ - } - -// Helper for BOOST_PARAMETER_FUNCTION_DEFAULT_LAYER below. -# define BOOST_PARAMETER_FUNCTION_DEFAULT_LAYER_AUX( \ - name, split_args, skip_fwd_decl, const_, tag_namespace \ - ) \ - BOOST_PP_REPEAT_FROM_TO( \ - 0 \ - , BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(4, 2, split_args)) \ - , BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION \ - , (name, split_args, const_, tag_namespace, skip_fwd_decl) \ - ) \ - \ - BOOST_PARAMETER_FUNCTION_INITIAL_DISPATCH_FUNCTION(name, split_args, const_, tag_namespace) \ -\ - template < \ - class ResultType \ - , class Args \ - BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \ - BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_TEMPLATE_ARG \ - , 0 \ - , split_args \ - ) \ - > \ - BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(name) \ - ResultType BOOST_PARAMETER_FUNCTION_DEFAULT_NAME(name)( \ - ResultType(*)() \ - , Args const& \ - , int \ - BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \ - BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG \ - , 0 \ - , split_args \ - ) \ - ) BOOST_PP_EXPR_IF(const_, const) - -// Generates a bunch of forwarding functions that each extract -// one more argument. -# define BOOST_PARAMETER_FUNCTION_DEFAULT_LAYER(name, args, skip_fwd_decl, const_, tag_ns) \ - BOOST_PARAMETER_FUNCTION_DEFAULT_LAYER_AUX( \ - name, BOOST_PARAMETER_FUNCTION_SPLIT_ARGS(args), skip_fwd_decl, const_, tag_ns \ - ) -/**/ - -// Defines the result metafunction and the parameters specialization. -# define BOOST_PARAMETER_FUNCTION_HEAD(result, name, tag_namespace, args) \ - BOOST_PARAMETER_FUNCTION_RESULT_(result, name, args) \ - \ - BOOST_PARAMETER_FUNCTION_PARAMETERS(tag_namespace, name, args) \ - BOOST_PARAMETER_FUNCTION_PARAMETERS_NAME(name); \ - -// Helper for BOOST_PARAMETER_FUNCTION below. -# define BOOST_PARAMETER_FUNCTION_AUX(result, name, tag_namespace, args) \ - BOOST_PARAMETER_FUNCTION_HEAD(result, name, tag_namespace, args) \ - BOOST_PARAMETER_FUNCTION_IMPL_HEAD(name); \ -\ - BOOST_PARAMETER_FUNCTION_FWD_FUNCTIONS( \ - result, name, args, 0 \ - , BOOST_PARAMETER_FUNCTION_FWD_COMBINATIONS(args) \ - ) \ - \ - BOOST_PARAMETER_FUNCTION_DEFAULT_LAYER(name, args, 0, 0, tag_namespace) - -// Defines a Boost.Parameter enabled function with the new syntax. -# define BOOST_PARAMETER_FUNCTION(result, name, tag_namespace, args) \ - BOOST_PARAMETER_FUNCTION_AUX( \ - result, name, tag_namespace \ - , BOOST_PARAMETER_FLATTEN(3, 2, 3, args) \ - ) \ -/**/ - -// Defines a Boost.Parameter enabled function. -# define BOOST_PARAMETER_BASIC_FUNCTION_AUX(result, name, tag_namespace, args) \ - BOOST_PARAMETER_FUNCTION_HEAD(result, name, tag_namespace, args) \ - \ - BOOST_PARAMETER_FUNCTION_IMPL_FWD(name) \ - \ - BOOST_PARAMETER_FUNCTION_FWD_FUNCTIONS( \ - result, name, args, 0 \ - , BOOST_PARAMETER_FUNCTION_FWD_COMBINATIONS(args) \ - ) \ - \ - BOOST_PARAMETER_FUNCTION_IMPL_HEAD(name) - -# define BOOST_PARAMETER_BASIC_FUNCTION(result, name, tag_namespace, args) \ - BOOST_PARAMETER_BASIC_FUNCTION_AUX( \ - result, name, tag_namespace \ - , BOOST_PARAMETER_FLATTEN(2, 2, 3, args) \ - ) \ -/**/ - -// Defines a Boost.Parameter enabled member function. -# define BOOST_PARAMETER_BASIC_MEMBER_FUNCTION_AUX(result, name, tag_namespace, args, const_) \ - BOOST_PARAMETER_FUNCTION_HEAD(result, name, tag_namespace, args) \ - \ - BOOST_PARAMETER_FUNCTION_FWD_FUNCTIONS( \ - result, name, args, const_ \ - , BOOST_PARAMETER_FUNCTION_FWD_COMBINATIONS(args) \ - ) \ - \ - BOOST_PARAMETER_FUNCTION_IMPL_HEAD(name) BOOST_PP_EXPR_IF(const_, const) \ -/**/ - -# define BOOST_PARAMETER_BASIC_MEMBER_FUNCTION(result, name, tag_namespace, args) \ - BOOST_PARAMETER_BASIC_MEMBER_FUNCTION_AUX( \ - result, name, tag_namespace \ - , BOOST_PARAMETER_FLATTEN(2, 2, 3, args) \ - , 0 \ +// Helper macro for BOOST_PARAMETER_FUNCTION. +#define BOOST_PARAMETER_FUNCTION_AUX(result, name, tag_ns, args) \ + BOOST_PARAMETER_FUNCTION_HEAD(result, name, tag_ns, args, 0) \ + BOOST_PARAMETER_FUNCTION_IMPL_HEAD(name, 0); \ + BOOST_PARAMETER_FUNCTION_FORWARD_OVERLOADS(name, name, args, 0, 0) \ + BOOST_PARAMETER_FUNCTION_DISPATCH_LAYER( \ + 1, (name, BOOST_PARAMETER_FUNCTION_SPLIT_ARGS(args), 0, 0, tag_ns) \ ) /**/ -# define BOOST_PARAMETER_BASIC_CONST_MEMBER_FUNCTION(result, name, tag_namespace, args) \ - BOOST_PARAMETER_BASIC_MEMBER_FUNCTION_AUX( \ - result, name, tag_namespace \ - , BOOST_PARAMETER_FLATTEN(2, 2, 3, args) \ - , 1 \ - ) -/**/ - - - -# define BOOST_PARAMETER_MEMBER_FUNCTION_AUX(result, name, tag_namespace, const_, args) \ - BOOST_PARAMETER_FUNCTION_HEAD(result, name, tag_namespace, args) \ -\ - BOOST_PARAMETER_FUNCTION_FWD_FUNCTIONS( \ - result, name, args, const_ \ - , BOOST_PARAMETER_FUNCTION_FWD_COMBINATIONS(args) \ - ) \ - \ - BOOST_PARAMETER_FUNCTION_DEFAULT_LAYER(name, args, 1, const_, tag_namespace) - -// Defines a Boost.Parameter enabled function with the new syntax. -# define BOOST_PARAMETER_MEMBER_FUNCTION(result, name, tag_namespace, args) \ - BOOST_PARAMETER_MEMBER_FUNCTION_AUX( \ - result, name, tag_namespace, 0 \ - , BOOST_PARAMETER_FLATTEN(3, 2, 3, args) \ - ) \ -/**/ - -# define BOOST_PARAMETER_CONST_MEMBER_FUNCTION(result, name, tag_namespace, args) \ - BOOST_PARAMETER_MEMBER_FUNCTION_AUX( \ - result, name, tag_namespace, 1 \ - , BOOST_PARAMETER_FLATTEN(3, 2, 3, args) \ - ) \ -/**/ - -// Defines a Boost.Parameter enabled constructor. - -# define BOOST_PARAMETER_FUNCTION_ARGUMENT(r, _, i, elem) \ - BOOST_PP_COMMA_IF(i) elem& BOOST_PP_CAT(a, i) -/**/ - -# define BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR00(z, n, r, data, elem) \ - BOOST_PP_IF( \ - n \ - , BOOST_PARAMETER_FUNCTION_FWD_FUNCTION_TEMPLATE_Z, BOOST_PP_TUPLE_EAT(2) \ - )(z, n) \ - BOOST_PP_EXPR_IF(BOOST_PP_EQUAL(n,1), explicit) \ - BOOST_PP_TUPLE_ELEM(6,2,data)( \ - BOOST_PP_IF( \ - n \ - , BOOST_PP_SEQ_FOR_EACH_I_R \ - , BOOST_PP_TUPLE_EAT(4) \ - )( \ - r \ - , BOOST_PARAMETER_FUNCTION_ARGUMENT \ - , ~ \ - , elem \ - ) \ - BOOST_PP_IF(n, BOOST_PARAMETER_FUNCTION_FWD_MATCH_Z, BOOST_PP_TUPLE_EAT(4))( \ - z \ - , BOOST_PP_TUPLE_ELEM(6,3,data) \ - , BOOST_PP_CAT(constructor_parameters, __LINE__) \ - , n \ - ) \ - ) \ - : BOOST_PARAMETER_PARENTHESIZED_TYPE(BOOST_PP_TUPLE_ELEM(6,3,data)) ( \ - BOOST_PP_CAT(constructor_parameters, __LINE__)()( \ - BOOST_PP_ENUM_PARAMS_Z(z, n, a) \ - ) \ - ) \ - {} -/**/ - -# define BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR0(r, data, elem) \ - BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR00( \ - BOOST_PP_TUPLE_ELEM(6,0,data) \ - , BOOST_PP_TUPLE_ELEM(6,1,data) \ - , r \ - , data \ - , elem \ +// Expands to a Boost.Parameter-enabled function header. All arguments are +// accessible via args and keywords, as well as by name. +#define BOOST_PARAMETER_FUNCTION(result, name, tag_namespace, args) \ + BOOST_PARAMETER_FUNCTION_AUX( \ + result, name, tag_namespace \ + , BOOST_PARAMETER_AUX_PP_FLATTEN(3, 2, 3, args) \ ) /**/ -# define BOOST_PARAMETER_FUNCTION_FWD_PRODUCT(r, product) \ - (product) -/**/ +#include <boost/preprocessor/control/if.hpp> -# define BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR_ARITY_0(z, n, data) \ - BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR00( \ - z, n, BOOST_PP_DEDUCE_R() \ - , (z, n, BOOST_PP_TUPLE_REM(4) data) \ - , ~ \ +// Helper macro for BOOST_PARAMETER_MEMBER_FUNCTION +// BOOST_PARAMETER_CONST_MEMBER_FUNCTION, +// BOOST_PARAMETER_FUNCTION_CALL_OPERATOR, and +// BOOST_PARAMETER_CONST_FUNCTION_CALL_OPERATOR. +#define BOOST_PARAMETER_MEMBER_FUNCTION_AUX(r, name, impl, tag_ns, c, args) \ + BOOST_PARAMETER_FUNCTION_HEAD(r, impl, tag_ns, args, c) \ + BOOST_PARAMETER_FUNCTION_FORWARD_OVERLOADS(name, impl, args, 1, c) \ + BOOST_PARAMETER_FUNCTION_DISPATCH_LAYER( \ + 0, ( \ + impl \ + , BOOST_PARAMETER_FUNCTION_SPLIT_ARGS(args) \ + , BOOST_PP_IF( \ + BOOST_PARAMETER_MEMBER_FUNCTION_IS_STATIC(impl) \ + , 0 \ + , 1 \ + ) \ + , c \ + , tag_ns \ + ) \ ) /**/ -# define BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR_ARITY_N(z, n, data) \ - BOOST_PP_SEQ_FOR_EACH( \ - BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR0 \ - , (z, n, BOOST_PP_TUPLE_REM(4) data) \ - , BOOST_PP_SEQ_FOR_EACH_PRODUCT( \ - BOOST_PARAMETER_FUNCTION_FWD_PRODUCT \ - , BOOST_PP_SEQ_FIRST_N( \ - n, BOOST_PP_TUPLE_ELEM(4,2,data) \ - ) \ - ) \ +// Expands to a Boost.Parameter-enabled member function header. All +// arguments are accessible via args and keywords, as well as by name. +#define BOOST_PARAMETER_MEMBER_FUNCTION(result, name, tag_ns, args) \ + BOOST_PARAMETER_MEMBER_FUNCTION_AUX( \ + result, name, name, tag_ns, 0 \ + , BOOST_PARAMETER_AUX_PP_FLATTEN(3, 2, 3, args) \ ) /**/ -# define BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR(z, n, data) \ - BOOST_PP_IF( \ - n \ - , BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR_ARITY_N \ - , BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR_ARITY_0 \ - )(z,n,data) \ -/**/ - -# define BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTORS0(class_,base,args,combinations,range) \ - BOOST_PP_REPEAT_FROM_TO( \ - BOOST_PP_TUPLE_ELEM(2,0,range), BOOST_PP_TUPLE_ELEM(2,1,range) \ - , BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR \ - , (class_,base,combinations,BOOST_PP_TUPLE_ELEM(2,1,range)) \ +// Expands to a Boost.Parameter-enabled const-qualified member function +// header. All arguments are accessible via args and keywords, as well as +// by name. +#define BOOST_PARAMETER_CONST_MEMBER_FUNCTION(result, name, tag_ns, args) \ + BOOST_PARAMETER_MEMBER_FUNCTION_AUX( \ + result, name, name, tag_ns, 1 \ + , BOOST_PARAMETER_AUX_PP_FLATTEN(3, 2, 3, args) \ ) /**/ -# define BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTORS(class_,base,args,combinations) \ - BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTORS0( \ - class_, base, args, combinations, BOOST_PARAMETER_ARITY_RANGE(args) \ +// Expands to a Boost.Parameter-enabled function call operator header. All +// arguments are accessible via args and keywords, as well as by name. +#define BOOST_PARAMETER_FUNCTION_CALL_OPERATOR(result, tag_ns, args) \ + BOOST_PARAMETER_MEMBER_FUNCTION_AUX( \ + result, operator(), operator, tag_ns, 0 \ + , BOOST_PARAMETER_AUX_PP_FLATTEN(3, 2, 3, args) \ ) /**/ -# define BOOST_PARAMETER_CONSTRUCTOR_AUX(class_, base, tag_namespace, args) \ - BOOST_PARAMETER_FUNCTION_PARAMETERS(tag_namespace, ctor, args) \ - BOOST_PP_CAT(constructor_parameters, __LINE__); \ -\ - BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTORS( \ - class_, base, args \ - , BOOST_PARAMETER_FUNCTION_FWD_COMBINATIONS(args) \ - ) \ -/**/ - -# define BOOST_PARAMETER_CONSTRUCTOR(class_, base, tag_namespace, args) \ - BOOST_PARAMETER_CONSTRUCTOR_AUX( \ - class_, base, tag_namespace \ - , BOOST_PARAMETER_FLATTEN(2, 2, 3, args) \ +// Expands to a Boost.Parameter-enabled const-qualified function call operator +// header. All arguments are accessible via args and keywords, as well as +// by name. +#define BOOST_PARAMETER_CONST_FUNCTION_CALL_OPERATOR(result, tag_ns, args) \ + BOOST_PARAMETER_MEMBER_FUNCTION_AUX( \ + result, operator(), operator, tag_ns, 1 \ + , BOOST_PARAMETER_AUX_PP_FLATTEN(3, 2, 3, args) \ ) /**/ -# ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING -# define BOOST_PARAMETER_FUNCTION_FWD_COMBINATION(r, _, i, elem) \ - (BOOST_PP_IF( \ - BOOST_PARAMETER_FUNCTION_IS_KEYWORD_QUALIFIER( \ - BOOST_PARAMETER_FN_ARG_NAME(elem) \ - ) \ - , (const ParameterArgumentType ## i)(ParameterArgumentType ## i) \ - , (const ParameterArgumentType ## i) \ - )) -// No partial ordering. This feature doesn't work. -# else -# define BOOST_PARAMETER_FUNCTION_FWD_COMBINATION(r, _, i, elem) \ - (BOOST_PP_IF( \ - BOOST_PARAMETER_FUNCTION_IS_KEYWORD_QUALIFIER( \ - BOOST_PARAMETER_FN_ARG_NAME(elem) \ - ) \ - , (ParameterArgumentType ## i) \ - , (const ParameterArgumentType ## i) \ - )) -# endif - -# define BOOST_PARAMETER_FUNCTION_FWD_COMBINATIONS(args) \ - BOOST_PP_SEQ_FOR_EACH_I(BOOST_PARAMETER_FUNCTION_FWD_COMBINATION, ~, args) - -#endif // BOOST_PARAMETER_PREPROCESSOR_060206_HPP +#endif // include guard diff --git a/boost/parameter/preprocessor_no_spec.hpp b/boost/parameter/preprocessor_no_spec.hpp new file mode 100644 index 0000000000..a40b89c485 --- /dev/null +++ b/boost/parameter/preprocessor_no_spec.hpp @@ -0,0 +1,74 @@ +// Copyright Cromwell D. Enage 2019. +// 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_PREPROCESSOR_NO_SPEC_HPP +#define BOOST_PARAMETER_PREPROCESSOR_NO_SPEC_HPP + +#include <boost/parameter/aux_/preprocessor/impl/function_name.hpp> +#include <boost/parameter/aux_/preprocessor/impl/no_spec_overloads.hpp> + +// Exapnds to a variadic function header that is enabled if and only if all +// its arguments are tagged arguments. All arguments are accessible via args +// and keywords only. +#define BOOST_PARAMETER_NO_SPEC_FUNCTION(result, name) \ + BOOST_PARAMETER_NO_SPEC_FUNCTION_HEAD(result, name, 0) \ + BOOST_PARAMETER_NO_SPEC_FUNCTION_IMPL_HEAD(name, 0); \ + BOOST_PARAMETER_NO_SPEC_FUNCTION_OVERLOAD(name, name, 0, 0) \ + BOOST_PARAMETER_NO_SPEC_FUNCTION_IMPL_HEAD(name, 0) +/**/ + +#include <boost/preprocessor/control/expr_if.hpp> +#include <boost/preprocessor/control/if.hpp> + +// Helper macro for BOOST_PARAMETER_NO_SPEC_MEMBER_FUNCTION, +// BOOST_PARAMETER_NO_SPEC_CONST_MEMBER_FUNCTION, +// BOOST_PARAMETER_NO_SPEC_FUNCTION_CALL_OPERATOR, and +// and BOOST_PARAMETER_NO_SPEC_CONST_FUNCTION_CALL_OPERATOR. +#define BOOST_PARAMETER_NO_SPEC_MEMBER_FUNCTION_AUX(result, name, impl, c) \ + BOOST_PARAMETER_NO_SPEC_FUNCTION_HEAD(result, impl, c) \ + BOOST_PARAMETER_NO_SPEC_FUNCTION_OVERLOAD( \ + name \ + , impl \ + , BOOST_PP_IF(BOOST_PARAMETER_MEMBER_FUNCTION_IS_STATIC(impl), 0, 1) \ + , c \ + ) \ + BOOST_PARAMETER_NO_SPEC_FUNCTION_IMPL_HEAD(impl, c) \ + BOOST_PP_EXPR_IF(c, const) +/**/ + +// Exapnds to a variadic member function header that is enabled if and only if +// all its arguments are tagged arguments. All arguments are accessible via +// args and keywords only. +#define BOOST_PARAMETER_NO_SPEC_MEMBER_FUNCTION(result, name) \ + BOOST_PARAMETER_NO_SPEC_MEMBER_FUNCTION_AUX(result, name, name, 0) +/**/ + +// Exapnds to a const-qualified variadic member function header that is +// enabled if and only if all its arguments are tagged arguments. All +// arguments are accessible via args and keywords only. +#define BOOST_PARAMETER_NO_SPEC_CONST_MEMBER_FUNCTION(result, name) \ + BOOST_PARAMETER_NO_SPEC_MEMBER_FUNCTION_AUX(result, name, name, 1) +/**/ + +// Exapnds to a variadic function call operator header that is enabled if and +// only if all its arguments are tagged arguments. All arguments are +// accessible via args and keywords only. +#define BOOST_PARAMETER_NO_SPEC_FUNCTION_CALL_OPERATOR(result) \ + BOOST_PARAMETER_NO_SPEC_MEMBER_FUNCTION_AUX( \ + result, operator(), operator, 0 \ + ) +/**/ + +// Exapnds to a const-qualified variadic function call operator header that is +// enabled if and only if all its arguments are tagged arguments. All +// arguments are accessible via args and keywords only. +#define BOOST_PARAMETER_NO_SPEC_CONST_FUNCTION_CALL_OPERATOR(result) \ + BOOST_PARAMETER_NO_SPEC_MEMBER_FUNCTION_AUX( \ + result, operator(), operator, 1 \ + ) +/**/ + +#endif // include guard + diff --git a/boost/parameter/required.hpp b/boost/parameter/required.hpp new file mode 100644 index 0000000000..cd08405f28 --- /dev/null +++ b/boost/parameter/required.hpp @@ -0,0 +1,66 @@ +// 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_REQUIRED_HPP +#define BOOST_PARAMETER_REQUIRED_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. In order for + // a treated function to participate in overload resolution: + // + // - all keyword tags wrapped in required<...> must have a matching + // actual argument + // + // - The actual argument type matched by every keyword tag + // associated with a predicate must satisfy that predicate + template < + typename Tag + , typename Predicate = ::boost::parameter::aux::use_default + > + struct required + { + typedef Tag key_type; + typedef Predicate predicate; + }; +}} + +#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_required +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + : ::boost::mp11::mp_false +#else + : ::boost::mpl::false_ +#endif + { + }; + + template <typename Tag, typename Predicate> + struct is_required< ::boost::parameter::required<Tag,Predicate> > +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + : ::boost::mp11::mp_true +#else + : ::boost::mpl::true_ +#endif + { + }; +}}} // namespace boost::parameter::aux + +#endif // include guard + diff --git a/boost/parameter/template_keyword.hpp b/boost/parameter/template_keyword.hpp new file mode 100644 index 0000000000..ef2aa58d14 --- /dev/null +++ b/boost/parameter/template_keyword.hpp @@ -0,0 +1,87 @@ +// Copyright Daniel Wallin 2006. +// 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_TEMPLATE_KEYWORD_HPP +#define BOOST_PARAMETER_TEMPLATE_KEYWORD_HPP + +#include <boost/parameter/aux_/template_keyword.hpp> +#include <boost/parameter/config.hpp> + +#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/mpl/identity.hpp> +#include <boost/type_traits/add_lvalue_reference.hpp> +#include <boost/type_traits/is_function.hpp> +#include <boost/type_traits/is_array.hpp> +#endif + +namespace boost { namespace parameter { + + template <typename Tag, typename T> + struct template_keyword : ::boost::parameter::aux::template_keyword_base + { + typedef Tag key_type; + typedef T value_type; + + // reference is needed for two reasons: + // + // 1. It is used in the body of arg_list<...> + // + // 2. It is the result of binding<...>, which we mistakenly told + // people to use instead of value_type<...> to access named + // template parameters + // + // It used to be that reference == value_type, but that broke when + // the argument was a function or array type, because various + // arg_list functions return reference. + // + // Simply making reference == value_type& would break all the + // legacy code that uses binding<...> to access named template + // parameters. -- David Abrahams +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using reference = typename ::boost::mp11::mp_eval_if< + ::boost::mp11::mp_if< + ::std::is_function<value_type> + , ::boost::mp11::mp_true + , ::std::is_array<value_type> + > + , ::std::add_lvalue_reference<value_type> + , ::boost::mp11::mp_identity + , value_type + >::type; +#else + typedef typename ::boost::mpl::eval_if< + typename ::boost::mpl::if_< + ::boost::is_function<value_type> + , ::boost::mpl::true_ + , ::boost::is_array<value_type> + >::type + , ::boost::add_lvalue_reference<value_type> + , ::boost::mpl::identity<value_type> + >::type reference; +#endif // BOOST_PARAMETER_CAN_USE_MP11 + }; +}} // namespace boost::parameter + +#define BOOST_PARAMETER_TEMPLATE_KEYWORD(name) \ + namespace tag \ + { \ + struct name; \ + } \ + template <typename T> \ + struct name : ::boost::parameter::template_keyword<tag::name,T> \ + { \ + }; +/**/ + +#endif // include guard + diff --git a/boost/parameter/value_type.hpp b/boost/parameter/value_type.hpp index a323dcf37c..1b0ad354c9 100644 --- a/boost/parameter/value_type.hpp +++ b/boost/parameter/value_type.hpp @@ -1,82 +1,164 @@ -// Copyright Daniel Wallin 2006. Use, modification and distribution is -// subject to the Boost Software License, Version 1.0. (See accompanying -// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +// Copyright Daniel Wallin 2006. +// 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_VALUE_TYPE_060921_HPP -# define BOOST_PARAMETER_VALUE_TYPE_060921_HPP +#define BOOST_PARAMETER_VALUE_TYPE_060921_HPP -# include <boost/mpl/apply.hpp> -# include <boost/mpl/assert.hpp> -# include <boost/mpl/and.hpp> -# include <boost/parameter/aux_/result_of0.hpp> -# include <boost/parameter/aux_/void.hpp> -# include <boost/type_traits/is_same.hpp> +#include <boost/parameter/aux_/void.hpp> +#include <boost/parameter/config.hpp> + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) +#include <boost/mp11/integral.hpp> +#include <boost/mp11/list.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/mpl/identity.hpp> +#include <boost/mpl/apply_wrap.hpp> +#include <boost/mpl/assert.hpp> +#include <boost/type_traits/is_same.hpp> +#endif namespace boost { namespace parameter { -// A metafunction that, given an argument pack, returns the type of -// the parameter identified by the given keyword. If no such -// parameter has been specified, returns Default - -# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) -template <class Parameters, class Keyword, class Default> -struct value_type0 -{ - typedef typename mpl::apply_wrap3< - typename Parameters::binding,Keyword,Default,mpl::false_ - >::type type; - - BOOST_MPL_ASSERT_NOT(( - mpl::and_< - is_same<Default, void_> - , is_same<type, void_> - > - )); -}; -# endif - -template <class Parameters, class Keyword, class Default = void_> -struct value_type -{ -# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) - typedef typename mpl::eval_if< - mpl::is_placeholder<Parameters> - , mpl::identity<int> - , value_type0<Parameters,Keyword,Default> - >::type type; -# else - typedef typename mpl::apply_wrap3< - typename Parameters::binding,Keyword,Default,mpl::false_ - >::type type; - - BOOST_MPL_ASSERT_NOT(( - mpl::and_< - is_same<Default, void_> - , is_same<type, void_> + // A metafunction that, given an argument pack, returns the value type + // of the parameter identified by the given keyword. If no such parameter + // has been specified, returns Default + + template <typename Parameters, typename Keyword, typename Default> + struct value_type0 + { +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using type = ::boost::mp11::mp_apply_q< + typename Parameters::binding + , ::boost::mp11::mp_list<Keyword,Default,::boost::mp11::mp_false> + >; + + static_assert( + ::boost::mp11::mp_if< + ::std::is_same<Default,::boost::parameter::void_> + , ::boost::mp11::mp_if< + ::std::is_same<type,::boost::parameter::void_> + , ::boost::mp11::mp_false + , ::boost::mp11::mp_true + > + , ::boost::mp11::mp_true + >::value + , "required parameters must not result in void_ type" + ); +#else // !defined(BOOST_PARAMETER_CAN_USE_MP11) + typedef typename ::boost::mpl::apply_wrap3< + typename Parameters::binding + , Keyword + , Default + , ::boost::mpl::false_ + >::type type; + + BOOST_MPL_ASSERT(( + typename ::boost::mpl::eval_if< + ::boost::is_same<Default,::boost::parameter::void_> + , ::boost::mpl::if_< + ::boost::is_same<type,::boost::parameter::void_> + , ::boost::mpl::false_ + , ::boost::mpl::true_ + > + , ::boost::mpl::true_ + >::type + )); +#endif // BOOST_PARAMETER_CAN_USE_MP11 + }; + +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + template <typename Placeholder, typename Keyword, typename Default> + struct value_type1 + { + using type = ::boost::mp11::mp_apply_q< + Placeholder + , ::boost::mp11::mp_list<Keyword,Default,::boost::mp11::mp_false> + >; + + static_assert( + ::boost::mp11::mp_if< + ::std::is_same<Default,::boost::parameter::void_> + , ::boost::mp11::mp_if< + ::std::is_same<type,::boost::parameter::void_> + , ::boost::mp11::mp_false + , ::boost::mp11::mp_true + > + , ::boost::mp11::mp_true + >::value + , "required parameters must not result in void_ type" + ); + }; +#endif // BOOST_PARAMETER_CAN_USE_MP11 +}} // namespace boost::parameter + +#include <boost/parameter/aux_/is_placeholder.hpp> + +namespace boost { namespace parameter { + + template < + typename Parameters + , typename Keyword + , typename Default = ::boost::parameter::void_ + > + struct value_type +#if !defined(BOOST_PARAMETER_CAN_USE_MP11) + : ::boost::mpl::eval_if< + ::boost::parameter::aux::is_mpl_placeholder<Parameters> + , ::boost::mpl::identity<int> + , ::boost::parameter::value_type0<Parameters,Keyword,Default> > - )); -# endif - - BOOST_MPL_AUX_LAMBDA_SUPPORT(3,value_type,(Parameters,Keyword,Default)) -}; - -// A metafunction that, given an argument pack, returns the type of -// the parameter identified by the given keyword. If no such -// parameter has been specified, returns the type returned by invoking -// DefaultFn -template <class Parameters, class Keyword, class DefaultFn> -struct lazy_value_type -{ - typedef typename mpl::apply_wrap3< - typename Parameters::binding - , Keyword - , typename aux::result_of0<DefaultFn>::type - , mpl::false_ - >::type type; -}; +#endif + { +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using type = typename ::boost::mp11::mp_if< + ::boost::parameter::aux::is_mpl_placeholder<Parameters> + , ::boost::mp11::mp_identity<int> + , ::boost::mp11::mp_if< + ::boost::parameter::aux::is_mp11_placeholder<Parameters> + , ::boost::parameter::value_type1<Parameters,Keyword,Default> + , ::boost::parameter::value_type0<Parameters,Keyword,Default> + > + >::type; +#endif + }; +}} // namespace boost::parameter + +#include <boost/parameter/aux_/result_of0.hpp> +namespace boost { namespace parameter { + // A metafunction that, given an argument pack, returns the value type + // of the parameter identified by the given keyword. If no such parameter + // has been specified, returns the type returned by invoking DefaultFn + template <typename Parameters, typename Keyword, typename DefaultFn> + struct lazy_value_type + { +#if defined(BOOST_PARAMETER_CAN_USE_MP11) + using type = ::boost::mp11::mp_apply_q< + typename Parameters::binding + , ::boost::mp11::mp_list< + Keyword + , typename ::boost::parameter::aux::result_of0<DefaultFn>::type + , ::boost::mp11::mp_false + > + >; +#else + typedef typename ::boost::mpl::apply_wrap3< + typename Parameters::binding + , Keyword + , typename ::boost::parameter::aux::result_of0<DefaultFn>::type + , ::boost::mpl::false_ + >::type type; +#endif // BOOST_PARAMETER_CAN_USE_MP11 + }; }} // namespace boost::parameter -#endif // BOOST_PARAMETER_VALUE_TYPE_060921_HPP +#endif // include guard |