++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ The Boost Parameter Library Reference Documentation ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ :Authors: David Abrahams, Daniel Wallin :Contact: dave@boost-consulting.com, daniel@boostpro.com :organization: `BoostPro Computing`_ :date: $Date: 2005/07/17 19:53:01 $ :copyright: Copyright David Abrahams, Daniel Wallin 2005-2009. Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) |(logo)|__ .. |(logo)| image:: ../../../../boost.png :alt: Boost __ ../../../../index.htm .. _`BoostPro Computing`: http://www.boostpro.com ////////////////////////////////////////////////////////////////////////////// .. contents:: :depth: 2 ////////////////////////////////////////////////////////////////////////////// .. role:: class :class: class .. role:: concept :class: concept .. role:: function :class: function .. |ArgumentPack| replace:: :concept:`ArgumentPack` .. |ForwardSequence| replace:: :concept:`Forward Sequence` .. |ParameterSpec| replace:: :concept:`ParameterSpec` .. role:: vellipsis :class: vellipsis .. section-numbering:: :depth: 2 Preliminaries ============= This section covers some basic information you'll need to know in order to understand this reference. Namespaces ---------- In this document, all unqualified identifiers should be assumed to be defined in namespace ``boost::parameter`` unless otherwise specified. Exceptions ---------- No operation described in this document throws an exception unless otherwise specified. Thread Safety ------------- All components of this library can be used safely from multiple threads without synchronization. [#thread]_ Typography ---------- Names written in :concept:`sans serif type` represent concepts_. In code blocks, *italic type* represents unspecified text that satisfies the requirements given in the detailed description that follows the code block. In a specification of the tokens generated by a macro, **bold type** is used to highlight the position of the expanded macro argument in the result. The special character β represents the value of |BOOST_PARAMETER_MAX_ARITY|_. ////////////////////////////////////////////////////////////////////////////// Terminology =========== .. |kw| replace:: keyword .. _kw: keyword The name of a function parameter. .. _keyword tag type: .. |keyword tag type| replace:: `keyword tag type`_ keyword tag type A type used to uniquely identify a function parameter. Typically its name will be the same as that of the parameter. .. _positional: .. |positional| replace:: `positional`_ positional argument An argument passed with no explicit |kw|. Its parameter is determined in the usual C++ way: by position with respect to a parameter list. .. _tag type: .. |tag type| replace:: `tag type`_ tag type Shorthand for “\ |keyword tag type|.” .. _keyword object: .. |keyword object| replace:: `keyword object`_ keyword object An instance of |keyword|_ ```` for some |tag type| ``T``. .. _tagged reference: .. |tagged reference| replace:: `tagged reference`_ tagged reference An object whose type is associated with a |keyword tag type| (the object's *keyword*), and that holds a reference (to the object's *value*). As a shorthand, a “tagged reference to ``x``\ ” means a tagged reference whose *value* is ``x``. .. _tagged default: .. |tagged default| replace:: `tagged default`_ tagged default A |tagged reference| whose *value* represents the value of a default argument. .. _tagged lazy default: .. |tagged lazy default| replace:: `tagged lazy default`_ tagged lazy default A |tagged reference| whose *value*, when invoked with no arguments, computes a default argument value. .. _intended argument type: .. |intended argument type| replace:: `intended argument type`_ intended argument type The *intended argument type* of a single-element |ArgumentPack|_ is the type of its element's *value*. The intended argument type of any other type ``X`` is ``X`` itself. .. Note:: In this reference, we will use concept names (and other names) to describe both types and objects, depending on context. So for example, “an |ArgumentPack|_\ ” can refer to a type that models |ArgumentPack|_ *or* an object of such a type. ////////////////////////////////////////////////////////////////////////////// Concepts ======== This section describes the generic type concepts used by the Parameter library. |ArgumentPack| -------------- An |ArgumentPack| is a collection of |tagged reference|\ s to the actual arguments passed to a function. Every |ArgumentPack| is also a valid `MPL Forward Sequence`_ and `MPL Associative Sequence`_ consisting of the |keyword tag type|\ s in its |tagged reference|\ s. .. _`MPL Forward Sequence`: ../../../mpl/doc/refmanual/forward-sequence.html .. _`MPL Associative Sequence`: ../../../mpl/doc/refmanual/associative-sequence.html Requirements ............ In the table below, * ``A`` is a model of |ArgumentPack| * ``x`` is an instance of ``A`` * ``u`` is a |keyword object| of type ``K`` * ``v`` is a |tagged default| with |tag type| ``L`` and *value* of type ``D`` * ``w`` is a |tagged lazy default| with |tag type| ``M`` and *value* of type ``E const`` * ``z`` is an |ArgumentPack| containing a single element (as created by |keyword|_\ ``<…>::operator=``) Any exceptions thrown from the invocation of ``w``\ 's *value* will be propagated to the caller. .. table:: |ArgumentPack| requirements +------------+-------------------+----------------+--------------------------+ | Expression | Type | Requirements | Semantics/Notes | +============+===================+================+==========================+ | ``x[u]`` | ``binding<`` | ``x`` contains | Returns *b*\ 's *value* | | | ``A, K`` | an element *b* | (by reference). | | | ``>::type`` | whose |kw|_ is | | | | | ``K`` | | +------------+-------------------+----------------+--------------------------+ | ``x[u]`` | ``binding<`` | *none* | If ``x`` contains an | | | ``A, L, D`` | | element *b* whose |kw|_ | | | ``>::type`` | | is the same as | | | | | ``u``\ 's, returns | | | | | *b*\ 's *value* (by | | | | | reference). Otherwise, | | | | | returns ``u``\ 's | | | | | *value*. | +------------+-------------------+----------------+--------------------------+ | ``x[w]`` | ``lazy_binding<`` | *none* | If ``x`` contains an | | | ``A, M, E`` | | element *b* whose |kw|_ | | | ``>::type`` | | is the same as | | | | | ``w``\ 's, returns | | | | | *b*\ 's *value* (by | | | | | reference). Otherwise, | | | | | invokes ``w``\ 's | | | | | *value* and returns the | | | | | result. | +------------+-------------------+----------------+--------------------------+ | ``x, z`` | Model of | *none* | Returns an | | | |ArgumentPack| | | |ArgumentPack|_ | | | | | containing all the | | | | | elements of both ``x`` | | | | | and ``z``. | +------------+-------------------+----------------+--------------------------+ .. _parameterspec: |ParameterSpec| --------------- A |ParameterSpec| describes the type requirements for arguments corresponding to a given |kw|_ and indicates whether the argument is optional or required. The table below details the allowed forms and describes their condition for satisfaction by an actual argument type. In each row, .. _conditions: * ``K`` is the |ParameterSpec|\ 's |keyword tag type| * ``A`` is an |intended argument type| associated with ``K``, if any * ``P`` is a model of |ArgumentPack| that contains ``A`` * ``F`` is an `MPL Binary Metafunction Class`_ .. _`MPL Binary Metafunction Class`: ../../../mpl/doc/refmanual/metafunction-class.html .. table:: |ParameterSpec| allowed forms and conditions of satisfaction +------------------------+----------+----------------------------------------+ | Type | ``A`` | Condition ``A`` must satisfy | | | required | | +========================+==========+========================================+ | ``K`` | no | *n/a* | +------------------------+----------+----------------------------------------+ | |optional|_\ ```` | no | ``mpl::apply2::type::value`` is | | | | ``true``. | +------------------------+----------+----------------------------------------+ | |required|_\ ```` | yes | ``mpl::apply2::type::value`` is | | | | ``true``. | +------------------------+----------+----------------------------------------+ The information in a |ParameterSpec| is used to `limit`__ the arguments that will be matched by `forwarding functions`_. __ overloadcontrol_ .. _overloadcontrol: index.html#controlling-overload-resolution .. _forwarding functions: index.html#forwarding-functions ////////////////////////////////////////////////////////////////////////////// Class Templates =============== .. |keyword| replace:: ``keyword`` .. _keyword: ``keyword`` ----------- The type of every |keyword object| is a specialization of |keyword|. :Defined in: `boost/parameter/keyword.hpp`__ __ ../../../../boost/parameter/keyword.hpp **If** |BOOST_PARAMETER_HAS_PERFECT_FORWARDING| is ``#defined``, **then** .. parsed-literal:: template struct keyword { typedef Tag tag; template typename boost::`enable_if`_< typename boost::mpl::`eval_if_`_< boost::`is_scalar`_ , boost::mpl::`true_`_ , boost::mpl::`eval_if_`_< boost::`is_same`_< typename Tag::qualifier , boost::parameter::in_reference > , boost::mpl::`true_`_ , boost::mpl::`if_`_< boost::`is_same`_< typename Tag::qualifier , boost::parameter::forward_reference > , boost::mpl::`true_`_ , boost::mpl::`false_`_ > > >::type , |ArgumentPack|_ >::type constexpr `operator=`_\(T const& value) const; template typename boost::`enable_if`_< typename boost::mpl::`eval_if_`_< typename boost::mpl::`eval_if_`_< boost::`is_same`_< typename Tag::qualifier , boost::parameter::out_reference > , boost::mpl::`true_`_ , boost::mpl::`if_`_< boost::`is_same`_< typename Tag::qualifier , boost::parameter::forward_reference > , boost::mpl::`true_`_ , boost::mpl::`false_`_ > >::type , boost::mpl::`if_`_< boost::`is_const`_ , boost::mpl::`false_`_ , boost::mpl::`true_`_ > , boost::mpl::`false_`_ >::type , |ArgumentPack|_ >::type constexpr `operator=`_\(T& value) const; template typename boost::`enable_if`_< typename boost::mpl::`eval_if_`_< boost::`is_scalar`_ , boost::mpl::`false_`_ , boost::mpl::`eval_if_`_< boost::`is_same`_< typename Tag::qualifier , boost::parameter::in_reference > , boost::mpl::`true_`_ , boost::mpl::`if_`_< boost::`is_same`_< typename Tag::qualifier , boost::parameter::forward_reference > , boost::mpl::`true_`_ , boost::mpl::`false_`_ > > >::type , |ArgumentPack|_ >::type constexpr `operator=`_\(T const&& value) const; template typename boost::`enable_if`_< typename boost::mpl::`eval_if_`_< boost::`is_scalar`_ , boost::mpl::`false_`_ , boost::mpl::`eval_if_`_< boost::`is_same`_< typename Tag::qualifier , boost::parameter::consume_reference > , boost::mpl::`true_`_ , boost::mpl::`if_`_< boost::`is_same`_< typename Tag::qualifier , boost::parameter::forward_reference > , boost::mpl::`true_`_ , boost::mpl::`false_`_ > > >::type , |ArgumentPack|_ >::type constexpr `operator=`_\(T&& value) const; template typename boost::`enable_if`_< typename boost::mpl::`eval_if_`_< boost::`is_scalar`_ , boost::mpl::`true_`_ , boost::mpl::`eval_if_`_< boost::`is_same`_< typename Tag::qualifier , boost::parameter::in_reference > , boost::mpl::`true_`_ , boost::mpl::`if_`_< boost::`is_same`_< typename Tag::qualifier , boost::parameter::forward_reference > , boost::mpl::`true_`_ , boost::mpl::`false_`_ > > >::type , *tagged default* >::type `operator|`_\(T const& x) const; template typename boost::`enable_if`_< typename boost::mpl::`eval_if_`_< typename boost::mpl::`eval_if_`_< boost::`is_same`_< typename Tag::qualifier , boost::parameter::out_reference > , boost::mpl::`true_`_ , boost::mpl::`if_`_< boost::`is_same`_< typename Tag::qualifier , boost::parameter::forward_reference > , boost::mpl::`true_`_ , boost::mpl::`false_`_ > >::type , boost::mpl::`if_`_< boost::`is_const`_ , boost::mpl::`false_`_ , boost::mpl::`true_`_ > , boost::mpl::`false_`_ >::type , *tagged default* >::type `operator|`_\(T& x) const; template typename boost::`enable_if`_< typename boost::mpl::`eval_if_`_< boost::`is_scalar`_ , boost::mpl::`true_`_ , boost::mpl::`eval_if_`_< boost::`is_same`_< typename Tag::qualifier , boost::parameter::in_reference > , boost::mpl::`true_`_ , boost::mpl::`if_`_< boost::`is_same`_< typename Tag::qualifier , boost::parameter::forward_reference > , boost::mpl::`true_`_ , boost::mpl::`false_`_ > > >::type , *tagged default* >::type `operator|`_\(T const&& x) const; template typename boost::`enable_if`_< typename boost::mpl::`eval_if_`_< boost::`is_scalar`_ , boost::mpl::`false_`_ , boost::mpl::`eval_if_`_< boost::`is_same`_< typename Tag::qualifier , boost::parameter::consume_reference > , boost::mpl::`true_`_ , boost::mpl::`if_`_< boost::`is_same`_< typename Tag::qualifier , boost::parameter::forward_reference > , boost::mpl::`true_`_ , boost::mpl::`false_`_ > > >::type , *tagged default* >::type constexpr `operator|`_\(T&& value) const; template *tagged lazy default* `operator||`_\(F const&) const; template *tagged lazy default* `operator||`_\(F&) const; static keyword const& instance; static keyword& get_\(); }; **If** |BOOST_PARAMETER_HAS_PERFECT_FORWARDING| is **not** ``#defined``, **then** .. parsed-literal:: template struct keyword { typedef Tag tag; template typename boost::`enable_if`_< typename boost::mpl::`eval_if_`_< boost::`is_scalar`_ , boost::mpl::`true_`_ , boost::mpl::`eval_if_`_< boost::`is_same`_< typename Tag::qualifier , boost::parameter::in_reference > , boost::mpl::`true_`_ , boost::mpl::`if_`_< boost::`is_same`_< typename Tag::qualifier , boost::parameter::forward_reference > , boost::mpl::`true_`_ , boost::mpl::`false_`_ > > >::type , |ArgumentPack|_ >::type constexpr `operator=`_\(T const& value) const; template typename boost::`enable_if`_< typename boost::mpl::`eval_if_`_< typename boost::mpl::`eval_if_`_< boost::`is_same`_< typename Tag::qualifier , boost::parameter::out_reference > , boost::mpl::`true_`_ , boost::mpl::`if_`_< boost::`is_same`_< typename Tag::qualifier , boost::parameter::forward_reference > , boost::mpl::`true_`_ , boost::mpl::`false_`_ > >::type , boost::mpl::`if_`_< boost::`is_const`_ , boost::mpl::`false_`_ , boost::mpl::`true_`_ > , boost::mpl::`false_`_ >::type , |ArgumentPack|_ >::type constexpr `operator=`_\(T& value) const; template typename boost::`enable_if`_< typename boost::mpl::`eval_if_`_< boost::`is_scalar`_ , boost::mpl::`true_`_ , boost::mpl::`eval_if_`_< boost::`is_same`_< typename Tag::qualifier , boost::parameter::in_reference > , boost::mpl::`true_`_ , boost::mpl::`if_`_< boost::`is_same`_< typename Tag::qualifier , boost::parameter::forward_reference > , boost::mpl::`true_`_ , boost::mpl::`false_`_ > > >::type , *tagged default* >::type `operator|`_\(T const& x) const; template typename boost::`enable_if`_< typename boost::mpl::`eval_if_`_< typename boost::mpl::`eval_if_`_< boost::`is_same`_< typename Tag::qualifier , boost::parameter::out_reference > , boost::mpl::`true_`_ , boost::mpl::`if_`_< boost::`is_same`_< typename Tag::qualifier , boost::parameter::forward_reference > , boost::mpl::`true_`_ , boost::mpl::`false_`_ > >::type , boost::mpl::`if_`_< boost::`is_const`_ , boost::mpl::`false_`_ , boost::mpl::`true_`_ > , boost::mpl::`false_`_ >::type , *tagged default* >::type `operator|`_\(T& x) const; template *tagged lazy default* `operator||`_\(F const&) const; template *tagged lazy default* `operator||`_\(F&) const; static keyword const& instance; static keyword& get_\(); }; .. _enable_if: ../../../core/doc/html/core/enable_if.html .. _eval_if_: ../../../mpl/doc/refmanual/eval-if.html .. _false_: ../../../mpl/doc/refmanual/bool.html .. _if_: ../../../mpl/doc/refmanual/if.html .. _is_const: ../../../type_traits/doc/html/boost_typetraits/is_const.html .. _is_same: ../../../type_traits/doc/html/boost_typetraits/is_same.html .. _is_scalar: ../../../type_traits/doc/html/boost_typetraits/is_scalar.html .. _true_: ../../../mpl/doc/refmanual/bool.html .. |operator=| replace:: ``operator=`` .. _operator=: ``operator=`` .. parsed-literal:: template |ArgumentPack|_ operator=(T const& value) const; template |ArgumentPack|_ operator=(T& value) const; **If** |BOOST_PARAMETER_HAS_PERFECT_FORWARDING| is ``#defined``, **then** .. parsed-literal:: template |ArgumentPack|_ operator=(T const&& value) const; template |ArgumentPack|_ operator=(T&& value) const; :Requires: one of the following: \*. The nested ``qualifier`` type of ``Tag`` must be ``forward_reference``. \*. To use the ``const`` lvalue reference overload, ``T`` must be scalar, or the nested ``qualifier`` type of ``Tag`` must be ``in_reference``. \*. To use the mutable lvalue reference overload, the nested ``qualifier`` type of ``Tag`` must be ``out_reference`` or ``in_out_reference``, and ``T`` must not be ``const``-qualified. \*. To use the ``const`` rvalue reference overload for non-scalar ``T``, the nested ``qualifier`` type of ``Tag`` must be ``in_reference``. \*. To use the mutable rvalue reference overload for non-scalar ``T``, the nested ``qualifier`` type of ``Tag`` must be ``consume_reference`` or ``move_from_reference``. :Returns: an |ArgumentPack|_ containing a single |tagged reference| to ``value`` with |kw|_ ``Tag`` .. _operator|: ``operator|`` .. parsed-literal:: template *tagged default* operator|(T const& x) const; template *tagged default* operator|(T& x) const; **If** |BOOST_PARAMETER_HAS_PERFECT_FORWARDING| is ``#defined``, **then** .. parsed-literal:: template *tagged default* operator|(T const&& x) const; template *tagged default* operator|(T&& x) const; :Requires: one of the following: \*. The nested ``qualifier`` type of ``Tag`` must be ``forward_reference``. \*. To use the ``const`` lvalue reference overload, ``T`` must be scalar, or the nested ``qualifier`` type of ``Tag`` must be ``in_reference``. \*. To use the mutable lvalue reference overload, the nested ``qualifier`` type of ``Tag`` must be ``out_reference`` or ``in_out_reference``, and ``T`` must not be ``const``-qualified. \*. To use the ``const`` rvalue reference overload for non-scalar ``T``, the nested ``qualifier`` type of ``Tag`` must be ``in_reference``. \*. To use the mutable rvalue reference overload for non-scalar ``T``, the nested ``qualifier`` type of ``Tag`` must be ``consume_reference`` or ``move_from_reference``. :Returns: a |tagged default| with *value* ``x`` and |kw|_ ``Tag``. .. _operator||: ``operator||`` .. parsed-literal:: template *tagged lazy default* operator||(F const& g) const; template *tagged lazy default* operator||(F& g) const; :Requires: ``g()`` must be valid, with type ``boost::``\ |result_of|_\ ``::type``. [#no_result_of]_ :Returns: a |tagged lazy default| with *value* ``g`` and |kw|_ ``Tag``. .. _instance: ``instance`` .. parsed-literal:: static keyword const& instance; :Returns: a “singleton instance”: the same object will be returned on each invocation of ``instance``. :Thread Safety: ``instance`` can be accessed from multiple threads simultaneously. .. _get: ``get`` .. parsed-literal:: static keyword& get\(); .. admonition:: Deprecated This function has been deprecated in favor of ``instance``. :Returns: a “singleton instance”: the same object will be returned on each invocation of ``get()``. :Thread Safety: ``get()`` can be called from multiple threads simultaneously. .. |template_keyword| replace:: ``template_keyword`` .. _template_keyword: ``template_keyword`` -------------------- This class template encapsulates a named template parameter. Every type generated by the |BOOST_PARAMETER_TEMPLATE_KEYWORD| macro is a specialization of |template_keyword|. :Defined in: `boost/parameter/template_keyword.hpp`__ __ ../../../../boost/parameter/template_keyword.hpp .. parsed-literal:: template struct template_keyword { typedef Tag key_type; typedef T value_type; typedef *implementation defined* reference; }; The |ntp_cpp|_ test program demonstrates proper usage of this class template. .. |ntp_cpp| replace:: ntp.cpp .. _ntp_cpp: ../../test/ntp.cpp ``parameters`` -------------- Provides an interface for assembling the actual arguments to a `forwarding function` into an |ArgumentPack|, in which any |positional| arguments will be tagged according to the corresponding template argument to ``parameters``. .. _forwarding function: `forwarding functions`_ :Defined in: `boost/parameter/parameters.hpp`__ __ ../../../../boost/parameter/parameters.hpp **If** |BOOST_PARAMETER_HAS_PERFECT_FORWARDING| is ``#defined``, **then** .. parsed-literal:: template struct parameters { template struct `match`_ { typedef … type; }; template |ArgumentPack|_ `operator()`_\(Args&&... args) const; }; :Requires: Each element in the ``PSpec`` parameter pack must be a model of |ParameterSpec|_. .. Note:: In this section, ``R`` ## *i* and ``K`` ## *i* are defined as follows, for any argument type ``A`` ## *i*: | let ``D0`` the set [d0, …, d ## *j*] of all **deduced** | *parameter specs* in the ``PSpec`` parameter pack | ``R`` ## *i* is the |intended argument type| of ``A`` ## *i* | | if ``A`` ## *i* is a result type of ``keyword::`` |operator=|_ | then | ``K`` ## *i* is ``T`` | else | if some ``A`` ## *j* where *j* ≤ *i* is a result type of | ``keyword::`` |operator=|_ | *or* some ``P`` ## *j* in *j* ≤ *i* is **deduced** | then | if some *parameter spec* ``d`` ## *j* in ``D`` ## *i* | matches ``A`` ## *i* | then | ``K`` ## *i* is the |keyword tag type| of ``d`` ## *j*. | ``D``:sub:`i+1` is ``D`` ## *i* - [ ``d`` ## *j*] | else | ``K`` ## *i* is the |keyword tag type| of ``P`` ## *i*. **If** |BOOST_PARAMETER_HAS_PERFECT_FORWARDING| is **not** ``#defined``, **then** .. parsed-literal:: template < typename P0 = *unspecified* , typename P1 = *unspecified* , … , typename P ## β = *unspecified* > struct parameters { template < typename A0 , typename A1 = *unspecified* , … , typename A ## β = *unspecified* > struct `match`_ { typedef … type; }; template |ArgumentPack|_ `operator()`_\(A0& a0) const; template |ArgumentPack|_ `operator()`_\(A0& a0, A1& a1) const; :vellipsis:`⋮` template |ArgumentPack|_ `operator()`_\(A0& a0, A1& a1, …, A ## β & a ## β) const; }; :Requires: ``P0``, ``P1``, …, ``P`` ## β must be models of |ParameterSpec|_. .. Note:: In this section, ``R`` ## *i* and ``K`` ## *i* are defined as follows: for any argument type ``A`` ## *i*: | let ``D0`` the set [ d0, …, d ## *j*] of all **deduced** | *parameter specs* in [ ``P0``, …, ``P`` ## β] | ``R`` ## *i* is the |intended argument type| of ``A`` ## *i* | | if ``A`` ## *i* is a result type of ``keyword::`` |operator=|_ | then | ``K`` ## *i* is ``T`` | else | if some ``A`` ## *j* where *j* ≤ *i* is a result type of | ``keyword::`` |operator=|_ | *or* some ``P`` ## *j* in *j* ≤ *i* is **deduced** | then | if some *parameter spec* ``d`` ## *j* in ``D`` ## *i* | matches ``A`` ## *i* | then | ``K`` ## *i* is the |keyword tag type| of ``d`` ## *j*. | ``D``:sub:`i+1` is ``D`` ## *i* - [ ``d`` ## *j*] | else | ``K`` ## *i* is the |keyword tag type| of ``P`` ## *i*. .. _match: ``match`` A |Metafunction|_ used to remove a `forwarding function`_ from overload resolution. **If** |BOOST_PARAMETER_HAS_PERFECT_FORWARDING| is ``#defined``, **then** :Returns: if all elements in ``Params...`` are *satisfied* (see below), then ``parameters``. Otherwise, ``match::type`` is not defined. Each element ``P`` in ``Params...`` is **satisfied** if either: * ``P`` is the *unspecified* default * **or**, ``P`` is a *keyword tag type* * **or**, ``P`` is |optional|_ ```` and either - ``X`` is not ``K`` ## *i* for any *i*, - **or** ``X`` is some ``K`` ## *i* and ``mpl::apply::type::value`` is ``true`` * **or**, ``P`` is |required|_ ````, and - ``X`` is some ``K`` ## *i*, **and** - ``mpl::apply::type::value`` is ``true`` **If** |BOOST_PARAMETER_HAS_PERFECT_FORWARDING| is **not** ``#defined``, **then** :Returns: if ``P0``, ``P1``, …, ``Pβ`` are *satisfied* (see below), then ``parameters``. Otherwise, ``match::type`` is not defined. ``P0``, ``P1``, …, ``Pβ`` are **satisfied** if, for every *j* in 0…β, either: * ``P`` ## *j* is the *unspecified* default * **or**, ``P`` ## *j* is a *keyword tag type* * **or**, ``P`` ## *j* is |optional|_ ```` and either - ``X`` is not ``K`` ## *i* for any *i*, - **or** ``X`` is some ``K`` ## *i* and ``mpl::apply::type::value`` is ``true`` * **or**, ``P`` ## *j* is |required|_ ````, and - ``X`` is some ``K`` ## *i*, **and** - ``mpl::apply::type::value`` is ``true`` .. _operator(): ``operator()`` **If** |BOOST_PARAMETER_HAS_PERFECT_FORWARDING| is ``#defined``, **then** .. parsed-literal:: template |ArgumentPack|_ operator()(Args&&... args) const; **Else** .. parsed-literal:: template |ArgumentPack|_ operator()(A0 const& a0) const; :vellipsis:`⋮` template |ArgumentPack|_ `operator()`_\(A0 const& a0, …, A ## β const& a ## β) const; :Returns: An |ArgumentPack|_ containing, for each ``a`` ## *i*, - if ``a`` ## *i* is a single-element |ArgumentPack|, its element - Otherwise, a |tagged reference| with |kw|_ ``K`` ## *i* and *value* ``a`` ## *i* .. |optional| replace:: ``optional`` .. |required| replace:: ``required`` .. _optional: .. _required: ``optional``, ``required`` -------------------------- These templates describe the requirements on a function parameter. ``optional`` is defined in: |optional_header|_ ``required`` is defined in: |required_header|_ Both headers are included by: |preprocessor_header|_ .. |optional_header| replace:: boost/parameter/optional.hpp .. _optional_header: ../../../../boost/parameter/optional.hpp .. |required_header| replace:: boost/parameter/required.hpp .. _required_header: ../../../../boost/parameter/required.hpp .. |preprocessor_header| replace:: boost/parameter/preprocessor.hpp .. _preprocessor_header: ../../../../boost/parameter/preprocessor.hpp :Specializations model: |ParameterSpec|_ .. parsed-literal:: template struct optional; template struct required; The default value of ``Predicate`` is an unspecified `MPL Binary Metafunction Class`_ that returns ``mpl::true_`` for any argument. .. _`MPL Binary Metafunction Class`: ../../../mpl/doc/refmanual/metafunction-class.html ``deduced`` ----------- This template is used to wrap the *keyword tag* argument to ``optional`` or ``required``. :Defined in: |deduced_header|_ :Included by: |preprocessor_header|_ .. |deduced_header| replace:: boost/parameter/deduced.hpp .. _deduced_header: ../../../../boost/parameter/deduced.hpp .. |preprocessor_header| replace:: boost/parameter/preprocessor.hpp .. _preprocessor_header: ../../../../boost/parameter/preprocessor.hpp .. parsed-literal:: template struct deduced; :Requires: nothing ////////////////////////////////////////////////////////////////////////////// Metafunctions ============= A |Metafunction|_ is conceptually a function that operates on, and returns, C++ types. ``binding`` ----------- Returns the result type of indexing an argument pack with a |keyword tag type| or with a |tagged default|. :Defined in: `boost/parameter/binding.hpp`__ __ ../../../../boost/parameter/binding.hpp .. parsed-literal:: template struct binding { typedef … type; }; :Requires: ``A`` must be a model of |ArgumentPack|_. :Returns: the reference type of the |tagged reference| in ``A`` having |keyword tag type| ``K``, if any. If no such |tagged reference| exists, returns ``D``. ``lazy_binding`` ---------------- Returns the result type of indexing an argument pack with a |tagged lazy default|. :Defined in: `boost/parameter/binding.hpp`__ __ ../../../../boost/parameter/binding.hpp .. parsed-literal:: template struct lazy_binding { typedef … type; }; :Requires: ``A`` must be a model of |ArgumentPack|_. :Returns: the reference type of the |tagged reference| in ``A`` having |keyword tag type| ``K``, if any. If no such |tagged reference| exists, returns ``boost::``\ |result_of|_\ ``::type``. [#no_result_of]_ ``value_type`` -------------- Returns the result type of indexing an argument pack with a |keyword tag type| or with a |tagged default|. :Defined in: `boost/parameter/value_type.hpp`__ __ ../../../../boost/parameter/value_type.hpp .. parsed-literal:: template struct value_type { typedef … type; }; :Requires: ``A`` must be a model of |ArgumentPack|_. :Returns: the (possibly const-qualified) type of the |tagged reference| in ``A`` having |keyword tag type| ``K``, if any. If no such |tagged reference| exists, returns ``D``. Equivalent to:: typename remove_reference< typename binding::type >::type … when ``D`` is not a reference type. ``is_argument_pack`` -------------------- :Defined in: `boost/parameter/is_argument_pack.hpp`__ __ ../../../../boost/parameter/is_argument_pack.hpp .. parsed-literal:: template struct is_argument_pack // : mpl::true_ or mpl::false_ { }; :Returns: ``mpl::true_`` if ``T`` is a model of |ArgumentPack|_, ``mpl::false_`` otherwise. ////////////////////////////////////////////////////////////////////////////// Code Generation Macros ====================== Macros in this section can be used to ease the writing of code using the Parameter library by eliminating repetitive boilerplate. ``BOOST_PARAMETER_FUNCTION(result, name, tag_namespace, arguments)`` -------------------------------------------------------------------- :Defined in: `boost/parameter/preprocessor.hpp`__ __ ../../../../boost/parameter/preprocessor.hpp :Requires: ``result`` is the parenthesized return type of the function. ``name`` is the base name of the function; it determines the name of the generated forwarding functions. ``tag_namespace`` is the namespace in which the keywords used by the function resides. ``arguments`` is a `Boost.Preprocessor`_ `sequence`_ of *argument-specifiers*, as defined below. :Argument specifiers syntax: .. parsed-literal:: argument-specifiers ::= *specifier-group0* {*specifier-group0*\ } specifier-group0 ::= *specifier-group1* | ( '**(**' '**deduced**' *specifier-group1* {*specifier-group1*\ } '**)**' ) specifier-group1 ::= ( '**(**' '**optional**' *optional-specifier* {*optional-specifier*\ } '**)**' ) | ( '**(**' '**required**' *required-specifier* {*required-specifier*\ } '**)**' ) optional-specifier ::= '**(**' *argument-name* '**,**' *restriction* '**,**' *default-value* ')' required-specifier ::= '**(**' *argument-name* '**,**' *restriction* ')' restriction ::= ( '**\***' '**(**' *mfc* '**)**' ) | ( '**(**' *type-name* '**)**' ) | '**\***' * ``argument-name`` is any valid C++ identifier. * ``default-value`` is any valid C++ expression; if necessary, user code can compute it in terms of ``previous-name ## _type``, where ``previous-name`` is the ``argument-name`` in a previous ``specifier-group0`` or ``specifier-group1``. *This expression will be invoked exactly once.* * ``mfc`` is an `MPL Binary Metafunction Class`_ whose first argument will be the type of the corresponding ``argument-name``, whose second argument will be the entire |ArgumentPack|_, and whose return type is a `Boolean Integral Constant`_; however, user code *cannot* compute ``mfc`` in terms of ``previous-name ## _type``. * ``type-name`` is either the name of a **target type** or an `MPL Binary Metafunction Class`_ whose first argument will be the type of the corresponding ``argument-name``, whose second argument will be the entire |ArgumentPack|_, and whose return type is the **target type**. If ``restriction`` uses this form, then the type of the generated name ``argument-name ## _type`` will be computed in terms of the **target type**, and the generated reference ``argument-name`` (but not its corresponding entry in ``args``) will be cast to that type. .. _`Boost.Preprocessor`: ../../../preprocessor/doc/index.html .. _`sequence`: ../../../preprocessor/doc/data/sequences.html .. _`MPL Binary Metafunction Class`: ../../../mpl/doc/refmanual/metafunction-class.html .. _`Boolean Integral Constant`: ../../../mpl/doc/refmanual/integral-constant.html :Generated names in enclosing scope: * ``boost_param_result_ ## __LINE__ ## name`` * ``boost_param_params_ ## __LINE__ ## name`` * ``boost_param_parameters_ ## __LINE__ ## name`` * ``boost_param_impl ## name`` * ``boost_param_dispatch_0boost_ ## __LINE__ ## name`` * ``boost_param_dispatch_1boost_ ## __LINE__ ## name`` Approximate expansion: **Where**: * ``n`` denotes the *minimum* arity, as determined from ``arguments``. * ``m`` denotes the *maximum* arity, as determined from ``arguments``. **If** |BOOST_PARAMETER_HAS_PERFECT_FORWARDING| is ``#defined``, **then** .. parsed-literal:: template struct boost_param_result\_ ## __LINE__ ## **name** { typedef **result** type; }; struct boost_param_params\_ ## __LINE__ ## **name** : boost::parameter::parameters< *list of parameter specifications, based on arguments* > { }; typedef boost_param_params\_ ## __LINE__ ## **name** boost_param_parameters\_ ## __LINE__ ## **name**; template typename boost_param_result\_ ## __LINE__ ## **name**\ ::type boost_param_impl ## **name**\ (Args const&); template **result** **name**\ ( A0&& a0, …, A ## **n**\ && a ## **n** , typename boost_param_parameters\_ ## __LINE__ ## **name**::match< A0, …, A ## **n** >::type = boost_param_parameters\_ ## __LINE__ ## **name**\ () ) { return boost_param_impl ## **name**\ ( boost_param_parameters\_ ## __LINE__ ## **name**\ ()( std::`forward`_(a0) , … , std::`forward`_(a ## **n**) ) ); } :vellipsis:`⋮` template **result** **name**\ ( A0&& a0, …, A ## **m**\ && a ## **m** , typename boost_param_parameters\_ ## __LINE__ ## **name**::match< A0, …, A ## **m** >::type = boost_param_parameters\_ ## __LINE__ ## **name**\ () ) { return boost_param_impl ## **name**\ ( boost_param_parameters\_ ## __LINE__ ## **name**\ ()( std::`forward`_(a0) , … , std::`forward`_(a ## **m**) ) ); } template < typename ResultType , typename Args , typename *argument name* ## **0** ## _type , … , typename *argument name* ## **n** ## _type > ResultType boost_param_dispatch_0boost\_ ## __LINE__ ## **name**\ ( (ResultType(\ *)()) , Args const& args , *argument name* ## **0** ## _type&& *argument name* ## **0** , … , *argument name* ## **n** ## _type&& *argument name* ## **m** ); :vellipsis:`⋮` template < typename ResultType , typename Args , typename *argument name* ## **0** ## _type , … , typename *argument name* ## **m** ## _type > ResultType boost_param_dispatch_0boost\_ ## __LINE__ ## **name**\ ( (ResultType(\ *)()) , Args const& args , *argument name* ## **0** ## _type&& *argument name* ## **0** , … , *argument name* ## **m** ## _type&& *argument name* ## **m** ); template typename boost_param_result\_ ## __LINE__ ## **name**\ ::type boost_param_impl ## **name**\ (Args const& args) { return boost_param_dispatch_0boost\_ ## __LINE__ ## **name**\ ( static_cast(std::nullptr) , args , std::`forward`_< typename boost::parameter::value_type< Args , *keyword tag type of required parameter* ## **0** >::type >(args[ *keyword object of required parameter* ## **0**]) , … , std::`forward`_< typename boost::parameter::value_type< Args , *keyword tag type of required parameter* ## **n** >::type >(args[ *keyword object of required parameter* ## **n**]) ); } template < typename ResultType , typename Args , typename *argument name* ## **0** ## _type , … , typename *argument name* ## **n** ## _type > ResultType boost_param_dispatch_0boost\_ ## __LINE__ ## **name**\ ( (ResultType(\ *)()) , Args const& args , *argument name* ## **0** ## _type&& *argument name* ## **0** , … , *argument name* ## **n** ## _type&& *argument name* ## **n** ) { return boost_param_dispatch_0boost\_ ## __LINE__ ## **name**\ ( static_cast(std::nullptr) , (args, *keyword object of optional parameter* ## **n + 1** = *default value of optional parameter* ## **n + 1** ) , std::`forward`_<*argument name* ## **0** ## _type>( *argument name* ## **0** ) , … , std::`forward`_<*argument name* ## **n** ## _type>( *argument name* ## **n** ) , std::`forward`_< typename boost::parameter::value_type< Args , *keyword tag type of optional parameter* ## **n + 1** >::type >(*default value of optional parameter* ## **n + 1**) ); } :vellipsis:`⋮` template < typename ResultType , typename Args , typename *argument name* ## **0** ## _type , … , typename *argument name* ## **m** ## _type > ResultType boost_param_dispatch_0boost\_ ## __LINE__ ## **name**\ ( (ResultType(\ *)()) , Args const& args , *argument name* ## **0** ## _type&& *argument name* ## **0** , … , *argument name* ## **m** ## _type&& *argument name* ## **m** ) **If** |BOOST_PARAMETER_HAS_PERFECT_FORWARDING| is **not** ``#defined``, **then** .. parsed-literal:: template struct boost_param_result\_ ## __LINE__ ## **name** { typedef **result** type; }; struct boost_param_params\_ ## __LINE__ ## **name** : boost::parameter::parameters< *list of parameter specifications, based on arguments* > { }; typedef boost_param_params\_ ## __LINE__ ## **name** boost_param_parameters\_ ## __LINE__ ## **name**; template typename boost_param_result\_ ## __LINE__ ## **name**\ ::type boost_param_impl ## **name**\ (Args const&); template **result** **name**\ ( A0 const& a0, …, A ## **n** const& a ## **n** , typename boost_param_parameters\_ ## __LINE__ ## **name**::match< A0 const, …, A ## **n** const >::type = boost_param_parameters\_ ## __LINE__ ## **name**\ () ) { return boost_param_impl ## **name**\ ( boost_param_parameters\_ ## __LINE__ ## **name**\ ()( a0, …, a ## **n** ) ); } *… exponential number of overloads …* :vellipsis:`⋮` template **result** **name**\ ( A0& a0, …, A ## **n** & a ## **n** , typename boost_param_parameters\_ ## __LINE__ ## **name**::match< A0, …, A ## **n** >::type = boost_param_parameters\_ ## __LINE__ ## **name**\ () ) { return boost_param_impl ## **name**\ ( boost_param_parameters\_ ## __LINE__ ## **name**\ ()( a0, …, a ## **n** ) ); } :vellipsis:`⋮` template **result** **name**\ ( A0 const& a0, …, A ## **m** const& a ## **m** , typename boost_param_parameters\_ ## __LINE__ ## **name**::match< A0 const, …, A ## **m** const >::type = boost_param_parameters\_ ## __LINE__ ## **name**\ () ) { return boost_param_impl ## **name**\ ( boost_param_parameters\_ ## __LINE__ ## **name**\ ()( a0, …, a ## **m** ) ); } *… exponential number of overloads …* :vellipsis:`⋮` template **result** **name**\ ( A0& a0, …, A ## **m** & a ## **m** , typename boost_param_parameters\_ ## __LINE__ ## **name**::match< A0, …, A ## **m** >::type = boost_param_parameters\_ ## __LINE__ ## **name**\ () ) { return boost_param_impl ## **name**\ ( boost_param_parameters\_ ## __LINE__ ## **name**\ ()( a0, …, a ## **m** ) ); } template < typename ResultType , typename Args , typename *argument name* ## **0** ## _type , … , typename *argument name* ## **n** ## _type > ResultType boost_param_dispatch_0boost\_ ## __LINE__ ## **name**\ ( (ResultType(\ *)()) , Args const& args , *argument name* ## **0** ## _type& *argument name* ## **0** , … , *argument name* ## **n** ## _type& *argument name* ## **m** ); :vellipsis:`⋮` template < typename ResultType , typename Args , typename *argument name* ## **0** ## _type , … , typename *argument name* ## **m** ## _type > ResultType boost_param_dispatch_0boost\_ ## __LINE__ ## **name**\ ( (ResultType(\ *)()) , Args const& args , *argument name* ## **0** ## _type& *argument name* ## **0** , … , *argument name* ## **m** ## _type& *argument name* ## **m** ); template typename boost_param_result\_ ## __LINE__ ## **name**\ ::type boost_param_impl ## **name**\ (Args const& args) { return boost_param_dispatch_0boost\_ ## __LINE__ ## **name**\ ( static_cast(std::nullptr) , args , args[ *keyword object of required parameter* ## **0**] , … , args[ *keyword object of required parameter* ## **n**] ); } template < typename ResultType , typename Args , typename *argument name* ## **0** ## _type , … , typename *argument name* ## **n** ## _type > ResultType boost_param_dispatch_0boost\_ ## __LINE__ ## **name**\ ( (ResultType(\ *)()) , Args const& args , *argument name* ## **0** ## _type& *argument name* ## **0** , … , *argument name* ## **n** ## _type& *argument name* ## **m** ) { return boost_param_dispatch_0boost\_ ## __LINE__ ## **name**\ ( static_cast(std::nullptr) , (args, *keyword object of optional parameter* ## **n + 1** = *default value of optional parameter* ## **n + 1** ) , *argument name* ## **0** , … , *argument name* ## **n** , *default value of optional parameter* ## **n + 1** ); } :vellipsis:`⋮` template < typename ResultType , typename Args , typename *argument name* ## **0** ## _type , … , typename *argument name* ## **m** ## _type > ResultType boost_param_dispatch_0boost\_ ## __LINE__ ## **name**\ ( (ResultType(\ *)()) , Args const& args , *argument name* ## **0** ## _type& *argument name* ## **0** :vellipsis:`⋮` , *argument name* ## **m** ## _type& *argument name* ## **m** ) The |preprocessor|_, |preprocessor_deduced|_, and |preprocessor_eval_cat|_ test programs demonstrate proper usage of this macro. .. _`forward`: http\://en.cppreference.com/w/cpp/utility/forward .. |preprocessor| replace:: preprocessor.cpp .. _preprocessor: ../../test/preprocessor.cpp .. |preprocessor_deduced| replace:: preprocessor_deduced.cpp .. _preprocessor_deduced: ../../test/preprocessor_deduced.cpp .. |preprocessor_eval_cat| replace:: preprocessor_eval_category.cpp .. _preprocessor_eval_cat: ../../test/preprocessor_eval_category.cpp ``BOOST_PARAMETER_MEMBER_FUNCTION(result, name, tag_namespace, arguments)`` --------------------------------------------------------------------------- :Defined in: `boost/parameter/preprocessor.hpp`__ __ ../../../../boost/parameter/preprocessor.hpp Same as ``BOOST_PARAMETER_FUNCTION``, except: \*. ``name`` may be qualified by the ``static`` keyword to declare the member function and its helpers as not associated with any object of the enclosing type. \*. Expansion of this macro omits all forward declarations of the front-end implementation and dispatch functions. The |preprocessor|_ and |preprocessor_eval_cat|_ test programs demonstrate proper usage of this macro. .. |preprocessor| replace:: preprocessor.cpp .. _preprocessor: ../../test/preprocessor.cpp .. |preprocessor_eval_cat| replace:: preprocessor_eval_category.cpp .. _preprocessor_eval_cat: ../../test/preprocessor_eval_category.cpp ``BOOST_PARAMETER_CONST_MEMBER_FUNCTION(result, name, tag_ns, arguments)`` -------------------------------------------------------------------------- :Defined in: `boost/parameter/preprocessor.hpp`__ __ ../../../../boost/parameter/preprocessor.hpp Same as ``BOOST_PARAMETER_MEMBER_FUNCTION``, except that the overloaded forwarding member functions and their helper methods are ``const``-qualified. The |preprocessor|_ test program demonstrates proper usage of this macro. .. |preprocessor| replace:: preprocessor.cpp .. _preprocessor: ../../test/preprocessor.cpp ``BOOST_PARAMETER_FUNCTION_CALL_OPERATOR(result, tag_namespace, arguments)`` ---------------------------------------------------------------------------- :Defined in: `boost/parameter/preprocessor.hpp`__ __ ../../../../boost/parameter/preprocessor.hpp Same as ``BOOST_PARAMETER_MEMBER_FUNCTION``, except that the name of the forwarding member function overloads is ``operator()``. :Generated names in enclosing scope: * ``boost_param_result_ ## __LINE__ ## operator`` * ``boost_param_params_ ## __LINE__ ## operator`` * ``boost_param_parameters_ ## __LINE__ ## operator`` * ``boost_param_impl ## operator`` * ``boost_param_dispatch_0boost_ ## __LINE__ ## operator`` * ``boost_param_dispatch_1boost_ ## __LINE__ ## operator`` The |preprocessor|_ test program demonstrates proper usage of this macro. .. |preprocessor| replace:: preprocessor.cpp .. _preprocessor: ../../test/preprocessor.cpp ``BOOST_PARAMETER_CONST_FUNCTION_CALL_OPERATOR(result, tag_ns, arguments)`` --------------------------------------------------------------------------- :Defined in: `boost/parameter/preprocessor.hpp`__ __ ../../../../boost/parameter/preprocessor.hpp Same as ``BOOST_PARAMETER_FUNCTION_CALL_OPERATOR``, except that the overloaded function call operators and their helper methods are ``const``-qualified. The |preprocessor|_ and |preprocessor_eval_cat_8|_ test programs demonstrate proper usage of this macro. .. |preprocessor| replace:: preprocessor.cpp .. _preprocessor: ../../test/preprocessor.cpp .. |preprocessor_eval_cat_8| replace:: preprocessor_eval_cat_8.cpp .. _preprocessor_eval_cat_8: ../../test/preprocessor_eval_cat_8.cpp ``BOOST_PARAMETER_CONSTRUCTOR(cls, impl, tag_namespace, arguments)`` -------------------------------------------------------------------- :Defined in: `boost/parameter/preprocessor.hpp`__ __ ../../../../boost/parameter/preprocessor.hpp :Requires: ``cls`` is the name of the enclosing class. ``impl`` is the parenthesized implementation base class for ``cls``. ``tag_namespace`` is the namespace in which the keywords used by the function resides. ``arguments`` is a list of *argument-specifiers*, as defined in ``BOOST_PARAMETER_FUNCTION`` except that *optional-specifier* no longer includes *default-value*. It is up to the delegate constructor in ``impl`` to determine the default value of all optional arguments. :Generated names in enclosing scope: * ``boost_param_params_ ## __LINE__ ## ctor`` * ``constructor_parameters ## __LINE__`` Approximate expansion: **Where**: * ``n`` denotes the *minimum* arity, as determined from ``arguments``. * ``m`` denotes the *maximum* arity, as determined from ``arguments``. **If** |BOOST_PARAMETER_HAS_PERFECT_FORWARDING| is ``#defined``, **then** .. parsed-literal:: struct boost_param_params\_ ## __LINE__ ## ctor : boost::parameter::parameters< *list of parameter specifications, based on arguments* > { }; typedef boost_param_params\_ ## __LINE__ ## **name** constructor_parameters ## __LINE__; template *cls*\ (A0&& a0, …, A ## **n** && a ## **n**) : *impl*\ ( constructor_parameters ## __LINE__( std::`forward`_(a0) , … , std::`forward`_(a ## **n**) ) ) { } :vellipsis:`⋮` template *cls*\ (A0&& a0, …, A ## **m** && a ## **m**) : *impl*\ ( constructor_parameters ## __LINE__( std::`forward`_(a0) , … , std::`forward`_(a ## **m**) ) ) { } **If** |BOOST_PARAMETER_HAS_PERFECT_FORWARDING| is **not** ``#defined``, **then** .. parsed-literal:: struct boost_param_params\_ ## __LINE__ ## ctor : boost::parameter::parameters< *list of parameter specifications, based on arguments* > { }; typedef boost_param_params\_ ## __LINE__ ## **name** constructor_parameters ## __LINE__; template *cls*\ (A0 const& a0, …, A ## **n** const& a ## **n**) : *impl*\ (constructor_parameters ## __LINE__(a0, …, a ## **n**)) { } *… exponential number of overloads …* :vellipsis:`⋮` template *cls*\ (A0& a0, …, A ## **n** & a ## **n**) : *impl*\ (constructor_parameters ## __LINE__(a0, …, a ## **n**)) { } :vellipsis:`⋮` template *cls*\ (A0 const& a0, …, A ## **m** const& a ## **m**) : *impl*\ (constructor_parameters ## __LINE__(a0, …, a ## **m**)) { } *… exponential number of overloads …* :vellipsis:`⋮` template *cls*\ (A0& a0, …, A ## **m** & a ## **m**) : *impl*\ (constructor_parameters ## __LINE__(a0, …, a ## **m**)) { } The |preprocessor|_ and |preprocessor_eval_cat|_ test programs demonstrate proper usage of this macro. .. _`forward`: http\://en.cppreference.com/w/cpp/utility/forward .. |preprocessor| replace:: preprocessor.cpp .. _preprocessor: ../../test/preprocessor.cpp .. |preprocessor_eval_cat| replace:: preprocessor_eval_category.cpp .. _preprocessor_eval_cat: ../../test/preprocessor_eval_category.cpp ``BOOST_PARAMETER_BASIC_FUNCTION(result, name, tag_namespace, arguments)`` -------------------------------------------------------------------------- :Defined in: `boost/parameter/preprocessor.hpp`__ __ ../../../../boost/parameter/preprocessor.hpp Same as ``BOOST_PARAMETER_FUNCTION``, except: \*. For the argument specifiers syntax, *optional-specifier* no longer includes *default-value*. It is up to the function body to determine the default value of all optional arguments. \*. Generated names in the enclosing scope no longer include ``boost_param_dispatch_0boost_ ## __LINE__ ## name`` or ``boost_param_dispatch_1boost_ ## __LINE__ ## name``. \*. Expansion of this macro omits all overloads of ``boost_param_dispatch_0boost_ ## __LINE__ ## name`` and ``boost_param_dispatch_1boost_ ## __LINE__ ## name`` and stops at the header of ``boost_param_impl ## name``. Therefore, only the |ArgumentPack|_ type ``Args`` and its object instance ``args`` are available for use within the function body. The |preprocessor|_ test program demonstrates proper usage of this macro. .. |preprocessor| replace:: preprocessor.cpp .. _preprocessor: ../../test/preprocessor.cpp ``BOOST_PARAMETER_BASIC_MEMBER_FUNCTION(result, name, tag_ns, arguments)`` -------------------------------------------------------------------------- :Defined in: `boost/parameter/preprocessor.hpp`__ __ ../../../../boost/parameter/preprocessor.hpp Same as ``BOOST_PARAMETER_BASIC_FUNCTION``, except that: \*. ``name`` may be qualified by the ``static`` keyword to declare the member function and its helpers as not associated with any object of the enclosing type. \*. Expansion of this macro omits the forward declaration of the implementation function. The |preprocessor|_ test program demonstrates proper usage of this macro. .. |preprocessor| replace:: preprocessor.cpp .. _preprocessor: ../../test/preprocessor.cpp ``BOOST_PARAMETER_BASIC_CONST_MEMBER_FUNCTION(result, name, tag_ns, args)`` --------------------------------------------------------------------------- :Defined in: `boost/parameter/preprocessor.hpp`__ __ ../../../../boost/parameter/preprocessor.hpp Same as ``BOOST_PARAMETER_BASIC_MEMBER_FUNCTION``, except that the overloaded forwarding member functions and their helper methods are ``const``-qualified. The |preprocessor|_ test program demonstrates proper usage of this macro. .. |preprocessor| replace:: preprocessor.cpp .. _preprocessor: ../../test/preprocessor.cpp ``BOOST_PARAMETER_NAME(name)`` ------------------------------ :Defined in: `boost/parameter/name.hpp`__ __ ../../../../boost/parameter/name.hpp Declares a tag-type and keyword object. **If** *name* is of the form: .. parsed-literal:: (*object-name*, *namespace-name*) *qualifier*\ (*tag-name*) **then** :Requires: *qualifier* is either ``in``, ``out``, ``in_out``, ``consume``, ``move_from``, or ``forward``. Expands to: .. parsed-literal:: namespace *namespace-name* { struct *tag-name* { static char const* keyword_name() { return ## *tag-name*; } typedef *unspecified* _; typedef *unspecified* _1; typedef boost::parameter::*qualifier* ## _reference qualifier; }; } ::boost::parameter::keyword<*tag-namespace* :: *tag-name* > const& *object-name* = ::boost::parameter::keyword< *tag-namespace* :: *tag-name* >::instance; **Else If** *name* is of the form: .. parsed-literal:: (*tag-name*, *namespace-name*) *object-name* **then** Treats *name* as if it were of the form: .. parsed-literal:: (forward(*tag-name*), *namespace-name*) *object-name* **Else If** *name* is of the form: .. parsed-literal:: *qualifier*\ (*tag-name*) **then** :Requires: *qualifier* is either ``in``, ``out``, ``in_out``, ``consume``, ``move_from``, or ``forward``. Expands to: .. parsed-literal:: namespace tag { struct *tag-name* { static char const* keyword_name() { return ## *tag-name*; } typedef *unspecified* _; typedef *unspecified* _1; typedef boost::parameter::*qualifier* ## _reference qualifier; }; } ::boost::parameter::keyword const& _ ## *tag-name* = ::boost::parameter::keyword::instance; **Else** Treats *name* as if it were of the form: .. parsed-literal:: forward(*tag-name*) ``BOOST_PARAMETER_NESTED_KEYWORD(tag_namespace, name, alias)`` ------------------------------------------ :Defined in: `boost/parameter/nested_keyword.hpp`__ __ ../../../../boost/parameter/nested_keyword.hpp Declares a tag-type, a keyword object, and an alias for that object nested in the tag-type. **If** *name* is of the form: .. parsed-literal:: *qualifier*\ (*tag-name*) **then** :Requires: *qualifier* is either ``in``, ``out``, ``in_out``, ``consume``, ``move_from``, or ``forward``. Expands to: .. parsed-literal:: namespace tag { struct *tag-name* { static char const* keyword_name() { return ## *tag-name* ## _; } typedef *unspecified* _; typedef *unspecified* _1; typedef boost::parameter::*qualifier* ## _reference qualifier; static ::boost::parameter::keyword<*tag-name*> const& *alias*; }; } ::boost::parameter::keyword<*tag-name*> const& *tag-name*::*alias* = ::boost::parameter::keyword<*tag-name*>::instance; **Else** Treats *name* as if it were of the form: .. parsed-literal:: forward(*tag-name*) ``BOOST_PARAMETER_TEMPLATE_KEYWORD(name)`` ------------------------------------------ :Defined in: |template_keyword_header|_ :Included by: |name_header|_ .. |template_keyword_header| replace:: boost/parameter/template_keyword.hpp .. _template_keyword_header: ../../../../boost/parameter/template_keyword.hpp .. |name_header| replace:: boost/parameter/name.hpp .. _name_header: ../../../../boost/parameter/name.hpp Expands to: .. parsed-literal:: namespace tag { struct *name*; } template struct *name* : ::boost::parameter::template_keyword { }; The |function_type_tpl_param_cpp|_ test program demonstrates proper usage of this macro. .. |function_type_tpl_param_cpp| replace:: function_type_tpl_param.cpp .. _function_type_tpl_param_cpp: ../../test/function_type_tpl_param.cpp ``BOOST_PARAMETER_FUN(r, n, l, h, p)`` -------------------------------------- .. admonition:: Deprecated This macro has been deprecated in favor of ``BOOST_PARAMETER_FUNCTION``. Generates a sequence of `forwarding function`_ templates named ``n``, with arities ranging from ``l`` to ``h``, returning ``r``, and using ``p`` to control overload resolution and assign tags to positional arguments. :Defined in: `boost/parameter/macros.hpp`__ __ ../../../../boost/parameter/macros.hpp :Requires: ``l`` and ``h`` are nonnegative integer tokens such that ``l`` < ``h`` **If** |BOOST_PARAMETER_HAS_PERFECT_FORWARDING| is ``#defined``, **then** Expands to: .. parsed-literal:: template r name( A1 && a1, A2 && a2, …, A ## **l** && a ## **l** , typename **p**::match::type p = **p**\ () ) { return **name**\ _with_named_params( **p**\ ( std::`forward`_(a1) , std::`forward`_(a2) , … , std::`forward`_(a ## **l**) ) ); } template < typename A1 , typename A2 , … , typename A ## **l** , typename A ## BOOST_PP_INC_\ (**l**) > r name( A1 && a1, A2 && a2, …, A ## **l** && a ## **l** , A ## BOOST_PP_INC_\ (**l**) const& a ## BOOST_PP_INC_\ (**l**) , typename **p**::match< A1, A2, …, A ## **l**, A ## BOOST_PP_INC_\ (**l**) >::type p = **p**\ () ) { return **name**\ _with_named_params( **p**\ ( std::`forward`_(a1) , std::`forward`_(a2) , … , std::`forward`_(a ## **l**) , std::`forward`_( a ## `BOOST_PP_INC`_\ (**l**) ) ) ); } :vellipsis:`⋮` template r name( A1 && a1, A2 && a2, …, A ## **h** && x ## **h** , typename **p**::match::type p = **p**\ () ) { return **name**\ _with_named_params( **p**\ ( std::`forward`_(a1) , std::`forward`_(a2) , … , std::`forward`_(a ## **h**) ) ); } **If** |BOOST_PARAMETER_HAS_PERFECT_FORWARDING| is **not** ``#defined``, **then** Expands to: .. parsed-literal:: template r name( A1 const& a1, A2 const& a2, …, A ## **l** const& a ## **l** , typename **p**::match::type pk = **p**\ () ) { return **name**\ _with_named_params(pk(a1, a2, …, a ## **l**)); } *… exponential number of overloads …* :vellipsis:`⋮` template r name( A1& a1, A2& a2, …, A ## **l** & a ## **l** , typename **p**::match::type pk = **p**\ () ) { return **name**\ _with_named_params(pk(a1, a2, …, a ## **l**)); } template < typename A1 , typename A2 , … , typename A ## **l** , typename A ## `BOOST_PP_INC`_\ (**l**) > r name( A1 const& a1, A2 const& a2, …, A ## **l** const& a ## **l** , A ## `BOOST_PP_INC`_\ (**l**) const& a ## `BOOST_PP_INC`_\ (**l**) , typename **p**::match< A1 const, A2 const, …, A ## **l** const , A ## `BOOST_PP_INC`_\ (**l**) const >::type pk = **p**\ () ) { return **name**\ _with_named_params( pk(a1, a2, …, a ## **l**, a ## `BOOST_PP_INC`_\ (**l**)) ); } *… exponential number of overloads …* :vellipsis:`⋮` template < typename A1 , typename A2 , … , typename A ## **l** , typename A ## `BOOST_PP_INC`_\ (**l**) > r name( A1& a1, A2& a2, …, A ## **l** & a ## **l** , A ## `BOOST_PP_INC`_\ (**l**) & a ## `BOOST_PP_INC`_\ (**l**) , typename **p**::match< A1, A2, …, A ## **l**, A ## `BOOST_PP_INC`_\ (**l**) >::type pk = **p**\ () ) { return **name**\ _with_named_params( pk(a1, a2, …, a ## **l**, a ## `BOOST_PP_INC`_\ (**l**)) ); } :vellipsis:`⋮` template r name( A1 const& a1, A2 const& a2, …, A ## **h** const& x ## **h** , typename **p**::match< A1 const, A2 const, …, A ## **h** const >::type pk = **p**\ () ) { return **name**\ _with_named_params(pk(a1, a2, …, a ## **h**)); } *… exponential number of overloads …* :vellipsis:`⋮` template r name( A1& a1, A2& a2, …, A ## **h** & x ## **h** , typename **p**::match::type pk = **p**\ () ) { return **name**\ _with_named_params(pk(a1, a2, …, a ## **h**)); } The |macros_cpp|_ and |macros_eval_cat_cpp|_ test programs demonstrate proper usage of this macro. .. _`BOOST_PP_INC`: ../../../preprocessor/doc/ref/inc.html .. _`forward`: http\://en.cppreference.com/w/cpp/utility/forward .. |macros_cpp| replace:: macros.cpp .. _macros_cpp: ../../test/macros.cpp .. |macros_eval_cat_cpp| replace:: macros_eval_category.cpp .. _macros_eval_cat_cpp: ../../test/macros_eval_category.cpp ``BOOST_PARAMETER_KEYWORD(n, k)`` --------------------------------- .. admonition:: Deprecated This macro has been deprecated in favor of ``BOOST_PARAMETER_NAME``. Generates the declaration of a |keyword tag type| named ``k`` in namespace ``n`` and a corresponding |keyword object| definition in the enclosing namespace. :Defined in: `boost/parameter/keyword.hpp`__ __ ../../../../boost/parameter/keyword.hpp Expands to: .. parsed-literal:: namespace **n** { struct **k** { typedef boost::parameter::forward_reference qualifier; }; } namespace { boost::parameter::keyword<*tag-namespace*::**k**>& **k** = boost::parameter::keyword<*tag-namespace*::**k**>::instance; } ``BOOST_PARAMETER_MATCH(p, a, x)`` ---------------------------------- Generates a defaulted parameter declaration for a `forwarding function`_. :Defined in: `boost/parameter/match.hpp`__ __ ../../../../boost/parameter/match.hpp :Requires: ``a`` is a `Boost.Preprocessor sequence`__ of the form .. parsed-literal:: (A0)(A1)…(A ## *n*) __ ../../../preprocessor/doc/data.html Expands to: .. parsed-literal:: typename **p**::match<**A0**\ , **A1**\ , …, **A** ## *n*>::type **x** = **p**\ () Configuration Macros ==================== ``BOOST_PARAMETER_HAS_PERFECT_FORWARDING`` ------------------------------------------ Determines whether or not the library supports perfect forwarding, or the preservation of parameter value categories. Users can manually disable this macro by ``#defining`` the |BOOST_PARAMETER_DISABLE_PERFECT_FORWARDING| macro. Otherwise, the library will ``#define`` this macro if and only if it and the configuration macros |BOOST_NO_FUNCTION_TEMPLATE_ORDERING|_, |BOOST_NO_SFINAE|_, |BOOST_NO_CXX11_RVALUE_REFERENCES|_, and |BOOST_NO_CXX11_VARIADIC_TEMPLATES|_ are not already defined by `Boost.Config`_. .. |BOOST_PARAMETER_HAS_PERFECT_FORWARDING| replace:: ``BOOST_PARAMETER_HAS_PERFECT_FORWARDING`` .. |BOOST_PARAMETER_DISABLE_PERFECT_FORWARDING| replace:: ``BOOST_PARAMETER_DISABLE_PERFECT_FORWARDING`` .. |BOOST_NO_FUNCTION_TEMPLATE_ORDERING| replace:: ``BOOST_NO_FUNCTION_TEMPLATE_ORDERING`` .. _BOOST_NO_FUNCTION_TEMPLATE_ORDERING: ../../../config/doc/html/boost_config/boost_macro_reference.html .. |BOOST_NO_SFINAE| replace:: ``BOOST_NO_SFINAE`` .. _BOOST_NO_SFINAE: ../../../config/doc/html/boost_config/boost_macro_reference.html .. |BOOST_NO_CXX11_RVALUE_REFERENCES| replace:: ``BOOST_NO_CXX11_RVALUE_REFERENCES`` .. _BOOST_NO_CXX11_RVALUE_REFERENCES: ../../../config/doc/html/boost_config/boost_macro_reference.html .. |BOOST_NO_CXX11_VARIADIC_TEMPLATES| replace:: ``BOOST_NO_CXX11_VARIADIC_TEMPLATES`` .. _BOOST_NO_CXX11_VARIADIC_TEMPLATES: ../../../config/doc/html/boost_config/boost_macro_reference.html .. _`Boost.Config`: ../../../config/doc/html/index.html :Defined in: `boost/parameter/config.hpp`__ __ ../../../../boost/parameter/config.hpp ``BOOST_PARAMETER_DISABLE_PERFECT_FORWARDING`` ---------------------------------------------- It may be necessary to test user code in case perfect forwarding support is unavailable. Users can ``#define`` this macro either in their project settings or before including any library header files. Doing so will leave |BOOST_PARAMETER_HAS_PERFECT_FORWARDING| undefined. ``BOOST_PARAMETER_VARIADIC_MPL_SEQUENCE`` ----------------------------------------- If |BOOST_PARAMETER_HAS_PERFECT_FORWARDING| is ``#defined``, then determines the `MPL Variadic Sequence`_ underlying the nested ``parameter_spec`` type of |parameters|. If the user does not manually ``#define`` this macro, then the library will ``#define`` it as |boost_fusion_list|_ if |BOOST_FUSION_HAS_VARIADIC_LIST|_ is defined (by `Boost.Fusion`_), |boost_fusion_deque|_ if |BOOST_FUSION_HAS_VARIADIC_DEQUE|_ is defined (by `Boost.Fusion`_), or |boost_mpl_vector|_ otherwise. :Example: .. parsed-literal:: #define BOOST_PARAMETER_VARIADIC_MPL_SEQUENCE |boost_fusion_vector|_ .. |BOOST_PARAMETER_HAS_PERFECT_FORWARDING| replace:: ``BOOST_PARAMETER_HAS_PERFECT_FORWARDING`` .. |BOOST_PARAMETER_VARIADIC_MPL_SEQUENCE| replace:: ``BOOST_PARAMETER_VARIADIC_MPL_SEQUENCE`` .. _`MPL Variadic Sequence`: ../../../mpl/doc/refmanual/variadic-sequence.html .. _`Boost.Fusion`: ../../../fusion/doc/html/index.html .. |BOOST_FUSION_HAS_VARIADIC_LIST| replace:: ``BOOST_FUSION_HAS_VARIADIC_LIST`` .. _BOOST_FUSION_HAS_VARIADIC_LIST: ../../../../boost/fusion/container/list/list_fwd.hpp .. |boost_fusion_list| replace:: ``boost\:\:fusion\:\:list`` .. _boost_fusion_list: ../../../fusion/doc/html/fusion/container/list.html .. |BOOST_FUSION_HAS_VARIADIC_DEQUE| replace:: ``BOOST_FUSION_HAS_VARIADIC_DEQUE`` .. _BOOST_FUSION_HAS_VARIADIC_DEQUE: ../../../../boost/fusion/container/deque/deque_fwd.hpp .. |boost_fusion_deque| replace:: ``boost\:\:fusion\:\:deque`` .. _boost_fusion_deque: ../../../fusion/doc/html/fusion/container/deque.html .. |boost_fusion_vector| replace:: ``boost\:\:fusion\:\:vector`` .. _boost_fusion_vector: ../../../fusion/doc/html/fusion/container/vector.html .. |boost_mpl_vector| replace:: ``boost\:\:mpl\:\:vector`` .. _boost_mpl_vector: ../../../mpl/doc/refmanual/vector.html :Defined in: `boost/parameter/parameters.hpp`__ __ ../../../../boost/parameter/parameters.hpp ``BOOST_PARAMETER_MAX_ARITY`` ----------------------------- Determines the maximum number of arguments supported by the library. If |BOOST_PARAMETER_HAS_PERFECT_FORWARDING| is ``#defined``, then: \*. If the `MPL Variadic Sequence`_ underlying the nested ``parameter_spec`` type of |parameters| does not have a size limit--which is the case with |boost_fusion_list|_ and |boost_fusion_deque|_, but not |boost_mpl_vector|_--then this macro can be safely ignored. User code that manually defines |BOOST_PARAMETER_VARIADIC_MPL_SEQUENCE| should also manually define this macro to the size limit of the sequence if it has one. If |BOOST_PARAMETER_HAS_PERFECT_FORWARDING| is **not** ``#defined``, then: \*. Mutable references must be wrapped by |boost_ref|_ or |std_ref|_ if passed by position to Boost.Parameter-enabled functions with arity greater than or equal to ``BOOST_PARAMETER_EXPONENTIAL_OVERLOAD_THRESHOLD_ARITY``. .. |BOOST_PARAMETER_HAS_PERFECT_FORWARDING| replace:: ``BOOST_PARAMETER_HAS_PERFECT_FORWARDING`` .. |BOOST_PARAMETER_VARIADIC_MPL_SEQUENCE| replace:: ``BOOST_PARAMETER_VARIADIC_MPL_SEQUENCE`` .. |BOOST_PARAMETER_MAX_ARITY| replace:: ``BOOST_PARAMETER_MAX_ARITY`` .. _`MPL Variadic Sequence`: ../../../mpl/doc/refmanual/variadic-sequence.html .. |boost_fusion_list| replace:: ``boost\:\:fusion\:\:list`` .. _boost_fusion_list: ../../../fusion/doc/html/fusion/container/list.html .. |boost_fusion_deque| replace:: ``boost\:\:fusion\:\:deque`` .. _boost_fusion_deque: ../../../fusion/doc/html/fusion/container/deque.html .. |boost_mpl_vector| replace:: ``boost\:\:mpl\:\:vector`` .. _boost_mpl_vector: ../../../mpl/doc/refmanual/vector.html .. |boost_ref| replace:: ``boost\:\:ref`` .. _boost_ref: ../../../core/doc/html/core/ref.html .. |std_ref| replace:: ``std\:\:ref`` .. _std_ref: http://en.cppreference.com/w/cpp/utility/functional/ref :Defined in: `boost/parameter/config.hpp`__ __ ../../../../boost/parameter/config.hpp :Default Value: |BOOST_MPL_LIMIT_VECTOR_SIZE|_ (defined by `Boost.MPL`_) if perfect forwarding is supported, ``8`` otherwise. :Minimum Value: ``2`` .. |BOOST_MPL_LIMIT_VECTOR_SIZE| replace:: ``BOOST_MPL_LIMIT_VECTOR_SIZE`` .. _BOOST_MPL_LIMIT_VECTOR_SIZE: ../../../mpl/doc/refmanual/limit-vector-size.html .. _`Boost.MPL`: ../../../mpl/doc/index.html ``BOOST_PARAMETER_EXPONENTIAL_OVERLOAD_THRESHOLD_ARITY`` -------------------------------------------------------- If this library does **not** support perfect forwarding, determines the number of arguments less than which |parameters| generates an exponential number of function call operator overloads, and greater than or equal to which |parameters| does not. Will only be ``#defined`` by the library if it is not already ``#defined`` and ``BOOST_PARAMETER_HAS_PERFECT_FORWARDING`` is **not** ``#defined``. .. |BOOST_PARAMETER_EXPONENTIAL_OVERLOAD_THRESHOLD_ARITY| replace:: ``BOOST_PARAMETER_EXPONENTIAL_OVERLOAD_THRESHOLD_ARITY`` :Defined in: `boost/parameter/config.hpp`__ __ ../../../../boost/parameter/config.hpp :Default Value: ``0`` :Minimum Value: ``0`` ...Outside Of This Library -------------------------- #. If `Boost.Config`_ defines the macro |BOOST_NO_FUNCTION_TEMPLATE_ORDERING|_, then the macro |BOOST_PARAMETER_HAS_PERFECT_FORWARDING| will be left undefined; otherwise, the code generation macros would not work correctly. #. If `Boost.Config`_ defines the macro |BOOST_NO_SFINAE|_, then the macro |BOOST_PARAMETER_HAS_PERFECT_FORWARDING| will be left undefined; otherwise, keyword types generated by |BOOST_PARAMETER_NAME| and |BOOST_PARAMETER_NESTED_KEYWORD| would not work correctly. #. If `Boost.Config`_ defines the macro |BOOST_NO_CXX11_RVALUE_REFERENCES|_, then the macro |BOOST_PARAMETER_HAS_PERFECT_FORWARDING| will be left undefined. #. If `Boost.Config`_ defines the macro |BOOST_NO_CXX11_VARIADIC_TEMPLATES|_, then the macro |BOOST_PARAMETER_HAS_PERFECT_FORWARDING| will be left undefined. #. If `Boost.Fusion`_ defines the macro |BOOST_FUSION_HAS_VARIADIC_LIST|_, if this library defines the macro |BOOST_PARAMETER_HAS_PERFECT_FORWARDING|, and if |BOOST_PARAMETER_VARIADIC_MPL_SEQUENCE| is left undefined, then the `MPL Variadic Sequence`_ underlying the nested ``parameter_spec`` type of |parameters| will be |boost_fusion_list|_. #. If `Boost.Fusion`_ defines the macro |BOOST_FUSION_HAS_VARIADIC_DEQUE|_, if this library defines the macro |BOOST_PARAMETER_HAS_PERFECT_FORWARDING|, and if |BOOST_PARAMETER_VARIADIC_MPL_SEQUENCE| is left undefined, then the `MPL Variadic Sequence`_ underlying the nested ``parameter_spec`` type of |parameters| will be |boost_fusion_deque|_. #. The value that `Boost.MPL`_ defines the macro |BOOST_MPL_LIMIT_VECTOR_SIZE|_ as will be the value that this library defines the macro |BOOST_PARAMETER_MAX_ARITY| as if this library defines the macro |BOOST_PARAMETER_HAS_PERFECT_FORWARDING|. .. |BOOST_PARAMETER_HAS_PERFECT_FORWARDING| replace:: ``BOOST_PARAMETER_HAS_PERFECT_FORWARDING`` .. |BOOST_PARAMETER_VARIADIC_MPL_SEQUENCE| replace:: ``BOOST_PARAMETER_VARIADIC_MPL_SEQUENCE`` .. |BOOST_PARAMETER_MAX_ARITY| replace:: ``BOOST_PARAMETER_MAX_ARITY`` .. |BOOST_PARAMETER_NAME| replace:: ``BOOST_PARAMETER_NAME`` .. |BOOST_PARAMETER_NESTED_KEYWORD| replace:: ``BOOST_PARAMETER_NESTED_KEYWORD`` .. |BOOST_NO_FUNCTION_TEMPLATE_ORDERING| replace:: ``BOOST_NO_FUNCTION_TEMPLATE_ORDERING`` .. _BOOST_NO_FUNCTION_TEMPLATE_ORDERING: ../../../config/doc/html/boost_config/boost_macro_reference.html .. |BOOST_NO_SFINAE| replace:: ``BOOST_NO_SFINAE`` .. _BOOST_NO_SFINAE: ../../../config/doc/html/boost_config/boost_macro_reference.html .. |BOOST_NO_CXX11_RVALUE_REFERENCES| replace:: ``BOOST_NO_CXX11_RVALUE_REFERENCES`` .. _BOOST_NO_CXX11_RVALUE_REFERENCES: ../../../config/doc/html/boost_config/boost_macro_reference.html .. |BOOST_NO_CXX11_VARIADIC_TEMPLATES| replace:: ``BOOST_NO_CXX11_VARIADIC_TEMPLATES`` .. _BOOST_NO_CXX11_VARIADIC_TEMPLATES: ../../../config/doc/html/boost_config/boost_macro_reference.html .. |BOOST_FUSION_HAS_VARIADIC_LIST| replace:: ``BOOST_FUSION_HAS_VARIADIC_LIST`` .. _BOOST_FUSION_HAS_VARIADIC_LIST: ../../../../boost/fusion/container/list/list_fwd.hpp .. |BOOST_FUSION_HAS_VARIADIC_DEQUE| replace:: ``BOOST_FUSION_HAS_VARIADIC_DEQUE`` .. _BOOST_FUSION_HAS_VARIADIC_DEQUE: ../../../../boost/fusion/container/deque/deque_fwd.hpp .. |BOOST_MPL_LIMIT_VECTOR_SIZE| replace:: ``BOOST_MPL_LIMIT_VECTOR_SIZE`` .. _BOOST_MPL_LIMIT_VECTOR_SIZE: ../../../mpl/doc/refmanual/limit-vector-size.html .. |boost_fusion_list| replace:: ``boost\:\:fusion\:\:list`` .. _boost_fusion_list: ../../../fusion/doc/html/fusion/container/list.html .. |boost_fusion_deque| replace:: ``boost\:\:fusion\:\:deque`` .. _boost_fusion_deque: ../../../fusion/doc/html/fusion/container/deque.html .. _`Boost.Config`: ../../../config/doc/html/index.html .. _`Boost.Fusion`: ../../../fusion/doc/html/index.html .. _`Boost.MPL`: ../../../mpl/doc/index.html .. _`MPL Variadic Sequence`: ../../../mpl/doc/refmanual/variadic-sequence.html Tutorial ======== Follow `this link`__ to the Boost.Parameter tutorial documentation. __ index.html#tutorial ////////////////////////////////////////////////////////////////////////////// .. [#thread] References to tag objects may be initialized multiple times. This scenario can only occur in the presence of threading. Because the C++ standard doesn't consider threading, it doesn't explicitly allow or forbid multiple initialization of references. That said, it's hard to imagine an implementation where it could make a difference. .. [#no_result_of] Where |BOOST_NO_RESULT_OF|_ is ``#defined``, ``boost::``\ |result_of|_\ ``::type`` is replaced by ``F::result_type``. .. |result_of| replace:: ``result_of`` .. _result_of: ../../../utility/utility.htm#result_of .. |BOOST_NO_RESULT_OF| replace:: ``BOOST_NO_RESULT_OF`` .. _BOOST_NO_RESULT_OF: ../../../utility/utility.htm#BOOST_NO_RESULT_OF