3rdparty/boost/boost/parameter/parameters.hpp

   1 // Copyright David Abrahams, Daniel Wallin 2003.
   2 // Copyright Cromwell D. Enage 2017.
   3 // Distributed under the Boost Software License, Version 1.0.
   4 // (See accompanying file LICENSE_1_0.txt or copy at
   5 // http://www.boost.org/LICENSE_1_0.txt)
   6
   7 #ifndef BOOST_PARAMETERS_031014_HPP
   8 #define BOOST_PARAMETERS_031014_HPP
   9
  10 #include <boost/parameter/config.hpp>
  11
  12 #if defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING)
  13
  14 namespace boost { namespace parameter { namespace aux {
  15
  16     // The make_arg_list<> metafunction produces a reversed arg_list,
  17     // so pass the arguments to the arg_list constructor reversed in turn.
  18     template <typename ArgList, typename ...Args>
  19     struct arg_list_factory;
  20 }}} // namespace boost::parameter::aux
  21
  22 #include <boost/parameter/aux_/arg_list.hpp>
  23 #include <utility>
  24
  25 #if defined(BOOST_PARAMETER_CAN_USE_MP11)
  26 #include <boost/mp11/utility.hpp>
  27 #include <type_traits>
  28 #else
  29 #include <boost/mpl/if.hpp>
  30 #include <boost/type_traits/is_same.hpp>
  31 #endif
  32
  33 namespace boost { namespace parameter { namespace aux {
  34
  35     // TODO: Reduce template code bloat. -- Cromwell D. Enage
  36     template <typename ArgList>
  37     struct arg_list_factory<ArgList>
  38     {
  39         template <typename ...ReversedArgs>
  40         static inline BOOST_CONSTEXPR ArgList
  41             reverse(ReversedArgs&&... reversed_args)
  42         {
  43             return ArgList(
  44 #if defined(BOOST_PARAMETER_CAN_USE_MP11)
  45                 ::boost::mp11::mp_if<
  46                     ::std::is_same<
  47 #else
  48                 typename ::boost::mpl::if_<
  49                     ::boost::is_same<
  50 #endif
  51                         typename ArgList::tagged_arg::value_type
  52                       , ::boost::parameter::void_
  53                     >
  54                   , ::boost::parameter::aux::value_type_is_void
  55                   , ::boost::parameter::aux::value_type_is_not_void
  56 #if defined(BOOST_PARAMETER_CAN_USE_MP11)
  57                 >()
  58 #else
  59                 >::type()
  60 #endif
  61               , ::std::forward<ReversedArgs>(reversed_args)...
  62             );
  63         }
  64     };
  65
  66     template <typename ArgList, typename A0, typename ...Args>
  67     struct arg_list_factory<ArgList,A0,Args...>
  68     {
  69         template <typename ...ReversedArgs>
  70         static inline BOOST_CONSTEXPR ArgList
  71             reverse(A0&& a0, Args&&... args, ReversedArgs&&... reversed_args)
  72         {
  73             return ::boost::parameter::aux
  74             ::arg_list_factory<ArgList,Args...>::reverse(
  75                 ::std::forward<Args>(args)...
  76               , ::std::forward<A0>(a0)
  77               , ::std::forward<ReversedArgs>(reversed_args)...
  78             );
  79         }
  80     };
  81 }}} // namespace boost::parameter::aux
  82
  83 #include <boost/parameter/aux_/void.hpp>
  84 #include <boost/parameter/aux_/pack/make_arg_list.hpp>
  85 #include <boost/parameter/aux_/pack/make_parameter_spec_items.hpp>
  86 #include <boost/parameter/aux_/pack/tag_keyword_arg.hpp>
  87 #include <boost/parameter/aux_/pack/tag_template_keyword_arg.hpp>
  88
  89 #if defined(BOOST_PARAMETER_CAN_USE_MP11)
  90 #include <boost/mp11/integral.hpp>
  91 #include <boost/mp11/list.hpp>
  92 #else
  93 #include <boost/mpl/bool.hpp>
  94 #include <boost/mpl/pair.hpp>
  95 #include <boost/mpl/identity.hpp>
  96 #endif
  97
  98 #if !defined(BOOST_PARAMETER_VARIADIC_MPL_SEQUENCE)
  99 #if defined(BOOST_PARAMETER_CAN_USE_MP11)
 100 //#include <boost/mp11/mpl.hpp>
 101 #define BOOST_PARAMETER_VARIADIC_MPL_SEQUENCE ::boost::mp11::mp_list
 102 #else
 103 #include <boost/fusion/container/list/list_fwd.hpp>
 104
 105 // Newer versions of MSVC fail on the evaluate_category and
 106 // preprocessor_eval_category test programs when parameters uses
 107 // boost::fusion::list.
 108 // -- Cromwell D. Enage
 109 #if defined(BOOST_FUSION_HAS_VARIADIC_LIST) && ( \
 110         !defined(BOOST_MSVC) || (BOOST_MSVC < 1800) \
 111     )
 112 #include <boost/fusion/container/list.hpp>
 113 #include <boost/fusion/mpl.hpp>
 114 #define BOOST_PARAMETER_VARIADIC_MPL_SEQUENCE ::boost::fusion::list
 115 #else
 116 #include <boost/fusion/container/deque/deque_fwd.hpp>
 117
 118 #if defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
 119 #include <boost/fusion/container/deque.hpp>
 120 #include <boost/fusion/mpl.hpp>
 121 #define BOOST_PARAMETER_VARIADIC_MPL_SEQUENCE ::boost::fusion::deque
 122 #else
 123 #include <boost/mpl/vector.hpp>
 124 #define BOOST_PARAMETER_VARIADIC_MPL_SEQUENCE ::boost::mpl::vector
 125 #endif  // BOOST_FUSION_HAS_VARIADIC_DEQUE
 126 #endif  // BOOST_FUSION_HAS_VARIADIC_LIST
 127 #endif  // BOOST_PARAMETER_CAN_USE_MP11
 128 #endif  // BOOST_PARAMETER_VARIADIC_MPL_SEQUENCE
 129
 130 namespace boost { namespace parameter {
 131
 132     template <typename ...Spec>
 133     struct parameters
 134     {
 135         typedef BOOST_PARAMETER_VARIADIC_MPL_SEQUENCE<Spec...> parameter_spec;
 136
 137         typedef typename ::boost::parameter::aux
 138         ::make_deduced_list<parameter_spec>::type deduced_list;
 139
 140         // If the elements of NamedList match the criteria of overload
 141         // resolution, returns a type which can be constructed from
 142         // parameters.  Otherwise, this is not a valid metafunction
 143         // (no nested ::type).
 144         template <typename ArgumentPackAndError>
 145         struct match_base
 146 #if !defined(BOOST_PARAMETER_CAN_USE_MP11)
 147           : ::boost::mpl::if_<
 148                 typename ::boost::parameter::aux::match_parameters_base_cond<
 149                     ArgumentPackAndError
 150                   , parameter_spec
 151                 >::type
 152               , ::boost::mpl::identity<
 153                     ::boost::parameter::parameters<Spec...>
 154                 >
 155               , ::boost::parameter::void_
 156             >
 157 #endif
 158         {
 159 #if defined(BOOST_PARAMETER_CAN_USE_MP11)
 160             using type = ::boost::mp11::mp_if<
 161                 typename ::boost::parameter::aux::match_parameters_base_cond<
 162                     ArgumentPackAndError
 163                   , parameter_spec
 164                 >::type
 165               , ::boost::mp11::mp_identity<
 166                     ::boost::parameter::parameters<Spec...>
 167                 >
 168               , ::boost::parameter::void_
 169             >;
 170 #endif
 171         };
 172
 173         // Specializations are to be used as an optional argument
 174         // to eliminate overloads via SFINAE.
 175         template <typename ...Args>
 176         struct match
 177           : ::boost::parameter::parameters<Spec...>
 178             ::BOOST_NESTED_TEMPLATE match_base<
 179                 typename ::boost::parameter::aux::make_arg_list<
 180                     typename ::boost::parameter::aux
 181                     ::make_parameter_spec_items<parameter_spec,Args...>::type
 182                   , deduced_list
 183                   , ::boost::parameter::aux::tag_keyword_arg
 184                     // Don't emit errors when doing SFINAE.
 185 #if defined(BOOST_PARAMETER_CAN_USE_MP11)
 186                   , ::boost::mp11::mp_false
 187 #else
 188                   , ::boost::mpl::false_
 189 #endif
 190                 >::type
 191             >::type
 192         {
 193         };
 194
 195         // Metafunction that returns an ArgumentPack.
 196         template <typename ...Args>
 197         struct bind
 198 #if !defined(BOOST_PARAMETER_CAN_USE_MP11)
 199           : ::boost::mpl::first<
 200                 typename ::boost::parameter::aux::make_arg_list<
 201                     typename ::boost::parameter::aux
 202                     ::make_parameter_spec_items<parameter_spec,Args...>::type
 203                   , deduced_list
 204                   , ::boost::parameter::aux::tag_template_keyword_arg
 205                 >::type
 206             >
 207 #endif
 208         {
 209 #if defined(BOOST_PARAMETER_CAN_USE_MP11)
 210             using type = ::boost::mp11::mp_at_c<
 211                 typename ::boost::parameter::aux::make_arg_list<
 212                     typename ::boost::parameter::aux
 213                     ::make_parameter_spec_items<parameter_spec,Args...>::type
 214                   , deduced_list
 215                   , ::boost::parameter::aux::tag_template_keyword_arg
 216                 >::type
 217               , 0
 218             >;
 219 #endif
 220         };
 221
 222         // The function call operator is used to build an arg_list that
 223         // labels the positional parameters and maintains whatever other
 224         // tags may have been specified by the caller.
 225         inline ::boost::parameter::aux::empty_arg_list operator()() const
 226         {
 227             return ::boost::parameter::aux::empty_arg_list();
 228         }
 229
 230         template <typename A0, typename ...Args>
 231 #if defined(BOOST_PARAMETER_CAN_USE_MP11)
 232         inline ::boost::mp11::mp_at_c<
 233 #else
 234         inline typename ::boost::mpl::first<
 235 #endif
 236             typename ::boost::parameter::aux::make_arg_list<
 237                 typename ::boost::parameter::aux
 238                 ::make_parameter_spec_items<parameter_spec,A0,Args...>::type
 239               , deduced_list
 240               , ::boost::parameter::aux::tag_keyword_arg
 241             >::type
 242 #if defined(BOOST_PARAMETER_CAN_USE_MP11)
 243           , 0
 244         >
 245 #else
 246         >::type
 247 #endif
 248             operator()(A0&& a0, Args&& ...args) const
 249         {
 250             typedef typename ::boost::parameter::aux::make_arg_list<
 251                 typename ::boost::parameter::aux
 252                 ::make_parameter_spec_items<parameter_spec,A0,Args...>::type
 253               , deduced_list
 254               , ::boost::parameter::aux::tag_keyword_arg
 255             >::type list_error_pair;
 256
 257 #if defined(BOOST_PARAMETER_CAN_USE_MP11)
 258             using result_type = ::boost::mp11::mp_at_c<list_error_pair,0>;
 259
 260             using error = ::boost::mp11::mp_at_c<list_error_pair,1>;
 261 #else
 262             typedef typename ::boost::mpl
 263             ::first<list_error_pair>::type result_type;
 264
 265             typedef typename ::boost::mpl
 266             ::second<list_error_pair>::type error;
 267 #endif
 268
 269             error();
 270
 271             return ::boost::parameter::aux
 272             ::arg_list_factory<result_type,A0,Args...>::reverse(
 273                 ::std::forward<A0>(a0)
 274               , ::std::forward<Args>(args)...
 275             );
 276         }
 277     };
 278 }} // namespace boost::parameter
 279
 280 #else   // !defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING)
 281
 282 #include <boost/parameter/aux_/void.hpp>
 283 #include <boost/parameter/aux_/arg_list.hpp>
 284 #include <boost/parameter/aux_/pack/make_arg_list.hpp>
 285 #include <boost/parameter/aux_/pack/make_items.hpp>
 286 #include <boost/parameter/aux_/pack/make_deduced_items.hpp>
 287 #include <boost/parameter/aux_/pack/tag_template_keyword_arg.hpp>
 288 #include <boost/parameter/aux_/preprocessor/binary_seq_for_each.hpp>
 289 #include <boost/preprocessor/arithmetic/inc.hpp>
 290 #include <boost/preprocessor/repetition/enum_shifted.hpp>
 291 #include <boost/preprocessor/repetition/repeat.hpp>
 292 #include <boost/preprocessor/selection/min.hpp>
 293
 294 #if ( \
 295         BOOST_PARAMETER_EXPONENTIAL_OVERLOAD_THRESHOLD_ARITY < \
 296         BOOST_PARAMETER_MAX_ARITY \
 297     )
 298 #include <boost/parameter/aux_/pack/tag_keyword_arg_ref.hpp>
 299 #include <boost/mpl/pair.hpp>
 300 #include <boost/preprocessor/arithmetic/dec.hpp>
 301 #include <boost/preprocessor/arithmetic/sub.hpp>
 302 #include <boost/preprocessor/facilities/intercept.hpp>
 303 #include <boost/preprocessor/iteration/iterate.hpp>
 304 #include <boost/preprocessor/repetition/enum.hpp>
 305 #include <boost/preprocessor/repetition/enum_trailing_params.hpp>
 306 #endif
 307
 308 #if !defined(BOOST_NO_SFINAE) && \
 309     !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
 310 #include <boost/parameter/aux_/pack/tag_keyword_arg.hpp>
 311 #include <boost/mpl/bool.hpp>
 312 #include <boost/mpl/if.hpp>
 313 #include <boost/mpl/identity.hpp>
 314 #include <boost/type_traits/is_same.hpp>
 315 #endif
 316
 317 #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
 318 #include <boost/preprocessor/repetition/enum_params.hpp>
 319 #else
 320 #include <boost/preprocessor/repetition/enum_binary_params.hpp>
 321 #endif
 322
 323 #include <boost/parameter/aux_/preprocessor/no_perfect_forwarding_begin.hpp>
 324
 325 namespace boost { namespace parameter {
 326
 327     template <
 328         typename PS0
 329       , BOOST_PP_ENUM_SHIFTED(
 330             BOOST_PARAMETER_MAX_ARITY
 331           , BOOST_PARAMETER_template_args
 332           , PS
 333         )
 334     >
 335     struct parameters
 336     {
 337         typedef typename BOOST_PARAMETER_build_deduced_list(
 338             BOOST_PARAMETER_MAX_ARITY
 339           , ::boost::parameter::aux::make_deduced_items
 340           , PS
 341         )::type deduced_list;
 342
 343         // If the elements of NamedList match the criteria of overload
 344         // resolution, returns a type which can be constructed from
 345         // parameters.  Otherwise, this is not a valid metafunction
 346         // (no nested ::type).
 347 #if !defined(BOOST_NO_SFINAE) && \
 348     !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
 349         // If NamedList satisfies the PS0, PS1, ..., this is a metafunction
 350         // returning parameters.  Otherwise it has no nested ::type.
 351         template <typename ArgumentPackAndError>
 352         struct match_base
 353           : ::boost::mpl::if_<
 354                 // ::boost::mpl::and_<
 355                 //    aux::satisfies_requirements_of<NamedList,PS0>
 356                 //  , ::boost::mpl::and_<
 357                 //       aux::satisfies_requirements_of<NamedList,PS1>...
 358                 //           ..., ::boost::mpl::true_
 359                 // ...> >
 360                 typename BOOST_PP_REPEAT(
 361                     BOOST_PARAMETER_MAX_ARITY
 362                   , BOOST_PARAMETER_satisfies_begin
 363                   , PS
 364                 )
 365                 ::boost::is_same<
 366                     typename ::boost::mpl
 367                     ::second<ArgumentPackAndError>::type
 368                   , ::boost::parameter::void_
 369                 >
 370                 BOOST_PP_REPEAT(
 371                     BOOST_PARAMETER_MAX_ARITY
 372                   , BOOST_PARAMETER_satisfies_end
 373                   , ::boost::mpl::false_
 374                 )::type
 375               , ::boost::mpl::identity<
 376                     ::boost::parameter::parameters<
 377                         BOOST_PP_ENUM_PARAMS(BOOST_PARAMETER_MAX_ARITY, PS)
 378                     >
 379                 >
 380               , ::boost::parameter::void_
 381             >
 382         {
 383         };
 384 #endif  // SFINAE enabled, not Borland
 385
 386         // Specializations are to be used as an optional argument
 387         // to eliminate overloads via SFINAE.
 388         template <
 389 #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
 390             // Borland simply can't handle default arguments in member
 391             // class templates.  People wishing to write portable code can
 392             // explicitly specify BOOST_PARAMETER_MAX_ARITY arguments.
 393             BOOST_PP_ENUM_PARAMS(BOOST_PARAMETER_MAX_ARITY, typename A)
 394 #else
 395             BOOST_PP_ENUM_BINARY_PARAMS(
 396                 BOOST_PARAMETER_MAX_ARITY
 397               , typename A
 398               , = ::boost::parameter::void_ BOOST_PP_INTERCEPT
 399             )
 400 #endif
 401         >
 402         struct match
 403 #if !defined(BOOST_NO_SFINAE) && \
 404     !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
 405           : ::boost::parameter::parameters<
 406                 BOOST_PP_ENUM_PARAMS(BOOST_PARAMETER_MAX_ARITY, PS)
 407             >::BOOST_NESTED_TEMPLATE match_base<
 408                 typename ::boost::parameter::aux::make_arg_list<
 409                     typename BOOST_PARAMETER_build_arg_list(
 410                         BOOST_PARAMETER_MAX_ARITY
 411                       , ::boost::parameter::aux::make_items
 412                       , PS
 413                       , A
 414                     )::type
 415                   , deduced_list
 416                   , ::boost::parameter::aux::tag_keyword_arg
 417                     // Don't emit errors when doing SFINAE.
 418                   , ::boost::mpl::false_
 419                 >::type
 420             >::type
 421         {
 422         };
 423 #else
 424         {
 425             typedef ::boost::parameter::parameters<
 426                 BOOST_PP_ENUM_PARAMS(BOOST_PARAMETER_MAX_ARITY, PS)
 427             > type;
 428         };
 429 #endif  // SFINAE enabled, not Borland
 430
 431         // Metafunction that returns an ArgumentPack.
 432
 433         // TODO, bind has to instantiate the error type in the result
 434         // of make_arg_list.
 435
 436         template <
 437 #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
 438             // Borland simply can't handle default arguments in member
 439             // class templates.  People wishing to write portable code can
 440             // explicitly specify BOOST_PARAMETER_MAX_ARITY arguments.
 441             BOOST_PP_ENUM_PARAMS(BOOST_PARAMETER_MAX_ARITY, typename A)
 442 #else
 443             BOOST_PP_ENUM_BINARY_PARAMS(
 444                 BOOST_PARAMETER_MAX_ARITY
 445               , typename A
 446               , = ::boost::parameter::void_ BOOST_PP_INTERCEPT
 447             )
 448 #endif
 449         >
 450         struct bind
 451         {
 452             typedef typename ::boost::parameter::aux::make_arg_list<
 453                 typename BOOST_PARAMETER_build_arg_list(
 454                     BOOST_PARAMETER_MAX_ARITY
 455                   , ::boost::parameter::aux::make_items
 456                   , PS
 457                   , A
 458                 )::type
 459               , deduced_list
 460               , ::boost::parameter::aux::tag_template_keyword_arg
 461             >::type result;
 462
 463             typedef typename ::boost::mpl::first<result>::type type;
 464         };
 465
 466         BOOST_PP_REPEAT(
 467             BOOST_PARAMETER_MAX_ARITY
 468           , BOOST_PARAMETER_forward_typedef
 469           , (PS)(parameter_spec)
 470         )
 471
 472         // The function call operator is used to build an arg_list that
 473         // labels the positional parameters and maintains whatever other
 474         // tags may have been specified by the caller.
 475         //
 476         // !!!NOTE!!!
 477         //
 478         // The make_arg_list<> metafunction produces a reversed arg_list,
 479         // so pass the arguments to the arg_list constructor reversed in turn.
 480         inline ::boost::parameter::aux::empty_arg_list operator()() const
 481         {
 482             return ::boost::parameter::aux::empty_arg_list();
 483         }
 484
 485 #if (0 < BOOST_PARAMETER_EXPONENTIAL_OVERLOAD_THRESHOLD_ARITY)
 486         BOOST_PP_REPEAT(
 487             BOOST_PP_MIN(
 488                 BOOST_PP_INC(BOOST_PARAMETER_MAX_ARITY)
 489               , BOOST_PARAMETER_EXPONENTIAL_OVERLOAD_THRESHOLD_ARITY
 490             )
 491           , BOOST_PARAMETER_AUX_PP_BINARY_SEQ_FOR_EACH_Z
 492           , (BOOST_PARAMETER_function_call_op_overload_R)(_)
 493         )
 494 #if ( \
 495         BOOST_PARAMETER_EXPONENTIAL_OVERLOAD_THRESHOLD_ARITY < \
 496         BOOST_PARAMETER_MAX_ARITY \
 497     )
 498 #define BOOST_PP_ITERATION_PARAMS_1 \
 499     (3,( \
 500         BOOST_PARAMETER_EXPONENTIAL_OVERLOAD_THRESHOLD_ARITY \
 501       , BOOST_PARAMETER_MAX_ARITY \
 502       , <boost/parameter/aux_/preprocessor/overloads.hpp> \
 503     ))
 504 #include BOOST_PP_ITERATE()
 505 #endif
 506 #else   // (0 == BOOST_PARAMETER_EXPONENTIAL_OVERLOAD_THRESHOLD_ARITY)
 507         template <typename A0>
 508         inline typename ::boost::mpl::first<
 509             typename ::boost::parameter::aux::make_arg_list<
 510                 ::boost::parameter::aux::item<
 511                     PS0,A0
 512                 >
 513               , deduced_list
 514               , ::boost::parameter::aux::tag_keyword_arg_ref
 515             >::type
 516         >::type
 517             operator()(A0& a0) const
 518         {
 519             typedef typename ::boost::parameter::aux::make_arg_list<
 520                 ::boost::parameter::aux::item<
 521                     PS0,A0
 522                 >
 523               , deduced_list
 524               , ::boost::parameter::aux::tag_keyword_arg_ref
 525             >::type result;
 526
 527             typedef typename ::boost::mpl::first<result>::type result_type;
 528             typedef typename ::boost::mpl::second<result>::type error;
 529             error();
 530
 531             return result_type(
 532                 a0
 533                 // , void_(), void_(), void_() ...
 534                 BOOST_PP_ENUM_TRAILING_PARAMS(
 535                     BOOST_PP_SUB(BOOST_PARAMETER_COMPOSE_MAX_ARITY, 1)
 536                   , ::boost::parameter::aux::void_reference() BOOST_PP_INTERCEPT
 537                 )
 538             );
 539         }
 540
 541         template <typename A0, typename A1>
 542         inline typename ::boost::mpl::first<
 543             typename ::boost::parameter::aux::make_arg_list<
 544                 ::boost::parameter::aux::item<
 545                     PS0,A0
 546                   , ::boost::parameter::aux::item<
 547                         PS1,A1
 548                     >
 549                 >
 550               , deduced_list
 551               , ::boost::parameter::aux::tag_keyword_arg_ref
 552             >::type
 553         >::type
 554             operator()(A0& a0, A1& a1) const
 555         {
 556             typedef typename ::boost::parameter::aux::make_arg_list<
 557                 ::boost::parameter::aux::item<
 558                     PS0,A0
 559                   , ::boost::parameter::aux::item<
 560                         PS1,A1
 561                     >
 562                 >
 563               , deduced_list
 564               , ::boost::parameter::aux::tag_keyword_arg
 565             >::type result;
 566
 567             typedef typename ::boost::mpl::first<result>::type result_type;
 568             typedef typename ::boost::mpl::second<result>::type error;
 569             error();
 570
 571             return result_type(
 572                 a1
 573               , a0
 574                 // , void_(), void_() ...
 575                 BOOST_PP_ENUM_TRAILING_PARAMS(
 576                     BOOST_PP_SUB(BOOST_PARAMETER_COMPOSE_MAX_ARITY, 2)
 577                   , ::boost::parameter::aux::void_reference() BOOST_PP_INTERCEPT
 578                 )
 579             );
 580         }
 581
 582 #if (2 < BOOST_PARAMETER_MAX_ARITY)
 583         // Higher arities are handled by the preprocessor
 584 #define BOOST_PP_ITERATION_PARAMS_1 \
 585     (3,( \
 586         3 \
 587       , BOOST_PARAMETER_MAX_ARITY \
 588       , <boost/parameter/aux_/preprocessor/overloads.hpp> \
 589     ))
 590 #include BOOST_PP_ITERATE()
 591 #endif
 592 #endif  // exponential overloads
 593     };
 594 }} // namespace boost::parameter
 595
 596 #include <boost/parameter/aux_/preprocessor/no_perfect_forwarding_end.hpp>
 597
 598 #endif  // BOOST_PARAMETER_HAS_PERFECT_FORWARDING
 599 #endif  // include guard
 600