| +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| 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|_ ``<T>`` 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. |
| |
| .. _concepts: http://www.boost.org/more/generic_programming.html#concept |
| |
| |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 |ForwardSequence|__ consisting of the |keyword tag |
| type|\ s in its |tagged reference|\ s. |
| |
| __ ../../../mpl/doc/refmanual/forward-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 are 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<A,K>::type`` |``x`` contains an |Returns *b*\ 's *value* (by | |
| | | |element *b* whose |reference). | |
| | | ||kw|_ is ``K`` | | |
| +----------+-----------------------------+------------------+--------------------------------------+ |
| |``x[u]`` |``binding<A,L,D>::type`` |*none* |If ``x`` contains an element *b* whose| |
| | | | ||kw|_ is the same as ``u``\ 's, | |
| | | | |returns *b*\ 's *value* (by | |
| | | | |reference). Otherwise, returns ``u``\| |
| | | | |'s *value*. | |
| +----------+-----------------------------+------------------+--------------------------------------+ |
| |``x[w]`` |``lazy_binding<A,M,E>::type``|*none* |If ``x`` contains an element *b* whose| |
| | | | ||kw|_ 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 |ArgumentPack| |*none* |Returns an |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 |
| * ``F`` is a unary `MPL lambda expression`_ |
| |
| .. _`MPL lambda expression`: ../../../mpl/doc/refmanual/lambda-expression.html |
| |
| .. table:: |ParameterSpec| allowed forms and conditions of satisfaction |
| |
| +----------------------+--------------+--------------------------------+ |
| |Type |``A`` required|Condition ``A`` must satisfy | |
| +======================+==============+================================+ |
| |``K`` |no |*n/a* | |
| +----------------------+--------------+--------------------------------+ |
| ||optional|_\ ``<K,F>``|no |``mpl::apply<F,A>::type::value``| |
| | | |is ``true``. | |
| +----------------------+--------------+--------------------------------+ |
| ||required|_\ ``<K,F>``|yes |``mpl::apply<F,A>::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 |
| |
| .. parsed-literal:: |
| |
| template <class Tag> |
| struct keyword |
| { |
| template <class T> |ArgumentPack|_ `operator=`_\(T& value) const; |
| template <class T> |ArgumentPack|_ `operator=`_\(T const& value) const; |
| |
| template <class T> *tagged default* `operator|`_\(T& x) const; |
| template <class T> *tagged default* `operator|`_\(T const& x) const; |
| |
| template <class F> *tagged lazy default* `operator||`_\(F const&) const; |
| |
| static keyword<Tag>& get_\(); |
| }; |
| |
| |
| .. |operator=| replace:: ``operator=`` |
| .. _operator=: |
| |
| ``operator=`` |
| .. parsed-literal:: |
| |
| template <class T> |ArgumentPack|_ operator=(T& value) const; |
| template <class T> |ArgumentPack|_ operator=(T const& value) const; |
| |
| :Requires: nothing |
| |
| :Returns: |
| an |ArgumentPack|_ containing a single |tagged reference| to |
| ``value`` with |kw|_ ``Tag`` |
| |
| .. _operator|: |
| |
| ``operator|`` |
| .. parsed-literal:: |
| |
| template <class T> *tagged default* operator|(T& x) const; |
| template <class T> *tagged default* operator|(T const& x) const; |
| |
| :Returns: a |tagged default| with *value* ``x`` and |kw|_ ``Tag``. |
| |
| .. _operator||: |
| |
| ``operator||`` |
| .. parsed-literal:: |
| |
| template <class F> *tagged lazy default* operator||(F const& g) const; |
| |
| :Requires: ``g()`` is valid, with type ``boost::``\ |result_of|_\ |
| ``<F()>::type``. [#no_result_of]_ |
| |
| |
| :Returns: a |tagged lazy default| with *value* ``g`` and |kw|_ ``Tag``. |
| |
| .. _get: |
| |
| ``get`` |
| .. parsed-literal:: |
| |
| static keyword<Tag>& get\(); |
| |
| :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. |
| |
| ``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 |
| |
| .. parsed-literal:: |
| |
| template <class P0 = *unspecified*, class P1 = *unspecified*, …class P\ β = *unspecified*> |
| struct parameters |
| { |
| template <class A0, class A1 = *unspecified*, …class A\ β = *unspecified*> |
| struct `match`_ |
| { |
| typedef … type; |
| }; |
| |
| template <class A0> |
| |ArgumentPack|_ `operator()`_\(A0& a0) const; |
| |
| template <class A0, class A1> |
| |ArgumentPack|_ `operator()`_\(A0& a0, A1& a1) const; |
| |
| :vellipsis:`⋮` |
| |
| template <class A0, class A1, …class A\ β> |
| |ArgumentPack|_ `operator()`_\(A0& a0, A1& a1, …A\ β& a\ β) const; |
| }; |
| |
| |
| :Requires: ``P0``, ``P1``, … ``P``\ β are 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 ``A``\ *i*\ 's |intended argument type| |
| | |
| | if ``A``\ *i* is a result type of ``keyword<T>::``\ |operator=|_ |
| | then |
| | ``K``\ *i* is ``T`` |
| | else |
| | if some ``A``\ *j* where *j*\ ≤\ *i* is a result type of ``keyword<T>::``\ |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 ``d``\ *j*\ 's |keyword tag type|. |
| | ``D``\ :sub:`i+1` is ``D``\ *i* - [``d``\ *j*] |
| | else |
| | ``K``\ *i* is ``P``\ *i*\ 's |keyword tag type|. |
| |
| |
| .. _match: |
| |
| ``match`` |
| A |Metafunction|_ used to remove a `forwarding function`_ from overload resolution. |
| |
| :Returns: if ``P0``, ``P1``, …\ ``P``\ β are *satisfied* (see |
| below), then ``parameters<P0,P1,…Pβ>``. Otherwise, |
| ``match<A0,A1,…Aβ>::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|_ ``<X,F>`` and either |
| |
| - ``X`` is not ``K``\ *i* for any *i*, |
| - **or** ``X`` is some ``K``\ *i* and ``mpl::apply<F,R``\ *i*\ |
| ``>::type::value`` is ``true`` |
| |
| * **or**, ``P``\ *j* is |required|_ ``<X,F>``, and |
| |
| - ``X`` is some ``K``\ *i*, **and** |
| - ``mpl::apply<F,R``\ *i*\ ``>::type::value`` is ``true`` |
| |
| .. _operator(): |
| |
| ``operator()`` |
| .. parsed-literal:: |
| |
| template <class A0> |ArgumentPack|_ operator()(A0 const& a0) const; |
| |
| :vellipsis:`⋮` |
| |
| template <class A0, …class A\ β> |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. |
| |
| :Defined in: `boost/parameter/parameters.hpp`__ |
| |
| __ ../../../../boost/parameter/parameters.hpp |
| |
| :Specializations model: |ParameterSpec|_ |
| |
| .. parsed-literal:: |
| |
| template <class Tag, class Predicate = *unspecified*> |
| struct optional; |
| |
| template <class Tag, class Predicate = *unspecified*> |
| struct required; |
| |
| The default value of ``Predicate`` is an unspecified |Metafunction|_ that returns |
| ``mpl::true_`` for any argument. |
| |
| .. |Metafunction| replace:: :concept:`Metafunction` |
| .. _Metafunction: ../../../mpl/doc/refmanual/metafunction.html |
| |
| |
| ``deduced`` |
| ----------- |
| |
| This template is used to wrap the *keyword tag* argument to |
| ``optional`` or ``required``. |
| |
| :Defined in: `boost/parameter/parameters.hpp`__ |
| |
| __ ../../../../boost/parameter/parameters.hpp |
| |
| .. parsed-literal:: |
| |
| template <class Tag> |
| struct deduced; |
| |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| 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 n: `boost/parameter/binding.hpp`__ |
| |
| __ ../../../../boost/parameter/binding.hpp |
| |
| .. parsed-literal:: |
| |
| template <class A, class K, class D = void> |
| struct binding |
| { |
| typedef … type; |
| }; |
| |
| :Requires: ``A`` is 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 <class A, class K, class F> |
| struct lazy_binding |
| { |
| typedef … type; |
| }; |
| |
| :Requires: ``A`` is 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|_\ ``<F()>::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 n: `boost/parameter/value_type.hpp`__ |
| |
| __ ../../../../boost/parameter/value_type.hpp |
| |
| .. parsed-literal:: |
| |
| template <class A, class K, class D = void> |
| struct value_type |
| { |
| typedef … type; |
| }; |
| |
| :Requires: ``A`` is a model of |ArgumentPack|_. |
| |
| :Returns: the 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<A, K, D>::type |
| >::type |
| |
| … when ``D`` is not a reference type. |
| |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| Code Generation Macros |
| ====================== |
| |
| Macros in this section can be used to ease the writing of code |
| using the Parameter libray 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, this is the name of the |
| generated forwarding functions. ``tag_namespace`` is the namespace in |
| which the keywords used by the function resides. ``arguments`` is |
| a list of *argument specifiers*, as defined below. |
| |
| |
| :Argument specifiers syntax: |
| .. parsed-literal:: |
| |
| argument-specifiers ::= *specifier-group* {*specifier-group*} |
| |
| specifier-group0 ::= *specifier-group1* | |
| ( '**(**' '**deduced**' *specifier-group1* {*specifier-group1*} '**)**' ) |
| |
| specifier-group1 ::= ( '**(**' '**optional**' *optional-specifier* {*optional-specifier*} '**)**' ) | |
| ( '**(**' '**required**' *required-specifier* {*required-specifier*} '**)**' ) |
| |
| optional-specifier ::= '**(**' *name* '**,**' *restriction* '**,**' *default-value* ')' |
| required-specifier ::= '**(**' *name* '**,**' *restriction* ')' |
| |
| restriction ::= ('*****' '**(**' *lambda-expression* '**)**' ) | |
| ( '**(**' *typename* '**)**' ) | |
| '*****' |
| |
| ``name`` is any valid C++ identifier. ``default-value`` is any valid |
| C++ expression. ``typename`` is the name of a type. |
| ``lambda-expression`` is an `MPL lambda expression`_. |
| |
| .. _`MPL lambda expression`: ../../../mpl/doc/refmanual/lambda-expression.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_default_ ## __LINE__ ## name`` |
| |
| |
| Approximate expansion: |
| **Where**: |
| |
| * ``n`` denotes the *minimum* arity, as determined from ``arguments``. |
| * ``m`` denotes the *maximum* arity, as determined from ``arguments``. |
| |
| .. parsed-literal:: |
| |
| template <class T> |
| 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 <class A0, …, class A\ **n**> |
| *result type* **name**\ ( |
| A0 *cv*\ & a0, …, A\ **n** *cv*\ & a\ **n** |
| , typename boost_param_parameters\_ ## __LINE__ ## **name**::match< |
| A0 *cv*, …, A\ **n** *cv* |
| >::type = boost_param_parameters\_ ## __LINE__ ## **name**\ () |
| ) |
| { |
| *… forward to implementation …* |
| } |
| |
| :vellipsis:`⋮` |
| |
| template <class A0, …, class A\ **m**> |
| *result type* **name**\ ( |
| A0 *cv*\ & a0, …, A\ **m** *cv*\ & a\ **m** |
| , typename boost_param_parameters\_ ## __LINE__ ## **name**::match< |
| A0 *cv*, …, A\ **m** *cv* |
| >::type = boost_param_parameters\_ ## __LINE__ ## **name**\ () |
| ) |
| { |
| *… forward to implementation …* |
| } |
| |
| template < |
| class ResultType |
| , class *argument name*\ **0** ## _type |
| … |
| , class *argument name*\ **m** ## _type |
| > |
| ResultType boost_param_default\_ ## __LINE__ ## **name**\ ( |
| (ResultType(*)()) |
| , *argument name*\ **0** ## _type& *argument name*\ **0** |
| … |
| , *argument name*\ **m** ## _type& *argument name*\ **m** |
| ) |
| |
| |
| |
| ``BOOST_PARAMETER_MEMBER_FUNCTION(result,name,tag_namespace,arguments)`` |
| ------------------------------------------------------------------------ |
| |
| :Defined in: `boost/parameter/preprocessor.hpp`__ |
| |
| __ ../../../../boost/parameter/preprocessor.hpp |
| |
| See ``BOOST_PARAMETER_FUNCTION(result,name,tag_namespace,arguments)`` |
| |
| |
| |
| ``BOOST_PARAMETER_CONSTRUCTOR(cls, impl, tag_namespace, arguments)`` |
| -------------------------------------------------------------------- |
| |
| :Defined in: `boost/parameter/preprocessor.hpp`__ |
| |
| __ ../../../../boost/parameter/preprocessor.hpp |
| |
| :Requires: ``cls`` is the name of this 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(result,name,tag_namespace,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``. |
| |
| .. 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 <class A0, …, class A\ **n**> |
| *cls*\ (A0 const& a0, …, A\ **n** const& a\ **n**) |
| : *impl*\ (constructor_parameters ## __LINE__(a0, …, a\ **n**)) |
| {} |
| |
| :vellipsis:`⋮` |
| |
| template <class A0, …, class A\ **m**> |
| *cls*\ (A0 const& a0, …, A\ **n** const& a\ **m**) |
| : *impl*\ (constructor_parameters ## __LINE__(a0, …, a\ **m**)) |
| {} |
| |
| |
| ``BOOST_PARAMETER_NAME(name)`` |
| ------------------------------ |
| |
| Declares a tag-type and keyword object. |
| |
| Expands to: |
| |
| **If** *name* is of the form: |
| |
| .. parsed-literal:: |
| |
| (*tag-name*, *namespace-name*) *object-name* |
| |
| **then** |
| |
| .. parsed-literal:: |
| |
| namespace *namespace-name* |
| { |
| struct *tag-name* |
| { |
| static char const* keyword_name() |
| { |
| return ##\ *tag-name*; |
| } |
| |
| typedef *unspecified* _; |
| typedef *unspecified* _1; |
| }; |
| } |
| |
| ::boost::parameter::keyword<*tag-namespace*\ ::\ *tag-name*\ > const& *object-name* |
| = ::boost::parameter::keyword<*tag-namespace*\ ::\ *tag-name*\ >::instance; |
| |
| **Else** |
| |
| .. parsed-literal:: |
| |
| namespace tag |
| { |
| struct *name* |
| { |
| static char const* keyword_name() |
| { |
| return ##\ *name*; |
| } |
| |
| typedef *unspecified* _; |
| typedef *unspecified* _1; |
| }; |
| } |
| |
| ::boost::parameter::keyword<tag::\ *name*\ > const& _\ *name* |
| = ::boost::parameter::keyword<tag::\ *name*\ >::instance; |
| |
| |
| ``BOOST_PARAMETER_TEMPLATE_KEYWORD(name)`` |
| ------------------------------------------ |
| |
| Expands to: |
| |
| .. parsed-literal:: |
| |
| namespace tag |
| { |
| struct *name*; |
| } |
| |
| template <class T> |
| struct *name* |
| : ::boost::parameter::template_keyword<tag::\ *name*, T> |
| {}; |
| |
| |
| ``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`` |
| |
| Generates |
| .. parsed-literal:: |
| |
| template <class A1, class A2, …class A##\ **l**> |
| r name( |
| A1 const& a1, A2 const& a2, …A\ **l** const& x\ **l** |
| , typename **p**::match<A1,A2,…A\ **l**>::type p = **p**\ ()) |
| { |
| return **name**\ _with_named_params(**p**\ (x1,x2,…x\ **l**)); |
| } |
| |
| template <class A1, class A2, …class A\ **l**, class A\ ##\ BOOST_PP_INC_\ (**l**)> |
| r name( |
| A1 const& a1, A2 const& a2, …A\ **l** const& x\ **l** |
| , A\ ##\ BOOST_PP_INC_\ (**l**) const& x\ ##\ 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**\ (x1,x2,…x\ **l**,x\ ##\ BOOST_PP_INC_\ (**l**))); |
| } |
| |
| :vellipsis:`⋮` |
| |
| template <class A1, class A2, …class A\ **h**> |
| r name( |
| A1 const& a1, A2 const& a2, …A\ **h** const& x\ **h** |
| , typename **p**::match<A1,A2,…A\ **h**>::type p = **p**\ ()) |
| { |
| return **name**\ _with_named_params(**p**\ (a1,a2,…a\ **h**)); |
| } |
| |
| |
| .. _BOOST_PP_INC: ../../../preprocessor/doc/ref/inc.html |
| |
| ``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 |
| |
| Generates |
| .. parsed-literal:: |
| |
| namespace **n** { struct **k**; } |
| namespace { |
| boost::parameter::keyword<*tag-namespace*::**k**>& **k** |
| = boost::parameter::keyword<*tag-namespace*::**k**>::get(); |
| } |
| |
| ``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*) |
| |
| __ http://www.boost.org/libs/preprocessor/doc/data.html |
| |
| Generates |
| .. parsed-literal:: |
| |
| typename **p**::match<**A0**\ ,\ **A1**\ …,\ **A**\ *n*>::type **x** = **p**\ () |
| |
| |
| Configuration Macros |
| ==================== |
| |
| ``BOOST_PARAMETER_MAX_ARITY`` |
| ----------------------------- |
| |
| Determines the maximum number of arguments supported by the |
| library. Will only be ``#defined`` by the library if it is not |
| already ``#defined``. |
| |
| .. |BOOST_PARAMETER_MAX_ARITY| replace:: ``BOOST_PARAMETER_MAX_ARITY`` |
| |
| :Defined in: `boost/parameter/config.hpp`__ |
| |
| __ ../../../../boost/parameter/config.hpp |
| |
| :Default Value: ``5`` |
| |
| 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|_\ ``<F()>::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 |
| |