libs/parameter/doc/reference.rst

   1 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
   2 The Boost Parameter Library Reference Documentation
   3 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
   4
   5 :Authors:       David Abrahams, Daniel Wallin
   6 :Contact:       dave@boost-consulting.com, daniel@boostpro.com
   7 :organization:  `BoostPro Computing`_
   8 :date:          $Date: 2005/07/17 19:53:01 $
   9
  10 :copyright:     Copyright David Abrahams, Daniel Wallin
  11                 2005-2009.  Distributed under the Boost Software License,
  12                 Version 1.0.  (See accompanying file LICENSE_1_0.txt
  13                 or copy at http://www.boost.org/LICENSE_1_0.txt)
  14
  15 |(logo)|__
  16
  17 .. |(logo)| image:: ../../../../boost.png
  18     :alt: Boost
  19
  20 __ ../../../../index.htm
  21
  22 .. _`BoostPro Computing`: http://www.boostpro.com
  23
  24
  25 //////////////////////////////////////////////////////////////////////////////
  26
  27 .. contents::
  28     :depth: 2
  29
  30 //////////////////////////////////////////////////////////////////////////////
  31
  32 .. role:: class
  33     :class: class
  34
  35 .. role:: concept
  36     :class: concept
  37
  38 .. role:: function
  39     :class: function
  40
  41 .. |ArgumentPack| replace:: :concept:`ArgumentPack`
  42 .. |ForwardSequence| replace:: :concept:`Forward Sequence`
  43 .. |ParameterSpec| replace:: :concept:`ParameterSpec`
  44
  45 .. role:: vellipsis
  46     :class: vellipsis
  47
  48 .. section-numbering::
  49     :depth: 2
  50
  51 Preliminaries
  52 =============
  53
  54 This section covers some basic information you'll need to know in order to
  55 understand this reference.
  56
  57 Namespaces
  58 ----------
  59
  60 In this document, all unqualified identifiers should be assumed to be defined
  61 in namespace ``boost::parameter`` unless otherwise specified.
  62
  63 Exceptions
  64 ----------
  65
  66 No operation described in this document throws an exception unless otherwise
  67 specified.
  68
  69 Thread Safety
  70 -------------
  71
  72 All components of this library can be used safely from multiple threads
  73 without synchronization.  [#thread]_
  74
  75 Typography
  76 ----------
  77
  78 Names written in :concept:`sans serif type` represent concepts_.
  79
  80 In code blocks, *italic type* represents unspecified text that satisfies the
  81 requirements given in the detailed description that follows the code block.
  82
  83 In a specification of the tokens generated by a macro, **bold type** is used
  84 to highlight the position of the expanded macro argument in the result.
  85
  86 The special character β represents the value of |BOOST_PARAMETER_MAX_ARITY|_.
  87
  88 //////////////////////////////////////////////////////////////////////////////
  89
  90 Terminology
  91 ===========
  92
  93 .. |kw| replace:: keyword
  94 .. _kw:
  95
  96 keyword
  97     The name of a function parameter.
  98
  99 .. _keyword tag type:
 100 .. |keyword tag type| replace:: `keyword tag type`_
 101
 102 keyword tag type
 103     A type used to uniquely identify a function parameter.  Typically its name
 104     will be the same as that of the parameter.
 105
 106 .. _positional:
 107 .. |positional| replace:: `positional`_
 108
 109 positional argument
 110     An argument passed with no explicit |kw|.  Its parameter is determined
 111     in the usual C++ way: by position with respect to a parameter list.
 112
 113 .. _tag type:
 114 .. |tag type| replace:: `tag type`_
 115
 116 tag type
 117     Shorthand for “\ |keyword tag type|.”
 118
 119 .. _keyword object:
 120 .. |keyword object| replace:: `keyword object`_
 121
 122 keyword object
 123     An instance of |keyword|_\ ``<T>`` for some |tag type| ``T``.
 124
 125 .. _tagged reference:
 126 .. |tagged reference| replace:: `tagged reference`_
 127
 128 tagged reference
 129     An object whose type is associated with a |keyword tag type| (the object's
 130     *keyword*), and that holds a reference (to the object's *value*).
 131
 132     As a shorthand, a “tagged reference to ``x``\ ” means a tagged reference
 133     whose *value* is ``x``.
 134
 135 .. _tagged default:
 136 .. |tagged default| replace:: `tagged default`_
 137
 138 tagged default
 139     A |tagged reference| whose *value* represents the value of a
 140     default argument.
 141
 142 .. _tagged lazy default:
 143 .. |tagged lazy default| replace:: `tagged lazy default`_
 144
 145 tagged lazy default
 146     A |tagged reference| whose *value*, when invoked with no arguments,
 147     computes a default argument value.
 148
 149 .. _intended argument type:
 150 .. |intended argument type| replace:: `intended argument type`_
 151
 152 intended argument type
 153     The *intended argument type* of a single-element |ArgumentPack|_ is the
 154     type of its element's *value*.  The intended argument type of any other
 155     type ``X`` is ``X`` itself.
 156
 157 .. Note::
 158
 159     In this reference, we will use concept names (and other names) to describe
 160     both types and objects, depending on context.  So for example, “an
 161     |ArgumentPack|_\ ” can refer to a type that models |ArgumentPack|_
 162     *or* an object of such a type.
 163
 164 //////////////////////////////////////////////////////////////////////////////
 165
 166 Concepts
 167 ========
 168
 169 This section describes the generic type concepts used by the Parameter
 170 library.
 171
 172 |ArgumentPack|
 173 --------------
 174
 175 An |ArgumentPack| is a collection of |tagged reference|\ s to the actual
 176 arguments passed to a function.  Every |ArgumentPack| is also a valid `MPL
 177 Forward Sequence`_ and `MPL Associative Sequence`_ consisting of the |keyword
 178 tag type|\ s in its |tagged reference|\ s.  If |BOOST_PARAMETER_CAN_USE_MP11|
 179 is defined, then every |ArgumentPack| is also a valid |Boost_MP11|_ map whose
 180 keys are |keyword tag type|\ s.  The |singular_cpp|_, |compose_cpp|_, and
 181 |mpl_cpp|_ test programs demonstrate this functionality.
 182
 183 Requirements
 184 ............
 185
 186 In the table below,
 187
 188 * ``A`` is a model of |ArgumentPack|
 189 * ``x`` is an instance of ``A``
 190 * ``u`` is a |keyword object| of type ``K``
 191 * ``v`` is a |tagged default| with |tag type| ``L`` and *value* of type ``D``
 192 * ``w`` is a |tagged lazy default| with |tag type| ``M`` and *value* of type ``E const``
 193 * ``z`` is an |ArgumentPack| containing a single element (as created by |keyword|_\ ``<…>::operator=``)
 194
 195 Any exceptions thrown from the invocation of ``w``\ 's *value*
 196 will be propagated to the caller.
 197
 198 .. table:: |ArgumentPack| requirements
 199
 200     +------------+---------------------------------+----------------+----------------------+
 201     | Expression | Type                            | Requirements   | Semantics/Notes      |
 202     +============+=================================+================+======================+
 203     |  ``x[u]``  | ``binding<A, K>::type``         | ``x`` contains | Returns *b*\ 's      |
 204     |            |                                 | an element *b* | *value* (by          |
 205     |            |                                 | whose |kw|_ is | reference).          |
 206     |            |                                 | ``K``          |                      |
 207     +------------+---------------------------------+----------------+----------------------+
 208     |  ``x[u]``  | ``binding<A, L, D>::type``      | *none*         | If ``x`` contains an |
 209     |            |                                 |                | element *b* whose    |
 210     |            |                                 |                | |kw|_ is the same as |
 211     |            |                                 |                | ``u``\ 's, returns   |
 212     |            |                                 |                | *b*\ 's *value* (by  |
 213     |            |                                 |                | reference).          |
 214     |            |                                 |                | Otherwise, returns   |
 215     |            |                                 |                | ``u``\ 's *value*.   |
 216     +------------+---------------------------------+----------------+----------------------+
 217     |  ``x[w]``  | ``lazy_binding<A, M, E>::type`` | *none*         | If ``x`` contains an |
 218     |            |                                 |                | element *b* whose    |
 219     |            |                                 |                | |kw|_ is the same as |
 220     |            |                                 |                | ``w``\ 's, returns   |
 221     |            |                                 |                | *b*\ 's *value* (by  |
 222     |            |                                 |                | reference).          |
 223     |            |                                 |                | Otherwise, invokes   |
 224     |            |                                 |                | ``w``\ 's *value*    |
 225     |            |                                 |                | and returns the      |
 226     |            |                                 |                | result.              |
 227     +------------+---------------------------------+----------------+----------------------+
 228     |  ``x, z``  | Model of |ArgumentPack|_        | *none*         | Returns an           |
 229     |            |                                 |                | |ArgumentPack|_      |
 230     |            |                                 |                | containing all the   |
 231     |            |                                 |                | elements of both     |
 232     |            |                                 |                | ``x`` and ``z``.     |
 233     +------------+---------------------------------+----------------+----------------------+
 234
 235 .. _parameterspec:
 236
 237 |ParameterSpec|
 238 ---------------
 239
 240 A |ParameterSpec| describes the type requirements for arguments corresponding
 241 to a given |kw|_ and indicates whether the argument is optional or
 242 required.  The table below details the allowed forms and describes their
 243 condition for satisfaction by an actual argument type. In each row,
 244
 245 .. _conditions:
 246
 247 * ``K`` is the |ParameterSpec|\ 's |keyword tag type|
 248 * ``A`` is an |intended argument type| associated with ``K``, if any
 249 * ``P`` is a model of |ArgumentPack| that contains ``A``
 250 * ``F`` is an `MPL Binary Metafunction Class`_
 251
 252 .. _`MPL Binary Metafunction Class`: ../../../mpl/doc/refmanual/metafunction-class.html
 253
 254 .. table:: |ParameterSpec| allowed forms and conditions of satisfaction
 255
 256     +------------------------+----------+----------------------------------------+
 257     | Type                   | ``A``    | Condition ``A`` must satisfy           |
 258     |                        | required |                                        |
 259     +========================+==========+========================================+
 260     | ``K``                  | no       |       *n/a*                            |
 261     +------------------------+----------+----------------------------------------+
 262     | |optional|_\ ``<K,F>`` | no       | ``mpl::apply2<F,A,P>::type::value`` is |
 263     |                        |          | ``true``.                              |
 264     +------------------------+----------+----------------------------------------+
 265     | |required|_\ ``<K,F>`` | yes      | ``mpl::apply2<F,A,P>::type::value`` is |
 266     |                        |          | ``true``.                              |
 267     +------------------------+----------+----------------------------------------+
 268
 269 The information in a |ParameterSpec| is used to `limit`__ the arguments that
 270 will be matched by `forwarding functions`_.
 271
 272 __ overloadcontrol_
 273 .. _overloadcontrol: index.html#controlling-overload-resolution
 274 .. _forwarding functions: index.html#forwarding-functions
 275
 276 //////////////////////////////////////////////////////////////////////////////
 277
 278 Class Templates
 279 ===============
 280
 281 .. |keyword| replace:: ``keyword``
 282 .. _keyword:
 283
 284 ``keyword``
 285 -----------
 286
 287 The type of every |keyword object| is a specialization of |keyword|.
 288
 289 :Defined in: |keyword_header|_
 290
 291 .. parsed-literal::
 292
 293     template <typename Tag>
 294     struct keyword
 295     {
 296         typedef Tag tag;
 297
 298         template <typename T>
 299         constexpr typename |boost_enable_if|_\<
 300             typename |mpl_eval_if|_\<
 301                 |boost_is_scalar|_\<T>
 302               , |mpl_true|_\  // Enable this overload for scalar types.
 303               , |mpl_eval_if|_\<
 304                     |boost_is_same|_\<
 305                         typename Tag\:\:qualifier
 306                       , boost::parameter::in_reference
 307                     >
 308                   , |mpl_true|_\  // Enable this overload for "in" references.
 309                   , |mpl_if|_\<
 310                         |boost_is_same|_\<
 311                             typename Tag\:\:qualifier
 312                           , boost::parameter::forward_reference
 313                         >
 314                       , |mpl_true|_\  // Enable this overload for "forward" references.
 315                       , |mpl_false|_\  // Disable this overload for all other reference categories.
 316                     >
 317                 >
 318             >::type
 319           , |ArgumentPack|_
 320         >::type
 321             |assignment operator|_\(T const& value) const;
 322
 323         template <typename T>
 324         constexpr typename |boost_enable_if|_\<
 325             typename |mpl_eval_if|_\<
 326                 typename |mpl_eval_if|_\<
 327                     |boost_is_same|_\<
 328                         typename Tag\:\:qualifier
 329                       , boost::parameter::out_reference
 330                     >
 331                   , |mpl_true|_\  // The reference category is "out".
 332                   , |mpl_if|_\<
 333                         |boost_is_same|_\<
 334                             typename Tag\:\:qualifier
 335                           , boost::parameter::forward_reference
 336                         >
 337                       , |mpl_true|_\  // The reference category is "forward".
 338                       , |mpl_false|_\  // The reference category is neither "out" nor "forward".
 339                     >
 340                 >::type
 341               , |mpl_if|_\<
 342                     |boost_is_const|_\<T>
 343                   , |mpl_false|_\  // Disable this overload for reference-to-const types.
 344                   , |mpl_true|_\  // Enable this overload for referece-to-mutable types.
 345                 >
 346               , |mpl_false|_\  // Disable this overload for references neither "out" nor "forward".
 347             >::type
 348           , |ArgumentPack|_
 349         >::type
 350             |assignment operator|_\(T& value) const;
 351
 352         template <typename T>
 353         constexpr typename |boost_enable_if|_\<
 354             typename |mpl_eval_if|_\<
 355                 |boost_is_scalar|_\<T>
 356               , |mpl_false|_\  // Disable this overload for scalar types.
 357               , |mpl_eval_if|_\<
 358                     |boost_is_same|_\<
 359                         typename Tag\:\:qualifier
 360                       , boost::parameter::in_reference
 361                     >
 362                   , |mpl_true|_\  // Enable this overload for "in" references.
 363                   , |mpl_if|_\<
 364                         |boost_is_same|_\<
 365                             typename Tag\:\:qualifier
 366                           , boost::parameter::forward_reference
 367                         >
 368                       , |mpl_true|_\  // Enable this overload for "forward" references.
 369                       , |mpl_false|_\  // Disable this overload for all other reference categories.
 370                     >
 371                 >
 372             >::type
 373           , |ArgumentPack|_
 374         >::type
 375             |assignment operator|_\(T const&& value) const;
 376
 377         template <typename T>
 378         constexpr typename |boost_enable_if|_\<
 379             typename |mpl_eval_if|_\<
 380                 |boost_is_scalar|_\<T>
 381               , |mpl_false|_\  // Disable this overload for scalar types.
 382               , |mpl_eval_if|_\<
 383                     |boost_is_same|_\<
 384                         typename Tag\:\:qualifier
 385                       , boost::parameter::consume_reference
 386                     >
 387                   , |mpl_true|_\  // Enable this overload for "consume" references.
 388                   , |mpl_if|_\<
 389                         |boost_is_same|_\<
 390                             typename Tag\:\:qualifier
 391                           , boost::parameter::forward_reference
 392                         >
 393                       , |mpl_true|_\  // Enable this overload for "forward" references.
 394                       , |mpl_false|_\  // Disable this overload for all other reference categories.
 395                     >
 396                 >
 397             >::type
 398           , |ArgumentPack|_
 399         >::type
 400             |assignment operator|_\(T&& value) const;
 401
 402         template <typename T>
 403         constexpr typename |boost_enable_if|_\<
 404             typename |mpl_eval_if|_\<
 405                 |boost_is_scalar|_\<T>
 406               , |mpl_true|_\  // Enable this overload for scalar types.
 407               , |mpl_eval_if|_\<
 408                     |boost_is_same|_\<
 409                         typename Tag\:\:qualifier
 410                       , boost::parameter::in_reference
 411                     >
 412                   , |mpl_true|_\  // Enable this overload for "in" references.
 413                   , |mpl_if|_\<
 414                         |boost_is_same|_\<
 415                             typename Tag\:\:qualifier
 416                           , boost::parameter::forward_reference
 417                         >
 418                       , |mpl_true|_\  // Enable this overload for "forward" references.
 419                       , |mpl_false|_\  // Disable this overload for all other reference categories.
 420                     >
 421                 >
 422             >::type
 423           , *tagged default*
 424         >::type
 425             |bitwise or operator|_\(T const& x) const;
 426
 427         template <typename T>
 428         constexpr typename |boost_enable_if|_\<
 429             typename |mpl_eval_if|_\<
 430                 typename |mpl_eval_if|_\<
 431                     |boost_is_same|_\<
 432                         typename Tag\:\:qualifier
 433                       , boost::parameter::out_reference
 434                     >
 435                   , |mpl_true|_\  // The reference category is "out".
 436                   , |mpl_if|_\<
 437                         |boost_is_same|_\<
 438                             typename Tag\:\:qualifier
 439                           , boost::parameter::forward_reference
 440                         >
 441                       , |mpl_true|_\  // The reference category is "forward".
 442                       , |mpl_false|_\  // The reference category is neither "out" nor "forward".
 443                     >
 444                 >::type
 445               , |mpl_if|_\<
 446                     |boost_is_const|_\<T>
 447                   , |mpl_false|_\  // Disable this overload for reference-to-const types.
 448                   , |mpl_true|_\  // Enable this overload for referece-to-mutable types.
 449                 >
 450               , |mpl_false|_\  // Disable this overload for references neither "out" nor "forward".
 451             >::type
 452           , *tagged default*
 453         >::type
 454             |bitwise or operator|_\(T& x) const;
 455
 456         template <typename T>
 457         constexpr typename |boost_enable_if|_\<
 458             typename |mpl_eval_if|_\<
 459                 |boost_is_scalar|_\<T>
 460               , |mpl_false|_\  // Disable this overload for scalar types.
 461               , |mpl_eval_if|_\<
 462                     |boost_is_same|_\<
 463                         typename Tag\:\:qualifier
 464                       , boost::parameter::in_reference
 465                     >
 466                   , |mpl_true|_\  // Enable this overload for "in" references.
 467                   , |mpl_if|_\<
 468                         |boost_is_same|_\<
 469                             typename Tag\:\:qualifier
 470                           , boost::parameter::forward_reference
 471                         >
 472                       , |mpl_true|_\  // Enable this overload for "forward" references.
 473                       , |mpl_false|_\  // Disable this overload for all other reference categories.
 474                     >
 475                 >
 476             >::type
 477           , *tagged default*
 478         >::type
 479             |bitwise or operator|_\(T const&& x) const;
 480
 481         template <typename T>
 482         constexpr typename |boost_enable_if|_\<
 483             typename |mpl_eval_if|_\<
 484                 |boost_is_scalar|_\<T>
 485               , |mpl_false|_\  // Disable this overload for scalar types.
 486               , |mpl_eval_if|_\<
 487                     |boost_is_same|_\<
 488                         typename Tag\:\:qualifier
 489                       , boost::parameter::consume_reference
 490                     >
 491                   , |mpl_true|_\  // Enable this overload for "consume" references.
 492                   , |mpl_if|_\<
 493                         |boost_is_same|_\<
 494                             typename Tag\:\:qualifier
 495                           , boost::parameter::forward_reference
 496                         >
 497                       , |mpl_true|_\  // Enable this overload for "forward" references.
 498                       , |mpl_false|_\  // Disable this overload for all other reference categories.
 499                     >
 500                 >
 501             >::type
 502           , *tagged default*
 503         >::type constexpr
 504             |bitwise or operator|_\(T&& value) const;
 505
 506         template <typename F>
 507         constexpr *tagged lazy default* |logical or operator|_\(F const&) const;
 508
 509         template <typename F>
 510         constexpr *tagged lazy default* |logical or operator|_\(F&) const;
 511
 512         static keyword<Tag> const& instance;
 513
 514         static keyword<Tag>& get_\();
 515     };
 516
 517 .. |assignment operator| replace:: ``operator=``
 518 .. _assignment operator:
 519
 520 ``operator=``
 521
 522 :Synopsis:
 523
 524 .. parsed-literal::
 525
 526     template <typename T>
 527     constexpr |ArgumentPack|_ operator=(T const& value) const;
 528
 529     template <typename T>
 530     constexpr |ArgumentPack|_ operator=(T& value) const;
 531
 532     template <typename T>
 533     constexpr |ArgumentPack|_ operator=(T const&& value) const;
 534
 535     template <typename T>
 536     constexpr |ArgumentPack|_ operator=(T&& value) const;
 537
 538 :Requires: one of the following:
 539
 540 *   The nested ``qualifier`` type of ``Tag`` must be ``forward_reference``.
 541 *   To use the ``const`` lvalue reference overload, ``T`` must be scalar, or
 542     the nested ``qualifier`` type of ``Tag`` must be ``in_reference``.
 543 *   To use the mutable lvalue reference overload, the nested ``qualifier``
 544     type of ``Tag`` must be ``out_reference`` or ``in_out_reference``, and
 545     ``T`` must not be ``const``-qualified.
 546 *   To use the ``const`` rvalue reference overload for non-scalar ``T``, the
 547     nested ``qualifier`` type of ``Tag`` must be ``in_reference``.
 548 *   To use the mutable rvalue reference overload for non-scalar ``T``, the
 549     nested ``qualifier`` type of ``Tag`` must be ``consume_reference`` or
 550     ``move_from_reference``.
 551
 552 :Returns: an |ArgumentPack|_  containing a single |tagged reference| to
 553     ``value`` with |kw|_ ``Tag``
 554
 555 .. |bitwise or operator| replace:: ``operator|``
 556 .. _bitwise or operator:
 557
 558 ``operator|``
 559
 560 :Synopsis:
 561
 562 .. parsed-literal::
 563
 564     template <typename T>
 565     constexpr *tagged default* operator|(T const& x) const;
 566
 567     template <typename T>
 568     constexpr *tagged default* operator|(T& x) const;
 569
 570     template <typename T>
 571     constexpr *tagged default* operator|(T const&& x) const;
 572
 573     template <typename T>
 574     constexpr *tagged default* operator|(T&& x) const;
 575
 576 :Requires: one of the following:
 577
 578 *   The nested ``qualifier`` type of ``Tag`` must be ``forward_reference``.
 579 *   To use the ``const`` lvalue reference overload, ``T`` must be scalar, or
 580     the nested ``qualifier`` type of ``Tag`` must be ``in_reference``.
 581 *   To use the mutable lvalue reference overload, the nested ``qualifier``
 582     type of ``Tag`` must be ``out_reference`` or ``in_out_reference``, and
 583     ``T`` must not be ``const``-qualified.
 584 *   To use the ``const`` rvalue reference overload for non-scalar ``T``, the
 585     nested ``qualifier`` type of ``Tag`` must be ``in_reference``.
 586 *   To use the mutable rvalue reference overload for non-scalar ``T``, the
 587     nested ``qualifier`` type of ``Tag`` must be ``consume_reference`` or
 588     ``move_from_reference``.
 589
 590 :Returns: a |tagged default| with *value* ``x`` and |kw|_ ``Tag``.
 591
 592 .. |logical or operator| replace:: ``operator||``
 593 .. _logical or operator:
 594
 595 ``operator||``
 596
 597 :Synopsis:
 598
 599 .. parsed-literal::
 600
 601     template <typename F>
 602     constexpr *tagged lazy default* operator||(F const& g) const;
 603
 604     template <typename F>
 605     constexpr *tagged lazy default* operator||(F& g) const;
 606
 607 :Requires: ``g()`` must be valid, with type
 608     |boost_result_of|_\ ``<F()>::type``.  [#no_result_of]_
 609
 610 :Returns: a |tagged lazy default| with *value* ``g`` and |kw|_ ``Tag``.
 611
 612 .. _instance:
 613
 614 ``instance``
 615
 616 :Synopsis:
 617
 618 .. parsed-literal::
 619
 620     static keyword<Tag> const& instance;
 621
 622 :Returns: a “singleton instance”: the same object will be returned on each
 623     invocation of ``instance``.
 624
 625 :Thread Safety:
 626     ``instance`` can be accessed from multiple threads simultaneously.
 627
 628 .. _get:
 629
 630 ``get``
 631
 632 :Synopsis:
 633
 634 .. parsed-literal::
 635
 636     static keyword<Tag>& get\();
 637
 638 .. admonition:: Deprecated
 639
 640     This function has been deprecated in favor of ``instance``.
 641
 642 :Returns: a “singleton instance”: the same object will be returned on each
 643     invocation of ``get()``.
 644
 645 :Thread Safety: ``get()`` can be called from multiple threads simultaneously.
 646
 647 .. |template_keyword| replace:: ``template_keyword``
 648 .. _template_keyword:
 649
 650 ``template_keyword``
 651 --------------------
 652
 653 This class template encapsulates a named template parameter.  Every type
 654 generated by the |BOOST_PARAMETER_TEMPLATE_KEYWORD|_ macro is a specialization
 655 of |template_keyword|.
 656
 657 :Defined in: |template_keyword_header|_
 658
 659 .. parsed-literal::
 660
 661     template <typename Tag, typename T>
 662     struct template_keyword
 663     {
 664         typedef Tag key_type;
 665         typedef T value_type;
 666         typedef *implementation defined* reference;
 667     };
 668
 669 The |ntp_cpp|_ test program demonstrates proper usage of this class template.
 670
 671 .. |parameters| replace:: ``parameters``
 672 .. _parameters:
 673
 674 ``parameters``
 675 --------------
 676
 677 Provides an interface for assembling the actual arguments to a `forwarding
 678 function` into an |ArgumentPack|, in which any |positional| arguments will be
 679 tagged according to the corresponding template argument to ``parameters``.
 680
 681 .. _forwarding function: `forwarding functions`_
 682
 683 :Defined in: |parameters_header|_
 684
 685 .. parsed-literal::
 686
 687     template <typename ...PSpec>
 688     struct parameters
 689     {
 690         template <typename ...Args>
 691         struct |match|_
 692         {
 693             typedef … type;
 694         };
 695
 696         template <typename ...Args>
 697         |ArgumentPack|_ |function call operator|_\(Args&&... args) const;
 698     };
 699
 700 :Requires: Each element in the ``PSpec`` parameter pack must be a model of
 701     |ParameterSpec|_.
 702
 703 .. Note::
 704
 705     In this section, ``R`` ## *i* and ``K`` ## *i* are defined as
 706     follows, for any argument type ``A`` ## *i*:
 707
 708     | let ``D0`` the set [d0, …, d ## *j*] of all **deduced**
 709     | *parameter specs* in the ``PSpec`` parameter pack
 710     | ``R`` ## *i* is the |intended argument type| of ``A`` ## *i*
 711     |
 712     | if ``A`` ## *i* is a result type of ``keyword<T>::`` |assignment operator|_
 713     | then
 714     |     ``K`` ## *i* is ``T``
 715     | else
 716     |     if some ``A`` ## *j* where *j* ≤ *i* is a result type of
 717     |     ``keyword<T>::`` |assignment operator|_
 718     |     *or* some ``P`` ## *j* in *j* ≤ *i* is **deduced**
 719     |     then
 720     |         if some *parameter spec* ``d`` ## *j* in ``D`` ## *i*
 721     |         matches ``A`` ## *i*
 722     |         then
 723     |             ``K`` ## *i* is the |keyword tag type| of ``d`` ## *j*.
 724     |             ``D``:sub:`i+1` is ``D`` ## *i* - [ ``d`` ## *j*]
 725     |     else
 726     |         ``K`` ## *i* is the |keyword tag type| of ``P`` ## *i*.
 727
 728 .. |match| replace:: ``match``
 729 .. _match:
 730
 731 ``match``
 732     A `Metafunction`_ used to remove a `forwarding function`_ from overload
 733     resolution.
 734
 735 :Returns: if all elements in ``Params...`` are *satisfied* (see below), then
 736     ``parameters<Params...>``.  Otherwise, ``match<Args...>::type`` is not
 737     defined.
 738
 739 Each element ``P`` in ``Params...`` is **satisfied** if either:
 740
 741 * ``P`` is the *unspecified* default
 742 * **or**, ``P`` is a *keyword tag type*
 743 * **or**, ``P`` is |optional|_ ``<X,F>`` and either
 744     - ``X`` is not ``K`` ## *i* for any *i*,
 745     - **or** ``X`` is some ``K`` ## *i*  and ``mpl::apply<F,R`` ## *i*\
 746         ``>::type::value`` is ``true``
 747 * **or**, ``P`` is |required|_ ``<X,F>``, and
 748     - ``X`` is some ``K`` ## *i*, **and**
 749     - ``mpl::apply<F,R`` ## *i* ``>::type::value`` is ``true``
 750
 751 .. |function call operator| replace:: ``operator()``
 752 .. _function call operator:
 753
 754 ``operator()``
 755
 756 :Synopsis:
 757
 758 .. parsed-literal::
 759
 760     template <typename ...Args>
 761     |ArgumentPack|_ operator()(Args&&... args) const;
 762
 763 :Returns: An |ArgumentPack|_ containing, for each ``a`` ## *i*,
 764
 765     - if ``a`` ## *i*  is a single-element |ArgumentPack|, its element
 766     - Otherwise, a |tagged reference| with |kw|_ ``K`` ## *i* and *value*
 767         ``a`` ## *i*
 768
 769 .. |optional| replace:: ``optional``
 770 .. |required| replace:: ``required``
 771
 772 .. _optional:
 773 .. _required:
 774
 775 ``optional``, ``required``
 776 --------------------------
 777
 778 These templates describe the requirements on a function parameter.
 779
 780 ``optional`` is defined in: |optional_header|_
 781
 782 ``required`` is defined in: |required_header|_
 783
 784 Both headers are included by: |preprocessor_header|_
 785
 786 :Specializations model: |ParameterSpec|_
 787
 788 .. parsed-literal::
 789
 790     template <typename Tag, typename Predicate = *unspecified*>
 791     struct optional;
 792
 793     template <typename Tag, typename Predicate = *unspecified*>
 794     struct required;
 795
 796 The default value of ``Predicate`` is an unspecified `MPL Binary Metafunction
 797 Class`_ that returns ``mpl::true_`` for any argument.  If
 798 |BOOST_PARAMETER_CAN_USE_MP11|_ is defined, then the default value of
 799 ``Predicate`` is also a |Boost_MP11|_-style quoted metafunction that returns
 800 ``mp11::mp_true`` for any argument.
 801
 802 .. |deduced| replace:: ``deduced``
 803 .. _deduced:
 804
 805 ``deduced``
 806 -----------
 807
 808 This template is used to wrap the *keyword tag* argument to
 809 ``optional`` or ``required``.
 810
 811 :Defined in: |deduced_header|_
 812 :Included by: |preprocessor_header|_
 813
 814 .. parsed-literal::
 815
 816     template <typename Tag>
 817     struct deduced;
 818
 819 :Requires: nothing
 820
 821 //////////////////////////////////////////////////////////////////////////////
 822
 823 Metafunctions
 824 =============
 825
 826 A `Metafunction`_ is conceptually a function that operates on, and returns,
 827 C++ types.
 828
 829 .. |binding| replace:: ``binding``
 830 .. _binding:
 831
 832 ``binding``
 833 -----------
 834
 835 Returns the result type of indexing an argument pack with a
 836 |keyword tag type| or with a |tagged default|.
 837
 838 :Defined in: |binding_header|_
 839
 840 .. parsed-literal::
 841
 842     template <typename A, typename K, typename D = void\_>
 843     struct binding
 844     {
 845         typedef … type;
 846     };
 847
 848 :Requires: ``A`` must be a model of |ArgumentPack|_.
 849
 850 :Returns: the reference type of the |tagged reference| in ``A`` having
 851     |keyword tag type| ``K``, if any.  If no such |tagged reference| exists,
 852     returns ``D``.
 853
 854 .. |lazy_binding| replace:: ``lazy_binding``
 855 .. _lazy_binding:
 856
 857 ``lazy_binding``
 858 ----------------
 859
 860 Returns the result type of indexing an argument pack with a
 861 |tagged lazy default|.
 862
 863 :Defined in: |binding_header|_
 864
 865 .. parsed-literal::
 866
 867     template <typename A, typename K, typename F>
 868     struct lazy_binding
 869     {
 870         typedef … type;
 871     };
 872
 873 :Requires: ``A`` must be a model of |ArgumentPack|_.
 874
 875 :Returns: the reference type of the |tagged reference| in ``A`` having
 876     |keyword tag type| ``K``, if any.  If no such |tagged reference| exists,
 877     returns |boost_result_of|_\ ``<F()>::type``. [#no_result_of]_
 878
 879 .. |value_type| replace:: ``value_type``
 880 .. _value_type:
 881
 882 ``value_type``
 883 --------------
 884
 885 Returns the result type of indexing an argument pack with a
 886 |keyword tag type| or with a |tagged default|.
 887
 888 :Defined in: |value_type_header|_
 889
 890 .. parsed-literal::
 891
 892     template <typename A, typename K, typename D = void\_>
 893     struct value_type
 894     {
 895         typedef … type;
 896     };
 897
 898 :Requires: ``A`` must be a model of |ArgumentPack|_.
 899
 900 :Returns: the (possibly const-qualified) type of the |tagged reference| in
 901     ``A`` having |keyword tag type| ``K``, if any.  If no such
 902     |tagged reference| exists, returns ``D``.  Equivalent to:
 903
 904     .. parsed-literal::
 905
 906         typename |boost_remove_reference|_\<
 907             typename |binding|_\<A, K, D>::type
 908         >::type
 909
 910     … when ``D`` is not a reference type.
 911
 912 .. |lazy_value_type| replace:: ``lazy_value_type``
 913 .. _lazy_value_type:
 914
 915 ``lazy_value_type``
 916 -------------------
 917
 918 Returns the result type of indexing an argument pack with a
 919 |tagged lazy default|.
 920
 921 :Defined in: |value_type_header|_
 922
 923 .. parsed-literal::
 924
 925     template <typename A, typename K, typename F>
 926     struct lazy_value_type
 927     {
 928         typedef … type;
 929     };
 930
 931 :Requires: ``A`` must be a model of |ArgumentPack|_.
 932
 933 :Returns: the (possibly const-qualified) type of the |tagged reference| in
 934     ``A`` having |keyword tag type| ``K``, if any.  If no such
 935     |tagged reference| exists, returns
 936     |boost_result_of|_\ ``<F()>::type``. [#no_result_of]_
 937
 938 .. |are_tagged_arguments| replace:: ``are_tagged_arguments``
 939 .. _are_tagged_arguments:
 940
 941 ``are_tagged_arguments``
 942 ------------------------
 943
 944 :Defined in: |are_tagged_arguments_header|_
 945
 946 .. parsed-literal::
 947
 948     template <typename T0, typename ...Pack>
 949     struct are_tagged_arguments
 950         // : |mpl_true|_\  if T0 and all elements in Pack are
 951         // tagged reference types, |mpl_false|_\  otherwise.
 952     {
 953     };
 954
 955 :Returns:
 956     ``mpl::true_`` if ``T0`` and all elements in parameter pack ``Pack`` are
 957     |tagged reference| types, ``mpl::false_`` otherwise.
 958
 959 :Example usage:
 960
 961 When implementing a Boost.Parameter-enabled constructor for a container that
 962 conforms to the C++ standard, one needs to remember that the standard requires
 963 the presence of other constructors that are typically defined as templates,
 964 such as range constructors.  To avoid overload ambiguities between the two
 965 constructors, use this metafunction in conjunction with ``disable_if`` to
 966 define the range constructor.
 967
 968 .. parsed-literal::
 969
 970     template <typename B>
 971     class frontend : public B
 972     {
 973         struct _enabler
 974         {
 975         };
 976
 977      public:
 978         |BOOST_PARAMETER_NO_SPEC_CONSTRUCTOR|_\(frontend, (B))
 979
 980         template <typename Iterator>
 981         frontend(
 982             Iterator itr
 983           , Iterator itr_end
 984           , typename |boost_disable_if|_\<
 985                 are_tagged_arguments<Iterator>
 986               , _enabler
 987             >::type = _enabler()
 988         ) : B(itr, itr_end)
 989         {
 990         }
 991     };
 992
 993 .. |is_argument_pack| replace:: ``is_argument_pack``
 994 .. _is_argument_pack:
 995
 996 ``is_argument_pack``
 997 --------------------
 998
 999 :Defined in: |is_argument_pack_header|_
1000
1001 .. parsed-literal::
1002
1003     template <typename T>
1004     struct is_argument_pack
1005         // : |mpl_true|_\  if T is a model of |ArgumentPack|_\,
1006         // |mpl_false|_\  otherwise.
1007     {
1008     };
1009
1010 :Returns:
1011     ``mpl::true_`` if ``T`` is a model of |ArgumentPack|_, ``mpl::false_``
1012     otherwise.
1013
1014 :Example usage:
1015
1016 To avoid overload ambiguities between a constructor that takes in an
1017 |ArgumentPack|_ and a templated conversion constructor, use this
1018 metafunction in conjunction with ``enable_if``.
1019
1020 .. parsed-literal::
1021
1022     |BOOST_PARAMETER_NAME|_\(a0)
1023
1024     template <typename T>
1025     class backend0
1026     {
1027         struct _enabler
1028         {
1029         };
1030
1031         T a0;
1032
1033      public:
1034         template <typename ArgPack>
1035         explicit backend0(
1036             ArgPack const& args
1037           , typename |boost_enable_if|_\<
1038                 is_argument_pack<ArgPack>
1039               , _enabler
1040             >::type = _enabler()
1041         ) : a0(args[_a0])
1042         {
1043         }
1044
1045         template <typename U>
1046         backend0(
1047             backend0<U> const& copy
1048           , typename |boost_enable_if|_\<
1049                 |boost_is_convertible|_\<U,T>
1050               , _enabler
1051             >::type = _enabler()
1052         ) : a0(copy.get_a0())
1053         {
1054         }
1055
1056         T const& get_a0() const
1057         {
1058             return this->a0;
1059         }
1060     };
1061
1062 .. |result_of_compose| replace:: ``result_of::compose``
1063 .. _result_of_compose:
1064
1065 ``result_of::compose``
1066 ----------------------
1067
1068 Returns the result type of the |compose|_ function.
1069
1070 :Defined in: |compose_header|_
1071
1072 .. parsed-literal::
1073
1074     template <typename ...TaggedArgs>
1075     struct compose
1076       : |boost_enable_if|_\<
1077             |are_tagged_arguments|_\<T0,Pack...>
1078           , |ArgumentPack|_
1079         >
1080     {
1081     };
1082
1083     template <>
1084     struct compose<>
1085     {
1086         typedef *empty* |ArgumentPack|_ type;
1087     };
1088
1089 :Requires: All elements in ``TaggedArgs`` must be |tagged reference| types, if
1090     specified.
1091
1092 :Returns: the result type of the |compose|_ function.
1093
1094 //////////////////////////////////////////////////////////////////////////////
1095
1096 Function Templates
1097 ==================
1098
1099 .. |compose| replace:: ``compose``
1100 .. _compose:
1101
1102 ``compose``
1103 -----------
1104
1105 :Defined in: |compose_header|_
1106
1107 .. parsed-literal::
1108
1109     template <typename ...Pack>
1110     constexpr typename |result_of_compose|_\<Pack...>::type
1111         compose(Pack const&... args);
1112
1113 This function facilitates easier variadic argument composition.  It is used by
1114 the |BOOST_PARAMETER_NO_SPEC_FUNCTION|_,
1115 |BOOST_PARAMETER_NO_SPEC_MEMBER_FUNCTION|_,
1116 |BOOST_PARAMETER_NO_SPEC_CONST_MEMBER_FUNCTION|_,
1117 |BOOST_PARAMETER_NO_SPEC_FUNCTION_CALL_OPERATOR|_,
1118 |BOOST_PARAMETER_NO_SPEC_CONST_FUNCTION_CALL_OPERATOR|_,
1119 |BOOST_PARAMETER_NO_SPEC_CONSTRUCTOR|_, and
1120 |BOOST_PARAMETER_NO_SPEC_NO_BASE_CONSTRUCTOR|_ code generation macros.  You
1121 can use it to write your own code generation macros if the ones provided by
1122 this library do not suffice.
1123
1124 Unlike the |tagged reference| comma operator, the ``compose()`` function is
1125 variadic, as mentioned before.  However, the |tagged reference| comma operator
1126 can be invoked indefinitely and therefore does not limit the size of the
1127 resulting |ArgumentPack|, while the ``compose()`` function cannot take in more
1128 than |BOOST_PARAMETER_COMPOSE_MAX_ARITY|_ arguments for compilers that do not
1129 support perfect forwarding.
1130
1131 :Requires: All elements in ``args`` must be |tagged reference| objects, if
1132     specified.
1133
1134 :Returns: an |ArgumentPack|_ containing all elements in ``args``, if
1135     specified; an empty |ArgumentPack|_ otherwise.
1136
1137 :Example usage:
1138
1139 .. parsed-literal::
1140
1141     BOOST_PARAMETER_NAME(index)
1142     BOOST_PARAMETER_NAME(name)
1143
1144     template <typename ArgumentPack>
1145     int print_name_and_index(ArgumentPack const& args)
1146     {
1147         std::cout << "index = " << args[_index];
1148         std::cout << "name = " << args[_name];
1149         std::cout << "; " << std::endl;
1150         return 0;
1151     }
1152
1153     int y = print_name_and_index(compose(_index = 3, _name = "jones"));
1154
1155 The |compose_cpp|_ test program shows more examples using this function.
1156
1157 //////////////////////////////////////////////////////////////////////////////
1158
1159 Code Generation Macros
1160 ======================
1161
1162 Macros in this section can be used to ease the writing of code
1163 using the Parameter library by eliminating repetitive boilerplate.
1164
1165 .. |BOOST_PARAMETER_FUNCTION| replace:: ``BOOST_PARAMETER_FUNCTION``
1166 .. _BOOST_PARAMETER_FUNCTION:
1167
1168 ``BOOST_PARAMETER_FUNCTION(result, name, tag_namespace, arguments)``
1169 --------------------------------------------------------------------
1170
1171 :Defined in: |preprocessor_header|_
1172
1173 Generates a function that can take in positional arguments, composed
1174 arguments, named arguments, and deduced arguments.
1175
1176 :Example usage:
1177
1178 The return type of each of the following function templates falls under a
1179 different value category.
1180
1181 .. parsed-literal::
1182
1183     template <std::size_t N>
1184     |std_bitset|_\<N + 1> rvalue_bitset()
1185     {
1186         return |std_bitset|_\<N + 1>();
1187     }
1188
1189     template <std::size_t N>
1190     |std_bitset|_\<N + 1> const rvalue_const_bitset()
1191     {
1192         return |std_bitset|_\<N + 1>();
1193     }
1194
1195     template <std::size_t N>
1196     |std_bitset|_\<N + 1>& lvalue_bitset()
1197     {
1198         static |std_bitset|_\<N + 1> lset = |std_bitset|_\<N + 1>();
1199         return lset;
1200     }
1201
1202     template <std::size_t N>
1203     |std_bitset|_\<N + 1> const& lvalue_const_bitset()
1204     {
1205         static |std_bitset|_\<N + 1> const clset = |std_bitset|_\<N + 1>();
1206         return clset;
1207     }
1208
1209 The ``U::evaluate_category`` static member function template has a simple job:
1210 to return the correct value category when passed in an object returned by one
1211 of the functions defined above.  Assume that
1212 |BOOST_PARAMETER_HAS_PERFECT_FORWARDING|_ is defined.
1213
1214 .. parsed-literal::
1215
1216     enum invoked
1217     {
1218         passed_by_lvalue_reference_to_const
1219       , passed_by_lvalue_reference
1220       , passed_by_rvalue_reference_to_const
1221       , passed_by_rvalue_reference
1222     };
1223
1224     struct U
1225     {
1226         template <std::size_t N>
1227         static invoked evaluate_category(|std_bitset|_\<N + 1> const&)
1228         {
1229             return passed_by_lvalue_reference_to_const;
1230         }
1231
1232         template <std::size_t N>
1233         static invoked evaluate_category(|std_bitset|_\<N + 1>&)
1234         {
1235             return passed_by_lvalue_reference;
1236         }
1237
1238         template <std::size_t N>
1239         static invoked evaluate_category(|std_bitset|_\<N + 1> const&&)
1240         {
1241             return passed_by_rvalue_reference_to_const;
1242         }
1243
1244         template <std::size_t N>
1245         static invoked evaluate_category(|std_bitset|_\<N + 1>&&)
1246         {
1247             return passed_by_rvalue_reference;
1248         }
1249     };
1250
1251 Define the named parameters that will comprise the argument specification that
1252 this macro will use.  Ensure that all their tag types are in the same
1253 namespace, which is ``kw`` in this case.  The identifiers with leading
1254 underscores can be passed to the bracket operator of ``args`` to extract the
1255 same argument to which the corresponding named parameter (without underscores)
1256 is bound, as will be shown later.
1257
1258 .. parsed-literal::
1259
1260     |BOOST_PARAMETER_NAME|_\((_lrc, kw) in(lrc))
1261     |BOOST_PARAMETER_NAME|_\((_lr, kw) in_out(lr))
1262     |BOOST_PARAMETER_NAME|_\((_rrc, kw) in(rrc))
1263     |BOOST_PARAMETER_NAME|_\((_rr, kw) consume(rr))
1264
1265 Use the macro as a substitute for a normal function header.  Enclose the
1266 return type ``bool`` in parentheses.  For each parameter, also enclose the
1267 expected value type in parentheses.  Since the value types are mutually
1268 exclusive, you can wrap the parameters in a ``(deduced …)``
1269 clause.  Otherwise, just as with a normal function, the order in which you
1270 specify the parameters determines their position.  Also, just as with a normal
1271 function, optional parameters have default values, whereas required parameters
1272 do not.  Within the function body, either simply use the parameter name or
1273 pass the matching identifier with the leading underscore to the bracket
1274 operator of ``args`` to extract the corresponding argument.  Note that the
1275 second method doesn't require ``std::forward`` to preserve value categories.
1276
1277 .. parsed-literal::
1278
1279     BOOST_PARAMETER_FUNCTION((bool), evaluate, kw,
1280         (deduced
1281             (required
1282                 (lrc, (|std_bitset|_\<1>))
1283                 (lr, (|std_bitset|_\<2>))
1284             )
1285             (optional
1286                 (rrc, (|std_bitset|_\<3>), rvalue_const_bitset<2>())
1287                 (rr, (|std_bitset|_\<4>), rvalue_bitset<3>())
1288             )
1289         )
1290     )
1291     {
1292         BOOST_TEST_EQ(
1293             passed_by_lvalue_reference_to_const
1294           , U::evaluate_category<0>(lrc)
1295         );
1296         BOOST_TEST_EQ(
1297             passed_by_lvalue_reference
1298           , U::evaluate_category<1>(lr)
1299         );
1300         BOOST_TEST_EQ(
1301             passed_by_rvalue_reference_to_const
1302           , U::evaluate_category<2>(|std_forward|_\<rrc0_type>(rrc0))
1303         );
1304         BOOST_TEST_EQ(
1305             passed_by_rvalue_reference
1306           , U::evaluate_category<3>(args[_rr0])
1307         );
1308
1309         return true;
1310     }
1311
1312 The following function calls are legal.
1313
1314 .. parsed-literal::
1315
1316     evaluate(  // positional arguments
1317         lvalue_const_bitset<0>()
1318       , lvalue_bitset<1>()
1319       , rvalue_const_bitset<2>()
1320       , rvalue_bitset<3>()
1321     );
1322     evaluate(  // positional arguments
1323         lvalue_const_bitset<0>()
1324       , lvalue_bitset<1>()
1325     );
1326     evaluate((  // composed arguments
1327         _rr0 = rvalue_bitset<3>()
1328       , _lrc0 = lvalue_const_bitset<0>()
1329       , _lr0 = lvalue_bitset<1>()
1330       , _rrc0 = rvalue_const_bitset<2>()
1331     ));
1332     evaluate(  // named arguments
1333         _rr0 = rvalue_bitset<3>()
1334       , _lrc0 = lvalue_const_bitset<0>()
1335       , _lr0 = lvalue_bitset<1>()
1336       , _rrc0 = rvalue_const_bitset<2>()
1337     );
1338     evaluate(  // named arguments
1339         _lr0 = lvalue_bitset<1>()
1340       , _lrc0 = lvalue_const_bitset<0>()
1341     );
1342
1343 Because the parameters were wrapped in a ``(deduced …)`` clause, the following
1344 function calls are also legal.
1345
1346 .. parsed-literal::
1347
1348     evaluate(  // deduced arguments
1349         rvalue_bitset<3>()
1350       , lvalue_const_bitset<0>()
1351       , lvalue_bitset<1>()
1352       , rvalue_const_bitset<2>()
1353     );
1354     evaluate(  // deduced arguments
1355         lvalue_bitset<1>()
1356       , lvalue_const_bitset<0>()
1357     );
1358
1359 The |preprocessor_cpp|_, |preprocessor_deduced_cpp|_, and
1360 |preprocessor_eval_cat_cpp|_ test programs demonstrate proper usage of this
1361 macro.
1362
1363 **Macro parameters:**
1364
1365 *   ``result`` is the parenthesized return type of the function.
1366 *   ``name`` is the base name of the function; it determines the name of the
1367     generated forwarding functions.
1368 *   ``tag_namespace`` is the namespace in which the keywords used by the
1369     function resides.
1370 *   ``arguments`` is a |Boost_Preprocessor|_ `sequence`_ of
1371     *argument-specifiers*, as defined below.
1372
1373 **Argument specifiers syntax:**
1374
1375 .. parsed-literal::
1376
1377     argument-specifiers ::= *specifier-group0* {*specifier-group0*\ }
1378
1379     specifier-group0 ::= *specifier-group1* |
1380         (
1381             '**(**' '**deduced**'
1382                 *specifier-group1* {*specifier-group1*\ }
1383             '**)**'
1384         )
1385
1386     specifier-group1 ::=
1387         (
1388             '**(**' '**optional**'
1389                 *optional-specifier* {*optional-specifier*\ }
1390             '**)**'
1391         ) | (
1392             '**(**' '**required**'
1393                 *required-specifier* {*required-specifier*\ }
1394             '**)**'
1395         )
1396
1397     optional-specifier ::=
1398         '**(**'
1399             *argument-name* '**,**' *restriction* '**,**' *default-value*
1400         ')'
1401
1402     required-specifier ::=
1403         '**(**' *argument-name* '**,**' *restriction* ')'
1404
1405     restriction ::=
1406         ( '**\***' '**(**' *mfc* '**)**' ) |
1407         ( '**(**' *type-name* '**)**' ) |
1408         '**\***'
1409
1410 *   ``argument-name`` is any valid C++ identifier.
1411 *   ``default-value`` is any valid C++ expression; if necessary, user code can
1412     compute it in terms of ``previous-name ## _type``, where ``previous-name``
1413     is the ``argument-name`` in a previous ``specifier-group0`` or
1414     ``specifier-group1``.  *This expression will be invoked exactly once.*
1415 *   ``mfc`` is an `MPL Binary Metafunction Class`_ whose first argument will
1416     be the type of the corresponding ``argument-name``, whose second argument
1417     will be the entire |ArgumentPack|_, and whose return type is a `Boolean
1418     Integral Constant`_; however, user code *cannot* compute ``mfc`` in terms
1419     of ``previous-name ## _type``.
1420 *   ``type-name`` is either the name of a **target type** or an `MPL Binary
1421     Metafunction Class`_ whose first argument will be the type of the
1422     corresponding ``argument-name``, whose second argument will be the entire
1423     |ArgumentPack|_, and whose return type is the **target type**.  If
1424     ``restriction`` uses this form, then the type of the generated name
1425     ``argument-name ## _type`` will be computed in terms of the **target
1426     type**, and the generated reference ``argument-name`` (but not its
1427     corresponding entry in ``args``) will be cast to that type.
1428
1429 **Approximate expansion:**
1430
1431 Where:
1432
1433 * ``n`` denotes the *minimum* arity, as determined from ``arguments``.
1434 * ``m`` denotes the *maximum* arity, as determined from ``arguments``.
1435
1436 .. parsed-literal::
1437
1438     // If **result** is a template instantiation of |boost_enable_if|_\,
1439     // |boost_enable_if_c|_\, |boost_lazy_enable_if|_\,
1440     // |boost_lazy_enable_if_c|_\, |boost_disable_if|_\, |boost_disable_if_c|_\,
1441     // |boost_lazy_disable_if|_\, |boost_lazy_disable_if_c|_\, or
1442     // |std_enable_if|_\:
1443     template <typename Args>
1444     using boost_param_result\_ ## __LINE__ ## **name** = **result**;
1445
1446     // If **result** is a simple return type:
1447     template <typename Args>
1448     struct boost_param_result\_ ## __LINE__ ## **name**
1449     {
1450         typedef **result** type;
1451     };
1452
1453     struct boost_param_params\_ ## __LINE__ ## **name**
1454       : |parameters|_\<
1455             *list of parameter specifications, based on arguments*
1456         >
1457     {
1458     };
1459
1460     typedef boost_param_params\_ ## __LINE__ ## **name**
1461         boost_param_parameters\_ ## __LINE__ ## **name**;
1462
1463     template <typename Args>
1464     typename boost_param_result\_ ## __LINE__ ## **name**\ <Args>::type
1465         boost_param_impl ## __LINE__ ## **name**\ (Args const&);
1466
1467     template <typename A0, …, typename A ## **n**>
1468     **result** **name**\ (
1469         A0&& a0, …, A ## **n**\ && a ## **n**
1470       , typename boost_param_parameters\_ ## __LINE__ ## **name**
1471         ::match<A0, …, A ## **n**>::type
1472         = boost_param_parameters\_ ## __LINE__ ## **name**\ ()
1473     )
1474     {
1475         return boost_param_impl ## __LINE__ ## **name**\ (
1476             boost_param_parameters\_ ## __LINE__ ## **name**\ ()(
1477                 |std_forward|_\<A0>(a0)
1478               , …
1479               , |std_forward|_\<A ## **n**>(a ## **n**)
1480             )
1481         );
1482     }
1483
1484     :vellipsis:`⋮`
1485
1486     template <typename A0, …, typename A ## **m**>
1487     **result** **name**\ (
1488         A0&& a0, …, A ## **m**\ && a ## **m**
1489       , typename boost_param_parameters\_ ## __LINE__ ## **name**
1490         ::match<A0, …, A ## **m**>::type
1491         = boost_param_parameters\_ ## __LINE__ ## **name**\ ()
1492     )
1493     {
1494         return boost_param_impl ## __LINE__ ## **name**\ (
1495             boost_param_parameters\_ ## __LINE__ ## **name**\ ()(
1496                 |std_forward|_\<A0>(a0)
1497               , …
1498               , |std_forward|_\<A ## **m**>(a ## **m**)
1499             )
1500         );
1501     }
1502
1503     template <
1504         typename ResultType
1505       , typename Args
1506       , typename *argument name* ## **0** ## _type
1507       , …
1508       , typename *argument name* ## **n** ## _type
1509     >
1510     ResultType
1511         boost_param_dispatch_0boost\_ ## __LINE__ ## **name**\ (
1512             (ResultType(*)())
1513           , Args const& args
1514           , *argument name* ## **0** ## _type&& *argument name* ## **0**
1515           , …
1516           , *argument name* ## **n** ## _type&& *argument name* ## **m**
1517         );
1518
1519     :vellipsis:`⋮`
1520
1521     template <
1522         typename ResultType
1523       , typename Args
1524       , typename *argument name* ## **0** ## _type
1525       , …
1526       , typename *argument name* ## **m** ## _type
1527     >
1528     ResultType
1529         boost_param_dispatch_0boost\_ ## __LINE__ ## **name**\ (
1530             (ResultType(*)())
1531           , Args const& args
1532           , *argument name* ## **0** ## _type&& *argument name* ## **0**
1533           , …
1534           , *argument name* ## **m** ## _type&& *argument name* ## **m**
1535         );
1536
1537     template <typename Args>
1538     typename boost_param_result\_ ## __LINE__ ## **name**\ <Args>::type
1539         boost_param_impl ## __LINE__ ## **name**\ (Args const& args)
1540     {
1541         return boost_param_dispatch_0boost\_ ## __LINE__ ## **name**\ (
1542             static_cast<
1543                 typename boost_param_result\_ ## __LINE__ ## **name**\ <
1544                     Args
1545                 >::type(*)()
1546             >(|std_nullptr|_\)
1547           , args
1548           , |std_forward|_\<
1549                 typename |value_type|_\<
1550                     Args
1551                   , *keyword tag type of required parameter* ## **0**
1552                 >::type
1553             >(args[ *keyword object of required parameter* ## **0**])
1554           , …
1555           , |std_forward|_\<
1556                 typename |value_type|_\<
1557                     Args
1558                   , *keyword tag type of required parameter* ## **n**
1559                 >::type
1560             >(args[ *keyword object of required parameter* ## **n**])
1561         );
1562     }
1563
1564     template <
1565         typename ResultType
1566       , typename Args
1567       , typename *argument name* ## **0** ## _type
1568       , …
1569       , typename *argument name* ## **n** ## _type
1570     >
1571     ResultType
1572         boost_param_dispatch_0boost\_ ## __LINE__ ## **name**\ (
1573             (ResultType(*)())
1574           , Args const& args
1575           , *argument name* ## **0** ## _type&& *argument name* ## **0**
1576           , …
1577           , *argument name* ## **n** ## _type&& *argument name* ## **n**
1578         )
1579     {
1580         return boost_param_dispatch_0boost\_ ## __LINE__ ## **name**\ (
1581             static_cast<ResultType(*)()>(|std_nullptr|_\)
1582           , (args, *keyword object of optional parameter* ## **n + 1** =
1583                 *default value of optional parameter* ## **n + 1**
1584             )
1585           , |std_forward|_\<*argument name* ## **0** ## _type>(
1586                 *argument name* ## **0**
1587             )
1588           , …
1589           , |std_forward|_\<*argument name* ## **n** ## _type>(
1590                 *argument name* ## **n**
1591             )
1592           , |std_forward|_\<
1593                 typename |value_type|_\<
1594                     Args
1595                   , *keyword tag type of optional parameter* ## **n + 1**
1596                 >::type
1597             >(*default value of optional parameter* ## **n + 1**)
1598         );
1599     }
1600
1601     :vellipsis:`⋮`
1602
1603     template <
1604         typename ResultType
1605       , typename Args
1606       , typename *argument name* ## **0** ## _type
1607       , …
1608       , typename *argument name* ## **m** ## _type
1609     >
1610     ResultType
1611         boost_param_dispatch_0boost\_ ## __LINE__ ## **name**\ (
1612             (ResultType(*)())
1613           , Args const& args
1614           , *argument name* ## **0** ## _type&& *argument name* ## **0**
1615           , …
1616           , *argument name* ## **m** ## _type&& *argument name* ## **m**
1617         )
1618
1619 .. |BOOST_PARAMETER_MEMBER_FUNCTION| replace:: ``BOOST_PARAMETER_MEMBER_FUNCTION``
1620 .. _BOOST_PARAMETER_MEMBER_FUNCTION:
1621
1622 ``BOOST_PARAMETER_MEMBER_FUNCTION(result, name, tag_namespace, arguments)``
1623 ---------------------------------------------------------------------------
1624
1625 :Defined in: |preprocessor_header|_
1626
1627 Generates a member function that can take in positional arguments, composed
1628 arguments, named arguments, and deduced arguments.
1629
1630 :Example usage:
1631
1632 The return type of each of the following function templates falls under a
1633 different value category.
1634
1635 .. parsed-literal::
1636
1637     template <std::size_t N>
1638     |std_bitset|_\<N + 1> rvalue_bitset()
1639     {
1640         return |std_bitset|_\<N + 1>();
1641     }
1642
1643     template <std::size_t N>
1644     |std_bitset|_\<N + 1> const rvalue_const_bitset()
1645     {
1646         return |std_bitset|_\<N + 1>();
1647     }
1648
1649     template <std::size_t N>
1650     |std_bitset|_\<N + 1>& lvalue_bitset()
1651     {
1652         static |std_bitset|_\<N + 1> lset = |std_bitset|_\<N + 1>();
1653         return lset;
1654     }
1655
1656     template <std::size_t N>
1657     |std_bitset|_\<N + 1> const& lvalue_const_bitset()
1658     {
1659         static |std_bitset|_\<N + 1> const clset = |std_bitset|_\<N + 1>();
1660         return clset;
1661     }
1662
1663 The ``U::evaluate_category`` static member function template has a simple job:
1664 to return the correct value category when passed in an object returned by one
1665 of the functions defined above.  Assume that
1666 |BOOST_PARAMETER_HAS_PERFECT_FORWARDING|_ is defined.
1667
1668 .. parsed-literal::
1669
1670     enum invoked
1671     {
1672         passed_by_lvalue_reference_to_const
1673       , passed_by_lvalue_reference
1674       , passed_by_rvalue_reference_to_const
1675       , passed_by_rvalue_reference
1676     };
1677
1678     struct U
1679     {
1680         template <std::size_t N>
1681         static invoked evaluate_category(|std_bitset|_\<N + 1> const&)
1682         {
1683             return passed_by_lvalue_reference_to_const;
1684         }
1685
1686         template <std::size_t N>
1687         static invoked evaluate_category(|std_bitset|_\<N + 1>&)
1688         {
1689             return passed_by_lvalue_reference;
1690         }
1691
1692         template <std::size_t N>
1693         static invoked evaluate_category(|std_bitset|_\<N + 1> const&&)
1694         {
1695             return passed_by_rvalue_reference_to_const;
1696         }
1697
1698         template <std::size_t N>
1699         static invoked evaluate_category(|std_bitset|_\<N + 1>&&)
1700         {
1701             return passed_by_rvalue_reference;
1702         }
1703     };
1704
1705 Define the named parameters that will comprise the argument specification that
1706 this macro will use.  Ensure that all their tag types are in the same
1707 namespace, which is ``kw`` in this case.  The identifiers with leading
1708 underscores can be passed to the bracket operator of ``args`` to extract the
1709 same argument to which the corresponding named parameter (without underscores)
1710 is bound, as will be shown later.
1711
1712 .. parsed-literal::
1713
1714     |BOOST_PARAMETER_NAME|_\((_lrc, kw) in(lrc))
1715     |BOOST_PARAMETER_NAME|_\((_lr, kw) in_out(lr))
1716     |BOOST_PARAMETER_NAME|_\((_rrc, kw) in(rrc))
1717     |BOOST_PARAMETER_NAME|_\((_rr, kw) consume(rr))
1718
1719 Use the macro as a substitute for a normal ``static`` member function
1720 header.  Enclose the return type ``bool`` in parentheses.  For each parameter,
1721 also enclose the expected value type in parentheses.  Since the value types
1722 are mutually exclusive, you can wrap the parameters in a ``(deduced …)``
1723 clause.  Otherwise, just as with a normal function, the order in which you
1724 specify the parameters determines their position.  Also, just as with a normal
1725 function, optional parameters have default values, whereas required parameters
1726 do not.  Within the function body, either simply use the parameter name or
1727 pass the matching identifier with the leading underscore to the bracket
1728 operator of ``args`` to extract the corresponding argument.  Note that the
1729 second method doesn't require ``std::forward`` to preserve value categories.
1730
1731 .. parsed-literal::
1732
1733     struct B
1734     {
1735         BOOST_PARAMETER_MEMBER_FUNCTION((bool), static evaluate, kw,
1736             (deduced
1737                 (required
1738                     (lrc, (|std_bitset|_\<1>))
1739                     (lr, (|std_bitset|_\<2>))
1740                 )
1741                 (optional
1742                     (rrc, (|std_bitset|_\<3>), rvalue_const_bitset<2>())
1743                     (rr, (|std_bitset|_\<4>), rvalue_bitset<3>())
1744                 )
1745             )
1746         )
1747         {
1748             BOOST_TEST_EQ(
1749                 passed_by_lvalue_reference_to_const
1750               , U::evaluate_category<0>(lrc)
1751             );
1752             BOOST_TEST_EQ(
1753                 passed_by_lvalue_reference
1754               , U::evaluate_category<1>(lr)
1755             );
1756             BOOST_TEST_EQ(
1757                 passed_by_rvalue_reference_to_const
1758               , U::evaluate_category<2>(|std_forward|_\<rrc0_type>(rrc0))
1759             );
1760             BOOST_TEST_EQ(
1761                 passed_by_rvalue_reference
1762               , U::evaluate_category<3>(args[_rr0])
1763             );
1764
1765             return true;
1766         }
1767     };
1768
1769 The following function calls are legal.
1770
1771 .. parsed-literal::
1772
1773     B::evaluate(  // positional arguments
1774         lvalue_const_bitset<0>()
1775       , lvalue_bitset<1>()
1776       , rvalue_const_bitset<2>()
1777       , rvalue_bitset<3>()
1778     );
1779     B::evaluate(  // positional arguments
1780         lvalue_const_bitset<0>()
1781       , lvalue_bitset<1>()
1782     );
1783     B::evaluate((  // composed arguments
1784         _rr0 = rvalue_bitset<3>()
1785       , _lrc0 = lvalue_const_bitset<0>()
1786       , _lr0 = lvalue_bitset<1>()
1787       , _rrc0 = rvalue_const_bitset<2>()
1788     ));
1789     B::evaluate(  // named arguments
1790         _rr0 = rvalue_bitset<3>()
1791       , _lrc0 = lvalue_const_bitset<0>()
1792       , _lr0 = lvalue_bitset<1>()
1793       , _rrc0 = rvalue_const_bitset<2>()
1794     );
1795     B::evaluate(  // named arguments
1796         _lr0 = lvalue_bitset<1>()
1797       , _lrc0 = lvalue_const_bitset<0>()
1798     );
1799
1800 Because the parameters were wrapped in a ``(deduced …)`` clause, the following
1801 function calls are also legal.
1802
1803 .. parsed-literal::
1804
1805     B::evaluate(  // deduced arguments
1806         rvalue_bitset<3>()
1807       , lvalue_const_bitset<0>()
1808       , lvalue_bitset<1>()
1809       , rvalue_const_bitset<2>()
1810     );
1811     B::evaluate(  // deduced arguments
1812         lvalue_bitset<1>()
1813       , lvalue_const_bitset<0>()
1814     );
1815
1816 The |preprocessor_cpp|_ and |preprocessor_eval_cat_cpp|_ test programs
1817 demonstrate proper usage of this macro.
1818
1819 **Macro parameters:**
1820
1821 *   ``result`` is the parenthesized return type of the function.
1822 *   ``name`` is the base name of the function; it determines the name of the
1823     generated forwarding functions.  ``name`` may be qualified by the
1824     ``static`` keyword to declare the member function and its helpers as not
1825     associated with any object of the enclosing type.
1826 *   ``tag_namespace`` is the namespace in which the keywords used by the
1827     function resides.
1828 *   ``arguments`` is a |Boost_Preprocessor|_ `sequence`_ of
1829     *argument-specifiers*, as defined below.
1830
1831 **Argument specifiers syntax:**
1832
1833 .. parsed-literal::
1834
1835     argument-specifiers ::= *specifier-group0* {*specifier-group0*\ }
1836
1837     specifier-group0 ::= *specifier-group1* |
1838         (
1839             '**(**' '**deduced**'
1840                 *specifier-group1* {*specifier-group1*\ }
1841             '**)**'
1842         )
1843
1844     specifier-group1 ::=
1845         (
1846             '**(**' '**optional**'
1847                 *optional-specifier* {*optional-specifier*\ }
1848             '**)**'
1849         ) | (
1850             '**(**' '**required**'
1851                 *required-specifier* {*required-specifier*\ }
1852             '**)**'
1853         )
1854
1855     optional-specifier ::=
1856         '**(**'
1857             *argument-name* '**,**' *restriction* '**,**' *default-value*
1858         ')'
1859
1860     required-specifier ::=
1861         '**(**' *argument-name* '**,**' *restriction* ')'
1862
1863     restriction ::=
1864         ( '**\***' '**(**' *mfc* '**)**' ) |
1865         ( '**(**' *type-name* '**)**' ) |
1866         '**\***'
1867
1868 *   ``argument-name`` is any valid C++ identifier.
1869 *   ``default-value`` is any valid C++ expression; if necessary, user code can
1870     compute it in terms of ``previous-name ## _type``, where ``previous-name``
1871     is the ``argument-name`` in a previous ``specifier-group0`` or
1872     ``specifier-group1``.  *This expression will be invoked exactly once.*
1873 *   ``mfc`` is an `MPL Binary Metafunction Class`_ whose first argument will
1874     be the type of the corresponding ``argument-name``, whose second argument
1875     will be the entire |ArgumentPack|_, and whose return type is a `Boolean
1876     Integral Constant`_; however, user code *cannot* compute ``mfc`` in terms
1877     of ``previous-name ## _type``.
1878 *   ``type-name`` is either the name of a **target type** or an `MPL Binary
1879     Metafunction Class`_ whose first argument will be the type of the
1880     corresponding ``argument-name``, whose second argument will be the entire
1881     |ArgumentPack|_, and whose return type is the **target type**.  If
1882     ``restriction`` uses this form, then the type of the generated name
1883     ``argument-name ## _type`` will be computed in terms of the **target
1884     type**, and the generated reference ``argument-name`` (but not its
1885     corresponding entry in ``args``) will be cast to that type.
1886
1887 **Approximate expansion:**
1888
1889 Where:
1890
1891 * ``n`` denotes the *minimum* arity, as determined from ``arguments``.
1892 * ``m`` denotes the *maximum* arity, as determined from ``arguments``.
1893
1894 .. parsed-literal::
1895
1896     // If **result** is a template instantiation of |boost_enable_if|_\,
1897     // |boost_enable_if_c|_\, |boost_lazy_enable_if|_\,
1898     // |boost_lazy_enable_if_c|_\, |boost_disable_if|_\, |boost_disable_if_c|_\,
1899     // |boost_lazy_disable_if|_\, |boost_lazy_disable_if_c|_\, or
1900     // |std_enable_if|_\:
1901     template <typename Args>
1902     using boost_param_result\_ ## __LINE__ ## **name** = **result**;
1903
1904     // If **result** is a simple return type:
1905     template <typename Args>
1906     struct boost_param_result\_ ## __LINE__ ## **name**
1907     {
1908         typedef **result** type;
1909     };
1910
1911     struct boost_param_params\_ ## __LINE__ ## **name**
1912       : |parameters|_\<
1913             *list of parameter specifications, based on arguments*
1914         >
1915     {
1916     };
1917
1918     typedef boost_param_params\_ ## __LINE__ ## **name**
1919         boost_param_parameters\_ ## __LINE__ ## **name**;
1920
1921     template <typename A0, …, typename A ## **n**>
1922     **result** **name**\ (
1923         A0&& a0, …, A ## **n**\ && a ## **n**
1924       , typename boost_param_parameters\_ ## __LINE__ ## **name**
1925         ::match<A0, …, A ## **n**>::type
1926         = boost_param_parameters\_ ## __LINE__ ## **name**\ ()
1927     )
1928     {
1929         return this->boost_param_impl ## __LINE__ ## **name**\ (
1930             boost_param_parameters\_ ## __LINE__ ## **name**\ ()(
1931                 |std_forward|_\<A0>(a0)
1932               , …
1933               , |std_forward|_\<A ## **n**>(a ## **n**)
1934             )
1935         );
1936     }
1937
1938     :vellipsis:`⋮`
1939
1940     template <typename A0, …, typename A ## **m**>
1941     **result** **name**\ (
1942         A0&& a0, …, A ## **m**\ && a ## **m**
1943       , typename boost_param_parameters\_ ## __LINE__ ## **name**
1944         ::match<A0, …, A ## **m**>::type
1945         = boost_param_parameters\_ ## __LINE__ ## **name**\ ()
1946     )
1947     {
1948         return this->boost_param_impl ## __LINE__ ## **name**\ (
1949             boost_param_parameters\_ ## __LINE__ ## **name**\ ()(
1950                 |std_forward|_\<A0>(a0)
1951               , …
1952               , |std_forward|_\<A ## **m**>(a ## **m**)
1953             )
1954         );
1955     }
1956
1957     template <typename Args>
1958     typename boost_param_result\_ ## __LINE__ ## **name**\ <Args>::type
1959         boost_param_impl ## __LINE__ ## **name**\ (Args const& args)
1960     {
1961         return this->boost_param_dispatch_0boost\_ ## __LINE__ ## **name**\ (
1962             static_cast<
1963                 typename boost_param_result\_ ## __LINE__ ## **name**\ <
1964                     Args
1965                 >::type(*)()
1966             >(|std_nullptr|_\)
1967           , args
1968           , |std_forward|_\<
1969                 typename |value_type|_\<
1970                     Args
1971                   , *keyword tag type of required parameter* ## **0**
1972                 >::type
1973             >(args[ *keyword object of required parameter* ## **0**])
1974           , …
1975           , |std_forward|_\<
1976                 typename |value_type|_\<
1977                     Args
1978                   , *keyword tag type of required parameter* ## **n**
1979                 >::type
1980             >(args[ *keyword object of required parameter* ## **n**])
1981         );
1982     }
1983
1984     template <
1985         typename ResultType
1986       , typename Args
1987       , typename *argument name* ## **0** ## _type
1988       , …
1989       , typename *argument name* ## **n** ## _type
1990     >
1991     ResultType
1992         boost_param_dispatch_0boost\_ ## __LINE__ ## **name**\ (
1993             (ResultType(*)())
1994           , Args const& args
1995           , *argument name* ## **0** ## _type&& *argument name* ## **0**
1996           , …
1997           , *argument name* ## **n** ## _type&& *argument name* ## **n**
1998         )
1999     {
2000         return this->boost_param_dispatch_0boost\_ ## __LINE__ ## **name**\ (
2001             static_cast<ResultType(*)()>(|std_nullptr|_\)
2002           , (args, *keyword object of optional parameter* ## **n + 1** =
2003                 *default value of optional parameter* ## **n + 1**
2004             )
2005           , |std_forward|_\<*argument name* ## **0** ## _type>(
2006                 *argument name* ## **0**
2007             )
2008           , …
2009           , |std_forward|_\<*argument name* ## **n** ## _type>(
2010                 *argument name* ## **n**
2011             )
2012           , |std_forward|_\<
2013                 typename |value_type|_\<
2014                     Args
2015                   , *keyword tag type of optional parameter* ## **n + 1**
2016                 >::type
2017             >(*default value of optional parameter* ## **n + 1**)
2018         );
2019     }
2020
2021     :vellipsis:`⋮`
2022
2023     template <
2024         typename ResultType
2025       , typename Args
2026       , typename *argument name* ## **0** ## _type
2027       , …
2028       , typename *argument name* ## **m** ## _type
2029     >
2030     ResultType
2031         boost_param_dispatch_0boost\_ ## __LINE__ ## **name**\ (
2032             (ResultType(*)())
2033           , Args const& args
2034           , *argument name* ## **0** ## _type&& *argument name* ## **0**
2035           , …
2036           , *argument name* ## **m** ## _type&& *argument name* ## **m**
2037         )
2038
2039 .. |BOOST_PARAMETER_CONST_MEMBER_FUNCTION| replace:: ``BOOST_PARAMETER_CONST_MEMBER_FUNCTION``
2040 .. _BOOST_PARAMETER_CONST_MEMBER_FUNCTION:
2041
2042 ``BOOST_PARAMETER_CONST_MEMBER_FUNCTION(result, name, tag_ns, arguments)``
2043 --------------------------------------------------------------------------
2044
2045 :Defined in: |preprocessor_header|_
2046
2047 Generates a member function that can take in positional arguments, composed
2048 arguments, named arguments, and deduced arguments.
2049
2050 :Example usage:
2051
2052 The return type of each of the following function templates falls under a
2053 different value category.
2054
2055 .. parsed-literal::
2056
2057     template <std::size_t N>
2058     |std_bitset|_\<N + 1> rvalue_bitset()
2059     {
2060         return |std_bitset|_\<N + 1>();
2061     }
2062
2063     template <std::size_t N>
2064     |std_bitset|_\<N + 1> const rvalue_const_bitset()
2065     {
2066         return |std_bitset|_\<N + 1>();
2067     }
2068
2069     template <std::size_t N>
2070     |std_bitset|_\<N + 1>& lvalue_bitset()
2071     {
2072         static |std_bitset|_\<N + 1> lset = |std_bitset|_\<N + 1>();
2073         return lset;
2074     }
2075
2076     template <std::size_t N>
2077     |std_bitset|_\<N + 1> const& lvalue_const_bitset()
2078     {
2079         static |std_bitset|_\<N + 1> const clset = |std_bitset|_\<N + 1>();
2080         return clset;
2081     }
2082
2083 The ``U::evaluate_category`` static member function template has a simple job:
2084 to return the correct value category when passed in an object returned by one
2085 of the functions defined above.  Assume that
2086 |BOOST_PARAMETER_HAS_PERFECT_FORWARDING|_ is defined.
2087
2088 .. parsed-literal::
2089
2090     enum invoked
2091     {
2092         passed_by_lvalue_reference_to_const
2093       , passed_by_lvalue_reference
2094       , passed_by_rvalue_reference_to_const
2095       , passed_by_rvalue_reference
2096     };
2097
2098     struct U
2099     {
2100         template <std::size_t N>
2101         static invoked evaluate_category(|std_bitset|_\<N + 1> const&)
2102         {
2103             return passed_by_lvalue_reference_to_const;
2104         }
2105
2106         template <std::size_t N>
2107         static invoked evaluate_category(|std_bitset|_\<N + 1>&)
2108         {
2109             return passed_by_lvalue_reference;
2110         }
2111
2112         template <std::size_t N>
2113         static invoked evaluate_category(|std_bitset|_\<N + 1> const&&)
2114         {
2115             return passed_by_rvalue_reference_to_const;
2116         }
2117
2118         template <std::size_t N>
2119         static invoked evaluate_category(|std_bitset|_\<N + 1>&&)
2120         {
2121             return passed_by_rvalue_reference;
2122         }
2123     };
2124
2125 Define the named parameters that will comprise the argument specification that
2126 this macro will use.  Ensure that all their tag types are in the same
2127 namespace, which is ``kw`` in this case.  The identifiers with leading
2128 underscores can be passed to the bracket operator of ``args`` to extract the
2129 same argument to which the corresponding named parameter (without underscores)
2130 is bound, as will be shown later.
2131
2132 .. parsed-literal::
2133
2134     |BOOST_PARAMETER_NAME|_\((_lrc, kw) in(lrc))
2135     |BOOST_PARAMETER_NAME|_\((_lr, kw) in_out(lr))
2136     |BOOST_PARAMETER_NAME|_\((_rrc, kw) in(rrc))
2137     |BOOST_PARAMETER_NAME|_\((_rr, kw) consume(rr))
2138
2139 Use the macro as a substitute for a normal ``const`` member function
2140 header.  Enclose the return type ``bool`` in parentheses.  For each parameter,
2141 also enclose the expected value type in parentheses.  Since the value types
2142 are mutually exclusive, you can wrap the parameters in a ``(deduced …)``
2143 clause.  Otherwise, just as with a normal function, the order in which you
2144 specify the parameters determines their position.  Also, just as with a normal
2145 function, optional parameters have default values, whereas required parameters
2146 do not.  Within the function body, either simply use the parameter name or
2147 pass the matching identifier with the leading underscore to the bracket
2148 operator of ``args`` to extract the corresponding argument.  Note that the
2149 second method doesn't require ``std::forward`` to preserve value categories.
2150
2151 .. parsed-literal::
2152
2153     struct B
2154     {
2155         B()
2156         {
2157         }
2158
2159         BOOST_PARAMETER_CONST_MEMBER_FUNCTION((bool), evaluate, kw,
2160             (deduced
2161                 (required
2162                     (lrc, (|std_bitset|_\<1>))
2163                     (lr, (|std_bitset|_\<2>))
2164                 )
2165                 (optional
2166                     (rrc, (|std_bitset|_\<3>), rvalue_const_bitset<2>())
2167                     (rr, (|std_bitset|_\<4>), rvalue_bitset<3>())
2168                 )
2169             )
2170         )
2171         {
2172             BOOST_TEST_EQ(
2173                 passed_by_lvalue_reference_to_const
2174               , U::evaluate_category<0>(lrc)
2175             );
2176             BOOST_TEST_EQ(
2177                 passed_by_lvalue_reference
2178               , U::evaluate_category<1>(lr)
2179             );
2180             BOOST_TEST_EQ(
2181                 passed_by_rvalue_reference_to_const
2182               , U::evaluate_category<2>(|std_forward|_\<rrc0_type>(rrc0))
2183             );
2184             BOOST_TEST_EQ(
2185                 passed_by_rvalue_reference
2186               , U::evaluate_category<3>(args[_rr0])
2187             );
2188
2189             return true;
2190         }
2191     };
2192
2193 The following function calls are legal.
2194
2195 .. parsed-literal::
2196
2197     B const b = B();
2198     b.evaluate(  // positional arguments
2199         lvalue_const_bitset<0>()
2200       , lvalue_bitset<1>()
2201       , rvalue_const_bitset<2>()
2202       , rvalue_bitset<3>()
2203     );
2204     b.evaluate(  // positional arguments
2205         lvalue_const_bitset<0>()
2206       , lvalue_bitset<1>()
2207     );
2208     b.evaluate((  // composed arguments
2209         _rr0 = rvalue_bitset<3>()
2210       , _lrc0 = lvalue_const_bitset<0>()
2211       , _lr0 = lvalue_bitset<1>()
2212       , _rrc0 = rvalue_const_bitset<2>()
2213     ));
2214     b.evaluate(  // named arguments
2215         _rr0 = rvalue_bitset<3>()
2216       , _lrc0 = lvalue_const_bitset<0>()
2217       , _lr0 = lvalue_bitset<1>()
2218       , _rrc0 = rvalue_const_bitset<2>()
2219     );
2220     b.evaluate(  // named arguments
2221         _lr0 = lvalue_bitset<1>()
2222       , _lrc0 = lvalue_const_bitset<0>()
2223     );
2224
2225 Because the parameters were wrapped in a ``(deduced …)`` clause, the following
2226 function calls are also legal.
2227
2228 .. parsed-literal::
2229
2230     b.evaluate(  // deduced arguments
2231         rvalue_bitset<3>()
2232       , lvalue_const_bitset<0>()
2233       , lvalue_bitset<1>()
2234       , rvalue_const_bitset<2>()
2235     );
2236     b.evaluate(  // deduced arguments
2237         lvalue_bitset<1>()
2238       , lvalue_const_bitset<0>()
2239     );
2240
2241 The |preprocessor_cpp|_ test program demonstrates proper usage of this macro.
2242
2243 **Macro parameters:**
2244
2245 *   ``result`` is the parenthesized return type of the function.
2246 *   ``name`` is the base name of the function; it determines the name of the
2247     generated forwarding functions.
2248 *   ``tag_namespace`` is the namespace in which the keywords used by the
2249     function resides.
2250 *   ``arguments`` is a |Boost_Preprocessor|_ `sequence`_ of
2251     *argument-specifiers*, as defined below.
2252
2253 **Argument specifiers syntax:**
2254
2255 .. parsed-literal::
2256
2257     argument-specifiers ::= *specifier-group0* {*specifier-group0*\ }
2258
2259     specifier-group0 ::= *specifier-group1* |
2260         (
2261             '**(**' '**deduced**'
2262                 *specifier-group1* {*specifier-group1*\ }
2263             '**)**'
2264         )
2265
2266     specifier-group1 ::=
2267         (
2268             '**(**' '**optional**'
2269                 *optional-specifier* {*optional-specifier*\ }
2270             '**)**'
2271         ) | (
2272             '**(**' '**required**'
2273                 *required-specifier* {*required-specifier*\ }
2274             '**)**'
2275         )
2276
2277     optional-specifier ::=
2278         '**(**'
2279             *argument-name* '**,**' *restriction* '**,**' *default-value*
2280         ')'
2281
2282     required-specifier ::=
2283         '**(**' *argument-name* '**,**' *restriction* ')'
2284
2285     restriction ::=
2286         ( '**\***' '**(**' *mfc* '**)**' ) |
2287         ( '**(**' *type-name* '**)**' ) |
2288         '**\***'
2289
2290 *   ``argument-name`` is any valid C++ identifier.
2291 *   ``default-value`` is any valid C++ expression; if necessary, user code can
2292     compute it in terms of ``previous-name ## _type``, where ``previous-name``
2293     is the ``argument-name`` in a previous ``specifier-group0`` or
2294     ``specifier-group1``.  *This expression will be invoked exactly once.*
2295 *   ``mfc`` is an `MPL Binary Metafunction Class`_ whose first argument will
2296     be the type of the corresponding ``argument-name``, whose second argument
2297     will be the entire |ArgumentPack|_, and whose return type is a `Boolean
2298     Integral Constant`_; however, user code *cannot* compute ``mfc`` in terms
2299     of ``previous-name ## _type``.
2300 *   ``type-name`` is either the name of a **target type** or an `MPL Binary
2301     Metafunction Class`_ whose first argument will be the type of the
2302     corresponding ``argument-name``, whose second argument will be the entire
2303     |ArgumentPack|_, and whose return type is the **target type**.  If
2304     ``restriction`` uses this form, then the type of the generated name
2305     ``argument-name ## _type`` will be computed in terms of the **target
2306     type**, and the generated reference ``argument-name`` (but not its
2307     corresponding entry in ``args``) will be cast to that type.
2308
2309 **Approximate expansion:**
2310
2311 Where:
2312
2313 * ``n`` denotes the *minimum* arity, as determined from ``arguments``.
2314 * ``m`` denotes the *maximum* arity, as determined from ``arguments``.
2315
2316 .. parsed-literal::
2317
2318     // If **result** is a template instantiation of |boost_enable_if|_\,
2319     // |boost_enable_if_c|_\, |boost_lazy_enable_if|_\,
2320     // |boost_lazy_enable_if_c|_\, |boost_disable_if|_\, |boost_disable_if_c|_\,
2321     // |boost_lazy_disable_if|_\, |boost_lazy_disable_if_c|_\, or
2322     // |std_enable_if|_\:
2323     template <typename Args>
2324     using boost_param_result_const\_ ## __LINE__ ## **name** = **result**;
2325
2326     // If **result** is a simple return type:
2327     template <typename Args>
2328     struct boost_param_result_const\_ ## __LINE__ ## **name**
2329     {
2330         typedef **result** type;
2331     };
2332
2333     struct boost_param_params_const\_ ## __LINE__ ## **name**
2334       : |parameters|_\<
2335             *list of parameter specifications, based on arguments*
2336         >
2337     {
2338     };
2339
2340     typedef boost_param_params_const\_ ## __LINE__ ## **name**
2341         boost_param_parameters_const\_ ## __LINE__ ## **name**;
2342
2343     template <typename A0, …, typename A ## **n**>
2344     **result** **name**\ (
2345         A0&& a0, …, A ## **n**\ && a ## **n**
2346       , typename boost_param_parameters_const\_ ## __LINE__ ## **name**
2347         ::match<A0, …, A ## **n**>::type
2348         = boost_param_parameters_const\_ ## __LINE__ ## **name**\ ()
2349     ) const
2350     {
2351         return this->boost_param_impl_const ## __LINE__ ## **name**\ (
2352             boost_param_parameters_const\_ ## __LINE__ ## **name**\ (
2353                 |std_forward|_\<A0>(a0)
2354               , …
2355               , |std_forward|_\<A ## **n**>(a ## **n**)
2356             )
2357         );
2358     }
2359
2360     :vellipsis:`⋮`
2361
2362     template <typename A0, …, typename A ## **m**>
2363     **result** **name**\ (
2364         A0&& a0, …, A ## **m**\ && a ## **m**
2365       , typename boost_param_parameters_const\_ ## __LINE__ ## **name**
2366         ::match<A0, …, A ## **m**>::type
2367         = boost_param_parameters_const\_ ## __LINE__ ## **name**\ ()
2368     ) const
2369     {
2370         return this->boost_param_impl_const ## __LINE__ ## **name**\ (
2371             boost_param_parameters_const\_ ## __LINE__ ## **name**\ ()(
2372                 |std_forward|_\<A0>(a0)
2373               , …
2374               , |std_forward|_\<A ## **m**>(a ## **m**)
2375             )
2376         );
2377     }
2378
2379     template <typename Args>
2380     typename boost_param_result_const\_ ## __LINE__ ## **name**\ <Args>::type
2381         boost_param_impl_const ## __LINE__ ## **name**\ (Args const& args) const
2382     {
2383         return this->
2384         boost_param_dispatch_const_0boost\_ ## __LINE__ ## **name**\ (
2385             static_cast<
2386                 typename boost_param_result_const\_ ## __LINE__ ## **name**\ <
2387                     Args
2388                 >::type(*)()
2389             >(|std_nullptr|_\)
2390           , args
2391           , |std_forward|_\<
2392                 typename |value_type|_\<
2393                     Args
2394                   , *keyword tag type of required parameter* ## **0**
2395                 >::type
2396             >(args[ *keyword object of required parameter* ## **0**])
2397           , …
2398           , |std_forward|_\<
2399                 typename |value_type|_\<
2400                     Args
2401                   , *keyword tag type of required parameter* ## **n**
2402                 >::type
2403             >(args[ *keyword object of required parameter* ## **n**])
2404         );
2405     }
2406
2407     template <
2408         typename ResultType
2409       , typename Args
2410       , typename *argument name* ## **0** ## _type
2411       , …
2412       , typename *argument name* ## **n** ## _type
2413     >
2414     ResultType
2415         boost_param_dispatch_const_0boost\_ ## __LINE__ ## **name**\ (
2416             (ResultType(*)())
2417           , Args const& args
2418           , *argument name* ## **0** ## _type&& *argument name* ## **0**
2419           , …
2420           , *argument name* ## **n** ## _type&& *argument name* ## **n**
2421         ) const
2422     {
2423         return this->
2424         boost_param_dispatch_const_0boost\_ ## __LINE__ ## **name**\ (
2425             static_cast<ResultType(*)()>(|std_nullptr|_\)
2426           , (args, *keyword object of optional parameter* ## **n + 1** =
2427                 *default value of optional parameter* ## **n + 1**
2428             )
2429           , |std_forward|_\<*argument name* ## **0** ## _type>(
2430                 *argument name* ## **0**
2431             )
2432           , …
2433           , |std_forward|_\<*argument name* ## **n** ## _type>(
2434                 *argument name* ## **n**
2435             )
2436           , |std_forward|_\<
2437                 typename |value_type|_\<
2438                     Args
2439                   , *keyword tag type of optional parameter* ## **n + 1**
2440                 >::type
2441             >(*default value of optional parameter* ## **n + 1**)
2442         );
2443     }
2444
2445     :vellipsis:`⋮`
2446
2447     template <
2448         typename ResultType
2449       , typename Args
2450       , typename *argument name* ## **0** ## _type
2451       , …
2452       , typename *argument name* ## **m** ## _type
2453     >
2454     ResultType
2455         boost_param_dispatch_const_0boost\_ ## __LINE__ ## **name**\ (
2456             (ResultType(*)())
2457           , Args const& args
2458           , *argument name* ## **0** ## _type&& *argument name* ## **0**
2459           , …
2460           , *argument name* ## **m** ## _type&& *argument name* ## **m**
2461         ) const
2462
2463 .. |BOOST_PARAMETER_FUNCTION_CALL_OPERATOR| replace:: ``BOOST_PARAMETER_FUNCTION_CALL_OPERATOR``
2464 .. _BOOST_PARAMETER_FUNCTION_CALL_OPERATOR:
2465
2466 ``BOOST_PARAMETER_FUNCTION_CALL_OPERATOR(result, tag_namespace, arguments)``
2467 ----------------------------------------------------------------------------
2468
2469 :Defined in: |preprocessor_header|_
2470
2471 Generates a function call operator that can take in positional arguments,
2472 composed arguments, named arguments, and deduced arguments.
2473
2474 :Example usage:
2475
2476 Define the named parameters that will comprise the argument specification that
2477 this macro will use.  Ensure that all their tag types are in the same
2478 namespace, which is ``tag`` by default.
2479
2480 .. parsed-literal::
2481
2482     |BOOST_PARAMETER_NAME|_\(y)
2483     |BOOST_PARAMETER_NAME|_\(z)
2484
2485 Use the macro as a substitute for a normal function call operator
2486 header.  Enclose the return type in parentheses.  For each parameter, also
2487 enclose the expected value type in parentheses.  Since the value types are
2488 mutually exclusive, you can wrap the parameters in a ``(deduced …)``
2489 clause.  This is especially useful when implementing multiple
2490 Boost.Parameter-enabled function call operator overloads.
2491
2492 .. parsed-literal::
2493
2494     class char_reader
2495     {
2496         int index;
2497         char const* key;
2498
2499      public:
2500         explicit char_reader(char const* k) : index(0), key(k)
2501         {
2502         }
2503
2504         BOOST_PARAMETER_FUNCTION_CALL_OPERATOR((void), tag,
2505             (deduced
2506                 (required
2507                     (y, (int))
2508                     (z, (char const*))
2509                 )
2510             )
2511         )
2512         {
2513             this->index = y;
2514             this->key = z;
2515         }
2516
2517         |BOOST_PARAMETER_CONST_FUNCTION_CALL_OPERATOR|_\((char), tag,
2518             (deduced
2519                 (required
2520                     (y, (bool))
2521                     (z, (|std_map|_\<char const*, |std_string|_\>))
2522                 )
2523             )
2524         )
2525         {
2526             return y ? (
2527                 (z.find(this->key)->second)[this->index]
2528             ) : this->key[this->index];
2529         }
2530     };
2531
2532 As with regular argument-dependent lookup, the value types of the arguments
2533 passed in determine which function call operator overload gets invoked.
2534
2535 .. parsed-literal::
2536
2537     char const* keys[] = {"foo", "bar", "baz"};
2538     |std_map|_\<char const*, |std_string|_\> k2s;
2539     k2s[keys[0]] = |std_string|_\("qux");
2540     k2s[keys[1]] = |std_string|_\("wmb");
2541     k2s[keys[2]] = |std_string|_\("zxc");
2542     char_reader r(keys[0]);
2543
2544     // positional arguments
2545     BOOST_TEST_EQ('q', (r(true, k2s)));
2546     BOOST_TEST_EQ('f', (r(false, k2s)));
2547
2548     // named arguments
2549     r(_z = keys[1], _y = 1);
2550     BOOST_TEST_EQ('m', (r(_z = k2s, _y = true)));
2551     BOOST_TEST_EQ('a', (r(_z = k2s, _y = false)));
2552
2553     // deduced arguments
2554     r(keys[2], 2);
2555     BOOST_TEST_EQ('c', (r(k2s, true)));
2556     BOOST_TEST_EQ('z', (r(k2s, false)));
2557
2558 The |preprocessor_cpp|_ and |preprocessor_deduced_cpp|_ test programs
2559 demonstrate proper usage of this macro.
2560
2561 **Macro parameters:**
2562
2563 *   ``result`` is the parenthesized return type of the function call operator.
2564 *   ``tag_namespace`` is the namespace in which the keywords used by the
2565     function call operator resides.
2566 *   ``arguments`` is a |Boost_Preprocessor|_ `sequence`_ of
2567     *argument-specifiers*, as defined below.
2568
2569 **Argument specifiers syntax:**
2570
2571 .. parsed-literal::
2572
2573     argument-specifiers ::= *specifier-group0* {*specifier-group0*\ }
2574
2575     specifier-group0 ::= *specifier-group1* |
2576         (
2577             '**(**' '**deduced**'
2578                 *specifier-group1* {*specifier-group1*\ }
2579             '**)**'
2580         )
2581
2582     specifier-group1 ::=
2583         (
2584             '**(**' '**optional**'
2585                 *optional-specifier* {*optional-specifier*\ }
2586             '**)**'
2587         ) | (
2588             '**(**' '**required**'
2589                 *required-specifier* {*required-specifier*\ }
2590             '**)**'
2591         )
2592
2593     optional-specifier ::=
2594         '**(**'
2595             *argument-name* '**,**' *restriction* '**,**' *default-value*
2596         ')'
2597
2598     required-specifier ::=
2599         '**(**' *argument-name* '**,**' *restriction* ')'
2600
2601     restriction ::=
2602         ( '**\***' '**(**' *mfc* '**)**' ) |
2603         ( '**(**' *type-name* '**)**' ) |
2604         '**\***'
2605
2606 *   ``argument-name`` is any valid C++ identifier.
2607 *   ``default-value`` is any valid C++ expression; if necessary, user code can
2608     compute it in terms of ``previous-name ## _type``, where ``previous-name``
2609     is the ``argument-name`` in a previous ``specifier-group0`` or
2610     ``specifier-group1``.  *This expression will be invoked exactly once.*
2611 *   ``mfc`` is an `MPL Binary Metafunction Class`_ whose first argument will
2612     be the type of the corresponding ``argument-name``, whose second argument
2613     will be the entire |ArgumentPack|_, and whose return type is a `Boolean
2614     Integral Constant`_; however, user code *cannot* compute ``mfc`` in terms
2615     of ``previous-name ## _type``.
2616 *   ``type-name`` is either the name of a **target type** or an `MPL Binary
2617     Metafunction Class`_ whose first argument will be the type of the
2618     corresponding ``argument-name``, whose second argument will be the entire
2619     |ArgumentPack|_, and whose return type is the **target type**.  If
2620     ``restriction`` uses this form, then the type of the generated name
2621     ``argument-name ## _type`` will be computed in terms of the **target
2622     type**, and the generated reference ``argument-name`` (but not its
2623     corresponding entry in ``args``) will be cast to that type.
2624
2625 **Approximate expansion:**
2626
2627 Where:
2628
2629 * ``n`` denotes the *minimum* arity, as determined from ``arguments``.
2630 * ``m`` denotes the *maximum* arity, as determined from ``arguments``.
2631
2632 .. parsed-literal::
2633
2634     // If **result** is a template instantiation of |boost_enable_if|_\,
2635     // |boost_enable_if_c|_\, |boost_lazy_enable_if|_\,
2636     // |boost_lazy_enable_if_c|_\, |boost_disable_if|_\, |boost_disable_if_c|_\,
2637     // |boost_lazy_disable_if|_\, |boost_lazy_disable_if_c|_\, or
2638     // |std_enable_if|_\:
2639     template <typename Args>
2640     using boost_param_result\_ ## __LINE__ ## operator = **result**;
2641
2642     // If **result** is a simple return type:
2643     template <typename Args>
2644     struct boost_param_result\_ ## __LINE__ ## operator
2645     {
2646         typedef **result** type;
2647     };
2648
2649     struct boost_param_params\_ ## __LINE__ ## operator
2650       : |parameters|_\<
2651             *list of parameter specifications, based on arguments*
2652         >
2653     {
2654     };
2655
2656     typedef boost_param_params\_ ## __LINE__ ## operator
2657         boost_param_parameters\_ ## __LINE__ ## operator;
2658
2659     template <typename A0, …, typename A ## **n**>
2660     **result** operator()(
2661         A0&& a0, …, A ## **n**\ && a ## **n**
2662       , typename boost_param_parameters\_ ## __LINE__ ## operator::match<
2663             A0, …, A ## **n**
2664         >::type = boost_param_parameters\_ ## __LINE__ ## operator()
2665     )
2666     {
2667         return this->boost_param_impl ## __LINE__ ## operator(
2668             boost_param_parameters\_ ## __LINE__ ## operator()(
2669                 |std_forward|_\<A0>(a0)
2670               , …
2671               , |std_forward|_\<A ## **n**>(a ## **n**)
2672             )
2673         );
2674     }
2675
2676     :vellipsis:`⋮`
2677
2678     template <typename A0, …, typename A ## **m**>
2679     **result** operator()(
2680         A0&& a0, …, A ## **m**\ && a ## **m**
2681       , typename boost_param_parameters\_ ## __LINE__ ## operator::match<
2682             A0, …, A ## **m**
2683         >::type = boost_param_parameters\_ ## __LINE__ ## operator()
2684     )
2685     {
2686         return this->boost_param_impl ## __LINE__ ## operator(
2687             boost_param_parameters\_ ## __LINE__ ## operator()(
2688                 |std_forward|_\<A0>(a0)
2689               , …
2690               , |std_forward|_\<A ## **m**>(a ## **m**)
2691             )
2692         );
2693     }
2694
2695     template <typename Args>
2696     typename boost_param_result\_ ## __LINE__ ## operator<Args>::type
2697         boost_param_impl ## __LINE__ ## operator(Args const& args)
2698     {
2699         return this->boost_param_dispatch_0boost\_ ## __LINE__ ## operator(
2700             static_cast<
2701                 typename boost_param_result\_ ## __LINE__ ## operator<
2702                     Args
2703                 >::type(*)()
2704             >(|std_nullptr|_\)
2705           , args
2706           , |std_forward|_\<
2707                 typename |value_type|_\<
2708                     Args
2709                   , *keyword tag type of required parameter* ## **0**
2710                 >::type
2711             >(args[ *keyword object of required parameter* ## **0**])
2712           , …
2713           , |std_forward|_\<
2714                 typename |value_type|_\<
2715                     Args
2716                   , *keyword tag type of required parameter* ## **n**
2717                 >::type
2718             >(args[ *keyword object of required parameter* ## **n**])
2719         );
2720     }
2721
2722     template <
2723         typename ResultType
2724       , typename Args
2725       , typename *argument name* ## **0** ## _type
2726       , …
2727       , typename *argument name* ## **n** ## _type
2728     >
2729     ResultType
2730         boost_param_dispatch_0boost\_ ## __LINE__ ## operator(
2731             (ResultType(*)())
2732           , Args const& args
2733           , *argument name* ## **0** ## _type&& *argument name* ## **0**
2734           , …
2735           , *argument name* ## **n** ## _type&& *argument name* ## **n**
2736         )
2737     {
2738         return this->boost_param_dispatch_0boost\_ ## __LINE__ ## operator(
2739             static_cast<ResultType(*)()>(|std_nullptr|_\)
2740           , (args, *keyword object of optional parameter* ## **n + 1** =
2741                 *default value of optional parameter* ## **n + 1**
2742             )
2743           , |std_forward|_\<*argument name* ## **0** ## _type>(
2744                 *argument name* ## **0**
2745             )
2746           , …
2747           , |std_forward|_\<*argument name* ## **n** ## _type>(
2748                 *argument name* ## **n**
2749             )
2750           , |std_forward|_\<
2751                 typename |value_type|_\<
2752                     Args
2753                   , *keyword tag type of optional parameter* ## **n + 1**
2754                 >::type
2755             >(*default value of optional parameter* ## **n + 1**)
2756         );
2757     }
2758
2759     :vellipsis:`⋮`
2760
2761     template <
2762         typename ResultType
2763       , typename Args
2764       , typename *argument name* ## **0** ## _type
2765       , …
2766       , typename *argument name* ## **m** ## _type
2767     >
2768     ResultType
2769         boost_param_dispatch_0boost\_ ## __LINE__ ## operator(
2770             (ResultType(*)())
2771           , Args const& args
2772           , *argument name* ## **0** ## _type&& *argument name* ## **0**
2773           , …
2774           , *argument name* ## **m** ## _type&& *argument name* ## **m**
2775         )
2776
2777 .. |BOOST_PARAMETER_CONST_FUNCTION_CALL_OPERATOR| replace:: ``BOOST_PARAMETER_CONST_FUNCTION_CALL_OPERATOR``
2778 .. _BOOST_PARAMETER_CONST_FUNCTION_CALL_OPERATOR:
2779
2780 ``BOOST_PARAMETER_CONST_FUNCTION_CALL_OPERATOR(result, tag_ns, arguments)``
2781 ---------------------------------------------------------------------------
2782
2783 :Defined in: |preprocessor_header|_
2784
2785 Generates a function call operator that can take in positional arguments,
2786 composed arguments, named arguments, and deduced arguments.
2787
2788 :Example usage:
2789
2790 The return type of each of the following function templates falls under a
2791 different value category.
2792
2793 .. parsed-literal::
2794
2795     template <std::size_t N>
2796     |std_bitset|_\<N + 1> rvalue_bitset()
2797     {
2798         return |std_bitset|_\<N + 1>();
2799     }
2800
2801     template <std::size_t N>
2802     |std_bitset|_\<N + 1> const rvalue_const_bitset()
2803     {
2804         return |std_bitset|_\<N + 1>();
2805     }
2806
2807     template <std::size_t N>
2808     |std_bitset|_\<N + 1>& lvalue_bitset()
2809     {
2810         static |std_bitset|_\<N + 1> lset = |std_bitset|_\<N + 1>();
2811         return lset;
2812     }
2813
2814     template <std::size_t N>
2815     |std_bitset|_\<N + 1> const& lvalue_const_bitset()
2816     {
2817         static |std_bitset|_\<N + 1> const clset = |std_bitset|_\<N + 1>();
2818         return clset;
2819     }
2820
2821 The ``U::evaluate_category`` static member function template has a simple job:
2822 to return the correct value category when passed in an object returned by one
2823 of the functions defined above.  Assume that
2824 |BOOST_PARAMETER_HAS_PERFECT_FORWARDING|_ is defined.
2825
2826 .. parsed-literal::
2827
2828     enum invoked
2829     {
2830         passed_by_lvalue_reference_to_const
2831       , passed_by_lvalue_reference
2832       , passed_by_rvalue_reference_to_const
2833       , passed_by_rvalue_reference
2834     };
2835
2836     struct U
2837     {
2838         template <std::size_t N>
2839         static invoked evaluate_category(|std_bitset|_\<N + 1> const&)
2840         {
2841             return passed_by_lvalue_reference_to_const;
2842         }
2843
2844         template <std::size_t N>
2845         static invoked evaluate_category(|std_bitset|_\<N + 1>&)
2846         {
2847             return passed_by_lvalue_reference;
2848         }
2849
2850         template <std::size_t N>
2851         static invoked evaluate_category(|std_bitset|_\<N + 1> const&&)
2852         {
2853             return passed_by_rvalue_reference_to_const;
2854         }
2855
2856         template <std::size_t N>
2857         static invoked evaluate_category(|std_bitset|_\<N + 1>&&)
2858         {
2859             return passed_by_rvalue_reference;
2860         }
2861     };
2862
2863 Define the named parameters that will comprise the argument specification that
2864 this macro will use.  Ensure that all their tag types are in the same
2865 namespace, which is ``kw`` in this case.  The identifiers with leading
2866 underscores can be passed to the bracket operator of ``args`` to extract the
2867 same argument to which the corresponding named parameter (without underscores)
2868 is bound, as will be shown later.
2869
2870 .. parsed-literal::
2871
2872     |BOOST_PARAMETER_NAME|_\((_lrc, kw) in(lrc))
2873     |BOOST_PARAMETER_NAME|_\((_lr, kw) in_out(lr))
2874     |BOOST_PARAMETER_NAME|_\((_rrc, kw) in(rrc))
2875     |BOOST_PARAMETER_NAME|_\((_rr, kw) consume(rr))
2876
2877 Use the macro as a substitute for a normal ``const`` function call operator
2878 header.  Enclose the return type ``bool`` in parentheses.  For each parameter,
2879 also enclose the expected value type in parentheses.  Since the value types
2880 are mutually exclusive, you can wrap the parameters in a ``(deduced …)``
2881 clause.  Otherwise, just as with a normal function, the order in which you
2882 specify the parameters determines their position.  Also, just as with a normal
2883 function, optional parameters have default values, whereas required parameters
2884 do not.  Within the function body, either simply use the parameter name or
2885 pass the matching identifier with the leading underscore to the bracket
2886 operator of ``args`` to extract the corresponding argument.  Note that the
2887 second method doesn't require ``std::forward`` to preserve value categories.
2888
2889 .. parsed-literal::
2890
2891     struct B
2892     {
2893         B()
2894         {
2895         }
2896
2897         BOOST_PARAMETER_CONST_FUNCTION_CALL_OPERATOR((bool), kw,
2898             (deduced
2899                 (required
2900                     (lrc, (|std_bitset|_\<1>))
2901                     (lr, (|std_bitset|_\<2>))
2902                 )
2903                 (optional
2904                     (rrc, (|std_bitset|_\<3>), rvalue_const_bitset<2>())
2905                     (rr, (|std_bitset|_\<4>), rvalue_bitset<3>())
2906                 )
2907             )
2908         )
2909         {
2910             BOOST_TEST_EQ(
2911                 passed_by_lvalue_reference_to_const
2912               , U::evaluate_category<0>(lrc)
2913             );
2914             BOOST_TEST_EQ(
2915                 passed_by_lvalue_reference
2916               , U::evaluate_category<1>(lr)
2917             );
2918             BOOST_TEST_EQ(
2919                 passed_by_rvalue_reference_to_const
2920               , U::evaluate_category<2>(|std_forward|_\<rrc0_type>(rrc0))
2921             );
2922             BOOST_TEST_EQ(
2923                 passed_by_rvalue_reference
2924               , U::evaluate_category<3>(args[_rr0])
2925             );
2926
2927             return true;
2928         }
2929     };
2930
2931 The following function calls are legal.
2932
2933 .. parsed-literal::
2934
2935     B const b = B();
2936     b(  // positional arguments
2937         lvalue_const_bitset<0>()
2938       , lvalue_bitset<1>()
2939       , rvalue_const_bitset<2>()
2940       , rvalue_bitset<3>()
2941     );
2942     b(  // positional arguments
2943         lvalue_const_bitset<0>()
2944       , lvalue_bitset<1>()
2945     );
2946     b((  // composed arguments
2947         _rr0 = rvalue_bitset<3>()
2948       , _lrc0 = lvalue_const_bitset<0>()
2949       , _lr0 = lvalue_bitset<1>()
2950       , _rrc0 = rvalue_const_bitset<2>()
2951     ));
2952     b(  // named arguments
2953         _rr0 = rvalue_bitset<3>()
2954       , _lrc0 = lvalue_const_bitset<0>()
2955       , _lr0 = lvalue_bitset<1>()
2956       , _rrc0 = rvalue_const_bitset<2>()
2957     );
2958     b(  // named arguments
2959         _lr0 = lvalue_bitset<1>()
2960       , _lrc0 = lvalue_const_bitset<0>()
2961     );
2962
2963 Because the parameters were wrapped in a ``(deduced …)`` clause, the following
2964 function calls are also legal.
2965
2966 .. parsed-literal::
2967
2968     b(  // deduced arguments
2969         rvalue_bitset<3>()
2970       , lvalue_const_bitset<0>()
2971       , lvalue_bitset<1>()
2972       , rvalue_const_bitset<2>()
2973     );
2974     b(  // deduced arguments
2975         lvalue_bitset<1>()
2976       , lvalue_const_bitset<0>()
2977     );
2978
2979 The |preprocessor_cpp|_, |preprocessor_deduced_cpp|_, and
2980 |preprocessor_eval_cat_8_cpp|_ test programs demonstrate proper usage of this
2981 macro.
2982
2983 **Macro parameters:**
2984
2985 *   ``result`` is the parenthesized return type of the function call operator.
2986 *   ``tag_namespace`` is the namespace in which the keywords used by the
2987     function call operator resides.
2988 *   ``arguments`` is a |Boost_Preprocessor|_ `sequence`_ of
2989     *argument-specifiers*, as defined below.
2990
2991 **Argument specifiers syntax:**
2992
2993 .. parsed-literal::
2994
2995     argument-specifiers ::= *specifier-group0* {*specifier-group0*\ }
2996
2997     specifier-group0 ::= *specifier-group1* |
2998         (
2999             '**(**' '**deduced**'
3000                 *specifier-group1* {*specifier-group1*\ }
3001             '**)**'
3002         )
3003
3004     specifier-group1 ::=
3005         (
3006             '**(**' '**optional**'
3007                 *optional-specifier* {*optional-specifier*\ }
3008             '**)**'
3009         ) | (
3010             '**(**' '**required**'
3011                 *required-specifier* {*required-specifier*\ }
3012             '**)**'
3013         )
3014
3015     optional-specifier ::=
3016         '**(**'
3017             *argument-name* '**,**' *restriction* '**,**' *default-value*
3018         ')'
3019
3020     required-specifier ::=
3021         '**(**' *argument-name* '**,**' *restriction* ')'
3022
3023     restriction ::=
3024         ( '**\***' '**(**' *mfc* '**)**' ) |
3025         ( '**(**' *type-name* '**)**' ) |
3026         '**\***'
3027
3028 *   ``argument-name`` is any valid C++ identifier.
3029 *   ``default-value`` is any valid C++ expression; if necessary, user code can
3030     compute it in terms of ``previous-name ## _type``, where ``previous-name``
3031     is the ``argument-name`` in a previous ``specifier-group0`` or
3032     ``specifier-group1``.  *This expression will be invoked exactly once.*
3033 *   ``mfc`` is an `MPL Binary Metafunction Class`_ whose first argument will
3034     be the type of the corresponding ``argument-name``, whose second argument
3035     will be the entire |ArgumentPack|_, and whose return type is a `Boolean
3036     Integral Constant`_; however, user code *cannot* compute ``mfc`` in terms
3037     of ``previous-name ## _type``.
3038 *   ``type-name`` is either the name of a **target type** or an `MPL Binary
3039     Metafunction Class`_ whose first argument will be the type of the
3040     corresponding ``argument-name``, whose second argument will be the entire
3041     |ArgumentPack|_, and whose return type is the **target type**.  If
3042     ``restriction`` uses this form, then the type of the generated name
3043     ``argument-name ## _type`` will be computed in terms of the **target
3044     type**, and the generated reference ``argument-name`` (but not its
3045     corresponding entry in ``args``) will be cast to that type.
3046
3047 **Approximate expansion:**
3048
3049 Where:
3050
3051 * ``n`` denotes the *minimum* arity, as determined from ``arguments``.
3052 * ``m`` denotes the *maximum* arity, as determined from ``arguments``.
3053
3054 .. parsed-literal::
3055
3056     // If **result** is a template instantiation of |boost_enable_if|_\,
3057     // |boost_enable_if_c|_\, |boost_lazy_enable_if|_\,
3058     // |boost_lazy_enable_if_c|_\, |boost_disable_if|_\, |boost_disable_if_c|_\,
3059     // |boost_lazy_disable_if|_\, |boost_lazy_disable_if_c|_\, or
3060     // |std_enable_if|_\:
3061     template <typename Args>
3062     using boost_param_result_const\_ ## __LINE__ ## operator = **result**;
3063
3064     // If **result** is a simple return type:
3065     template <typename Args>
3066     struct boost_param_result_const\_ ## __LINE__ ## operator
3067     {
3068         typedef **result** type;
3069     };
3070
3071     struct boost_param_params_const\_ ## __LINE__ ## operator
3072       : |parameters|_\<
3073             *list of parameter specifications, based on arguments*
3074         >
3075     {
3076     };
3077
3078     typedef boost_param_params_const\_ ## __LINE__ ## operator
3079         boost_param_parameters_const\_ ## __LINE__ ## operator;
3080
3081     template <typename A0, …, typename A ## **n**>
3082     **result** operator()(
3083         A0&& a0, …, A ## **n**\ && a ## **n**
3084       , typename boost_param_parameters_const\_ ## __LINE__ ## operator
3085         ::match<A0, …, A ## **n**>::type
3086         = boost_param_parameters_const\_ ## __LINE__ ## operator()
3087     ) const
3088     {
3089         return this->boost_param_impl_const ## __LINE__ ## operator(
3090             boost_param_parameters_const\_ ## __LINE__ ## operator()(
3091                 |std_forward|_\<A0>(a0)
3092               , …
3093               , |std_forward|_\<A ## **n**>(a ## **n**)
3094             )
3095         );
3096     }
3097
3098     :vellipsis:`⋮`
3099
3100     template <typename A0, …, typename A ## **m**>
3101     **result** operator()(
3102         A0&& a0, …, A ## **m**\ && a ## **m**
3103       , typename boost_param_parameters_const\_ ## __LINE__ ## operator
3104         ::match<A0, …, A ## **m**>::type
3105         = boost_param_parameters_const\_ ## __LINE__ ## operator()
3106     ) const
3107     {
3108         return this->boost_param_impl_const ## __LINE__ ## operator(
3109             boost_param_parameters_const\_ ## __LINE__ ## operator()(
3110                 |std_forward|_\<A0>(a0)
3111               , …
3112               , |std_forward|_\<A ## **m**>(a ## **m**)
3113             )
3114         );
3115     }
3116
3117     template <typename Args>
3118     typename boost_param_result_const\_ ## __LINE__ ## operator<Args>::type
3119         boost_param_impl_const ## __LINE__ ## operator(Args const& args) const
3120     {
3121         return this->
3122         boost_param_dispatch_const_0boost\_ ## __LINE__ ## operator(
3123             static_cast<
3124                 typename boost_param_result_const\_ ## __LINE__ ## operator<
3125                     Args
3126                 >::type(*)()
3127             >(|std_nullptr|_\)
3128           , args
3129           , |std_forward|_\<
3130                 typename |value_type|_\<
3131                     Args
3132                   , *keyword tag type of required parameter* ## **0**
3133                 >::type
3134             >(args[ *keyword object of required parameter* ## **0**])
3135           , …
3136           , |std_forward|_\<
3137                 typename |value_type|_\<
3138                     Args
3139                   , *keyword tag type of required parameter* ## **n**
3140                 >::type
3141             >(args[ *keyword object of required parameter* ## **n**])
3142         );
3143     }
3144
3145     template <
3146         typename ResultType
3147       , typename Args
3148       , typename *argument name* ## **0** ## _type
3149       , …
3150       , typename *argument name* ## **n** ## _type
3151     >
3152     ResultType
3153         boost_param_dispatch_const_0boost\_ ## __LINE__ ## operator(
3154             (ResultType(*)())
3155           , Args const& args
3156           , *argument name* ## **0** ## _type&& *argument name* ## **0**
3157           , …
3158           , *argument name* ## **n** ## _type&& *argument name* ## **n**
3159         ) const
3160     {
3161         return this->
3162         boost_param_dispatch_const_0boost\_ ## __LINE__ ## operator(
3163             static_cast<ResultType(*)()>(|std_nullptr|_\)
3164           , (args, *keyword object of optional parameter* ## **n + 1** =
3165                 *default value of optional parameter* ## **n + 1**
3166             )
3167           , |std_forward|_\<*argument name* ## **0** ## _type>(
3168                 *argument name* ## **0**
3169             )
3170           , …
3171           , |std_forward|_\<*argument name* ## **n** ## _type>(
3172                 *argument name* ## **n**
3173             )
3174           , |std_forward|_\<
3175                 typename |value_type|_\<
3176                     Args
3177                   , *keyword tag type of optional parameter* ## **n + 1**
3178                 >::type
3179             >(*default value of optional parameter* ## **n + 1**)
3180         );
3181     }
3182
3183     :vellipsis:`⋮`
3184
3185     template <
3186         typename ResultType
3187       , typename Args
3188       , typename *argument name* ## **0** ## _type
3189       , …
3190       , typename *argument name* ## **m** ## _type
3191     >
3192     ResultType
3193         boost_param_dispatch_const_0boost\_ ## __LINE__ ## operator(
3194             (ResultType(*)())
3195           , Args const& args
3196           , *argument name* ## **0** ## _type&& *argument name* ## **0**
3197           , …
3198           , *argument name* ## **m** ## _type&& *argument name* ## **m**
3199         ) const
3200
3201 .. |BOOST_PARAMETER_CONSTRUCTOR| replace:: ``BOOST_PARAMETER_CONSTRUCTOR``
3202 .. _BOOST_PARAMETER_CONSTRUCTOR:
3203
3204 ``BOOST_PARAMETER_CONSTRUCTOR(cls, impl, tag_namespace, arguments)``
3205 --------------------------------------------------------------------
3206
3207 :Defined in: |preprocessor_header|_
3208
3209 Generates a constructor that can take in positional arguments, composed
3210 arguments, named arguments, and deduced arguments.
3211
3212 :Example usage:
3213
3214 Define the named parameters that will comprise the argument specification that
3215 this macro will use.  Ensure that all their tag types are in the same
3216 namespace, which is ``tag`` by default.
3217
3218 .. parsed-literal::
3219
3220     |BOOST_PARAMETER_NAME|_\(y)
3221     |BOOST_PARAMETER_NAME|_\(z)
3222
3223 In the base class, implement a delegate constructor template that takes in an
3224 |ArgumentPack|_.  You must pass the identifiers with leading underscores to
3225 ``args`` in order to extract the corresponding arguments.
3226
3227 .. parsed-literal::
3228
3229     class char_read_base
3230     {
3231         int index;
3232         char const* key;
3233
3234      public:
3235         template <typename Args>
3236         explicit char_read_base(Args const& args)
3237           : index(args[_y]), key(args[_z])
3238         {
3239         }
3240
3241         |BOOST_PARAMETER_CONST_FUNCTION_CALL_OPERATOR|_\((char), tag,
3242             (deduced
3243                 (required
3244                     (y, (bool))
3245                     (z, (|std_map|_\<char const*, |std_string|_\>))
3246                 )
3247             )
3248         )
3249         {
3250             return y ? (
3251                 (z.find(this->key)->second)[this->index]
3252             ) : this->key[this->index];
3253         }
3254     };
3255
3256 Use the macro as a substitute for a normal constructor definition.  Note the
3257 lack of an explicit body.  Enclose the base type in parentheses.  For each
3258 parameter, also enclose the expected value type in parentheses.  Since the
3259 value types are mutually exclusive, you can wrap the parameters in a
3260 ``(deduced …)`` clause.
3261
3262 .. parsed-literal::
3263
3264     struct char_reader : public char_read_base
3265     {
3266         BOOST_PARAMETER_CONSTRUCTOR(char_reader, (char_read_base), tag,
3267             (deduced
3268                 (required
3269                     (y, (int))
3270                     (z, (char const*))
3271                 )
3272             )
3273         )
3274     };
3275
3276 The following ``char_reader`` constructor calls are legal.
3277
3278 .. parsed-literal::
3279
3280     char const* keys[] = {"foo", "bar", "baz"};
3281     |std_map|_\<char const*, |std_string|_\> k2s;
3282     k2s[keys[0]] = |std_string|_\("qux");
3283     k2s[keys[1]] = |std_string|_\("wmb");
3284     k2s[keys[2]] = |std_string|_\("zxc");
3285
3286     // positional arguments
3287     char_reader r0(0, keys[0]);
3288     BOOST_TEST_EQ('q', (r0(true, k2s)));
3289     BOOST_TEST_EQ('f', (r0(false, k2s)));
3290
3291     // named arguments
3292     char_reader r1(_z = keys[1], _y = 1);
3293     BOOST_TEST_EQ('m', (r1(_z = k2s, _y = true)));
3294     BOOST_TEST_EQ('a', (r1(_z = k2s, _y = false)));
3295
3296     // deduced arguments
3297     char_reader r2(keys[2], 2);
3298     BOOST_TEST_EQ('c', (r2(k2s, true)));
3299     BOOST_TEST_EQ('z', (r2(k2s, false)));
3300
3301 The |preprocessor_cpp|_ and |preprocessor_deduced_cpp|_ test programs
3302 demonstrate proper usage of this macro.
3303
3304 **Macro parameters:**
3305
3306 *   ``cls`` is the name of the enclosing class.
3307 *   ``impl`` is the parenthesized implementation base class for ``cls``.
3308 *   ``tag_namespace`` is the namespace in which the keywords used by the
3309     constructor resides.
3310 *   ``arguments`` is a list of *argument-specifiers*, as defined below.
3311
3312 **Argument specifiers syntax:**
3313
3314 .. parsed-literal::
3315
3316     argument-specifiers ::= *specifier-group0* {*specifier-group0*\ }
3317
3318     specifier-group0 ::= *specifier-group1* |
3319         (
3320             '**(**' '**deduced**'
3321                 *specifier-group1* {*specifier-group1*\ }
3322             '**)**'
3323         )
3324
3325     specifier-group1 ::=
3326         (
3327             '**(**' '**optional**'
3328                 *specifier* {*specifier*\ }
3329             '**)**'
3330         ) | (
3331             '**(**' '**required**'
3332                 *specifier* {*specifier*\ }
3333             '**)**'
3334         )
3335
3336     specifier ::=
3337         '**(**' *argument-name* '**,**' *restriction* ')'
3338
3339     restriction ::=
3340         ( '**\***' '**(**' *mfc* '**)**' ) |
3341         ( '**(**' *type-name* '**)**' ) |
3342         '**\***'
3343
3344 *   ``argument-name`` is any valid C++ identifier.
3345 *   ``mfc`` is an `MPL Binary Metafunction Class`_ whose first argument will
3346     be the type of the corresponding ``argument-name``, whose second argument
3347     will be the entire |ArgumentPack|_, and whose return type is a `Boolean
3348     Integral Constant`_; however, user code *cannot* compute ``mfc`` in terms
3349     of ``previous-name ## _type``.
3350 *   ``type-name`` is either the name of a **target type** or an `MPL Binary
3351     Metafunction Class`_ whose first argument will be the type of the
3352     corresponding ``argument-name``, whose second argument will be the entire
3353     |ArgumentPack|_, and whose return type is the **target type**.
3354
3355 Note that *specifier* does not include *default-value*.  It is up to the
3356 delegate constructor in ``impl`` to determine the default value of all
3357 optional arguments.
3358
3359 **Approximate expansion:**
3360
3361 Where:
3362
3363 * ``n`` denotes the *minimum* arity, as determined from ``arguments``.
3364 * ``m`` denotes the *maximum* arity, as determined from ``arguments``.
3365
3366 .. parsed-literal::
3367
3368     struct boost_param_params\_ ## __LINE__ ## ctor
3369       : |parameters|_\<
3370             *list of parameter specifications, based on arguments*
3371         >
3372     {
3373     };
3374
3375     typedef boost_param_params\_ ## __LINE__ ## ctor
3376         constructor_parameters ## __LINE__;
3377
3378     template <typename A0, …, typename A ## **n**>
3379     **cls**\ (A0&& a0, …, A ## **n** && a ## **n**)
3380       : **impl**\ (
3381             constructor_parameters ## __LINE__(
3382                 |std_forward|_\<A0>(a0)
3383               , …
3384               , |std_forward|_\<A ## **n**>(a ## **n**)
3385             )
3386         )
3387     {
3388     }
3389
3390     :vellipsis:`⋮`
3391
3392     template <typename A0, …, typename A ## **m**>
3393     **cls**\ (A0&& a0, …, A ## **m** && a ## **m**)
3394       : **impl**\ (
3395             constructor_parameters ## __LINE__(
3396                 |std_forward|_\<A0>(a0)
3397               , …
3398               , |std_forward|_\<A ## **m**>(a ## **m**)
3399             )
3400         )
3401     {
3402     }
3403
3404 .. |BOOST_PARAMETER_BASIC_FUNCTION| replace:: ``BOOST_PARAMETER_BASIC_FUNCTION``
3405 .. _BOOST_PARAMETER_BASIC_FUNCTION:
3406
3407 ``BOOST_PARAMETER_BASIC_FUNCTION(result, name, tag_namespace, arguments)``
3408 --------------------------------------------------------------------------
3409
3410 :Defined in: |preprocessor_header|_
3411
3412 Generates a function that can take in positional arguments, composed
3413 arguments, named arguments, and deduced arguments.
3414
3415 :Example usage:
3416
3417 The return type of each of the following function templates falls under a
3418 different value category.
3419
3420 .. parsed-literal::
3421
3422     template <std::size_t N>
3423     |std_bitset|_\<N + 1> rvalue_bitset()
3424     {
3425         return |std_bitset|_\<N + 1>();
3426     }
3427
3428     template <std::size_t N>
3429     |std_bitset|_\<N + 1> const rvalue_const_bitset()
3430     {
3431         return |std_bitset|_\<N + 1>();
3432     }
3433
3434     template <std::size_t N>
3435     |std_bitset|_\<N + 1>& lvalue_bitset()
3436     {
3437         static |std_bitset|_\<N + 1> lset = |std_bitset|_\<N + 1>();
3438         return lset;
3439     }
3440
3441     template <std::size_t N>
3442     |std_bitset|_\<N + 1> const& lvalue_const_bitset()
3443     {
3444         static |std_bitset|_\<N + 1> const clset = |std_bitset|_\<N + 1>();
3445         return clset;
3446     }
3447
3448 The ``U::evaluate_category`` static member function template has a simple job:
3449 to return the correct value category when passed in an object returned by one
3450 of the functions defined above.  Assume that
3451 |BOOST_PARAMETER_HAS_PERFECT_FORWARDING|_ is defined.
3452
3453 .. parsed-literal::
3454
3455     enum invoked
3456     {
3457         passed_by_lvalue_reference_to_const
3458       , passed_by_lvalue_reference
3459       , passed_by_rvalue_reference_to_const
3460       , passed_by_rvalue_reference
3461     };
3462
3463     struct U
3464     {
3465         template <std::size_t N>
3466         static invoked evaluate_category(|std_bitset|_\<N + 1> const&)
3467         {
3468             return passed_by_lvalue_reference_to_const;
3469         }
3470
3471         template <std::size_t N>
3472         static invoked evaluate_category(|std_bitset|_\<N + 1>&)
3473         {
3474             return passed_by_lvalue_reference;
3475         }
3476
3477         template <std::size_t N>
3478         static invoked evaluate_category(|std_bitset|_\<N + 1> const&&)
3479         {
3480             return passed_by_rvalue_reference_to_const;
3481         }
3482
3483         template <std::size_t N>
3484         static invoked evaluate_category(|std_bitset|_\<N + 1>&&)
3485         {
3486             return passed_by_rvalue_reference;
3487         }
3488     };
3489
3490 Define the named parameters that will comprise the argument specification that
3491 this macro will use.  Ensure that all their tag types are in the same
3492 namespace, which is ``kw`` in this case.  The identifiers with leading
3493 underscores can be passed to the bracket operator of ``args`` to extract the
3494 same argument to which the corresponding named parameter (without underscores)
3495 is bound, as will be shown later.
3496
3497 .. parsed-literal::
3498
3499     |BOOST_PARAMETER_NAME|_\((_lrc, kw) in(lrc))
3500     |BOOST_PARAMETER_NAME|_\((_lr, kw) in_out(lr))
3501     |BOOST_PARAMETER_NAME|_\((_rrc, kw) in(rrc))
3502     |BOOST_PARAMETER_NAME|_\((_rr, kw) consume(rr))
3503
3504 Use the macro as a substitute for a normal function header.  Enclose the
3505 return type ``bool`` in parentheses.  For each parameter, also enclose the
3506 expected value type in parentheses.  Since the value types are mutually
3507 exclusive, you can wrap the parameters in a ``(deduced …)``
3508 clause.  Otherwise, just as with a normal function, the order in which you
3509 specify the parameters determines their position.  However, unlike a normal
3510 function, default values must be specified within the function body.  Also
3511 within the function body, you must pass the matching identifier with the
3512 leading underscore to the bracket operator of ``args`` to extract the
3513 corresponding argument, but at least this doesn't require ``std::forward`` to
3514 preserve value categories.
3515
3516 .. parsed-literal::
3517
3518     BOOST_PARAMETER_BASIC_FUNCTION((bool), evaluate, kw,
3519         (deduced
3520             (required
3521                 (lrc, (|std_bitset|_\<1>))
3522                 (lr, (|std_bitset|_\<2>))
3523             )
3524             (optional
3525                 (rrc, (|std_bitset|_\<3>))
3526                 (rr, (|std_bitset|_\<4>))
3527             )
3528         )
3529     )
3530     {
3531         BOOST_TEST_EQ(
3532             passed_by_lvalue_reference_to_const
3533           , U::evaluate_category<0>(args[_lrc])
3534         );
3535         BOOST_TEST_EQ(
3536             passed_by_lvalue_reference
3537           , U::evaluate_category<1>(args[_lr])
3538         );
3539         BOOST_TEST_EQ(
3540             passed_by_rvalue_reference_to_const
3541           , U::evaluate_category<2>(
3542                 args[_rrc0 | rvalue_const_bitset<2>()]
3543             )
3544         );
3545         BOOST_TEST_EQ(
3546             passed_by_rvalue_reference
3547           , U::evaluate_category<3>(args[_rr0 | rvalue_bitset<3>()])
3548         );
3549
3550         return true;
3551     }
3552
3553 The following function calls are legal.
3554
3555 .. parsed-literal::
3556
3557     evaluate(  // positional arguments
3558         lvalue_const_bitset<0>()
3559       , lvalue_bitset<1>()
3560       , rvalue_const_bitset<2>()
3561       , rvalue_bitset<3>()
3562     );
3563     evaluate(  // positional arguments
3564         lvalue_const_bitset<0>()
3565       , lvalue_bitset<1>()
3566     );
3567     evaluate((  // composed arguments
3568         _rr0 = rvalue_bitset<3>()
3569       , _lrc0 = lvalue_const_bitset<0>()
3570       , _lr0 = lvalue_bitset<1>()
3571       , _rrc0 = rvalue_const_bitset<2>()
3572     ));
3573     evaluate(  // named arguments
3574         _rr0 = rvalue_bitset<3>()
3575       , _lrc0 = lvalue_const_bitset<0>()
3576       , _lr0 = lvalue_bitset<1>()
3577       , _rrc0 = rvalue_const_bitset<2>()
3578     );
3579     evaluate(  // named arguments
3580         _lr0 = lvalue_bitset<1>()
3581       , _lrc0 = lvalue_const_bitset<0>()
3582     );
3583
3584 Because the parameters were wrapped in a ``(deduced …)`` clause, the following
3585 function calls are also legal.
3586
3587 .. parsed-literal::
3588
3589     evaluate(  // deduced arguments
3590         rvalue_bitset<3>()
3591       , lvalue_const_bitset<0>()
3592       , lvalue_bitset<1>()
3593       , rvalue_const_bitset<2>()
3594     );
3595     evaluate(  // deduced arguments
3596         lvalue_bitset<1>()
3597       , lvalue_const_bitset<0>()
3598     );
3599
3600 The |preprocessor_cpp|_ test program demonstrates proper usage of this macro.
3601
3602 **Macro parameters:**
3603
3604 *   ``result`` is the parenthesized return type of the function.
3605 *   ``name`` is the base name of the function; it determines the name of the
3606     generated forwarding functions.
3607 *   ``tag_namespace`` is the namespace in which the keywords used by the
3608     function resides.
3609 *   ``arguments`` is a |Boost_Preprocessor|_ `sequence`_ of
3610     *argument-specifiers*, as defined below.
3611
3612 **Argument specifiers syntax:**
3613
3614 .. parsed-literal::
3615
3616     argument-specifiers ::= *specifier-group0* {*specifier-group0*\ }
3617
3618     specifier-group0 ::= *specifier-group1* |
3619         (
3620             '**(**' '**deduced**'
3621                 *specifier-group1* {*specifier-group1*\ }
3622             '**)**'
3623         )
3624
3625     specifier-group1 ::=
3626         (
3627             '**(**' '**optional**'
3628                 *specifier* {*specifier*\ }
3629             '**)**'
3630         ) | (
3631             '**(**' '**required**'
3632                 *specifier* {*specifier*\ }
3633             '**)**'
3634         )
3635
3636     specifier ::=
3637         '**(**' *argument-name* '**,**' *restriction* ')'
3638
3639     restriction ::=
3640         ( '**\***' '**(**' *mfc* '**)**' ) |
3641         ( '**(**' *type-name* '**)**' ) |
3642         '**\***'
3643
3644 *   ``argument-name`` is any valid C++ identifier.
3645 *   ``mfc`` is an `MPL Binary Metafunction Class`_ whose first argument will
3646     be the type of the corresponding ``argument-name``, whose second argument
3647     will be the entire |ArgumentPack|_, and whose return type is a `Boolean
3648     Integral Constant`_; however, user code *cannot* compute ``mfc`` in terms
3649     of ``previous-name ## _type``.
3650 *   ``type-name`` is either the name of a **target type** or an `MPL Binary
3651     Metafunction Class`_ whose first argument will be the type of the
3652     corresponding ``argument-name``, whose second argument will be the entire
3653     |ArgumentPack|_, and whose return type is the **target type**.
3654
3655 Note that *specifier* does not include *default-value*.  It is up to the
3656 function body to determine the default value of all optional arguments.
3657
3658 **Approximate expansion:**
3659
3660 Where:
3661
3662 * ``n`` denotes the *minimum* arity, as determined from ``arguments``.
3663 * ``m`` denotes the *maximum* arity, as determined from ``arguments``.
3664
3665 .. parsed-literal::
3666
3667     // If **result** is a template instantiation of |boost_enable_if|_\,
3668     // |boost_enable_if_c|_\, |boost_lazy_enable_if|_\,
3669     // |boost_lazy_enable_if_c|_\, |boost_disable_if|_\, |boost_disable_if_c|_\,
3670     // |boost_lazy_disable_if|_\, |boost_lazy_disable_if_c|_\, or
3671     // |std_enable_if|_\:
3672     template <typename Args>
3673     using boost_param_result\_ ## __LINE__ ## **name** = **result**;
3674
3675     // If **result** is a simple return type:
3676     template <typename Args>
3677     struct boost_param_result\_ ## __LINE__ ## **name**
3678     {
3679         typedef **result** type;
3680     };
3681
3682     struct boost_param_params\_ ## __LINE__ ## **name**
3683       : |parameters|_\<
3684             *list of parameter specifications, based on arguments*
3685         >
3686     {
3687     };
3688
3689     typedef boost_param_params\_ ## __LINE__ ## **name**
3690         boost_param_parameters\_ ## __LINE__ ## **name**;
3691
3692     template <typename Args>
3693     typename boost_param_result\_ ## __LINE__ ## **name**\ <Args>::type
3694         boost_param_impl ## **name**\ (Args const&);
3695
3696     template <typename A0, …, typename A ## **n**>
3697     **result** **name**\ (
3698         A0&& a0, …, A ## **n**\ && a ## **n**
3699       , typename boost_param_parameters\_ ## __LINE__ ## **name**
3700         ::match<A0, …, A ## **n**>::type
3701         = boost_param_parameters\_ ## __LINE__ ## **name**\ ()
3702     )
3703     {
3704         return boost_param_impl ## __LINE__ ## **name**\ (
3705             boost_param_parameters\_ ## __LINE__ ## **name**\ ()(
3706                 |std_forward|_\<A0>(a0)
3707               , …
3708               , |std_forward|_\<A ## **n**>(a ## **n**)
3709             )
3710         );
3711     }
3712
3713     :vellipsis:`⋮`
3714
3715     template <typename A0, …, typename A ## **m**>
3716     **result** **name**\ (
3717         A0&& a0, …, A ## **m**\ && a ## **m**
3718       , typename boost_param_parameters\_ ## __LINE__ ## **name**
3719         ::match<A0, …, A ## **m**>::type
3720         = boost_param_parameters\_ ## __LINE__ ## **name**\ ()
3721     )
3722     {
3723         return boost_param_impl ## __LINE__ ## **name**\ (
3724             boost_param_parameters\_ ## __LINE__ ## **name**\ ()(
3725                 |std_forward|_\<A0>(a0)
3726               , …
3727               , |std_forward|_\<A ## **m**>(a ## **m**)
3728             )
3729         );
3730     }
3731
3732     template <typename Args>
3733     typename boost_param_result\_ ## __LINE__ ## **name**\ <Args>::type
3734         boost_param_impl ## __LINE__ ## **name**\ (Args const& args)
3735
3736 Only the |ArgumentPack|_ type ``Args`` and its object instance ``args`` are
3737 available for use within the function body.
3738
3739 .. |BOOST_PARAMETER_BASIC_MEMBER_FUNCTION| replace:: ``BOOST_PARAMETER_BASIC_MEMBER_FUNCTION``
3740 .. _BOOST_PARAMETER_BASIC_MEMBER_FUNCTION:
3741
3742 ``BOOST_PARAMETER_BASIC_MEMBER_FUNCTION(result, name, tag_ns, arguments)``
3743 --------------------------------------------------------------------------
3744
3745 :Defined in: |preprocessor_header|_
3746
3747 Generates a member function that can take in positional arguments, composed
3748 arguments, named arguments, and deduced arguments.
3749
3750 :Example usage:
3751
3752 The return type of each of the following function templates falls under a
3753 different value category.
3754
3755 .. parsed-literal::
3756
3757     template <std::size_t N>
3758     |std_bitset|_\<N + 1> rvalue_bitset()
3759     {
3760         return |std_bitset|_\<N + 1>();
3761     }
3762
3763     template <std::size_t N>
3764     |std_bitset|_\<N + 1> const rvalue_const_bitset()
3765     {
3766         return |std_bitset|_\<N + 1>();
3767     }
3768
3769     template <std::size_t N>
3770     |std_bitset|_\<N + 1>& lvalue_bitset()
3771     {
3772         static |std_bitset|_\<N + 1> lset = |std_bitset|_\<N + 1>();
3773         return lset;
3774     }
3775
3776     template <std::size_t N>
3777     |std_bitset|_\<N + 1> const& lvalue_const_bitset()
3778     {
3779         static |std_bitset|_\<N + 1> const clset = |std_bitset|_\<N + 1>();
3780         return clset;
3781     }
3782
3783 The ``U::evaluate_category`` static member function template has a simple job:
3784 to return the correct value category when passed in an object returned by one
3785 of the functions defined above.  Assume that
3786 |BOOST_PARAMETER_HAS_PERFECT_FORWARDING|_ is defined.
3787
3788 .. parsed-literal::
3789
3790     enum invoked
3791     {
3792         passed_by_lvalue_reference_to_const
3793       , passed_by_lvalue_reference
3794       , passed_by_rvalue_reference_to_const
3795       , passed_by_rvalue_reference
3796     };
3797
3798     struct U
3799     {
3800         template <std::size_t N>
3801         static invoked evaluate_category(|std_bitset|_\<N + 1> const&)
3802         {
3803             return passed_by_lvalue_reference_to_const;
3804         }
3805
3806         template <std::size_t N>
3807         static invoked evaluate_category(|std_bitset|_\<N + 1>&)
3808         {
3809             return passed_by_lvalue_reference;
3810         }
3811
3812         template <std::size_t N>
3813         static invoked evaluate_category(|std_bitset|_\<N + 1> const&&)
3814         {
3815             return passed_by_rvalue_reference_to_const;
3816         }
3817
3818         template <std::size_t N>
3819         static invoked evaluate_category(|std_bitset|_\<N + 1>&&)
3820         {
3821             return passed_by_rvalue_reference;
3822         }
3823     };
3824
3825 Define the named parameters that will comprise the argument specification that
3826 this macro will use.  Ensure that all their tag types are in the same
3827 namespace, which is ``kw`` in this case.  The identifiers with leading
3828 underscores can be passed to the bracket operator of ``args`` to extract the
3829 same argument to which the corresponding named parameter (without underscores)
3830 is bound, as will be shown later.
3831
3832 .. parsed-literal::
3833
3834     |BOOST_PARAMETER_NAME|_\((_lrc, kw) in(lrc))
3835     |BOOST_PARAMETER_NAME|_\((_lr, kw) in_out(lr))
3836     |BOOST_PARAMETER_NAME|_\((_rrc, kw) in(rrc))
3837     |BOOST_PARAMETER_NAME|_\((_rr, kw) consume(rr))
3838
3839 Use the macro as a substitute for a normal ``static`` member function
3840 header.  Enclose the return type ``bool`` in parentheses.  For each parameter,
3841 also enclose the expected value type in parentheses.  Since the value types
3842 are mutually exclusive, you can wrap the parameters in a ``(deduced …)``
3843 clause.  Otherwise, just as with a normal function, the order in which you
3844 specify the parameters determines their position.  However, unlike a normal
3845 function, default values must be specified within the function body.  Also
3846 within the function body, you must pass the matching identifier with the
3847 leading underscore to the bracket operator of ``args`` to extract the
3848 corresponding argument, but at least this doesn't require ``std::forward`` to
3849 preserve value categories.
3850
3851 .. parsed-literal::
3852
3853     struct B
3854     {
3855         BOOST_PARAMETER_BASIC_MEMBER_FUNCTION((bool), static evaluate, kw,
3856             (deduced
3857                 (required
3858                     (lrc, (|std_bitset|_\<1>))
3859                     (lr, (|std_bitset|_\<2>))
3860                 )
3861                 (optional
3862                     (rrc, (|std_bitset|_\<3>))
3863                     (rr, (|std_bitset|_\<4>))
3864                 )
3865             )
3866         )
3867         {
3868             BOOST_TEST_EQ(
3869                 passed_by_lvalue_reference_to_const
3870               , U::evaluate_category<0>(args[_lrc])
3871             );
3872             BOOST_TEST_EQ(
3873                 passed_by_lvalue_reference
3874               , U::evaluate_category<1>(args[_lr])
3875             );
3876             BOOST_TEST_EQ(
3877                 passed_by_rvalue_reference_to_const
3878               , U::evaluate_category<2>(
3879                     args[_rrc0 | rvalue_const_bitset<2>()]
3880                 )
3881             );
3882             BOOST_TEST_EQ(
3883                 passed_by_rvalue_reference
3884               , U::evaluate_category<3>(
3885                     args[_rr0 | rvalue_bitset<3>()]
3886                 )
3887             );
3888
3889             return true;
3890         }
3891     };
3892
3893 The following function calls are legal.
3894
3895 .. parsed-literal::
3896
3897     B::evaluate(  // positional arguments
3898         lvalue_const_bitset<0>()
3899       , lvalue_bitset<1>()
3900       , rvalue_const_bitset<2>()
3901       , rvalue_bitset<3>()
3902     );
3903     B::evaluate(  // positional arguments
3904         lvalue_const_bitset<0>()
3905       , lvalue_bitset<1>()
3906     );
3907     B::evaluate((  // composed arguments
3908         _rr0 = rvalue_bitset<3>()
3909       , _lrc0 = lvalue_const_bitset<0>()
3910       , _lr0 = lvalue_bitset<1>()
3911       , _rrc0 = rvalue_const_bitset<2>()
3912     ));
3913     B::evaluate(  // named arguments
3914         _rr0 = rvalue_bitset<3>()
3915       , _lrc0 = lvalue_const_bitset<0>()
3916       , _lr0 = lvalue_bitset<1>()
3917       , _rrc0 = rvalue_const_bitset<2>()
3918     );
3919     B::evaluate(  // named arguments
3920         _lr0 = lvalue_bitset<1>()
3921       , _lrc0 = lvalue_const_bitset<0>()
3922     );
3923
3924 Because the parameters were wrapped in a ``(deduced …)`` clause, the following
3925 function calls are also legal.
3926
3927 .. parsed-literal::
3928
3929     B::evaluate(  // deduced arguments
3930         rvalue_bitset<3>()
3931       , lvalue_const_bitset<0>()
3932       , lvalue_bitset<1>()
3933       , rvalue_const_bitset<2>()
3934     );
3935     B::evaluate(  // deduced arguments
3936         lvalue_bitset<1>()
3937       , lvalue_const_bitset<0>()
3938     );
3939
3940 The |preprocessor_cpp|_ test program demonstrates proper usage of this macro.
3941
3942 **Macro parameters:**
3943
3944 *   ``result`` is the parenthesized return type of the function.
3945 *   ``name`` is the base name of the function; it determines the name of the
3946     generated forwarding functions.  ``name`` may be qualified by the
3947     ``static`` keyword to declare the member function and its helpers as not
3948     associated with any object of the enclosing type.
3949 *   ``tag_namespace`` is the namespace in which the keywords used by the
3950     function resides.
3951 *   ``arguments`` is a |Boost_Preprocessor|_ `sequence`_ of
3952     *argument-specifiers*, as defined below.
3953
3954 **Argument specifiers syntax:**
3955
3956 .. parsed-literal::
3957
3958     argument-specifiers ::= *specifier-group0* {*specifier-group0*\ }
3959
3960     specifier-group0 ::= *specifier-group1* |
3961         (
3962             '**(**' '**deduced**'
3963                 *specifier-group1* {*specifier-group1*\ }
3964             '**)**'
3965         )
3966
3967     specifier-group1 ::=
3968         (
3969             '**(**' '**optional**'
3970                 *specifier* {*specifier*\ }
3971             '**)**'
3972         ) | (
3973             '**(**' '**required**'
3974                 *specifier* {*specifier*\ }
3975             '**)**'
3976         )
3977
3978     specifier ::=
3979         '**(**' *argument-name* '**,**' *restriction* ')'
3980
3981     restriction ::=
3982         ( '**\***' '**(**' *mfc* '**)**' ) |
3983         ( '**(**' *type-name* '**)**' ) |
3984         '**\***'
3985
3986 *   ``argument-name`` is any valid C++ identifier.
3987 *   ``mfc`` is an `MPL Binary Metafunction Class`_ whose first argument will
3988     be the type of the corresponding ``argument-name``, whose second argument
3989     will be the entire |ArgumentPack|_, and whose return type is a `Boolean
3990     Integral Constant`_; however, user code *cannot* compute ``mfc`` in terms
3991     of ``previous-name ## _type``.
3992 *   ``type-name`` is either the name of a **target type** or an `MPL Binary
3993     Metafunction Class`_ whose first argument will be the type of the
3994     corresponding ``argument-name``, whose second argument will be the entire
3995     |ArgumentPack|_, and whose return type is the **target type**.
3996
3997 Note that *specifier* does not include *default-value*.  It is up to the
3998 function body to determine the default value of all optional arguments.
3999
4000 **Approximate expansion:**
4001
4002 Where:
4003
4004 * ``n`` denotes the *minimum* arity, as determined from ``arguments``.
4005 * ``m`` denotes the *maximum* arity, as determined from ``arguments``.
4006
4007 .. parsed-literal::
4008
4009     // If **result** is a template instantiation of |boost_enable_if|_\,
4010     // |boost_enable_if_c|_\, |boost_lazy_enable_if|_\,
4011     // |boost_lazy_enable_if_c|_\, |boost_disable_if|_\, |boost_disable_if_c|_\,
4012     // |boost_lazy_disable_if|_\, |boost_lazy_disable_if_c|_\, or
4013     // |std_enable_if|_\:
4014     template <typename Args>
4015     using boost_param_result\_ ## __LINE__ ## **name** = **result**;
4016
4017     // If **result** is a simple return type:
4018     template <typename Args>
4019     struct boost_param_result\_ ## __LINE__ ## **name**
4020     {
4021         typedef **result** type;
4022     };
4023
4024     struct boost_param_params\_ ## __LINE__ ## **name**
4025       : |parameters|_\<
4026             *list of parameter specifications, based on arguments*
4027         >
4028     {
4029     };
4030
4031     typedef boost_param_params\_ ## __LINE__ ## **name**
4032         boost_param_parameters\_ ## __LINE__ ## **name**;
4033
4034     template <typename A0, …, typename A ## **n**>
4035     **result** **name**\ (
4036         A0&& a0, …, A ## **n**\ && a ## **n**
4037       , typename boost_param_parameters\_ ## __LINE__ ## **name**
4038         ::match<A0, …, A ## **n**>::type
4039         = boost_param_parameters\_ ## __LINE__ ## **name**\ ()
4040     )
4041     {
4042         return this->boost_param_impl ## **name**\ (
4043             boost_param_parameters\_ ## __LINE__ ## **name**\ ()(
4044                 |std_forward|_\<A0>(a0)
4045               , …
4046               , |std_forward|_\<A ## **n**>(a ## **n**)
4047             )
4048         );
4049     }
4050
4051     :vellipsis:`⋮`
4052
4053     template <typename A0, …, typename A ## **m**>
4054     **result** **name**\ (
4055         A0&& a0, …, A ## **m**\ && a ## **m**
4056       , typename boost_param_parameters\_ ## __LINE__ ## **name**
4057         ::match<A0, …, A ## **m**>::type
4058         = boost_param_parameters\_ ## __LINE__ ## **name**\ ()
4059     )
4060     {
4061         return this->boost_param_impl ## **name**\ (
4062             boost_param_parameters\_ ## __LINE__ ## **name**\ ()(
4063                 |std_forward|_\<A0>(a0)
4064               , …
4065               , |std_forward|_\<A ## **m**>(a ## **m**)
4066             )
4067         );
4068     }
4069
4070     template <typename Args>
4071     typename boost_param_result\_ ## __LINE__ ## **name**\ <Args>::type
4072         boost_param_impl ## **name**\ (Args const& args)
4073
4074 Only the |ArgumentPack|_ type ``Args`` and its object instance ``args`` are
4075 available for use within the function body.
4076
4077 .. |BOOST_PARAMETER_BASIC_CONST_MEMBER_FUNCTION| replace:: ``BOOST_PARAMETER_BASIC_CONST_MEMBER_FUNCTION``
4078 .. _BOOST_PARAMETER_BASIC_CONST_MEMBER_FUNCTION:
4079
4080 ``BOOST_PARAMETER_BASIC_CONST_MEMBER_FUNCTION(result, name, tag_ns, args)``
4081 ---------------------------------------------------------------------------
4082
4083 :Defined in: |preprocessor_header|_
4084
4085 Generates a member function that can take in positional arguments, composed
4086 arguments, named arguments, and deduced arguments.
4087
4088 :Example usage:
4089
4090 The return type of each of the following function templates falls under a
4091 different value category.
4092
4093 .. parsed-literal::
4094
4095     template <std::size_t N>
4096     |std_bitset|_\<N + 1> rvalue_bitset()
4097     {
4098         return |std_bitset|_\<N + 1>();
4099     }
4100
4101     template <std::size_t N>
4102     |std_bitset|_\<N + 1> const rvalue_const_bitset()
4103     {
4104         return |std_bitset|_\<N + 1>();
4105     }
4106
4107     template <std::size_t N>
4108     |std_bitset|_\<N + 1>& lvalue_bitset()
4109     {
4110         static |std_bitset|_\<N + 1> lset = |std_bitset|_\<N + 1>();
4111         return lset;
4112     }
4113
4114     template <std::size_t N>
4115     |std_bitset|_\<N + 1> const& lvalue_const_bitset()
4116     {
4117         static |std_bitset|_\<N + 1> const clset = |std_bitset|_\<N + 1>();
4118         return clset;
4119     }
4120
4121 The ``U::evaluate_category`` static member function template has a simple job:
4122 to return the correct value category when passed in an object returned by one
4123 of the functions defined above.  Assume that
4124 |BOOST_PARAMETER_HAS_PERFECT_FORWARDING|_ is defined.
4125
4126 .. parsed-literal::
4127
4128     enum invoked
4129     {
4130         passed_by_lvalue_reference_to_const
4131       , passed_by_lvalue_reference
4132       , passed_by_rvalue_reference_to_const
4133       , passed_by_rvalue_reference
4134     };
4135
4136     struct U
4137     {
4138         template <std::size_t N>
4139         static invoked evaluate_category(|std_bitset|_\<N + 1> const&)
4140         {
4141             return passed_by_lvalue_reference_to_const;
4142         }
4143
4144         template <std::size_t N>
4145         static invoked evaluate_category(|std_bitset|_\<N + 1>&)
4146         {
4147             return passed_by_lvalue_reference;
4148         }
4149
4150         template <std::size_t N>
4151         static invoked evaluate_category(|std_bitset|_\<N + 1> const&&)
4152         {
4153             return passed_by_rvalue_reference_to_const;
4154         }
4155
4156         template <std::size_t N>
4157         static invoked evaluate_category(|std_bitset|_\<N + 1>&&)
4158         {
4159             return passed_by_rvalue_reference;
4160         }
4161     };
4162
4163 Define the named parameters that will comprise the argument specification that
4164 this macro will use.  Ensure that all their tag types are in the same
4165 namespace, which is ``kw`` in this case.  The identifiers with leading
4166 underscores can be passed to the bracket operator of ``args`` to extract the
4167 same argument to which the corresponding named parameter (without underscores)
4168 is bound, as will be shown later.
4169
4170 .. parsed-literal::
4171
4172     |BOOST_PARAMETER_NAME|_\((_lrc, kw) in(lrc))
4173     |BOOST_PARAMETER_NAME|_\((_lr, kw) in_out(lr))
4174     |BOOST_PARAMETER_NAME|_\((_rrc, kw) in(rrc))
4175     |BOOST_PARAMETER_NAME|_\((_rr, kw) consume(rr))
4176
4177 Use the macro as a substitute for a normal ``const`` member function
4178 header.  Enclose the return type ``bool`` in parentheses.  For each parameter,
4179 also enclose the expected value type in parentheses.  Since the value types
4180 are mutually exclusive, you can wrap the parameters in a ``(deduced …)``
4181 clause.  Otherwise, just as with a normal function, the order in which you
4182 specify the parameters determines their position.  However, unlike a normal
4183 function, default values must be specified within the function body.  Also
4184 within the function body, you must pass the matching identifier with the
4185 leading underscore to the bracket operator of ``args`` to extract the
4186 corresponding argument, but at least this doesn't require ``std::forward`` to
4187 preserve value categories.
4188
4189 .. parsed-literal::
4190
4191     struct B
4192     {
4193         B()
4194         {
4195         }
4196
4197         BOOST_PARAMETER_BASIC_CONST_MEMBER_FUNCTION((bool), evaluate, kw,
4198             (deduced
4199                 (required
4200                     (lrc, (|std_bitset|_\<1>))
4201                     (lr, (|std_bitset|_\<2>))
4202                 )
4203                 (optional
4204                     (rrc, (|std_bitset|_\<3>))
4205                     (rr, (|std_bitset|_\<4>))
4206                 )
4207             )
4208         )
4209         {
4210             BOOST_TEST_EQ(
4211                 passed_by_lvalue_reference_to_const
4212               , U::evaluate_category<0>(args[_lrc])
4213             );
4214             BOOST_TEST_EQ(
4215                 passed_by_lvalue_reference
4216               , U::evaluate_category<1>(args[_lr])
4217             );
4218             BOOST_TEST_EQ(
4219                 passed_by_rvalue_reference_to_const
4220               , U::evaluate_category<2>(
4221                     args[_rrc0 | rvalue_const_bitset<2>()]
4222                 )
4223             );
4224             BOOST_TEST_EQ(
4225                 passed_by_rvalue_reference
4226               , U::evaluate_category<3>(
4227                     args[_rr0 | rvalue_bitset<3>()]
4228                 )
4229             );
4230
4231             return true;
4232         }
4233     };
4234
4235 The following function calls are legal.
4236
4237 .. parsed-literal::
4238
4239     B const b = B();
4240     b.evaluate(  // positional arguments
4241         lvalue_const_bitset<0>()
4242       , lvalue_bitset<1>()
4243       , rvalue_const_bitset<2>()
4244       , rvalue_bitset<3>()
4245     );
4246     b.evaluate(  // positional arguments
4247         lvalue_const_bitset<0>()
4248       , lvalue_bitset<1>()
4249     );
4250     b.evaluate((  // composed arguments
4251         _rr0 = rvalue_bitset<3>()
4252       , _lrc0 = lvalue_const_bitset<0>()
4253       , _lr0 = lvalue_bitset<1>()
4254       , _rrc0 = rvalue_const_bitset<2>()
4255     ));
4256     b.evaluate(  // named arguments
4257         _rr0 = rvalue_bitset<3>()
4258       , _lrc0 = lvalue_const_bitset<0>()
4259       , _lr0 = lvalue_bitset<1>()
4260       , _rrc0 = rvalue_const_bitset<2>()
4261     );
4262     b.evaluate(  // named arguments
4263         _lr0 = lvalue_bitset<1>()
4264       , _lrc0 = lvalue_const_bitset<0>()
4265     );
4266
4267 Because the parameters were wrapped in a ``(deduced …)`` clause, the following
4268 function calls are also legal.
4269
4270 .. parsed-literal::
4271
4272     b.evaluate(  // deduced arguments
4273         rvalue_bitset<3>()
4274       , lvalue_const_bitset<0>()
4275       , lvalue_bitset<1>()
4276       , rvalue_const_bitset<2>()
4277     );
4278     b.evaluate(  // deduced arguments
4279         lvalue_bitset<1>()
4280       , lvalue_const_bitset<0>()
4281     );
4282
4283 The |preprocessor_cpp|_ test program demonstrates proper usage of this macro.
4284
4285 **Macro parameters:**
4286
4287 *   ``result`` is the parenthesized return type of the function.
4288 *   ``name`` is the base name of the function; it determines the name of the
4289     generated forwarding functions.
4290 *   ``tag_namespace`` is the namespace in which the keywords used by the
4291     function resides.
4292 *   ``arguments`` is a |Boost_Preprocessor|_ `sequence`_ of
4293     *argument-specifiers*, as defined below.
4294
4295 **Argument specifiers syntax:**
4296
4297 .. parsed-literal::
4298
4299     argument-specifiers ::= *specifier-group0* {*specifier-group0*\ }
4300
4301     specifier-group0 ::= *specifier-group1* |
4302         (
4303             '**(**' '**deduced**'
4304                 *specifier-group1* {*specifier-group1*\ }
4305             '**)**'
4306         )
4307
4308     specifier-group1 ::=
4309         (
4310             '**(**' '**optional**'
4311                 *specifier* {*specifier*\ }
4312             '**)**'
4313         ) | (
4314             '**(**' '**required**'
4315                 *specifier* {*specifier*\ }
4316             '**)**'
4317         )
4318
4319     specifier ::=
4320         '**(**' *argument-name* '**,**' *restriction* ')'
4321
4322     restriction ::=
4323         ( '**\***' '**(**' *mfc* '**)**' ) |
4324         ( '**(**' *type-name* '**)**' ) |
4325         '**\***'
4326
4327 *   ``argument-name`` is any valid C++ identifier.
4328 *   ``mfc`` is an `MPL Binary Metafunction Class`_ whose first argument will
4329     be the type of the corresponding ``argument-name``, whose second argument
4330     will be the entire |ArgumentPack|_, and whose return type is a `Boolean
4331     Integral Constant`_; however, user code *cannot* compute ``mfc`` in terms
4332     of ``previous-name ## _type``.
4333 *   ``type-name`` is either the name of a **target type** or an `MPL Binary
4334     Metafunction Class`_ whose first argument will be the type of the
4335     corresponding ``argument-name``, whose second argument will be the entire
4336     |ArgumentPack|_, and whose return type is the **target type**.
4337
4338 Note that *specifier* does not include *default-value*.  It is up to the
4339 function body to determine the default value of all optional arguments.
4340
4341 **Approximate expansion:**
4342
4343 Where:
4344
4345 * ``n`` denotes the *minimum* arity, as determined from ``arguments``.
4346 * ``m`` denotes the *maximum* arity, as determined from ``arguments``.
4347
4348 .. parsed-literal::
4349
4350     // If **result** is a template instantiation of |boost_enable_if|_\,
4351     // |boost_enable_if_c|_\, |boost_lazy_enable_if|_\,
4352     // |boost_lazy_enable_if_c|_\, |boost_disable_if|_\, |boost_disable_if_c|_\,
4353     // |boost_lazy_disable_if|_\, |boost_lazy_disable_if_c|_\, or
4354     // |std_enable_if|_\:
4355     template <typename Args>
4356     using boost_param_result_const\_ ## __LINE__ ## **name** = **result**;
4357
4358     // If **result** is a simple return type:
4359     template <typename Args>
4360     struct boost_param_result_const\_ ## __LINE__ ## **name**
4361     {
4362         typedef **result** type;
4363     };
4364
4365     struct boost_param_params_const\_ ## __LINE__ ## **name**
4366       : |parameters|_\<
4367             *list of parameter specifications, based on arguments*
4368         >
4369     {
4370     };
4371
4372     typedef boost_param_params_const\_ ## __LINE__ ## **name**
4373         boost_param_parameters_const\_ ## __LINE__ ## **name**;
4374
4375     template <typename A0, …, typename A ## **n**>
4376     **result** **name**\ (
4377         A0&& a0, …, A ## **n**\ && a ## **n**
4378       , typename boost_param_parameters_const\_ ## __LINE__ ## **name**
4379         ::match<A0, …, A ## **n**>::type
4380         = boost_param_parameters_const\_ ## __LINE__ ## **name**\ ()
4381     ) const
4382     {
4383         return this->boost_param_impl_const ## __LINE__ ## **name**\ (
4384             boost_param_parameters_const\_ ## __LINE__ ## **name**\ ()(
4385                 |std_forward|_\<A0>(a0)
4386               , …
4387               , |std_forward|_\<A ## **n**>(a ## **n**)
4388             )
4389         );
4390     }
4391
4392     :vellipsis:`⋮`
4393
4394     template <typename A0, …, typename A ## **m**>
4395     **result** **name**\ (
4396         A0&& a0, …, A ## **m**\ && a ## **m**
4397       , typename boost_param_parameters_const\_ ## __LINE__ ## **name**
4398         ::match<A0, …, A ## **m**>::type
4399         = boost_param_parameters_const\_ ## __LINE__ ## **name**\ ()
4400     ) const
4401     {
4402         return this->boost_param_impl_const ## __LINE__ ## **name**\ (
4403             boost_param_parameters_const\_ ## __LINE__ ## **name**\ ()(
4404                 |std_forward|_\<A0>(a0)
4405               , …
4406               , |std_forward|_\<A ## **m**>(a ## **m**)
4407             )
4408         );
4409     }
4410
4411     template <typename Args>
4412     typename boost_param_result_const\_ ## __LINE__ ## **name**\ <Args>::type
4413         boost_param_impl_const ## __LINE__ ## **name**\ (Args const& args) const
4414
4415 Only the |ArgumentPack|_ type ``Args`` and its object instance ``args`` are
4416 available for use within the function body.
4417
4418 .. |BOOST_PARAMETER_BASIC_FUNCTION_CALL_OPERATOR| replace:: ``BOOST_PARAMETER_BASIC_FUNCTION_CALL_OPERATOR``
4419 .. _BOOST_PARAMETER_BASIC_FUNCTION_CALL_OPERATOR:
4420
4421 ``BOOST_PARAMETER_BASIC_FUNCTION_CALL_OPERATOR(result, tag_ns, arguments)``
4422 ---------------------------------------------------------------------------
4423
4424 :Defined in: |preprocessor_header|_
4425
4426 Generates a function call operator that can take in positional arguments,
4427 composed arguments, named arguments, and deduced arguments.
4428
4429 :Example usage:
4430
4431 Define the named parameters that will comprise the argument specification that
4432 this macro will use.  Ensure that all their tag types are in the same
4433 namespace, which is ``tag`` by default.
4434
4435 .. parsed-literal::
4436
4437     |BOOST_PARAMETER_NAME|_\(y)
4438     |BOOST_PARAMETER_NAME|_\(z)
4439
4440 Use the macro as a substitute for a normal function call operator
4441 header.  Enclose the return type in parentheses.  For each parameter, also
4442 enclose the expected value type in parentheses.  Since the value types are
4443 mutually exclusive, you can wrap the parameters in a ``(deduced …)``
4444 clause.  This is especially useful when implementing multiple
4445 Boost.Parameter-enabled function call operator overloads.
4446
4447 .. parsed-literal::
4448
4449     class char_reader
4450     {
4451         int index;
4452         char const* key;
4453
4454      public:
4455         explicit char_reader(char const* k) : index(0), key(k)
4456         {
4457         }
4458
4459         BOOST_PARAMETER_BASIC_FUNCTION_CALL_OPERATOR((void), tag,
4460             (deduced
4461                 (required
4462                     (y, (int))
4463                     (z, (char const*))
4464                 )
4465             )
4466         )
4467         {
4468             this->index = args[_y];
4469             this->key = args[_z];
4470         }
4471
4472         |BOOST_PARAMETER_BASIC_CONST_FUNCTION_CALL_OPERATOR|_\((char), tag,
4473             (deduced
4474                 (required
4475                     (y, (bool))
4476                     (z, (|std_map|_\<char const*, |std_string|_\>))
4477                 )
4478             )
4479         )
4480         {
4481             return args[_y] ? (
4482                 (args[_z].find(this->key)->second)[this->index]
4483             ) : this->key[this->index];
4484         }
4485     };
4486
4487 As with regular argument-dependent lookup, the value types of the arguments
4488 passed in determine which function call operator overload gets invoked.
4489
4490 .. parsed-literal::
4491
4492     char const* keys[] = {"foo", "bar", "baz"};
4493     |std_map|_\<char const*, |std_string|_\> k2s;
4494     k2s[keys[0]] = |std_string|_\("qux");
4495     k2s[keys[1]] = |std_string|_\("wmb");
4496     k2s[keys[2]] = |std_string|_\("zxc");
4497     char_reader r(keys[0]);
4498
4499     // positional arguments
4500     BOOST_TEST_EQ('q', (r(true, k2s)));
4501     BOOST_TEST_EQ('f', (r(false, k2s)));
4502
4503     // named arguments
4504     r(_z = keys[1], _y = 1);
4505     BOOST_TEST_EQ('m', (r(_z = k2s, _y = true)));
4506     BOOST_TEST_EQ('a', (r(_z = k2s, _y = false)));
4507
4508     // deduced arguments
4509     r(keys[2], 2);
4510     BOOST_TEST_EQ('c', (r(k2s, true)));
4511     BOOST_TEST_EQ('z', (r(k2s, false)));
4512
4513 The |preprocessor_cpp|_ test program demonstrates proper usage of this macro.
4514
4515 **Macro parameters:**
4516
4517 *   ``result`` is the parenthesized return type of the function call operator.
4518 *   ``tag_namespace`` is the namespace in which the keywords used by the
4519     function call operator resides.
4520 *   ``arguments`` is a |Boost_Preprocessor|_ `sequence`_ of
4521     *argument-specifiers*, as defined below.
4522
4523 **Argument specifiers syntax:**
4524
4525 .. parsed-literal::
4526
4527     argument-specifiers ::= *specifier-group0* {*specifier-group0*\ }
4528
4529     specifier-group0 ::= *specifier-group1* |
4530         (
4531             '**(**' '**deduced**'
4532                 *specifier-group1* {*specifier-group1*\ }
4533             '**)**'
4534         )
4535
4536     specifier-group1 ::=
4537         (
4538             '**(**' '**optional**'
4539                 *specifier* {*specifier*\ }
4540             '**)**'
4541         ) | (
4542             '**(**' '**required**'
4543                 *specifier* {*specifier*\ }
4544             '**)**'
4545         )
4546
4547     specifier ::=
4548         '**(**' *argument-name* '**,**' *restriction* ')'
4549
4550     restriction ::=
4551         ( '**\***' '**(**' *mfc* '**)**' ) |
4552         ( '**(**' *type-name* '**)**' ) |
4553         '**\***'
4554
4555 *   ``argument-name`` is any valid C++ identifier.
4556 *   ``mfc`` is an `MPL Binary Metafunction Class`_ whose first argument will
4557     be the type of the corresponding ``argument-name``, whose second argument
4558     will be the entire |ArgumentPack|_, and whose return type is a `Boolean
4559     Integral Constant`_; however, user code *cannot* compute ``mfc`` in terms
4560     of ``previous-name ## _type``.
4561 *   ``type-name`` is either the name of a **target type** or an `MPL Binary
4562     Metafunction Class`_ whose first argument will be the type of the
4563     corresponding ``argument-name``, whose second argument will be the entire
4564     |ArgumentPack|_, and whose return type is the **target type**.
4565
4566 Note that *specifier* does not include *default-value*.  It is up to the
4567 function body to determine the default value of all optional arguments.
4568
4569 **Approximate expansion:**
4570
4571 Where:
4572
4573 * ``n`` denotes the *minimum* arity, as determined from ``arguments``.
4574 * ``m`` denotes the *maximum* arity, as determined from ``arguments``.
4575
4576 .. parsed-literal::
4577
4578     // If **result** is a template instantiation of |boost_enable_if|_\,
4579     // |boost_enable_if_c|_\, |boost_lazy_enable_if|_\,
4580     // |boost_lazy_enable_if_c|_\, |boost_disable_if|_\, |boost_disable_if_c|_\,
4581     // |boost_lazy_disable_if|_\, |boost_lazy_disable_if_c|_\, or
4582     // |std_enable_if|_\:
4583     template <typename Args>
4584     using boost_param_result\_ ## __LINE__ ## operator = **result**;
4585
4586     // If **result** is a simple return type:
4587     template <typename Args>
4588     struct boost_param_result\_ ## __LINE__ ## operator
4589     {
4590         typedef **result** type;
4591     };
4592
4593     struct boost_param_params\_ ## __LINE__ ## operator
4594       : |parameters|_\<
4595             *list of parameter specifications, based on arguments*
4596         >
4597     {
4598     };
4599
4600     typedef boost_param_params\_ ## __LINE__ ## operator
4601         boost_param_parameters\_ ## __LINE__ ## operator;
4602
4603     template <typename A0, …, typename A ## **n**>
4604     **result** operator()(
4605         A0&& a0, …, A ## **n**\ && a ## **n**
4606       , typename boost_param_parameters\_ ## __LINE__ ## operator::match<
4607             A0, …, A ## **n**
4608         >::type = boost_param_parameters\_ ## __LINE__ ## operator()
4609     )
4610     {
4611         return this->boost_param_impl ## __LINE__ ## operator(
4612             boost_param_parameters\_ ## __LINE__ ## operator()(
4613                 |std_forward|_\<A0>(a0)
4614               , …
4615               , |std_forward|_\<A ## **n**>(a ## **n**)
4616             )
4617         );
4618     }
4619
4620     :vellipsis:`⋮`
4621
4622     template <typename A0, …, typename A ## **m**>
4623     **result** operator()(
4624         A0&& a0, …, A ## **m**\ && a ## **m**
4625       , typename boost_param_parameters\_ ## __LINE__ ## operator::match<
4626             A0, …, A ## **m**
4627         >::type = boost_param_parameters\_ ## __LINE__ ## operator()
4628     )
4629     {
4630         return this->boost_param_impl ## __LINE__ ## operator(
4631             boost_param_parameters\_ ## __LINE__ ## operator()(
4632                 |std_forward|_\<A0>(a0)
4633               , …
4634               , |std_forward|_\<A ## **m**>(a ## **m**)
4635             )
4636         );
4637     }
4638
4639     template <typename Args>
4640     typename boost_param_result\_ ## __LINE__ ## operator<Args>::type
4641         boost_param_impl ## __LINE__ ## operator(Args const& args)
4642
4643 Only the |ArgumentPack|_ type ``Args`` and its object instance ``args`` are
4644 available for use within the function call operator body.
4645
4646 .. |BOOST_PARAMETER_BASIC_CONST_FUNCTION_CALL_OPERATOR| replace:: ``BOOST_PARAMETER_BASIC_CONST_FUNCTION_CALL_OPERATOR``
4647 .. _BOOST_PARAMETER_BASIC_CONST_FUNCTION_CALL_OPERATOR:
4648
4649 ``BOOST_PARAMETER_BASIC_CONST_FUNCTION_CALL_OPERATOR(result, tag_ns, args)``
4650 ----------------------------------------------------------------------------
4651
4652 :Defined in: |preprocessor_header|_
4653
4654 Generates a function call operator that can take in positional arguments,
4655 composed arguments, named arguments, and deduced arguments.
4656
4657 :Example usage:
4658
4659 The return type of each of the following function templates falls under a
4660 different value category.
4661
4662 .. parsed-literal::
4663
4664     template <std::size_t N>
4665     |std_bitset|_\<N + 1> rvalue_bitset()
4666     {
4667         return |std_bitset|_\<N + 1>();
4668     }
4669
4670     template <std::size_t N>
4671     |std_bitset|_\<N + 1> const rvalue_const_bitset()
4672     {
4673         return |std_bitset|_\<N + 1>();
4674     }
4675
4676     template <std::size_t N>
4677     |std_bitset|_\<N + 1>& lvalue_bitset()
4678     {
4679         static |std_bitset|_\<N + 1> lset = |std_bitset|_\<N + 1>();
4680         return lset;
4681     }
4682
4683     template <std::size_t N>
4684     |std_bitset|_\<N + 1> const& lvalue_const_bitset()
4685     {
4686         static |std_bitset|_\<N + 1> const clset = |std_bitset|_\<N + 1>();
4687         return clset;
4688     }
4689
4690 The ``U::evaluate_category`` static member function template has a simple job:
4691 to return the correct value category when passed in an object returned by one
4692 of the functions defined above.  Assume that
4693 |BOOST_PARAMETER_HAS_PERFECT_FORWARDING|_ is defined.
4694
4695 .. parsed-literal::
4696
4697     enum invoked
4698     {
4699         passed_by_lvalue_reference_to_const
4700       , passed_by_lvalue_reference
4701       , passed_by_rvalue_reference_to_const
4702       , passed_by_rvalue_reference
4703     };
4704
4705     struct U
4706     {
4707         template <std::size_t N>
4708         static invoked evaluate_category(|std_bitset|_\<N + 1> const&)
4709         {
4710             return passed_by_lvalue_reference_to_const;
4711         }
4712
4713         template <std::size_t N>
4714         static invoked evaluate_category(|std_bitset|_\<N + 1>&)
4715         {
4716             return passed_by_lvalue_reference;
4717         }
4718
4719         template <std::size_t N>
4720         static invoked evaluate_category(|std_bitset|_\<N + 1> const&&)
4721         {
4722             return passed_by_rvalue_reference_to_const;
4723         }
4724
4725         template <std::size_t N>
4726         static invoked evaluate_category(|std_bitset|_\<N + 1>&&)
4727         {
4728             return passed_by_rvalue_reference;
4729         }
4730     };
4731
4732 Define the named parameters that will comprise the argument specification that
4733 this macro will use.  Ensure that all their tag types are in the same
4734 namespace, which is ``kw`` in this case.  The identifiers with leading
4735 underscores can be passed to the bracket operator of ``args`` to extract the
4736 same argument to which the corresponding named parameter (without underscores)
4737 is bound, as will be shown later.
4738
4739 .. parsed-literal::
4740
4741     |BOOST_PARAMETER_NAME|_\((_lrc, kw) in(lrc))
4742     |BOOST_PARAMETER_NAME|_\((_lr, kw) in_out(lr))
4743     |BOOST_PARAMETER_NAME|_\((_rrc, kw) in(rrc))
4744     |BOOST_PARAMETER_NAME|_\((_rr, kw) consume(rr))
4745
4746 Use the macro as a substitute for a normal ``const`` function call operator
4747 header.  Enclose the return type ``bool`` in parentheses.  For each parameter,
4748 also enclose the expected value type in parentheses.  Since the value types
4749 are mutually exclusive, you can wrap the parameters in a ``(deduced …)``
4750 clause.  Otherwise, just as with a normal function, the order in which you
4751 specify the parameters determines their position.  However, unlike a normal
4752 function, default values must be specified within the function body.  Also
4753 within the function body, you must pass the matching identifier with the
4754 leading underscore to the bracket operator of ``args`` to extract the
4755 corresponding argument, but at least this doesn't require ``std::forward`` to
4756 preserve value categories.
4757
4758 .. parsed-literal::
4759
4760     struct B
4761     {
4762         B()
4763         {
4764         }
4765
4766         BOOST_PARAMETER_BASIC_CONST_FUNCTION_CALL_OPERATOR((bool), kw,
4767             (deduced
4768                 (required
4769                     (lrc, (|std_bitset|_\<1>))
4770                     (lr, (|std_bitset|_\<2>))
4771                 )
4772                 (optional
4773                     (rrc, (|std_bitset|_\<3>))
4774                     (rr, (|std_bitset|_\<4>))
4775                 )
4776             )
4777         )
4778         {
4779             BOOST_TEST_EQ(
4780                 passed_by_lvalue_reference_to_const
4781               , U::evaluate_category<0>(args[_lrc])
4782             );
4783             BOOST_TEST_EQ(
4784                 passed_by_lvalue_reference
4785               , U::evaluate_category<1>(args[_lr])
4786             );
4787             BOOST_TEST_EQ(
4788                 passed_by_rvalue_reference_to_const
4789               , U::evaluate_category<2>(
4790                     args[_rrc0 | rvalue_const_bitset<2>()]
4791                 )
4792             );
4793             BOOST_TEST_EQ(
4794                 passed_by_rvalue_reference
4795               , U::evaluate_category<3>(
4796                     args[_rr0 | rvalue_bitset<3>()]
4797                 )
4798             );
4799
4800             return true;
4801         }
4802     };
4803
4804 The following function calls are legal.
4805
4806 .. parsed-literal::
4807
4808     B const b = B();
4809     b(  // positional arguments
4810         lvalue_const_bitset<0>()
4811       , lvalue_bitset<1>()
4812       , rvalue_const_bitset<2>()
4813       , rvalue_bitset<3>()
4814     );
4815     b(  // positional arguments
4816         lvalue_const_bitset<0>()
4817       , lvalue_bitset<1>()
4818     );
4819     b((  // composed arguments
4820         _rr0 = rvalue_bitset<3>()
4821       , _lrc0 = lvalue_const_bitset<0>()
4822       , _lr0 = lvalue_bitset<1>()
4823       , _rrc0 = rvalue_const_bitset<2>()
4824     ));
4825     b(  // named arguments
4826         _rr0 = rvalue_bitset<3>()
4827       , _lrc0 = lvalue_const_bitset<0>()
4828       , _lr0 = lvalue_bitset<1>()
4829       , _rrc0 = rvalue_const_bitset<2>()
4830     );
4831     b(  // named arguments
4832         _lr0 = lvalue_bitset<1>()
4833       , _lrc0 = lvalue_const_bitset<0>()
4834     );
4835
4836 Because the parameters were wrapped in a ``(deduced …)`` clause, the following
4837 function calls are also legal.
4838
4839 .. parsed-literal::
4840
4841     b(  // deduced arguments
4842         rvalue_bitset<3>()
4843       , lvalue_const_bitset<0>()
4844       , lvalue_bitset<1>()
4845       , rvalue_const_bitset<2>()
4846     );
4847     b(  // deduced arguments
4848         lvalue_bitset<1>()
4849       , lvalue_const_bitset<0>()
4850     );
4851
4852 The |preprocessor_cpp|_ test program demonstrates proper usage of this macro.
4853
4854 **Macro parameters:**
4855
4856 *   ``result`` is the parenthesized return type of the function call operator.
4857 *   ``tag_namespace`` is the namespace in which the keywords used by the
4858     function call operator resides.
4859 *   ``arguments`` is a |Boost_Preprocessor|_ `sequence`_ of
4860     *argument-specifiers*, as defined below.
4861
4862 **Argument specifiers syntax:**
4863
4864 .. parsed-literal::
4865
4866     argument-specifiers ::= *specifier-group0* {*specifier-group0*\ }
4867
4868     specifier-group0 ::= *specifier-group1* |
4869         (
4870             '**(**' '**deduced**'
4871                 *specifier-group1* {*specifier-group1*\ }
4872             '**)**'
4873         )
4874
4875     specifier-group1 ::=
4876         (
4877             '**(**' '**optional**'
4878                 *specifier* {*specifier*\ }
4879             '**)**'
4880         ) | (
4881             '**(**' '**required**'
4882                 *specifier* {*specifier*\ }
4883             '**)**'
4884         )
4885
4886     specifier ::=
4887         '**(**' *argument-name* '**,**' *restriction* ')'
4888
4889     restriction ::=
4890         ( '**\***' '**(**' *mfc* '**)**' ) |
4891         ( '**(**' *type-name* '**)**' ) |
4892         '**\***'
4893
4894 *   ``argument-name`` is any valid C++ identifier.
4895 *   ``mfc`` is an `MPL Binary Metafunction Class`_ whose first argument will
4896     be the type of the corresponding ``argument-name``, whose second argument
4897     will be the entire |ArgumentPack|_, and whose return type is a `Boolean
4898     Integral Constant`_; however, user code *cannot* compute ``mfc`` in terms
4899     of ``previous-name ## _type``.
4900 *   ``type-name`` is either the name of a **target type** or an `MPL Binary
4901     Metafunction Class`_ whose first argument will be the type of the
4902     corresponding ``argument-name``, whose second argument will be the entire
4903     |ArgumentPack|_, and whose return type is the **target type**.
4904
4905 Note that *specifier* does not include *default-value*.  It is up to the
4906 function body to determine the default value of all optional arguments.
4907
4908 **Approximate expansion:**
4909
4910 Where:
4911
4912 * ``n`` denotes the *minimum* arity, as determined from ``arguments``.
4913 * ``m`` denotes the *maximum* arity, as determined from ``arguments``.
4914
4915 .. parsed-literal::
4916
4917     // If **result** is a template instantiation of |boost_enable_if|_\,
4918     // |boost_enable_if_c|_\, |boost_lazy_enable_if|_\,
4919     // |boost_lazy_enable_if_c|_\, |boost_disable_if|_\, |boost_disable_if_c|_\,
4920     // |boost_lazy_disable_if|_\, |boost_lazy_disable_if_c|_\, or
4921     // |std_enable_if|_\:
4922     template <typename Args>
4923     using boost_param_result_const\_ ## __LINE__ ## operator = **result**;
4924
4925     // If **result** is a simple return type:
4926     template <typename Args>
4927     struct boost_param_result_const\_ ## __LINE__ ## operator
4928     {
4929         typedef **result** type;
4930     };
4931
4932     struct boost_param_params_const\_ ## __LINE__ ## operator
4933       : |parameters|_\<
4934             *list of parameter specifications, based on arguments*
4935         >
4936     {
4937     };
4938
4939     typedef boost_param_params_const\_ ## __LINE__ ## operator
4940         boost_param_parameters_const\_ ## __LINE__ ## operator;
4941
4942     template <typename A0, …, typename A ## **n**>
4943     **result** operator()(
4944         A0&& a0, …, A ## **n**\ && a ## **n**
4945       , typename boost_param_parameters_const\_ ## __LINE__ ## operator
4946         ::match<A0, …, A ## **n**>::type
4947         = boost_param_parameters_const\_ ## __LINE__ ## operator()
4948     ) const
4949     {
4950         return this->boost_param_impl_const ## __LINE__ ## operator(
4951             boost_param_parameters_const\_ ## __LINE__ ## operator()(
4952                 |std_forward|_\<A0>(a0)
4953               , …
4954               , |std_forward|_\<A ## **n**>(a ## **n**)
4955             )
4956         );
4957     }
4958
4959     :vellipsis:`⋮`
4960
4961     template <typename A0, …, typename A ## **m**>
4962     **result** operator()(
4963         A0&& a0, …, A ## **m**\ && a ## **m**
4964       , typename boost_param_parameters_const\_ ## __LINE__ ## operator
4965         ::match<A0, …, A ## **m**>::type
4966         = boost_param_parameters_const\_ ## __LINE__ ## operator()
4967     ) const
4968     {
4969         return this->boost_param_impl_const ## __LINE__ ## operator(
4970             boost_param_parameters_const\_ ## __LINE__ ## operator()(
4971                 |std_forward|_\<A0>(a0)
4972               , …
4973               , |std_forward|_\<A ## **m**>(a ## **m**)
4974             )
4975         );
4976     }
4977
4978     template <typename Args>
4979     typename boost_param_result_const\_ ## __LINE__ ## operator<Args>::type
4980         boost_param_impl_const ## __LINE__ ## operator(Args const& args) const
4981
4982 Only the |ArgumentPack|_ type ``Args`` and its object instance ``args`` are
4983 available for use within the function call operator body.
4984
4985 .. |BOOST_PARAMETER_NO_SPEC_FUNCTION| replace:: ``BOOST_PARAMETER_NO_SPEC_FUNCTION``
4986 .. _BOOST_PARAMETER_NO_SPEC_FUNCTION:
4987
4988 ``BOOST_PARAMETER_NO_SPEC_FUNCTION(result, name)``
4989 --------------------------------------------------
4990
4991 :Defined in: |preprocessor_no_spec_header|_
4992
4993 Generates a function that can take in named arguments.
4994
4995 :Example usage:
4996
4997 The return type of each of the following function templates falls under a
4998 different value category.
4999
5000 .. parsed-literal::
5001
5002     template <std::size_t N>
5003     |std_bitset|_\<N + 1> rvalue_bitset()
5004     {
5005         return |std_bitset|_\<N + 1>();
5006     }
5007
5008     template <std::size_t N>
5009     |std_bitset|_\<N + 1> const rvalue_const_bitset()
5010     {
5011         return |std_bitset|_\<N + 1>();
5012     }
5013
5014     template <std::size_t N>
5015     |std_bitset|_\<N + 1>& lvalue_bitset()
5016     {
5017         static |std_bitset|_\<N + 1> lset = |std_bitset|_\<N + 1>();
5018         return lset;
5019     }
5020
5021     template <std::size_t N>
5022     |std_bitset|_\<N + 1> const& lvalue_const_bitset()
5023     {
5024         static |std_bitset|_\<N + 1> const clset = |std_bitset|_\<N + 1>();
5025         return clset;
5026     }
5027
5028 The ``U::evaluate_category`` static member function template has a simple job:
5029 to return the correct value category when passed in an object returned by one
5030 of the functions defined above.  Assume that
5031 |BOOST_PARAMETER_HAS_PERFECT_FORWARDING|_ is defined.
5032
5033 .. parsed-literal::
5034
5035     enum invoked
5036     {
5037         passed_by_lvalue_reference_to_const
5038       , passed_by_lvalue_reference
5039       , passed_by_rvalue_reference_to_const
5040       , passed_by_rvalue_reference
5041     };
5042
5043     struct U
5044     {
5045         template <std::size_t N>
5046         static invoked evaluate_category(|std_bitset|_\<N + 1> const&)
5047         {
5048             return passed_by_lvalue_reference_to_const;
5049         }
5050
5051         template <std::size_t N>
5052         static invoked evaluate_category(|std_bitset|_\<N + 1>&)
5053         {
5054             return passed_by_lvalue_reference;
5055         }
5056
5057         template <std::size_t N>
5058         static invoked evaluate_category(|std_bitset|_\<N + 1> const&&)
5059         {
5060             return passed_by_rvalue_reference_to_const;
5061         }
5062
5063         template <std::size_t N>
5064         static invoked evaluate_category(|std_bitset|_\<N + 1>&&)
5065         {
5066             return passed_by_rvalue_reference;
5067         }
5068     };
5069
5070 Named parameters are required when invoking the function; however, none of
5071 their tags need to be in the same namespace.
5072
5073 .. parsed-literal::
5074
5075     |BOOST_PARAMETER_NAME|_\((_lrc, kw0) in(lrc))
5076     |BOOST_PARAMETER_NAME|_\((_lr, kw1) in_out(lr))
5077     |BOOST_PARAMETER_NAME|_\((_rrc, kw2) in(rrc))
5078     |BOOST_PARAMETER_NAME|_\((_rr, kw3) consume(rr))
5079
5080 Use the macro as a substitute for a variadic function header.  Enclose the
5081 return type ``bool`` in parentheses.
5082
5083 .. parsed-literal::
5084
5085     BOOST_PARAMETER_NO_SPEC_FUNCTION((bool), evaluate)
5086     {
5087         BOOST_TEST_EQ(
5088             passed_by_lvalue_reference_to_const
5089           , U::evaluate_category<0>(args[_lrc])
5090         );
5091         BOOST_TEST_EQ(
5092             passed_by_lvalue_reference
5093           , U::evaluate_category<1>(args[_lr])
5094         );
5095         BOOST_TEST_EQ(
5096             passed_by_rvalue_reference_to_const
5097           , U::evaluate_category<2>(
5098                 args[_rrc | rvalue_const_bitset<2>()]
5099             )
5100         );
5101         BOOST_TEST_EQ(
5102             passed_by_rvalue_reference
5103           , U::evaluate_category<3>(args[_rr | rvalue_bitset<3>()])
5104         );
5105
5106         return true;
5107     }
5108
5109 To invoke the function, bind all its arguments to named parameters.
5110
5111 .. parsed-literal::
5112
5113     evaluate(
5114         _rr0 = rvalue_bitset<3>()
5115       , _lrc0 = lvalue_const_bitset<0>()
5116       , _lr0 = lvalue_bitset<1>()
5117       , _rrc0 = rvalue_const_bitset<2>()
5118     );
5119     evaluate(
5120         _lr0 = lvalue_bitset<1>()
5121       , _lrc0 = lvalue_const_bitset<0>()
5122     );
5123
5124 The |preproc_eval_cat_no_spec_cpp|_ test program demonstrates proper usage of
5125 this macro.
5126
5127 **Macro parameters:**
5128
5129 *   ``result`` is the parenthesized return type of the function.
5130 *   ``name`` is the base name of the function; it determines the name of the
5131     generated implementation function.
5132
5133 **Argument specifiers syntax:**
5134
5135 None.
5136
5137 **Approximate expansion:**
5138
5139 .. parsed-literal::
5140
5141     // If **result** is a template instantiation of |boost_enable_if|_\,
5142     // |boost_enable_if_c|_\, |boost_lazy_enable_if|_\,
5143     // |boost_lazy_enable_if_c|_\, |boost_disable_if|_\, |boost_disable_if_c|_\,
5144     // |boost_lazy_disable_if|_\, |boost_lazy_disable_if_c|_\, or
5145     // |std_enable_if|_\:
5146     template <typename TaggedArg0, typename ...TaggedArgs>
5147     using boost_param_no_spec_result\_ ## __LINE__ ## **name** = **result**;
5148
5149     // If **result** is a simple return type:
5150     template <typename TaggedArg0, typename ...TaggedArgs>
5151     struct boost_param_no_spec_result\_ ## __LINE__ ## **name**
5152     {
5153         typedef **result** type;
5154     };
5155
5156     template <typename ResultType, typename Args>
5157     ResultType
5158         boost_param_no_spec_impl ## __LINE__ ## **name**\ (
5159             (ResultType(*)())
5160           , Args const& args
5161         );
5162
5163     template <typename TaggedArg0, typename ...TaggedArgs>
5164     inline typename |boost_lazy_enable_if|_\<
5165         |are_tagged_arguments|_\<TaggedArg0,TaggedArgs...>
5166       , boost_param_no_spec_result\_ ## __LINE__ ## **name**\ <
5167             TaggedArg0
5168           , TaggedArgs...
5169         >
5170     >::type
5171         **name**\ (TaggedArg0 const& arg0, TaggedArgs const&... args)
5172     {
5173         return boost_param_no_spec_impl ## __LINE__ ## **name**\ (
5174             static_cast<
5175                 typename
5176                 boost_param_no_spec_result\_ ## __LINE__ ## **name**\ <
5177                     TaggedArg0
5178                   , TaggedArgs...
5179                 >::type(*)()
5180             >(|std_nullptr|_\)
5181           , |compose|_\(arg0, args...)
5182         );
5183     }
5184
5185     template <typename ResultType, typename Args>
5186     ResultType
5187         boost_param_no_spec_impl ## __LINE__ ## **name**\ (
5188             (ResultType(*)())
5189           , Args const& args
5190         )
5191
5192 Only the |ArgumentPack|_ type ``Args`` and its object instance ``args`` are
5193 available for use within the function body.
5194
5195 .. |BOOST_PARAMETER_NO_SPEC_MEMBER_FUNCTION| replace:: ``BOOST_PARAMETER_NO_SPEC_MEMBER_FUNCTION``
5196 .. _BOOST_PARAMETER_NO_SPEC_MEMBER_FUNCTION:
5197
5198 ``BOOST_PARAMETER_NO_SPEC_MEMBER_FUNCTION(result, name)``
5199 ---------------------------------------------------------
5200
5201 :Defined in: |preprocessor_no_spec_header|_
5202
5203 Generates a member function that can take in named arguments.
5204
5205 :Example usage:
5206
5207 When designing a front-end class template whose back-end is configurable via
5208 parameterized inheritance, it can be useful to omit argument specifiers from
5209 a named-parameter member function so that the delegate member functions of the
5210 back-end classes can enforce their own specifications.
5211
5212 .. parsed-literal::
5213
5214     template <typename B>
5215     struct frontend : B
5216     {
5217         frontend() : B()
5218         {
5219         }
5220
5221         BOOST_PARAMETER_NO_SPEC_MEMBER_FUNCTION((void), initialize)
5222         {
5223             this->initialize_impl(args);
5224         }
5225     };
5226
5227 Named parameters are required when invoking the member function; however, none
5228 of their tags need to be in the same namespace.
5229
5230 .. parsed-literal::
5231
5232     |BOOST_PARAMETER_NAME|_\(a0)
5233     |BOOST_PARAMETER_NAME|_\(a1)
5234     |BOOST_PARAMETER_NAME|_\(a2)
5235
5236 For this example, each of the back-end class templates requires its own
5237 parameter to be present in the argument pack.  In practice, such parameters
5238 should be optional, with default values.
5239
5240 .. parsed-literal::
5241
5242     template <typename T>
5243     class backend0
5244     {
5245         T a0;
5246
5247      public:
5248         backend0() : a0()
5249         {
5250         }
5251
5252         T const& get_a0() const
5253         {
5254             return this->a0;
5255         }
5256
5257      protected:
5258         template <typename ArgPack>
5259         void initialize_impl(ArgPack const& args)
5260         {
5261             this->a0 = args[_a0];
5262         }
5263     };
5264
5265     template <typename B, typename T>
5266     class backend1 : public B
5267     {
5268         T a1;
5269
5270      public:
5271         backend1() : B(), a1()
5272         {
5273         }
5274
5275         T const& get_a1() const
5276         {
5277             return this->a1;
5278         }
5279
5280      protected:
5281         template <typename ArgPack>
5282         void initialize_impl(ArgPack const& args)
5283         {
5284             B::initialize_impl(args);
5285             this->a1 = args[_a1];
5286         }
5287     };
5288
5289     template <typename B, typename T>
5290     class backend2 : public B
5291     {
5292         T a2;
5293
5294      public:
5295         backend2() : B(), a2()
5296         {
5297         }
5298
5299         T const& get_a2() const
5300         {
5301             return this->a2;
5302         }
5303
5304      protected:
5305         template <typename ArgPack>
5306         void initialize_impl(ArgPack const& args)
5307         {
5308             B::initialize_impl(args);
5309             this->a2 = args[_a2];
5310         }
5311     };
5312
5313 This example shows that while ``backend0`` must always be the root base class
5314 template and that ``frontend`` must always be the most derived class template,
5315 the other back-ends can be chained together in different orders.
5316
5317 .. parsed-literal::
5318
5319     char const* p = "foo";
5320     frontend<
5321         backend2<backend1<backend0<char const*>, char>, int>
5322     > composed_obj0;
5323     frontend<
5324         backend1<backend2<backend0<char const*>, int>, char>
5325     > composed_obj1;
5326     composed_obj0.initialize(_a2 = 4, _a1 = ' ', _a0 = p);
5327     composed_obj1.initialize(_a0 = p, _a1 = ' ', _a2 = 4);
5328     BOOST_TEST_EQ(composed_obj0.get_a0(), composed_obj1.get_a0());
5329     BOOST_TEST_EQ(composed_obj0.get_a1(), composed_obj1.get_a1());
5330     BOOST_TEST_EQ(composed_obj0.get_a2(), composed_obj1.get_a2());
5331
5332 The |parameterized_inheritance_cpp|_ and |preproc_eval_cat_no_spec_cpp|_ test
5333 programs demonstrate proper usage of this macro.
5334
5335 **Macro parameters:**
5336
5337 *   ``result`` is the parenthesized return type of the function.
5338 *   ``name`` is the base name of the function; it determines the name of the
5339     generated implementation function.  ``name`` may be qualified by the
5340     ``static`` keyword to declare the member function and its helpers as not
5341     associated with any object of the enclosing type.
5342
5343 **Argument specifiers syntax:**
5344
5345 None.
5346
5347 **Approximate expansion:**
5348
5349 .. parsed-literal::
5350
5351     // If **result** is a template instantiation of |boost_enable_if|_\,
5352     // |boost_enable_if_c|_\, |boost_lazy_enable_if|_\,
5353     // |boost_lazy_enable_if_c|_\, |boost_disable_if|_\, |boost_disable_if_c|_\,
5354     // |boost_lazy_disable_if|_\, |boost_lazy_disable_if_c|_\, or
5355     // |std_enable_if|_\:
5356     template <typename TaggedArg0, typename ...TaggedArgs>
5357     using boost_param_no_spec_result\_ ## __LINE__ ## **name** = **result**;
5358
5359     // If **result** is a simple return type:
5360     template <typename TaggedArg0, typename ...TaggedArgs>
5361     struct boost_param_no_spec_result\_ ## __LINE__ ## **name**
5362     {
5363         typedef **result** type;
5364     };
5365
5366     template <typename TaggedArg0, typename ...TaggedArgs>
5367     inline typename |boost_lazy_enable_if|_\<
5368         |are_tagged_arguments|_\<TaggedArg0,TaggedArgs...>
5369       , boost_param_no_spec_result\_ ## __LINE__ ## **name**\ <
5370             TaggedArg0
5371           , TaggedArgs...
5372         >
5373     >::type
5374         **name**\ (TaggedArg0 const& arg0, TaggedArgs const&... args)
5375     {
5376         return this->boost_param_no_spec_impl ## __LINE__ ## **name**\ (
5377             static_cast<
5378                 typename
5379                 boost_param_no_spec_result\_ ## __LINE__ ## **name**\ <
5380                     TaggedArg0
5381                   , TaggedArgs...
5382                 >::type(*)()
5383             >(|std_nullptr|_\)
5384           , |compose|_\(arg0, args...)
5385         );
5386     }
5387
5388     template <typename ResultType, typename Args>
5389     ResultType
5390         boost_param_no_spec_impl ## __LINE__ ## **name**\ (
5391             (ResultType(*)())
5392           , Args const& args
5393         )
5394
5395 Only the |ArgumentPack|_ type ``Args`` and its object instance ``args`` are
5396 available for use within the function body.
5397
5398 .. |BOOST_PARAMETER_NO_SPEC_CONST_MEMBER_FUNCTION| replace:: ``BOOST_PARAMETER_NO_SPEC_CONST_MEMBER_FUNCTION``
5399 .. _BOOST_PARAMETER_NO_SPEC_CONST_MEMBER_FUNCTION:
5400
5401 ``BOOST_PARAMETER_NO_SPEC_CONST_MEMBER_FUNCTION(result, name)``
5402 ---------------------------------------------------------------
5403
5404 :Defined in: |preprocessor_no_spec_header|_
5405
5406 Generates a member function that can take in named arguments.
5407
5408 :Example usage:
5409
5410 The return type of each of the following function templates falls under a
5411 different value category.
5412
5413 .. parsed-literal::
5414
5415     template <std::size_t N>
5416     |std_bitset|_\<N + 1> rvalue_bitset()
5417     {
5418         return |std_bitset|_\<N + 1>();
5419     }
5420
5421     template <std::size_t N>
5422     |std_bitset|_\<N + 1> const rvalue_const_bitset()
5423     {
5424         return |std_bitset|_\<N + 1>();
5425     }
5426
5427     template <std::size_t N>
5428     |std_bitset|_\<N + 1>& lvalue_bitset()
5429     {
5430         static |std_bitset|_\<N + 1> lset = |std_bitset|_\<N + 1>();
5431         return lset;
5432     }
5433
5434     template <std::size_t N>
5435     |std_bitset|_\<N + 1> const& lvalue_const_bitset()
5436     {
5437         static |std_bitset|_\<N + 1> const clset = |std_bitset|_\<N + 1>();
5438         return clset;
5439     }
5440
5441 The ``U::evaluate_category`` static member function template has a simple job:
5442 to return the correct value category when passed in an object returned by one
5443 of the functions defined above.  Assume that
5444 |BOOST_PARAMETER_HAS_PERFECT_FORWARDING|_ is defined.
5445
5446 .. parsed-literal::
5447
5448     enum invoked
5449     {
5450         passed_by_lvalue_reference_to_const
5451       , passed_by_lvalue_reference
5452       , passed_by_rvalue_reference_to_const
5453       , passed_by_rvalue_reference
5454     };
5455
5456     struct U
5457     {
5458         template <std::size_t N>
5459         static invoked evaluate_category(|std_bitset|_\<N + 1> const&)
5460         {
5461             return passed_by_lvalue_reference_to_const;
5462         }
5463
5464         template <std::size_t N>
5465         static invoked evaluate_category(|std_bitset|_\<N + 1>&)
5466         {
5467             return passed_by_lvalue_reference;
5468         }
5469
5470         template <std::size_t N>
5471         static invoked evaluate_category(|std_bitset|_\<N + 1> const&&)
5472         {
5473             return passed_by_rvalue_reference_to_const;
5474         }
5475
5476         template <std::size_t N>
5477         static invoked evaluate_category(|std_bitset|_\<N + 1>&&)
5478         {
5479             return passed_by_rvalue_reference;
5480         }
5481     };
5482
5483 Named parameters are required when invoking the member function; however, none
5484 of their tags need to be in the same namespace.
5485
5486 .. parsed-literal::
5487
5488     |BOOST_PARAMETER_NAME|_\((_lrc, kw0) in(lrc))
5489     |BOOST_PARAMETER_NAME|_\((_lr, kw1) in_out(lr))
5490     |BOOST_PARAMETER_NAME|_\((_rrc, kw2) in(rrc))
5491     |BOOST_PARAMETER_NAME|_\((_rr, kw3) consume(rr))
5492
5493 Use the macro as a substitute for a variadic function header.  Enclose the
5494 return type ``bool`` in parentheses.  The macro will qualify the function with
5495 the ``const`` keyword.
5496
5497 .. parsed-literal::
5498
5499     struct D
5500     {
5501         D()
5502         {
5503         }
5504
5505         BOOST_PARAMETER_NO_SPEC_CONST_MEMBER_FUNCTION((bool), evaluate_m)
5506         {
5507             BOOST_TEST_EQ(
5508                 passed_by_lvalue_reference_to_const
5509               , U::evaluate_category<0>(args[_lrc])
5510             );
5511             BOOST_TEST_EQ(
5512                 passed_by_lvalue_reference
5513               , U::evaluate_category<1>(args[_lr])
5514             );
5515             BOOST_TEST_EQ(
5516                 passed_by_rvalue_reference_to_const
5517               , U::evaluate_category<2>(
5518                     args[_rrc | rvalue_const_bitset<2>()]
5519                 )
5520             );
5521             BOOST_TEST_EQ(
5522                 passed_by_rvalue_reference
5523               , U::evaluate_category<3>(
5524                     args[_rr | rvalue_bitset<3>()]
5525                 )
5526             );
5527
5528             return true;
5529         }
5530     };
5531
5532 To invoke the member function, bind all its arguments to named parameters.
5533
5534 .. parsed-literal::
5535
5536     D const d = D();
5537     d.evaluate_m(
5538         _rr0 = rvalue_bitset<3>()
5539       , _lrc0 = lvalue_const_bitset<0>()
5540       , _lr0 = lvalue_bitset<1>()
5541       , _rrc0 = rvalue_const_bitset<2>()
5542     );
5543     d.evaluate_m(
5544         _lr0 = lvalue_bitset<1>()
5545       , _lrc0 = lvalue_const_bitset<0>()
5546     );
5547
5548 The |preproc_eval_cat_no_spec_cpp|_ test program demonstrates proper usage of
5549 this macro.
5550
5551 **Macro parameters:**
5552
5553 *   ``result`` is the parenthesized return type of the function.
5554 *   ``name`` is the base name of the function; it determines the name of the
5555     generated implementation function.
5556
5557 **Argument specifiers syntax:**
5558
5559 None.
5560
5561 **Approximate expansion:**
5562
5563 .. parsed-literal::
5564
5565     // If **result** is a template instantiation of |boost_enable_if|_\,
5566     // |boost_enable_if_c|_\, |boost_lazy_enable_if|_\,
5567     // |boost_lazy_enable_if_c|_\, |boost_disable_if|_\, |boost_disable_if_c|_\,
5568     // |boost_lazy_disable_if|_\, |boost_lazy_disable_if_c|_\, or
5569     // |std_enable_if|_\:
5570     template <typename TaggedArg0, typename ...TaggedArgs>
5571     using boost_param_no_spec_result_const\_ ## __LINE__ ## **name** = **result**;
5572
5573     // If **result** is a simple return type:
5574     template <typename TaggedArg0, typename ...TaggedArgs>
5575     struct boost_param_no_spec_result_const\_ ## __LINE__ ## **name**
5576     {
5577         typedef **result** type;
5578     };
5579
5580     template <typename TaggedArg0, typename ...TaggedArgs>
5581     inline typename |boost_lazy_enable_if|_\<
5582         |are_tagged_arguments|_\<TaggedArg0,TaggedArgs...>
5583       , boost_param_no_spec_result_const\_ ## __LINE__ ## **name**\ <
5584             TaggedArg0
5585           , TaggedArgs...
5586         >
5587     >::type
5588         **name**\ (TaggedArg0 const& arg0, TaggedArgs const&... args) const
5589     {
5590         return this->boost_param_no_spec_impl_const ## __LINE__ ## **name**\ (
5591             static_cast<
5592                 typename
5593                 boost_param_no_spec_result_const\_ ## __LINE__ ## **name**\ <
5594                     TaggedArg0
5595                   , TaggedArgs...
5596                 >::type(*)()
5597             >(|std_nullptr|_\)
5598           , |compose|_\(arg0, args...)
5599         );
5600     }
5601
5602     template <typename ResultType, typename Args>
5603     ResultType
5604         boost_param_no_spec_impl_const ## __LINE__ ## **name**\ (
5605             (ResultType(*)())
5606           , Args const& args
5607         ) const
5608
5609 Only the |ArgumentPack|_ type ``Args`` and its object instance ``args`` are
5610 available for use within the function body.
5611
5612 .. |BOOST_PARAMETER_NO_SPEC_FUNCTION_CALL_OPERATOR| replace:: ``BOOST_PARAMETER_NO_SPEC_FUNCTION_CALL_OPERATOR``
5613 .. _BOOST_PARAMETER_NO_SPEC_FUNCTION_CALL_OPERATOR:
5614
5615 ``BOOST_PARAMETER_NO_SPEC_FUNCTION_CALL_OPERATOR(result)``
5616 ----------------------------------------------------------
5617
5618 :Defined in: |preprocessor_no_spec_header|_
5619
5620 Generates a function call operator that can take in named arguments.
5621
5622 :Example usage:
5623
5624 When designing a front-end class template whose back-end is configurable via
5625 parameterized inheritance, it can be useful to omit argument specifiers from
5626 a named-parameter function call operator so that the delegate member functions
5627 of the back-end classes can enforce their own specifications.
5628
5629 .. parsed-literal::
5630
5631     template <typename B>
5632     struct frontend : B
5633     {
5634         frontend() : B()
5635         {
5636         }
5637
5638         BOOST_PARAMETER_NO_SPEC_FUNCTION_CALL_OPERATOR((void))
5639         {
5640             this->initialize_impl(args);
5641         }
5642     };
5643
5644 Named parameters are required when invoking the function call operator;
5645 however, none of their tags need to be in the same namespace.
5646
5647 .. parsed-literal::
5648
5649     |BOOST_PARAMETER_NAME|_\(a0)
5650     |BOOST_PARAMETER_NAME|_\(a1)
5651     |BOOST_PARAMETER_NAME|_\(a2)
5652
5653 For this example, each of the back-end class templates requires its own
5654 parameter to be present in the argument pack.  In practice, such parameters
5655 should be optional, with default values.
5656
5657 .. parsed-literal::
5658
5659     template <typename T>
5660     class backend0
5661     {
5662         T a0;
5663
5664      public:
5665         backend0() : a0()
5666         {
5667         }
5668
5669         T const& get_a0() const
5670         {
5671             return this->a0;
5672         }
5673
5674      protected:
5675         template <typename ArgPack>
5676         void initialize_impl(ArgPack const& args)
5677         {
5678             this->a0 = args[_a0];
5679         }
5680     };
5681
5682     template <typename B, typename T>
5683     class backend1 : public B
5684     {
5685         T a1;
5686
5687      public:
5688         backend1() : B(), a1()
5689         {
5690         }
5691
5692         T const& get_a1() const
5693         {
5694             return this->a1;
5695         }
5696
5697      protected:
5698         template <typename ArgPack>
5699         void initialize_impl(ArgPack const& args)
5700         {
5701             B::initialize_impl(args);
5702             this->a1 = args[_a1];
5703         }
5704     };
5705
5706     template <typename B, typename T>
5707     class backend2 : public B
5708     {
5709         T a2;
5710
5711      public:
5712         backend2() : B(), a2()
5713         {
5714         }
5715
5716         T const& get_a2() const
5717         {
5718             return this->a2;
5719         }
5720
5721      protected:
5722         template <typename ArgPack>
5723         void initialize_impl(ArgPack const& args)
5724         {
5725             B::initialize_impl(args);
5726             this->a2 = args[_a2];
5727         }
5728     };
5729
5730 This example shows that while ``backend0`` must always be the root base class
5731 template and that ``frontend`` must always be the most derived class template,
5732 the other back-ends can be chained together in different orders.
5733
5734 .. parsed-literal::
5735
5736     char const* p = "foo";
5737     frontend<
5738         backend2<backend1<backend0<char const*>, char>, int>
5739     > composed_obj0;
5740     frontend<
5741         backend1<backend2<backend0<char const*>, int>, char>
5742     > composed_obj1;
5743     composed_obj0(_a2 = 4, _a1 = ' ', _a0 = p);
5744     composed_obj1(_a0 = p, _a1 = ' ', _a2 = 4);
5745     BOOST_TEST_EQ(composed_obj0.get_a0(), composed_obj1.get_a0());
5746     BOOST_TEST_EQ(composed_obj0.get_a1(), composed_obj1.get_a1());
5747     BOOST_TEST_EQ(composed_obj0.get_a2(), composed_obj1.get_a2());
5748
5749 The |parameterized_inheritance_cpp|_ and |preproc_eval_cat_no_spec_cpp|_ test
5750 programs demonstrate proper usage of this macro.
5751
5752 **Macro parameters:**
5753
5754 *   ``result`` is the parenthesized return type of the function call operator.
5755
5756 **Argument specifiers syntax:**
5757
5758 None.
5759
5760 **Approximate expansion:**
5761
5762 .. parsed-literal::
5763
5764     // If **result** is a template instantiation of |boost_enable_if|_\,
5765     // |boost_enable_if_c|_\, |boost_lazy_enable_if|_\,
5766     // |boost_lazy_enable_if_c|_\, |boost_disable_if|_\, |boost_disable_if_c|_\,
5767     // |boost_lazy_disable_if|_\, |boost_lazy_disable_if_c|_\, or
5768     // |std_enable_if|_\:
5769     template <typename TaggedArg0, typename ...TaggedArgs>
5770     using boost_param_no_spec_result\_ ## __LINE__ ## operator = **result**;
5771
5772     // If **result** is a simple return type:
5773     template <typename TaggedArg0, typename ...TaggedArgs>
5774     struct boost_param_no_spec_result\_ ## __LINE__ ## operator
5775     {
5776         typedef **result** type;
5777     };
5778
5779     template <typename TaggedArg0, typename ...TaggedArgs>
5780     inline typename |boost_lazy_enable_if|_\<
5781         |are_tagged_arguments|_\<TaggedArg0,TaggedArgs...>
5782       , boost_param_no_spec_result\_ ## __LINE__ ## operator<
5783             TaggedArg0
5784           , TaggedArgs...
5785         >
5786     >::type
5787         operator()(TaggedArg0 const& arg0, TaggedArgs const&... args)
5788     {
5789         return this->boost_param_no_spec_impl ## __LINE__ ## operator(
5790             static_cast<
5791                 typename
5792                 boost_param_no_spec_result\_ ## __LINE__ ## operator<
5793                     TaggedArg0
5794                   , TaggedArgs...
5795                 >::type(*)()
5796             >(|std_nullptr|_\)
5797           , |compose|_\(arg0, args...)
5798         );
5799     }
5800
5801     template <typename ResultType, typename Args>
5802     ResultType
5803         boost_param_no_spec_impl ## __LINE__ ## operator(
5804             (ResultType(*)())
5805           , Args const& args
5806         )
5807
5808 Only the |ArgumentPack|_ type ``Args`` and its object instance ``args`` are
5809 available for use within the function body.
5810
5811 .. |BOOST_PARAMETER_NO_SPEC_CONST_FUNCTION_CALL_OPERATOR| replace:: ``BOOST_PARAMETER_NO_SPEC_CONST_FUNCTION_CALL_OPERATOR``
5812 .. _BOOST_PARAMETER_NO_SPEC_CONST_FUNCTION_CALL_OPERATOR:
5813
5814 ``BOOST_PARAMETER_NO_SPEC_CONST_FUNCTION_CALL_OPERATOR(result)``
5815 ----------------------------------------------------------------
5816
5817 :Defined in: |preprocessor_no_spec_header|_
5818
5819 Generates a function call operator that can take in named arguments.
5820
5821 :Example usage:
5822
5823 The return type of each of the following function templates falls under a
5824 different value category.
5825
5826 .. parsed-literal::
5827
5828     template <std::size_t N>
5829     |std_bitset|_\<N + 1> rvalue_bitset()
5830     {
5831         return |std_bitset|_\<N + 1>();
5832     }
5833
5834     template <std::size_t N>
5835     |std_bitset|_\<N + 1> const rvalue_const_bitset()
5836     {
5837         return |std_bitset|_\<N + 1>();
5838     }
5839
5840     template <std::size_t N>
5841     |std_bitset|_\<N + 1>& lvalue_bitset()
5842     {
5843         static |std_bitset|_\<N + 1> lset = |std_bitset|_\<N + 1>();
5844         return lset;
5845     }
5846
5847     template <std::size_t N>
5848     |std_bitset|_\<N + 1> const& lvalue_const_bitset()
5849     {
5850         static |std_bitset|_\<N + 1> const clset = |std_bitset|_\<N + 1>();
5851         return clset;
5852     }
5853
5854 The ``U::evaluate_category`` static member function template has a simple job:
5855 to return the correct value category when passed in an object returned by one
5856 of the functions defined above.  Assume that
5857 |BOOST_PARAMETER_HAS_PERFECT_FORWARDING|_ is defined.
5858
5859 .. parsed-literal::
5860
5861     enum invoked
5862     {
5863         passed_by_lvalue_reference_to_const
5864       , passed_by_lvalue_reference
5865       , passed_by_rvalue_reference_to_const
5866       , passed_by_rvalue_reference
5867     };
5868
5869     struct U
5870     {
5871         template <std::size_t N>
5872         static invoked evaluate_category(|std_bitset|_\<N + 1> const&)
5873         {
5874             return passed_by_lvalue_reference_to_const;
5875         }
5876
5877         template <std::size_t N>
5878         static invoked evaluate_category(|std_bitset|_\<N + 1>&)
5879         {
5880             return passed_by_lvalue_reference;
5881         }
5882
5883         template <std::size_t N>
5884         static invoked evaluate_category(|std_bitset|_\<N + 1> const&&)
5885         {
5886             return passed_by_rvalue_reference_to_const;
5887         }
5888
5889         template <std::size_t N>
5890         static invoked evaluate_category(|std_bitset|_\<N + 1>&&)
5891         {
5892             return passed_by_rvalue_reference;
5893         }
5894     };
5895
5896 Named parameters are required when invoking the function call operator;
5897 however, none of their tags need to be in the same namespace.
5898
5899 .. parsed-literal::
5900
5901     |BOOST_PARAMETER_NAME|_\((_lrc, kw0) in(lrc))
5902     |BOOST_PARAMETER_NAME|_\((_lr, kw1) in_out(lr))
5903     |BOOST_PARAMETER_NAME|_\((_rrc, kw2) in(rrc))
5904     |BOOST_PARAMETER_NAME|_\((_rr, kw3) consume(rr))
5905
5906 Use the macro as a substitute for a variadic function call operator
5907 header.  Enclose the return type ``bool`` in parentheses.  The macro will
5908 qualify the function with the ``const`` keyword.
5909
5910 .. parsed-literal::
5911
5912     struct D
5913     {
5914         D()
5915         {
5916         }
5917
5918         BOOST_PARAMETER_NO_SPEC_CONST_FUNCTION_CALL_OPERATOR((bool))
5919         {
5920             BOOST_TEST_EQ(
5921                 passed_by_lvalue_reference_to_const
5922               , U::evaluate_category<0>(args[_lrc])
5923             );
5924             BOOST_TEST_EQ(
5925                 passed_by_lvalue_reference
5926               , U::evaluate_category<1>(args[_lr])
5927             );
5928             BOOST_TEST_EQ(
5929                 passed_by_rvalue_reference_to_const
5930               , U::evaluate_category<2>(
5931                     args[_rrc | rvalue_const_bitset<2>()]
5932                 )
5933             );
5934             BOOST_TEST_EQ(
5935                 passed_by_rvalue_reference
5936               , U::evaluate_category<3>(
5937                     args[_rr | rvalue_bitset<3>()]
5938                 )
5939             );
5940
5941             return true;
5942         }
5943     };
5944
5945 To invoke the function call operator, bind all its arguments to named
5946 parameters.
5947
5948 .. parsed-literal::
5949
5950     D const d = D();
5951     d(
5952         _rr0 = rvalue_bitset<3>()
5953       , _lrc0 = lvalue_const_bitset<0>()
5954       , _lr0 = lvalue_bitset<1>()
5955       , _rrc0 = rvalue_const_bitset<2>()
5956     );
5957     d(
5958         _lr0 = lvalue_bitset<1>()
5959       , _lrc0 = lvalue_const_bitset<0>()
5960     );
5961
5962 The |preproc_eval_cat_no_spec_cpp|_ test program demonstrates proper usage of this
5963 macro.
5964
5965 **Macro parameters:**
5966
5967 *   ``result`` is the parenthesized return type of the function call operator.
5968
5969 **Argument specifiers syntax:**
5970
5971 None.
5972
5973 **Approximate expansion:**
5974
5975 .. parsed-literal::
5976
5977     // If **result** is a template instantiation of |boost_enable_if|_\,
5978     // |boost_enable_if_c|_\, |boost_lazy_enable_if|_\,
5979     // |boost_lazy_enable_if_c|_\, |boost_disable_if|_\, |boost_disable_if_c|_\,
5980     // |boost_lazy_disable_if|_\, |boost_lazy_disable_if_c|_\, or
5981     // |std_enable_if|_\:
5982     template <typename TaggedArg0, typename ...TaggedArgs>
5983     using boost_param_no_spec_result_const\_ ## __LINE__ ## operator = **result**;
5984
5985     // If **result** is a simple return type:
5986     template <typename TaggedArg0, typename ...TaggedArgs>
5987     struct boost_param_no_spec_result_const\_ ## __LINE__ ## operator
5988     {
5989         typedef **result** type;
5990     };
5991
5992     template <typename TaggedArg0, typename ...TaggedArgs>
5993     inline typename |boost_lazy_enable_if|_\<
5994         |are_tagged_arguments|_\<TaggedArg0,TaggedArgs...>
5995       , boost_param_no_spec_result_const\_ ## __LINE__ ## operator<
5996             TaggedArg0
5997           , TaggedArgs...
5998         >
5999     >::type
6000         operator()(
6001             TaggedArg0 const& arg0
6002           , TaggedArgs const&... args
6003         ) const
6004     {
6005         return this->boost_param_no_spec_impl_const ## __LINE__ ## operator(
6006             static_cast<
6007                 typename
6008                 boost_param_no_spec_result_const\_ ## __LINE__ ## operator<
6009                     TaggedArg0
6010                   , TaggedArgs...
6011                 >::type(*)()
6012             >(|std_nullptr|_\)
6013           , |compose|_\(arg0, args...)
6014         );
6015     }
6016
6017     template <typename ResultType, typename Args>
6018     ResultType
6019         boost_param_no_spec_impl_const ## __LINE__ ## operator(
6020             (ResultType(*)())
6021           , Args const& args
6022         ) const
6023
6024 Only the |ArgumentPack|_ type ``Args`` and its object instance ``args`` are
6025 available for use within the function body.
6026
6027 .. |BOOST_PARAMETER_NO_SPEC_CONSTRUCTOR| replace:: ``BOOST_PARAMETER_NO_SPEC_CONSTRUCTOR``
6028 .. _BOOST_PARAMETER_NO_SPEC_CONSTRUCTOR:
6029
6030 ``BOOST_PARAMETER_NO_SPEC_CONSTRUCTOR(cls, impl)``
6031 --------------------------------------------------
6032
6033 :Defined in: |preprocessor_no_spec_header|_
6034
6035 Generates a constructor that can take in named arguments.
6036
6037 :Example usage:
6038
6039 When designing a front-end class template whose back-end is configurable via
6040 parameterized inheritance, it can be useful to omit argument specifiers from
6041 a named-parameter constructor so that the delegate constructors of the
6042 back-end classes can enforce their own specifications.
6043
6044 .. parsed-literal::
6045
6046     template <typename B>
6047     struct frontend : B
6048     {
6049         BOOST_PARAMETER_NO_SPEC_CONSTRUCTOR(frontend, (B))
6050     };
6051
6052 Named parameters are required when invoking the constructor; however, none of
6053 their tags need to be in the same namespace.
6054
6055 .. parsed-literal::
6056
6057     |BOOST_PARAMETER_NAME|_\(a0)
6058     |BOOST_PARAMETER_NAME|_\(a1)
6059     |BOOST_PARAMETER_NAME|_\(a2)
6060
6061 For this example, each of the back-end class templates requires its own
6062 parameter to be present in the argument pack.  In practice, such parameters
6063 should be optional, with default values.
6064
6065 .. parsed-literal::
6066
6067     struct _enabler
6068     {
6069     };
6070
6071     template <typename T>
6072     class backend0
6073     {
6074         T a0;
6075
6076      public:
6077         template <typename ArgPack>
6078         explicit backend0(
6079             ArgPack const& args
6080           , typename |boost_enable_if|_\<
6081                 |is_argument_pack|_\<ArgPack>
6082               , _enabler
6083             >::type = _enabler()
6084         ) : a0(args[_a0])
6085         {
6086         }
6087
6088         T const& get_a0() const
6089         {
6090             return this->a0;
6091         }
6092     };
6093
6094     template <typename B, typename T>
6095     class backend1 : public B
6096     {
6097         T a1;
6098
6099      public:
6100         template <typename ArgPack>
6101         explicit backend1(
6102             ArgPack const& args
6103           , typename |boost_enable_if|_\<
6104                 |is_argument_pack|_\<ArgPack>
6105               , _enabler
6106             >::type = _enabler()
6107         ) : B(args), a1(args[_a1])
6108         {
6109         }
6110
6111         T const& get_a1() const
6112         {
6113             return this->a1;
6114         }
6115     };
6116
6117     template <typename B, typename T>
6118     class backend2 : public B
6119     {
6120         T a2;
6121
6122      public:
6123         template <typename ArgPack>
6124         explicit backend2(
6125             ArgPack const& args
6126           , typename |boost_enable_if|_\<
6127                 |is_argument_pack|_\<ArgPack>
6128               , _enabler
6129             >::type = _enabler()
6130         ) : B(args), a2(args[_a2])
6131         {
6132         }
6133
6134         T const& get_a2() const
6135         {
6136             return this->a2;
6137         }
6138     };
6139
6140 This example shows that while ``backend0`` must always be the root base class
6141 template and that ``frontend`` must always be the most derived class template,
6142 the other back-ends can be chained together in different orders.
6143
6144 .. parsed-literal::
6145
6146     char const* p = "foo";
6147     frontend<
6148         backend2<backend1<backend0<char const*>, char>, int>
6149     > composed_obj0(_a2 = 4, _a1 = ' ', _a0 = p);
6150     frontend<
6151         backend1<backend2<backend0<char const*>, int>, char>
6152     > composed_obj1(_a0 = p, _a1 = ' ', _a2 = 4);
6153     BOOST_TEST_EQ(composed_obj0.get_a0(), composed_obj1.get_a0());
6154     BOOST_TEST_EQ(composed_obj0.get_a1(), composed_obj1.get_a1());
6155     BOOST_TEST_EQ(composed_obj0.get_a2(), composed_obj1.get_a2());
6156
6157 The |parameterized_inheritance_cpp|_ and |preproc_eval_cat_no_spec_cpp|_ test
6158 programs demonstrate proper usage of this macro.
6159
6160 **Macro parameters:**
6161
6162 *   ``cls`` is the name of the enclosing class.
6163 *   ``impl`` is the parenthesized implementation base class for ``cls``.
6164
6165 **Argument specifiers syntax:**
6166
6167 None.
6168
6169 **Approximate expansion:**
6170
6171 .. parsed-literal::
6172
6173     template <
6174         typename TaggedArg0
6175       , typename ...TaggedArgs
6176       , typename = typename |boost_enable_if|_\<
6177             |are_tagged_arguments|_\<TaggedArg0,TaggedArgs...>
6178         >::type
6179     >
6180     inline explicit **cls**\ (
6181         TaggedArg0 const& arg0
6182       , TaggedArgs const&... args
6183     ) : **impl**\ (|compose|_\(arg0, args...))
6184     {
6185     }
6186
6187 .. |BOOST_PARAMETER_NO_SPEC_NO_BASE_CONSTRUCTOR| replace:: ``BOOST_PARAMETER_NO_SPEC_NO_BASE_CONSTRUCTOR``
6188 .. _BOOST_PARAMETER_NO_SPEC_NO_BASE_CONSTRUCTOR:
6189
6190 ``BOOST_PARAMETER_NO_SPEC_NO_BASE_CONSTRUCTOR(cls, impl)``
6191 ----------------------------------------------------------
6192
6193 :Defined in: |preprocessor_no_spec_header|_
6194
6195 Generates a constructor that can take in named arguments.
6196
6197 :Example usage:
6198
6199 The return type of each of the following function templates falls under a
6200 different value category.
6201
6202 .. parsed-literal::
6203
6204     template <std::size_t N>
6205     |std_bitset|_\<N + 1> rvalue_bitset()
6206     {
6207         return |std_bitset|_\<N + 1>();
6208     }
6209
6210     template <std::size_t N>
6211     |std_bitset|_\<N + 1> const rvalue_const_bitset()
6212     {
6213         return |std_bitset|_\<N + 1>();
6214     }
6215
6216     template <std::size_t N>
6217     |std_bitset|_\<N + 1>& lvalue_bitset()
6218     {
6219         static |std_bitset|_\<N + 1> lset = |std_bitset|_\<N + 1>();
6220         return lset;
6221     }
6222
6223     template <std::size_t N>
6224     |std_bitset|_\<N + 1> const& lvalue_const_bitset()
6225     {
6226         static |std_bitset|_\<N + 1> const clset = |std_bitset|_\<N + 1>();
6227         return clset;
6228     }
6229
6230 The ``U::evaluate_category`` static member function template has a simple job:
6231 to return the correct value category when passed in an object returned by one
6232 of the functions defined above.  Assume that
6233 |BOOST_PARAMETER_HAS_PERFECT_FORWARDING|_ is defined.
6234
6235 .. parsed-literal::
6236
6237     enum invoked
6238     {
6239         passed_by_lvalue_reference_to_const
6240       , passed_by_lvalue_reference
6241       , passed_by_rvalue_reference_to_const
6242       , passed_by_rvalue_reference
6243     };
6244
6245     struct U
6246     {
6247         template <std::size_t N>
6248         static invoked evaluate_category(|std_bitset|_\<N + 1> const&)
6249         {
6250             return passed_by_lvalue_reference_to_const;
6251         }
6252
6253         template <std::size_t N>
6254         static invoked evaluate_category(|std_bitset|_\<N + 1>&)
6255         {
6256             return passed_by_lvalue_reference;
6257         }
6258
6259         template <std::size_t N>
6260         static invoked evaluate_category(|std_bitset|_\<N + 1> const&&)
6261         {
6262             return passed_by_rvalue_reference_to_const;
6263         }
6264
6265         template <std::size_t N>
6266         static invoked evaluate_category(|std_bitset|_\<N + 1>&&)
6267         {
6268             return passed_by_rvalue_reference;
6269         }
6270     };
6271
6272 Named parameters are required when invoking the constructor; however, none of
6273 their tags need to be in the same namespace.
6274
6275 .. parsed-literal::
6276
6277     |BOOST_PARAMETER_NAME|_\((_lrc, kw0) in(lrc))
6278     |BOOST_PARAMETER_NAME|_\((_lr, kw1) in_out(lr))
6279     |BOOST_PARAMETER_NAME|_\((_rrc, kw2) in(rrc))
6280     |BOOST_PARAMETER_NAME|_\((_rr, kw3) consume(rr))
6281
6282 Unlike |BOOST_PARAMETER_NO_SPEC_CONSTRUCTOR|_, this macro doesn't require a
6283 base class, only a delegate function to which the generated constructor can
6284 pass its |ArgumentPack|_.
6285
6286 .. parsed-literal::
6287
6288     struct D
6289     {
6290         BOOST_PARAMETER_NO_SPEC_NO_BASE_CONSTRUCTOR(D, D::_evaluate)
6291
6292      private:
6293         template <typename Args>
6294         static bool _evaluate(Args const& args)
6295         {
6296             BOOST_TEST_EQ(
6297                 passed_by_lvalue_reference_to_const
6298               , U::evaluate_category<0>(args[_lrc])
6299             );
6300             BOOST_TEST_EQ(
6301                 passed_by_lvalue_reference
6302               , U::evaluate_category<1>(args[_lr])
6303             );
6304             BOOST_TEST_EQ(
6305                 passed_by_rvalue_reference_to_const
6306               , U::evaluate_category<2>(
6307                     args[_rrc | rvalue_const_bitset<2>()]
6308                 )
6309             );
6310             BOOST_TEST_EQ(
6311                 passed_by_rvalue_reference
6312               , U::evaluate_category<3>(
6313                     args[_rr | rvalue_bitset<3>()]
6314                 )
6315             );
6316
6317             return true;
6318         }
6319     };
6320
6321 To invoke the constructor, bind all its arguments to named parameters.
6322
6323 .. parsed-literal::
6324
6325     D dp0(
6326         _rr0 = rvalue_bitset<3>()
6327       , _lrc0 = lvalue_const_bitset<0>()
6328       , _lr0 = lvalue_bitset<1>()
6329       , _rrc0 = rvalue_const_bitset<2>()
6330     );
6331     D dp1(
6332         _lr0 = lvalue_bitset<1>()
6333       , _lrc0 = lvalue_const_bitset<0>()
6334     );
6335
6336 The |preproc_eval_cat_no_spec_cpp|_ test program demonstrates proper usage of
6337 this macro.
6338
6339 **Macro parameters:**
6340
6341 *   ``cls`` is the name of the enclosing class.
6342 *   ``func`` is a function that takes in the |ArgumentPack|_ that the
6343     generated constructor passes on.
6344
6345 **Argument specifiers syntax:**
6346
6347 None.
6348
6349 **Approximate expansion:**
6350
6351 .. parsed-literal::
6352
6353     template <
6354         typename TaggedArg0
6355       , typename ...TaggedArgs
6356       , typename = typename |boost_enable_if|_\<
6357             |are_tagged_arguments|_\<TaggedArg0,TaggedArgs...>
6358         >::type
6359     >
6360     inline explicit **cls**\ (
6361         TaggedArg0 const& arg0
6362       , TaggedArgs const&... args
6363     )
6364     {
6365         **func**\ (|compose|_\(arg0, args...));
6366     }
6367
6368 .. |BOOST_PARAMETER_NAME| replace:: ``BOOST_PARAMETER_NAME``
6369 .. _BOOST_PARAMETER_NAME:
6370
6371 ``BOOST_PARAMETER_NAME(name)``
6372 ------------------------------
6373
6374 :Defined in: |name_header|_
6375
6376 Declares a tag-type and keyword object.
6377
6378 **If** *name* is of the form:
6379
6380 .. parsed-literal::
6381
6382     (*object-name*, *namespace-name*) *qualifier*\ (*tag-name*)
6383
6384 **then**
6385
6386 :Requires: *qualifier* is either ``in``, ``out``, ``in_out``, ``consume``,
6387     ``move_from``, or ``forward``.
6388 :Expands to:
6389
6390 .. parsed-literal::
6391
6392     namespace *namespace-name* {
6393
6394         struct *tag-name*
6395         {
6396             static constexpr char const* keyword_name()
6397             {
6398                 return ## *tag-name*;
6399             }
6400
6401             typedef *unspecified* _;
6402             typedef *unspecified* _1;
6403             typedef boost::parameter::*qualifier* ## _reference qualifier;
6404
6405             // The following definitions are available only when
6406             // |BOOST_PARAMETER_CAN_USE_MP11|_ is defined.
6407
6408             template <typename ArgumentPack>
6409             using binding_fn = typename |binding|_\<
6410                 ArgumentPack
6411               , *tag-name*
6412             >::type;
6413
6414             template <typename ArgumentPack>
6415             using fn = typename |value_type|_\<ArgumentPack, *tag-name*>::type;
6416         };
6417     }
6418
6419     |keyword|_\<*tag-namespace*::*tag-name*> const& *object-name*
6420         = |keyword|_\<*tag-namespace*::*tag-name*>::instance;
6421
6422 **Else If** *name* is of the form:
6423
6424 .. parsed-literal::
6425
6426     (*tag-name*, *namespace-name*) *object-name*
6427
6428 **then**
6429
6430 Treats *name* as if it were of the form:
6431
6432 .. parsed-literal::
6433
6434     (forward(*tag-name*), *namespace-name*) *object-name*
6435
6436 **Else If** *name* is of the form:
6437
6438 .. parsed-literal::
6439
6440     *qualifier*\ (*tag-name*)
6441
6442 **then**
6443
6444 :Requires: *qualifier* is either ``in``, ``out``, ``in_out``, ``consume``,
6445     ``move_from``, or ``forward``.
6446 :Expands to:
6447
6448 .. parsed-literal::
6449
6450     namespace tag {
6451
6452         struct *tag-name*
6453         {
6454             static constexpr char const* keyword_name()
6455             {
6456                 return ## *tag-name*;
6457             }
6458
6459             typedef *unspecified* _;
6460             typedef *unspecified* _1;
6461             typedef boost::parameter::*qualifier* ## _reference qualifier;
6462
6463             // The following definitions are available only when
6464             // |BOOST_PARAMETER_CAN_USE_MP11|_ is defined.
6465
6466             template <typename ArgumentPack>
6467             using binding_fn = typename |binding|_\<
6468                 ArgumentPack
6469               , *tag-name*
6470             >::type;
6471
6472             template <typename ArgumentPack>
6473             using fn = typename |value_type|_\<ArgumentPack, *tag-name*>::type;
6474         };
6475     }
6476
6477     |keyword|_\<tag::*tag-name*> const& _ ## *tag-name*
6478         = |keyword|_\<tag::*tag-name*>::instance;
6479
6480 **Else**
6481
6482 Treats *name* as if it were of the form:
6483
6484 .. parsed-literal::
6485
6486     forward(*tag-name*)
6487
6488 .. |BOOST_PARAMETER_NESTED_KEYWORD| replace:: ``BOOST_PARAMETER_NESTED_KEYWORD``
6489 .. _BOOST_PARAMETER_NESTED_KEYWORD:
6490
6491 ``BOOST_PARAMETER_NESTED_KEYWORD(tag_namespace, name, alias)``
6492 --------------------------------------------------------------
6493
6494 :Defined in: |nested_keyword_header|_
6495
6496 Declares a tag-type, a keyword object, and an alias for that object nested in
6497 the tag-type.
6498
6499 **If** *name* is of the form:
6500
6501 .. parsed-literal::
6502
6503     *qualifier*\ (*tag-name*)
6504
6505 **then**
6506
6507 :Requires: *qualifier* is either ``in``, ``out``, ``in_out``, ``consume``,
6508     ``move_from``, or ``forward``.
6509
6510 :Expands to:
6511
6512 .. parsed-literal::
6513
6514     namespace tag {
6515
6516         struct *tag-name*
6517         {
6518             static constexpr char const* keyword_name()
6519             {
6520                 return ## *tag-name* ## _;
6521             }
6522
6523             typedef *unspecified* _;
6524             typedef *unspecified* _1;
6525             typedef boost::parameter::*qualifier* ## _reference qualifier;
6526             static |keyword|_\<*tag-name*> const& *alias*;
6527
6528             // The following definitions are available only when
6529             // |BOOST_PARAMETER_CAN_USE_MP11|_ is defined.
6530
6531             template <typename ArgumentPack>
6532             using binding_fn = typename |binding|_\<
6533                 ArgumentPack
6534               , *tag-name*
6535             >::type;
6536
6537             template <typename ArgumentPack>
6538             using fn = typename |value_type|_\<ArgumentPack, *tag-name*>::type;
6539         };
6540
6541         |keyword|_\<*tag-name*> const& tag::*tag-name*::*alias*
6542             = |keyword|_\<*tag-name*>::instance;
6543     }
6544
6545     |keyword|_\<tag::*tag-name*> const& tag::*tag-name*::*name*
6546         = |keyword|_\<tag::*tag-name*>::instance;
6547
6548 **Else**
6549
6550 Treats *name* as if it were of the form:
6551
6552 .. parsed-literal::
6553
6554     forward(*tag-name*)
6555
6556 .. |BOOST_PARAMETER_TEMPLATE_KEYWORD| replace:: ``BOOST_PARAMETER_TEMPLATE_KEYWORD``
6557 .. _BOOST_PARAMETER_TEMPLATE_KEYWORD:
6558
6559 ``BOOST_PARAMETER_TEMPLATE_KEYWORD(name)``
6560 ------------------------------------------
6561
6562 :Defined in: |template_keyword_header|_
6563 :Included by: |name_header|_
6564 :Expands to:
6565
6566 .. parsed-literal::
6567
6568     namespace tag {
6569
6570         struct *name*;
6571     }
6572
6573     template <typename T>
6574     struct *name* : |template_keyword|_\<tag:: *name*, T>
6575     {
6576     };
6577
6578 The |function_type_tpl_param_cpp|_ test program demonstrates proper usage of
6579 this macro.
6580
6581 .. |BOOST_PARAMETER_FUN| replace:: ``BOOST_PARAMETER_FUN``
6582 .. _BOOST_PARAMETER_FUN:
6583
6584 ``BOOST_PARAMETER_FUN(r, n, l, h, p)``
6585 --------------------------------------
6586
6587 .. admonition:: Deprecated
6588
6589     This macro has been deprecated in favor of
6590     ``BOOST_PARAMETER_FUNCTION``.
6591
6592 Generates a sequence of `forwarding function`_ templates named
6593 ``n``, with arities ranging from ``l`` to ``h``, returning ``r``,
6594 and using ``p`` to control overload resolution and assign tags to
6595 positional arguments.
6596
6597 :Defined in: |macros_header|_
6598 :Requires: ``l`` and ``h`` are nonnegative integer tokens
6599     such that ``l`` < ``h``
6600 :Expands to:
6601
6602 .. parsed-literal::
6603
6604     template <typename A1, typename A2, …, typename A ## **l**>
6605     r
6606         name(
6607             A1 && a1, A2 && a2, …, A ## **l** && a ## **l**
6608           , typename **p**::match<A1, A2, …, A ## **l**>::type p = **p**\ ()
6609         )
6610     {
6611         return **name**\ _with_named_params(
6612             **p**\ (
6613                 |std_forward|_\<A1>(a1)
6614               , |std_forward|_\<A2>(a2)
6615               , …
6616               , |std_forward|_\<A ## **l**>(a ## **l**)
6617             )
6618         );
6619     }
6620
6621     template <
6622         typename A1
6623       , typename A2
6624       , …
6625       , typename A ## **l**
6626       , typename A ## |BOOST_PP_INC|_\ (**l**)
6627     >
6628     r
6629         name(
6630             A1 && a1, A2 && a2, …, A ## **l** && a ## **l**
6631           , A ## |BOOST_PP_INC|_\ (**l**) const& a ## |BOOST_PP_INC|_\ (**l**)
6632           , typename **p**::match<
6633                 A1, A2, …, A ## **l**, A ## |BOOST_PP_INC|_\ (**l**)
6634             >::type p = **p**\ ()
6635         )
6636     {
6637         return **name**\ _with_named_params(
6638             **p**\ (
6639                 |std_forward|_\<A1>(a1)
6640               , |std_forward|_\<A2>(a2)
6641               , …
6642               , |std_forward|_\<A ## **l**>(a ## **l**)
6643               , |std_forward|_\<A ## |BOOST_PP_INC|_\ (**l**)>(
6644                     a ## |BOOST_PP_INC|_\ (**l**)
6645                 )
6646             )
6647         );
6648     }
6649
6650     :vellipsis:`⋮`
6651
6652     template <typename A1, typename A2, …, typename A ## **h**>
6653     r
6654         name(
6655             A1 && a1, A2 && a2, …, A ## **h** && x ## **h**
6656           , typename **p**::match<A1, A2, …, A ## **h**>::type p = **p**\ ()
6657         )
6658     {
6659         return **name**\ _with_named_params(
6660             **p**\ (
6661                 |std_forward|_\<A1>(a1)
6662               , |std_forward|_\<A2>(a2)
6663               , …
6664               , |std_forward|_\<A ## **h**>(a ## **h**)
6665             )
6666         );
6667     }
6668
6669 The |macros_cpp|_ and |macros_eval_cat_cpp|_ test programs demonstrate proper
6670 usage of this macro.
6671
6672 .. |BOOST_PARAMETER_KEYWORD| replace:: ``BOOST_PARAMETER_KEYWORD``
6673 .. _BOOST_PARAMETER_KEYWORD:
6674
6675 ``BOOST_PARAMETER_KEYWORD(n, k)``
6676 ---------------------------------
6677
6678 .. admonition:: Deprecated
6679
6680     This macro has been deprecated in favor of
6681     ``BOOST_PARAMETER_NAME``.
6682
6683 Generates the declaration of a |keyword tag type| named ``k`` in
6684 namespace ``n`` and a corresponding |keyword object| definition in
6685 the enclosing namespace.
6686
6687 :Defined in: |keyword_header|_
6688 :Expands to:
6689
6690 .. parsed-literal::
6691
6692     namespace **n** {
6693
6694         struct **k**
6695         {
6696             static constexpr char const* keyword_name()
6697             {
6698                 return ## *k*;
6699             }
6700
6701             typedef *unspecified* _;
6702             typedef *unspecified* _1;
6703             typedef boost::parameter::forward_reference qualifier;
6704
6705             // The following definitions are available only when
6706             // |BOOST_PARAMETER_CAN_USE_MP11|_ is defined.
6707
6708             template <typename ArgumentPack>
6709             using binding_fn = typename |binding|_\<
6710                 ArgumentPack
6711               , *k*
6712             >::type;
6713
6714             template <typename ArgumentPack>
6715             using fn = typename |value_type|_\<ArgumentPack, *k*>::type;
6716         };
6717     }
6718
6719     namespace {
6720
6721         |keyword|_\<*n*::**k**> const& **k**
6722             = |keyword|_\<*n*::**k**>::instance;
6723     }
6724
6725 ``BOOST_PARAMETER_MATCH(p, a, x)``
6726 ----------------------------------
6727
6728 Generates a defaulted parameter declaration for a `forwarding function`_.
6729
6730 :Defined in: |match_header|_
6731 :Requires: ``a`` is a `Boost.Preprocessor sequence`__ of the form
6732
6733 .. parsed-literal::
6734
6735     (A0)(A1)…(A ## *n*)
6736
6737 __ ../../../preprocessor/doc/data.html
6738
6739 :Expands to:
6740
6741 .. parsed-literal::
6742
6743     typename **p**::match<**A0**\ , **A1**\ , …, **A** ## *n*>::type
6744         **x** = **p**\ ()
6745
6746 Configuration Macros
6747 ====================
6748
6749 .. |BOOST_PARAMETER_HAS_PERFECT_FORWARDING| replace:: ``BOOST_PARAMETER_HAS_PERFECT_FORWARDING``
6750 .. _BOOST_PARAMETER_HAS_PERFECT_FORWARDING:
6751
6752 ``BOOST_PARAMETER_HAS_PERFECT_FORWARDING``
6753 ------------------------------------------
6754
6755 Determines whether or not the library supports perfect forwarding, or the
6756 preservation of parameter value categories.  Users can manually disable this
6757 macro by ``#defining`` the |BOOST_PARAMETER_DISABLE_PERFECT_FORWARDING|_
6758 macro.  Otherwise, the library will ``#define`` this macro if and only if it
6759 is not already defined, and if the configuration macros
6760 |BOOST_NO_FUNCTION_TEMPLATE_ORDERING|_, |BOOST_NO_SFINAE|_,
6761 |BOOST_NO_CXX11_RVALUE_REFERENCES|_, |BOOST_NO_CXX11_VARIADIC_TEMPLATES|_, and
6762 |BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS|_ are not already defined by
6763 |Boost_Config|_.
6764
6765 :Defined in: |config_header|_
6766
6767 .. |BOOST_PARAMETER_DISABLE_PERFECT_FORWARDING| replace:: ``BOOST_PARAMETER_DISABLE_PERFECT_FORWARDING``
6768 .. _BOOST_PARAMETER_DISABLE_PERFECT_FORWARDING:
6769
6770 ``BOOST_PARAMETER_DISABLE_PERFECT_FORWARDING``
6771 ----------------------------------------------
6772
6773 It may be necessary to test user code in case perfect forwarding support is
6774 unavailable.  Users can ``#define`` this macro either in their project
6775 settings or before including any library header files.  Doing so will leave
6776 both |BOOST_PARAMETER_HAS_PERFECT_FORWARDING|_ and
6777 |BOOST_PARAMETER_CAN_USE_MP11|_ undefined.
6778
6779 .. |BOOST_PARAMETER_CAN_USE_MP11| replace:: ``BOOST_PARAMETER_CAN_USE_MP11``
6780 .. _BOOST_PARAMETER_CAN_USE_MP11:
6781
6782 ``BOOST_PARAMETER_CAN_USE_MP11``
6783 --------------------------------
6784
6785 Determines whether or not the library can use |Boost_MP11|_, a C++11
6786 metaprogramming library.  Users can manually disable this macro by
6787 ``#defining`` the |BOOST_PARAMETER_DISABLE_MP11_USAGE|_ macro or the
6788 |BOOST_PARAMETER_DISABLE_PERFECT_FORWARDING|_ macro.  Otherwise, the library
6789 will ``#define`` this macro if and only if it is not already defined, if
6790 |BOOST_PARAMETER_HAS_PERFECT_FORWARDING|_ is defined, and if the configuration
6791 macros |BOOST_NO_CXX11_CONSTEXPR|_, |BOOST_NO_CXX11_DECLTYPE_N3276|_,
6792 |BOOST_NO_CXX11_AUTO_DECLARATIONS|_, |BOOST_NO_CXX11_TEMPLATE_ALIASES|_,
6793 |BOOST_NO_CXX11_STATIC_ASSERT|_, |BOOST_NO_CXX11_HDR_TYPE_TRAITS|_,
6794 |BOOST_NO_CXX11_HDR_INITIALIZER_LIST|_, and |BOOST_NO_CXX11_HDR_TUPLE|_
6795 are not already defined by |Boost_Config|_.
6796
6797 .. Admonition:: Usage Note
6798
6799     |Boost_MP11|_ and |Boost_MPL|_ are **not** mutually exclusive.  It's
6800     perfectly acceptable to specify deduced parameters using both quoted
6801     metafunctions and metafunction classes, for example.  See
6802     |evaluate_category_cpp|_.
6803
6804 :Defined in: |config_header|_
6805 :Example usage:
6806
6807 Given the following definitions:
6808
6809 .. parsed-literal::
6810
6811     |BOOST_PARAMETER_NAME|_\(x)
6812
6813     template <typename A0>
6814     typename |boost_enable_if|_\<|std_is_same|_\<int,A0>,int>::type
6815         sfinae(A0 const& a0)
6816     {
6817         return 0;
6818     }
6819
6820 |Boost_MP11|_ allows deduced parameters to be defined more succinctly:
6821
6822 .. parsed-literal::
6823
6824     template <typename T, typename Args>
6825     using predicate = |std_is_convertible|_\<T,char const*>;
6826
6827     |BOOST_PARAMETER_FUNCTION|_\((int), sfinae, tag,
6828         (deduced
6829             (optional
6830                 (x
6831                   , \*(|mp11_quote|_\<predicate>)
6832                   , static_cast<char const*>(|std_nullptr|_\)
6833                 )
6834             )
6835         )
6836     )
6837     {
6838         return 1;
6839     }
6840
6841 Without |Boost_MP11|_, deduced parameter definitions tend to be more verbose:
6842
6843 .. parsed-literal::
6844
6845     struct predicate
6846     {
6847         template <typename T, typename Args>
6848         struct apply
6849           : |mpl_if|_\<
6850                 |boost_is_convertible|_\<T,char const*>
6851               , |mpl_true|_\   // Still have to convert to a
6852               , |mpl_false|_\  // `Boolean Integral Constant`_.
6853             >
6854         {
6855         };
6856     };
6857
6858     |BOOST_PARAMETER_FUNCTION|_\((int), sfinae, tag,
6859         (deduced
6860             (optional
6861                 (x
6862                   , \*(predicate)
6863                   , static_cast<char const*>(|std_nullptr|_\)
6864                 )
6865             )
6866         )
6867     )
6868     {
6869         return 1;
6870     }
6871
6872 Either way, the following assertions will succeed:
6873
6874 .. parsed-literal::
6875
6876     assert(1 == sfinae());
6877     assert(1 == sfinae("foo"));
6878     assert(0 == sfinae(1));
6879
6880 As another example, given the following declarations and definitions:
6881
6882 .. parsed-literal::
6883
6884     |BOOST_PARAMETER_NAME|_\(x)
6885     |BOOST_PARAMETER_NAME|_\(y)
6886
6887     template <typename E, typename Args>
6888     void check0(E const& e, Args const& args);
6889
6890     template <typename P, typename E, typename ...Args>
6891     void check(E const& e, Args const&... args)
6892     {
6893         check0(e, P()(args...));
6894     }
6895
6896 Argument packs qualify as |Boost_MP11|_-style lists containing
6897 |keyword tag type|\ s:
6898
6899 .. parsed-literal::
6900
6901     template <typename Args>
6902     struct some_functor
6903     {
6904         template <typename K>
6905         void operator()(K&&) const
6906         {
6907             // K is one of tag\:\:x, tag\:\:y, etc.
6908         }
6909     };
6910
6911     template <typename E, typename Args>
6912     void check0(E const& e, Args const& args)
6913     {
6914         boost::mp11::mp_for_each<E>(some_functor<Args>());
6915     }
6916
6917 The first check determines whether or not the argument type of ``_y`` is the
6918 same as the reference type of ``_x``, while the second check determines
6919 whether or not the argument type of ``_y`` is convertible to the value type of
6920 ``_x``.  Here, it's possible to access the reference and value result types of
6921 indexing an argument pack a little more directly:
6922
6923 .. parsed-literal::
6924
6925     // Use mp_bind on tag\:\:x\:\:binding_fn to access the reference type of _x.
6926     check<
6927         |parameters|_\<
6928             tag\:\:x
6929           , |optional|_\<
6930                 |deduced|_\<tag\:\:y>
6931               , |mp11_bind|_\<
6932                     |std_is_same|_\  // |boost_is_same|_, standard version.
6933                   , |mp11_1|_\  // will be bound to the argument type of _y.
6934                   , |mp11_bind|_\<
6935                         tag\:\:x\:\:binding_fn
6936                       , |mp11_2|_\  // will be bound to the argument pack type.
6937                     >
6938                 >
6939             >
6940         >
6941     >((_x = 0, _y = 1), 0, 1);
6942
6943     // Use mp_bind_q on tag\:\:x to access the value type of _x.
6944     check<
6945         |parameters|_\<
6946             tag\:\:x
6947           , |optional|_\<
6948                 |deduced|_\<tag\:\:y>
6949               , |mp11_bind|_\<
6950                     |std_is_convertible|_\  // |boost_is_convertible|_, standard version.
6951                   , |mp11_1|_\  // will be bound to the argument type of _y.
6952                   , |mp11_bind_q|_\<
6953                         tag\:\:x
6954                       , |mp11_2|_\  // will be bound to the argument pack type.
6955                     >
6956                 >
6957             >
6958         >
6959     >((_x = 0U, _y = 1U), 0U, 1U);
6960
6961 Argument packs still qualify as |Boost_MPL|_-style lists containing
6962 |keyword tag type|\ s:
6963
6964 .. parsed-literal::
6965
6966     template <typename Args>
6967     struct some_functor
6968     {
6969         template <typename K>
6970         void operator()(K) const
6971         {
6972             // K is one of tag\:\:x, tag\:\:y, etc.
6973         }
6974     };
6975
6976     template <typename E, typename Args>
6977     void check0(E const& e, Args const& args)
6978     {
6979         boost::mpl::for_each<E>(some_functor<Args>());
6980     }
6981
6982 However, without |Boost_MP11|_, the corresponding checks become a little more
6983 verbose:
6984
6985 .. parsed-literal::
6986
6987     check<
6988         |parameters|_\<
6989             tag\:\:x
6990           , |optional|_\<
6991                 |deduced|_\<tag\:\:y>
6992               , |mpl_if|_\<
6993                     |boost_is_same|_\<
6994                         |boost_add_lvalue_reference|_\<|mp11_1|_\>
6995                       , |binding|_\<|mp11_2|_\, tag\:\:x>
6996                     >
6997                   , |mpl_true|_\   // Still have to convert to a
6998                   , |mpl_false|_\  // `Boolean Integral Constant`_.
6999                 >
7000             >
7001         >
7002     >((_x = 0, _y = 1), 0, 1);
7003
7004     // Use tag\:\:x\:\:_ or tag\:\:x\:\:_1 to access the value type of _x.
7005     check<
7006         |parameters|_\<
7007             tag\:\:x
7008           , |optional|_\<
7009                 |deduced|_\<tag\:\:y>
7010               , |mpl_if|_\<
7011                     |boost_is_convertible|_\<|mp11_1|_\, tag\:\:x\:\:_1>
7012                   , |mpl_true|_\   // Still have to convert to a
7013                   , |mpl_false|_\  // `Boolean Integral Constant`_.
7014                 >
7015             >
7016         >
7017     >((_x = 0U, _y = 1U), 0U, 1U);
7018
7019 The |singular_cpp|_, |compose_cpp|_, |optional_deduced_sfinae_cpp|_, and
7020 |deduced_dep_pred_cpp|_ test programs demonstrate proper usage of this
7021 macro.
7022
7023 .. |BOOST_PARAMETER_DISABLE_MP11_USAGE| replace:: ``BOOST_PARAMETER_DISABLE_MP11_USAGE``
7024 .. _BOOST_PARAMETER_DISABLE_MP11_USAGE:
7025
7026 ``BOOST_PARAMETER_DISABLE_MP11_USAGE``
7027 --------------------------------------
7028
7029 It may be necessary to disable usage of |Boost_MP11|_ for compilers that
7030 cannot support it.  Users can ``#define`` this macro either in their project
7031 settings or before including any library header files.  Doing so will leave
7032 |BOOST_PARAMETER_CAN_USE_MP11|_ undefined.
7033
7034 .. |BOOST_PARAMETER_VARIADIC_MPL_SEQUENCE| replace:: ``BOOST_PARAMETER_VARIADIC_MPL_SEQUENCE``
7035 .. _BOOST_PARAMETER_VARIADIC_MPL_SEQUENCE:
7036
7037 ``BOOST_PARAMETER_VARIADIC_MPL_SEQUENCE``
7038 -----------------------------------------
7039
7040 If |BOOST_PARAMETER_HAS_PERFECT_FORWARDING|_ is ``#defined``, then determines
7041 the `MPL Variadic Sequence`_ underlying the nested ``parameter_spec`` type of
7042 |parameters|.  If the user does not manually ``#define`` this macro, then the
7043 library will ``#define`` it as |mp11_list|_ if
7044 |BOOST_PARAMETER_CAN_USE_MP11|_ is defined, |fusion_list|_ if
7045 |BOOST_FUSION_HAS_VARIADIC_LIST|_ is defined (by |Boost_Fusion|_),
7046 |fusion_deque|_ if |BOOST_FUSION_HAS_VARIADIC_DEQUE|_ is defined
7047 (by |Boost_Fusion|_), or |mpl_vector|_ otherwise.
7048
7049 :Example:
7050
7051 .. parsed-literal::
7052
7053     #define BOOST_PARAMETER_VARIADIC_MPL_SEQUENCE |fusion_vector|_
7054
7055 :Defined in: |parameters_header|_
7056
7057 .. |BOOST_PARAMETER_MAX_ARITY| replace:: ``BOOST_PARAMETER_MAX_ARITY``
7058 .. _BOOST_PARAMETER_MAX_ARITY:
7059
7060 ``BOOST_PARAMETER_MAX_ARITY``
7061 -----------------------------
7062
7063 If |BOOST_PARAMETER_HAS_PERFECT_FORWARDING|_ is ``#defined``, then:
7064
7065 *   If the `MPL Variadic Sequence`_ underlying the nested ``parameter_spec``
7066     type of |parameters| does not have a size limit--which is the case with
7067     |mp11_list|_, |fusion_list|_, and |fusion_deque|_, but not
7068     |mpl_vector|_--then this macro can be safely ignored.  User code that
7069     manually defines |BOOST_PARAMETER_VARIADIC_MPL_SEQUENCE|_ should also
7070     manually define this macro to the size limit of the sequence if it has
7071     one.
7072
7073 If |BOOST_PARAMETER_HAS_PERFECT_FORWARDING|_ is **not** ``#defined``, then:
7074
7075 *   Mutable references must be wrapped by |boost_ref|_ or |std_ref|_ if passed
7076     by position to Boost.Parameter-enabled functions with arity greater than
7077     or equal to |BOOST_PARAMETER_EXPONENTIAL_OVERLOAD_THRESHOLD_ARITY|_.
7078
7079 :Defined in: |config_header|_
7080 :Default Value: |BOOST_MPL_LIMIT_VECTOR_SIZE|_ (defined by |Boost_MPL|_) if
7081     perfect forwarding is supported, ``8`` otherwise.
7082 :Minimum Value: ``2``
7083 :Maximum Value: |BOOST_PARAMETER_COMPOSE_MAX_ARITY|_
7084
7085 .. |BOOST_PARAMETER_COMPOSE_MAX_ARITY| replace:: ``BOOST_PARAMETER_COMPOSE_MAX_ARITY``
7086 .. _BOOST_PARAMETER_COMPOSE_MAX_ARITY:
7087
7088 ``BOOST_PARAMETER_COMPOSE_MAX_ARITY``
7089 -------------------------------------
7090
7091 If |BOOST_PARAMETER_HAS_PERFECT_FORWARDING|_ is **not** ``#defined``, then
7092 determines the maximum number of arguments supported by the |compose| function
7093 and by the |BOOST_PARAMETER_NO_SPEC_FUNCTION|_,
7094 |BOOST_PARAMETER_NO_SPEC_MEMBER_FUNCTION|_,
7095 |BOOST_PARAMETER_NO_SPEC_CONST_MEMBER_FUNCTION|_,
7096 |BOOST_PARAMETER_NO_SPEC_FUNCTION_CALL_OPERATOR|_,
7097 |BOOST_PARAMETER_NO_SPEC_CONST_FUNCTION_CALL_OPERATOR|_,
7098 |BOOST_PARAMETER_NO_SPEC_CONSTRUCTOR|_, and
7099 |BOOST_PARAMETER_NO_SPEC_NO_BASE_CONSTRUCTOR|_ code generation macros.
7100
7101 :Defined in: |config_header|_
7102 :Default Value: ``20`` for a few older compilers, ``64`` otherwise
7103 :Minimum Value: ``2``
7104
7105 .. |BOOST_PARAMETER_EXPONENTIAL_OVERLOAD_THRESHOLD_ARITY| replace:: ``BOOST_PARAMETER_EXPONENTIAL_OVERLOAD_THRESHOLD_ARITY``
7106 .. _BOOST_PARAMETER_EXPONENTIAL_OVERLOAD_THRESHOLD_ARITY:
7107
7108 ``BOOST_PARAMETER_EXPONENTIAL_OVERLOAD_THRESHOLD_ARITY``
7109 --------------------------------------------------------
7110
7111 If this library does **not** support perfect forwarding, determines the number
7112 of arguments less than which |parameters| generates an exponential number of
7113 function call operator overloads, and greater than or equal to which
7114 |parameters| does not.  Will only be ``#defined`` by the library if it is
7115 not already ``#defined`` and |BOOST_PARAMETER_HAS_PERFECT_FORWARDING|_ is
7116 **not** ``#defined``.
7117
7118 :Defined in: |config_header|_
7119 :Default Value: ``0``
7120 :Minimum Value: ``0``
7121
7122 ...Outside Of This Library
7123 --------------------------
7124
7125 #.  If |Boost_Config|_ defines the macro
7126     |BOOST_NO_FUNCTION_TEMPLATE_ORDERING|_, then the macros
7127     |BOOST_PARAMETER_HAS_PERFECT_FORWARDING|_ and
7128     |BOOST_PARAMETER_CAN_USE_MP11|_ will be left undefined; otherwise, the
7129     code generation macros would not work correctly.
7130 #.  If |Boost_Config|_ defines the macro |BOOST_NO_SFINAE|_, then the macros
7131     |BOOST_PARAMETER_HAS_PERFECT_FORWARDING|_ and
7132     |BOOST_PARAMETER_CAN_USE_MP11|_ will be left undefined; otherwise, keyword
7133     types generated by |BOOST_PARAMETER_NAME|_ and
7134     |BOOST_PARAMETER_NESTED_KEYWORD|_ would not work correctly.
7135 #.  If |Boost_Config|_ defines the macro
7136     |BOOST_NO_CXX11_RVALUE_REFERENCES|_, then the macros
7137     |BOOST_PARAMETER_HAS_PERFECT_FORWARDING|_ and
7138     |BOOST_PARAMETER_CAN_USE_MP11|_ will be left undefined.
7139 #.  If |Boost_Config|_ defines the macro |BOOST_NO_CXX11_VARIADIC_TEMPLATES|_,
7140     then the macros |BOOST_PARAMETER_HAS_PERFECT_FORWARDING|_ and
7141     |BOOST_PARAMETER_CAN_USE_MP11|_ will be left undefined.
7142 #.  If |Boost_Config|_ defines the macro
7143     |BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS|_, then the macros
7144     |BOOST_PARAMETER_HAS_PERFECT_FORWARDING|_ and
7145     |BOOST_PARAMETER_CAN_USE_MP11|_ will be left undefined.
7146 #.  If |Boost_Config|_ defines the macro |BOOST_NO_CXX11_CONSTEXPR|_, then the
7147     macro |BOOST_PARAMETER_CAN_USE_MP11|_ will be left undefined.
7148 #.  If |Boost_Config|_ defines the macro |BOOST_NO_CXX11_DECLTYPE_N3276|_,
7149     then the macro |BOOST_PARAMETER_CAN_USE_MP11|_ will be left undefined.
7150 #.  If |Boost_Config|_ defines the macro |BOOST_NO_CXX11_AUTO_DECLARATIONS|_,
7151     then the macro |BOOST_PARAMETER_CAN_USE_MP11|_ will be left undefined.
7152 #.  If |Boost_Config|_ defines the macro |BOOST_NO_CXX11_TEMPLATE_ALIASES|_,
7153     then the macro |BOOST_PARAMETER_CAN_USE_MP11|_ will be left undefined.
7154 #.  If |Boost_Config|_ defines the macro |BOOST_NO_CXX11_STATIC_ASSERT|_, then
7155     the macro |BOOST_PARAMETER_CAN_USE_MP11|_ will be left undefined.
7156 #.  If |Boost_Config|_ defines the macro |BOOST_NO_CXX11_HDR_TYPE_TRAITS|_,
7157     then the macro |BOOST_PARAMETER_CAN_USE_MP11|_ will be left undefined.
7158 #.  If |Boost_Config|_ defines the macro
7159     |BOOST_NO_CXX11_HDR_INITIALIZER_LIST|_, then the macro
7160     |BOOST_PARAMETER_CAN_USE_MP11|_ will be left undefined.
7161 #.  If |Boost_Config|_ defines the macro |BOOST_NO_CXX11_HDR_TUPLE|_, then the
7162     macro |BOOST_PARAMETER_CAN_USE_MP11|_ will be left undefined.
7163 #.  If |Boost_Fusion|_ defines the macro |BOOST_FUSION_HAS_VARIADIC_LIST|_,
7164     if this library defines the macro
7165     |BOOST_PARAMETER_HAS_PERFECT_FORWARDING|_, and if
7166     |BOOST_PARAMETER_VARIADIC_MPL_SEQUENCE|_ is left undefined, then the
7167     `MPL Variadic Sequence`_ underlying the nested ``parameter_spec`` type of
7168     |parameters| will be |fusion_list|_.
7169 #.  If |Boost_Fusion|_ defines the macro |BOOST_FUSION_HAS_VARIADIC_DEQUE|_,
7170     if this library defines the macro
7171     |BOOST_PARAMETER_HAS_PERFECT_FORWARDING|_, and if
7172     |BOOST_PARAMETER_VARIADIC_MPL_SEQUENCE|_ is left undefined, then the
7173     `MPL Variadic Sequence`_ underlying the nested ``parameter_spec`` type of
7174     |parameters| will be |fusion_deque|_.
7175 #.  The value that |Boost_MPL|_ defines the macro
7176     |BOOST_MPL_LIMIT_VECTOR_SIZE|_ as will be the value that this library
7177     defines the macro |BOOST_PARAMETER_MAX_ARITY|_ as if this library defines
7178     the macro |BOOST_PARAMETER_HAS_PERFECT_FORWARDING|_.
7179
7180 Tutorial
7181 ========
7182
7183 Follow `this link`__ to the Boost.Parameter tutorial documentation.
7184
7185 __ index.html#tutorial
7186
7187 //////////////////////////////////////////////////////////////////////////////
7188
7189 .. [#thread] References to tag objects may be initialized multiple
7190     times.  This scenario can only occur in the presence of
7191     threading.  Because the C++ standard doesn't consider threading,
7192     it doesn't explicitly allow or forbid multiple initialization of
7193     references.  That said, it's hard to imagine an implementation
7194     where it could make a difference.
7195
7196 .. [#no_result_of] Where |BOOST_NO_RESULT_OF|_ is ``#defined``,
7197     |boost_result_of|_\ ``<F()>::type`` is replaced by ``F::result_type``.
7198
7199 .. |std_nullptr| replace:: std::nullptr
7200 .. _std_nullptr: http://en.cppreference.com/w/cpp/language/nullptr
7201 .. |std_forward| replace:: std::forward
7202 .. _std_forward: http://en.cppreference.com/w/cpp/utility/forward
7203 .. |std_enable_if| replace:: std::enable_if
7204 .. _std_enable_if: http://en.cppreference.com/w/cpp/types/enable_if
7205 .. |std_is_convertible| replace:: std::is_convertible
7206 .. _std_is_convertible: http://en.cppreference.com/w/cpp/types/is_convertible
7207 .. |std_is_same| replace:: std::is_same
7208 .. _std_is_same: http://en.cppreference.com/w/cpp/types/is_same
7209 .. |std_ref| replace:: ``std::ref``
7210 .. _std_ref: http://en.cppreference.com/w/cpp/utility/functional/ref
7211 .. |std_map| replace:: std::map
7212 .. _std_map: http://en.cppreference.com/w/cpp/container/map
7213 .. |std_string| replace:: std::string
7214 .. _std_string: http://en.cppreference.com/w/cpp/string/basic_string
7215 .. |std_bitset| replace:: std::bitset
7216 .. _std_bitset: http://en.cppreference.com/w/cpp/utility/bitset
7217 .. |Boost_Config| replace:: Boost.Config
7218 .. _Boost_Config: ../../../config/doc/html/index.html
7219 .. |BOOST_NO_FUNCTION_TEMPLATE_ORDERING| replace:: ``BOOST_NO_FUNCTION_TEMPLATE_ORDERING``
7220 .. _BOOST_NO_FUNCTION_TEMPLATE_ORDERING: ../../../config/doc/html/boost_config/boost_macro_reference.html#boost_config.boost_macro_reference.macros_that_describe_c__03_defects
7221 .. |BOOST_NO_SFINAE| replace:: ``BOOST_NO_SFINAE``
7222 .. _BOOST_NO_SFINAE: ../../../config/doc/html/boost_config/boost_macro_reference.html#boost_config.boost_macro_reference.macros_that_describe_c__03_defects
7223 .. |BOOST_NO_CXX11_AUTO_DECLARATIONS| replace:: ``BOOST_NO_CXX11_AUTO_DECLARATIONS``
7224 .. _BOOST_NO_CXX11_AUTO_DECLARATIONS: ../../../config/doc/html/boost_config/boost_macro_reference.html#boost_config.boost_macro_reference.macros_that_describe_c__11_features_not_supported
7225 .. |BOOST_NO_CXX11_CONSTEXPR| replace:: ``BOOST_NO_CXX11_CONSTEXPR``
7226 .. _BOOST_NO_CXX11_CONSTEXPR: ../../../config/doc/html/boost_config/boost_macro_reference.html#boost_config.boost_macro_reference.macros_that_describe_c__11_features_not_supported
7227 .. |BOOST_NO_CXX11_DECLTYPE_N3276| replace:: ``BOOST_NO_CXX11_DECLTYPE_N3276``
7228 .. _BOOST_NO_CXX11_DECLTYPE_N3276: ../../../config/doc/html/boost_config/boost_macro_reference.html#boost_config.boost_macro_reference.macros_that_describe_c__11_features_not_supported
7229 .. |BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS| replace:: ``BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS``
7230 .. _BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS: ../../../config/doc/html/boost_config/boost_macro_reference.html#boost_config.boost_macro_reference.macros_that_describe_c__11_features_not_supported
7231 .. |BOOST_NO_CXX11_HDR_INITIALIZER_LIST| replace:: ``BOOST_NO_CXX11_HDR_INITIALIZER_LIST``
7232 .. _BOOST_NO_CXX11_HDR_INITIALIZER_LIST: ../../../config/doc/html/boost_config/boost_macro_reference.html#boost_config.boost_macro_reference.macros_that_describe_c__11_features_not_supported
7233 .. |BOOST_NO_CXX11_HDR_TUPLE| replace:: ``BOOST_NO_CXX11_HDR_TUPLE``
7234 .. _BOOST_NO_CXX11_HDR_TUPLE: ../../../config/doc/html/boost_config/boost_macro_reference.html#boost_config.boost_macro_reference.macros_that_describe_c__11_features_not_supported
7235 .. |BOOST_NO_CXX11_HDR_TYPE_TRAITS| replace:: ``BOOST_NO_CXX11_HDR_TYPE_TRAITS``
7236 .. _BOOST_NO_CXX11_HDR_TYPE_TRAITS: ../../../config/doc/html/boost_config/boost_macro_reference.html#boost_config.boost_macro_reference.macros_that_describe_c__11_features_not_supported
7237 .. |BOOST_NO_CXX11_RVALUE_REFERENCES| replace:: ``BOOST_NO_CXX11_RVALUE_REFERENCES``
7238 .. _BOOST_NO_CXX11_RVALUE_REFERENCES: ../../../config/doc/html/boost_config/boost_macro_reference.html#boost_config.boost_macro_reference.macros_that_describe_c__11_features_not_supported
7239 .. |BOOST_NO_CXX11_STATIC_ASSERT| replace:: ``BOOST_NO_CXX11_STATIC_ASSERT``
7240 .. _BOOST_NO_CXX11_STATIC_ASSERT: ../../../config/doc/html/boost_config/boost_macro_reference.html#boost_config.boost_macro_reference.macros_that_describe_c__11_features_not_supported
7241 .. |BOOST_NO_CXX11_TEMPLATE_ALIASES| replace:: ``BOOST_NO_CXX11_TEMPLATE_ALIASES``
7242 .. _BOOST_NO_CXX11_TEMPLATE_ALIASES: ../../../config/doc/html/boost_config/boost_macro_reference.html#boost_config.boost_macro_reference.macros_that_describe_c__11_features_not_supported
7243 .. |BOOST_NO_CXX11_VARIADIC_TEMPLATES| replace:: ``BOOST_NO_CXX11_VARIADIC_TEMPLATES``
7244 .. _BOOST_NO_CXX11_VARIADIC_TEMPLATES: ../../../config/doc/html/boost_config/boost_macro_reference.html#boost_config.boost_macro_reference.macros_that_describe_c__11_features_not_supported
7245 .. |Boost_Preprocessor| replace:: Boost.Preprocessor
7246 .. _Boost_Preprocessor: ../../../preprocessor/doc/index.html
7247 .. _`sequence`: ../../../preprocessor/doc/data/sequences.html
7248 .. |BOOST_PP_INC| replace:: BOOST_PP_INC
7249 .. _BOOST_PP_INC: ../../../preprocessor/doc/ref/inc.html
7250 .. |boost_enable_if| replace:: boost::enable_if
7251 .. _boost_enable_if: ../../../core/doc/html/core/enable_if.html
7252 .. |boost_enable_if_c| replace:: boost::enable_if_c
7253 .. _boost_enable_if_c: ../../../core/doc/html/core/enable_if.html
7254 .. |boost_lazy_enable_if| replace:: boost::lazy_enable_if
7255 .. _boost_lazy_enable_if: ../../../core/doc/html/core/enable_if.html
7256 .. |boost_lazy_enable_if_c| replace:: boost::lazy_enable_if_c
7257 .. _boost_lazy_enable_if_c: ../../../core/doc/html/core/enable_if.html
7258 .. |boost_disable_if| replace:: boost::disable_if
7259 .. _boost_disable_if: ../../../core/doc/html/core/enable_if.html
7260 .. |boost_disable_if_c| replace:: boost::disable_if_c
7261 .. _boost_disable_if_c: ../../../core/doc/html/core/enable_if.html
7262 .. |boost_lazy_disable_if| replace:: boost::lazy_disable_if
7263 .. _boost_lazy_disable_if: ../../../core/doc/html/core/enable_if.html
7264 .. |boost_lazy_disable_if_c| replace:: boost::lazy_disable_if_c
7265 .. _boost_lazy_disable_if_c: ../../../core/doc/html/core/enable_if.html
7266 .. |boost_ref| replace:: ``boost::ref``
7267 .. _boost_ref: ../../../core/doc/html/core/ref.html
7268 .. |BOOST_NO_RESULT_OF| replace:: ``BOOST_NO_RESULT_OF``
7269 .. _BOOST_NO_RESULT_OF: ../../../utility/utility.htm#BOOST_NO_RESULT_OF
7270 .. |boost_result_of| replace:: ``boost::result_of``
7271 .. _boost_result_of: ../../../utility/utility.htm#result_of
7272 .. |boost_is_const| replace:: boost::is_const
7273 .. _boost_is_const: ../../../type_traits/doc/html/boost_typetraits/is_const.html
7274 .. |boost_is_convertible| replace:: boost::is_convertible
7275 .. _boost_is_convertible: ../../../type_traits/doc/html/boost_typetraits/is_convertible.html
7276 .. |boost_is_same| replace:: boost::is_same
7277 .. _boost_is_same: ../../../type_traits/doc/html/boost_typetraits/is_same.html
7278 .. |boost_is_scalar| replace:: boost::is_scalar
7279 .. _boost_is_scalar: ../../../type_traits/doc/html/boost_typetraits/is_scalar.html
7280 .. |boost_add_lvalue_reference| replace:: boost::add_lvalue_reference
7281 .. _boost_add_lvalue_reference: ../../../type_traits/doc/html/boost_typetraits/add_lvalue_reference.html
7282 .. |boost_remove_reference| replace:: boost::remove_reference
7283 .. _boost_remove_reference: ../../../type_traits/doc/html/boost_typetraits/remove_reference.html
7284 .. |Boost_MPL| replace:: Boost.MPL
7285 .. _Boost_MPL: ../../../mpl/doc/index.html
7286 .. _`Metafunction`: ../../../mpl/doc/refmanual/metafunction.html
7287 .. _`Boolean Integral Constant`: ../../../mpl/doc/refmanual/integral-constant.html
7288 .. _`MPL Binary Metafunction Class`: ../../../mpl/doc/refmanual/metafunction-class.html
7289 .. _`MPL Forward Sequence`: ../../../mpl/doc/refmanual/forward-sequence.html
7290 .. _`MPL Associative Sequence`: ../../../mpl/doc/refmanual/associative-sequence.html
7291 .. _`MPL Variadic Sequence`: ../../../mpl/doc/refmanual/variadic-sequence.html
7292 .. |BOOST_MPL_LIMIT_VECTOR_SIZE| replace:: ``BOOST_MPL_LIMIT_VECTOR_SIZE``
7293 .. _BOOST_MPL_LIMIT_VECTOR_SIZE: ../../../mpl/doc/refmanual/limit-vector-size.html
7294 .. |mpl_eval_if| replace:: boost::mpl::eval_if
7295 .. _mpl_eval_if: ../../../mpl/doc/refmanual/eval-if.html
7296 .. |mpl_true| replace:: mpl::true\_
7297 .. _mpl_true: ../../../mpl/doc/refmanual/bool.html
7298 .. |mpl_false| replace:: mpl::false\_
7299 .. _mpl_false: ../../../mpl/doc/refmanual/bool.html
7300 .. |mpl_if| replace:: mpl::if\_
7301 .. _mpl_if: ../../../mpl/doc/refmanual/if.html
7302 .. |mpl_vector| replace:: ``boost::mpl::vector``
7303 .. _mpl_vector: ../../../mpl/doc/refmanual/vector.html
7304 .. |Boost_MP11| replace:: Boost.MP11
7305 .. _Boost_MP11: ../../../mp11/doc/html/mp11.html
7306 .. |mp11_quote| replace:: boost::mp11::mp_quote
7307 .. _mp11_quote: ../../../mp11/doc/html/mp11.html#mp_quotef
7308 .. |mp11_1| replace:: boost::mp11::_1
7309 .. _mp11_1: ../../../mp11/doc/html/mp11.html#1_9
7310 .. |mp11_2| replace:: boost::mp11::_2
7311 .. _mp11_2: ../../../mp11/doc/html/mp11.html#1_9
7312 .. |mp11_bind| replace:: boost::mp11::mp_bind
7313 .. _mp11_bind: ../../../mp11/doc/html/mp11.html#mp_bindf_t
7314 .. |mp11_bind_q| replace:: boost::mp11::mp_bind_q
7315 .. _mp11_bind_q: ../../../mp11/doc/html/mp11.html#mp_bind_qq_t
7316 .. |mp11_list| replace:: ``boost::mp11::mp_list``
7317 .. _mp11_list: ../../../mp11/doc/html/mp11.html#mp_listt
7318 .. |Boost_Fusion| replace:: Boost.Fusion
7319 .. _Boost_Fusion: ../../../fusion/doc/html/index.html
7320 .. |BOOST_FUSION_HAS_VARIADIC_DEQUE| replace:: ``BOOST_FUSION_HAS_VARIADIC_DEQUE``
7321 .. _BOOST_FUSION_HAS_VARIADIC_DEQUE: ../../../../boost/fusion/container/deque/deque_fwd.hpp
7322 .. |BOOST_FUSION_HAS_VARIADIC_LIST| replace:: ``BOOST_FUSION_HAS_VARIADIC_LIST``
7323 .. _BOOST_FUSION_HAS_VARIADIC_LIST: ../../../../boost/fusion/container/list/list_fwd.hpp
7324 .. |fusion_vector| replace:: ``boost::fusion::vector``
7325 .. _fusion_vector: ../../../fusion/doc/html/fusion/container/vector.html
7326 .. |fusion_deque| replace:: ``boost::fusion::deque``
7327 .. _fusion_deque: ../../../fusion/doc/html/fusion/container/deque.html
7328 .. |fusion_list| replace:: ``boost::fusion::list``
7329 .. _fusion_list: ../../../fusion/doc/html/fusion/container/list.html
7330 .. |config_header| replace:: boost/parameter/config.hpp
7331 .. _config_header: ../../../../boost/parameter/config.hpp
7332 .. |binding_header| replace:: boost/parameter/binding.hpp
7333 .. _binding_header: ../../../../boost/parameter/binding.hpp
7334 .. |value_type_header| replace:: boost/parameter/value_type.hpp
7335 .. _value_type_header: ../../../../boost/parameter/value_type.hpp
7336 .. |are_tagged_arguments_header| replace:: boost/parameter/are_tagged_arguments.hpp
7337 .. _are_tagged_arguments_header: ../../../../boost/parameter/are_tagged_arguments.hpp
7338 .. |is_argument_pack_header| replace:: boost/parameter/is_argument_pack.hpp
7339 .. _is_argument_pack_header: ../../../../boost/parameter/is_argument_pack.hpp
7340 .. |template_keyword_header| replace:: boost/parameter/template_keyword.hpp
7341 .. _template_keyword_header: ../../../../boost/parameter/template_keyword.hpp
7342 .. |keyword_header| replace:: boost/parameter/keyword.hpp
7343 .. _keyword_header: ../../../../boost/parameter/keyword.hpp
7344 .. |name_header| replace:: boost/parameter/name.hpp
7345 .. _name_header: ../../../../boost/parameter/name.hpp
7346 .. |nested_keyword_header| replace:: boost/parameter/nested_keyword.hpp
7347 .. _nested_keyword_header: ../../../../boost/parameter/nested_keyword.hpp
7348 .. |compose_header| replace:: boost/parameter/compose.hpp
7349 .. _compose_header: ../../../../boost/parameter/compose.hpp
7350 .. |preprocessor_no_spec_header| replace:: boost/parameter/preprocessor_no_spec.hpp
7351 .. _preprocessor_no_spec_header: ../../../../boost/parameter/preprocessor_no_spec.hpp
7352 .. |required_header| replace:: boost/parameter/required.hpp
7353 .. _required_header: ../../../../boost/parameter/required.hpp
7354 .. |optional_header| replace:: boost/parameter/optional.hpp
7355 .. _optional_header: ../../../../boost/parameter/optional.hpp
7356 .. |deduced_header| replace:: boost/parameter/deduced.hpp
7357 .. _deduced_header: ../../../../boost/parameter/deduced.hpp
7358 .. |parameters_header| replace:: boost/parameter/parameters.hpp
7359 .. _parameters_header: ../../../../boost/parameter/parameters.hpp
7360 .. |match_header| replace:: boost/parameter/match.hpp
7361 .. _match_header: ../../../../boost/parameter/match.hpp
7362 .. |macros_header| replace:: boost/parameter/macros.hpp
7363 .. _macros_header: ../../../../boost/parameter/macros.hpp
7364 .. |preprocessor_header| replace:: boost/parameter/preprocessor.hpp
7365 .. _preprocessor_header: ../../../../boost/parameter/preprocessor.hpp
7366 .. |function_type_tpl_param_cpp| replace:: function_type_tpl_param.cpp
7367 .. _function_type_tpl_param_cpp: ../../test/function_type_tpl_param.cpp
7368 .. |ntp_cpp| replace:: test/ntp.cpp
7369 .. _ntp_cpp: ../../test/ntp.cpp
7370 .. |singular_cpp| replace:: singular.cpp
7371 .. _singular_cpp: ../../test/singular.cpp
7372 .. |compose_cpp| replace:: compose.cpp
7373 .. _compose_cpp: ../../test/compose.cpp
7374 .. |evaluate_category_cpp| replace:: evaluate_category.cpp
7375 .. _evaluate_category_cpp: ../../test/evaluate_category.cpp
7376 .. |parameterized_inheritance_cpp| replace:: parameterized_inheritance.cpp
7377 .. _parameterized_inheritance_cpp: ../../test/parameterized_inheritance.cpp
7378 .. |preproc_eval_cat_no_spec_cpp| replace:: preprocessor_eval_cat_no_spec.cpp
7379 .. _preproc_eval_cat_no_spec_cpp: ../../test/preprocessor_eval_cat_no_spec.cpp
7380 .. |preprocessor_eval_cat_cpp| replace:: preprocessor_eval_category.cpp
7381 .. _preprocessor_eval_cat_cpp: ../../test/preprocessor_eval_category.cpp
7382 .. |preprocessor_eval_cat_8_cpp| replace:: preprocessor_eval_cat_8.cpp
7383 .. _preprocessor_eval_cat_8_cpp: ../../test/preprocessor_eval_cat_8.cpp
7384 .. |optional_deduced_sfinae_cpp| replace:: optional_deduced_sfinae.cpp
7385 .. _optional_deduced_sfinae_cpp: ../../test/optional_deduced_sfinae.cpp
7386 .. |mpl_cpp| replace:: mpl.cpp
7387 .. _mpl_cpp: ../../test/mpl.cpp
7388 .. |preprocessor_cpp| replace:: preprocessor.cpp
7389 .. _preprocessor_cpp: ../../test/preprocessor.cpp
7390 .. |preprocessor_deduced_cpp| replace:: preprocessor_deduced.cpp
7391 .. _preprocessor_deduced_cpp: ../../test/preprocessor_deduced.cpp
7392 .. |deduced_dep_pred_cpp| replace:: deduced_dependent_predicate.cpp
7393 .. _deduced_dep_pred_cpp: ../../test/deduced_dependent_predicate.cpp
7394 .. |macros_eval_cat_cpp| replace:: macros_eval_category.cpp
7395 .. _macros_eval_cat_cpp: ../../test/macros_eval_category.cpp
7396 .. |macros_cpp| replace:: macros.cpp
7397 .. _macros_cpp: ../../test/macros.cpp
7398