1 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
2 The Boost Parameter Library Reference Documentation
3 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
5 :Authors: David Abrahams, Daniel Wallin
6 :Contact: dave@boost-consulting.com, daniel@boostpro.com
7 :organization: `BoostPro Computing`_
8 :date: $Date: 2005/07/17 19:53:01 $
10 :copyright: Copyright David Abrahams, Daniel Wallin
11 2005-2009. Distributed under the Boost Software License,
12 Version 1.0. (See accompanying file LICENSE_1_0.txt
13 or copy at http://www.boost.org/LICENSE_1_0.txt)
17 .. |(logo)| image:: ../../../../boost.png
20 __ ../../../../index.htm
22 .. _`BoostPro Computing`: http://www.boostpro.com
25 //////////////////////////////////////////////////////////////////////////////
30 //////////////////////////////////////////////////////////////////////////////
41 .. |ArgumentPack| replace:: :concept:`ArgumentPack`
42 .. |ForwardSequence| replace:: :concept:`Forward Sequence`
43 .. |ParameterSpec| replace:: :concept:`ParameterSpec`
48 .. section-numbering::
54 This section covers some basic information you'll need to know in
55 order to understand this reference
60 In this document, all unqualified identifiers should be assumed to
61 be defined in namespace ``boost::parameter`` unless otherwise
67 No operation described in this document
68 throws an exception unless otherwise specified.
73 All components of this library can be used safely from multiple
74 threads without synchronization. [#thread]_
79 Names written in :concept:`sans serif type` represent concepts_.
81 In code blocks, *italic type* represents unspecified text that
82 satisfies the requirements given in the detailed description that
83 follows the code block.
85 In a specification of the tokens generated by a macro, **bold
86 type** is used to highlight the position of the expanded macro
87 argument in the result.
89 The special character β represents the value of |BOOST_PARAMETER_MAX_ARITY|_.
91 //////////////////////////////////////////////////////////////////////////////
96 .. |kw| replace:: keyword
100 The name of a function parameter.
102 .. _keyword tag type:
103 .. |keyword tag type| replace:: `keyword tag type`_
106 A type used to uniquely identify a function parameter. Typically
107 its name will be the same as that of the parameter.
110 .. |positional| replace:: `positional`_
113 An argument passed with no explicit |kw|. Its parameter is
114 determined in the usual C++ way: by position with respect to a
118 .. |tag type| replace:: `tag type`_
121 Shorthand for “\ |keyword tag type|.”
124 .. |keyword object| replace:: `keyword object`_
127 An instance of |keyword|_ ``<T>`` for some |tag
130 .. _tagged reference:
131 .. |tagged reference| replace:: `tagged reference`_
134 An object whose type is associated with a |keyword tag type| (the
135 object's *keyword*), and that holds a reference (to the object's
138 As a shorthand, a “tagged reference to ``x``\ ” means a tagged
139 reference whose *value* is ``x``.
142 .. |tagged default| replace:: `tagged default`_
145 A |tagged reference| whose *value* represents the value of a
148 .. _tagged lazy default:
149 .. |tagged lazy default| replace:: `tagged lazy default`_
152 A |tagged reference| whose *value*, when invoked with no
153 arguments, computes a default argument value.
155 .. _intended argument type:
156 .. |intended argument type| replace:: `intended argument type`_
158 intended argument type
159 The *intended argument type* of a single-element |ArgumentPack|_ is the
160 type of its element's *value*. The intended argument type of any other
161 type ``X`` is ``X`` itself.
165 In this reference, we will use concept names (and other names)
166 to describe both types and objects, depending on context. So
167 for example, “an |ArgumentPack|_\ ” can refer to a type that
168 models |ArgumentPack|_ *or* an object of such a type.
170 //////////////////////////////////////////////////////////////////////////////
175 This section describes the generic type concepts_ used by the Parameter library.
177 .. _concepts: http://www.boost.org/more/generic_programming.html#concept
182 An |ArgumentPack| is a collection of |tagged reference|\ s to the
183 actual arguments passed to a function. Every |ArgumentPack| is
184 also a valid MPL |ForwardSequence|__ consisting of the |keyword tag
185 type|\ s in its |tagged reference|\ s.
187 __ ../../../mpl/doc/refmanual/forward-sequence.html
194 * ``A`` is a model of |ArgumentPack|
195 * ``x`` is an instance of ``A``
196 * ``u`` is a |keyword object| of type ``K``
197 * ``v`` is a |tagged default| with |tag type| ``L`` and *value* of type ``D``
198 * ``w`` is a |tagged lazy default| with |tag type| ``M`` and *value* of type ``E const``
199 * ``z`` is an |ArgumentPack| containing a single element (as created by |keyword|_\ ``<…>::operator=``)
201 Any exceptions are thrown from the invocation of ``w``\ 's *value*
202 will be propagated to the caller.
204 .. table:: |ArgumentPack| requirements
206 +----------+-----------------------------+------------------+--------------------------------------+
207 |Expression| Type |Requirements |Semantics/Notes |
208 +==========+=============================+==================+======================================+
209 |``x[u]`` |``binding<A,K>::type`` |``x`` contains an |Returns *b*\ 's *value* (by |
210 | | |element *b* whose |reference). |
211 | | ||kw|_ is ``K`` | |
212 +----------+-----------------------------+------------------+--------------------------------------+
213 |``x[u]`` |``binding<A,L,D>::type`` |*none* |If ``x`` contains an element *b* whose|
214 | | | ||kw|_ is the same as ``u``\ 's, |
215 | | | |returns *b*\ 's *value* (by |
216 | | | |reference). Otherwise, returns ``u``\|
218 +----------+-----------------------------+------------------+--------------------------------------+
219 |``x[w]`` |``lazy_binding<A,M,E>::type``|*none* |If ``x`` contains an element *b* whose|
220 | | | ||kw|_ is the same as ``w``\ 's, |
221 | | | |returns *b*\ 's *value* (by |
222 | | | |reference). Otherwise, invokes ``w``\|
223 | | | |'s *value* and returns the result. |
224 +----------+-----------------------------+------------------+--------------------------------------+
225 |``x, z`` |Model of |ArgumentPack| |*none* |Returns an |ArgumentPack|_ containing |
226 | | | |all the elements of both ``x`` and |
228 +----------+-----------------------------+------------------+--------------------------------------+
237 A |ParameterSpec| describes the type requirements for arguments
238 corresponding to a given |kw|_ and indicates whether the argument
239 is optional or required. The table below details the allowed forms
240 and describes their condition for satisfaction by an actual
241 argument type. In each row,
245 * ``K`` is the |ParameterSpec|\ 's |keyword tag type|
246 * ``A`` is an |intended argument type| associated with ``K``, if any
247 * ``F`` is a unary `MPL lambda expression`_
249 .. _`MPL lambda expression`: ../../../mpl/doc/refmanual/lambda-expression.html
251 .. table:: |ParameterSpec| allowed forms and conditions of satisfaction
253 +----------------------+--------------+--------------------------------+
254 |Type |``A`` required|Condition ``A`` must satisfy |
255 +======================+==============+================================+
257 +----------------------+--------------+--------------------------------+
258 ||optional|_\ ``<K,F>``|no |``mpl::apply<F,A>::type::value``|
260 +----------------------+--------------+--------------------------------+
261 ||required|_\ ``<K,F>``|yes |``mpl::apply<F,A>::type::value``|
263 +----------------------+--------------+--------------------------------+
265 The information in a |ParameterSpec| is used to `limit`__ the
266 arguments that will be matched by `forwarding functions`_.
269 .. _overloadcontrol: index.html#controlling-overload-resolution
270 .. _forwarding functions: index.html#forwarding-functions
273 //////////////////////////////////////////////////////////////////////////////
278 .. |keyword| replace:: ``keyword``
284 The type of every |keyword object| is a specialization of |keyword|.
286 :Defined in: `boost/parameter/keyword.hpp`__
288 __ ../../../../boost/parameter/keyword.hpp
295 template <class T> |ArgumentPack|_ `operator=`_\(T& value) const;
296 template <class T> |ArgumentPack|_ `operator=`_\(T const& value) const;
298 template <class T> *tagged default* `operator|`_\(T& x) const;
299 template <class T> *tagged default* `operator|`_\(T const& x) const;
301 template <class F> *tagged lazy default* `operator||`_\(F const&) const;
303 static keyword<Tag>& get_\();
307 .. |operator=| replace:: ``operator=``
313 template <class T> |ArgumentPack|_ operator=(T& value) const;
314 template <class T> |ArgumentPack|_ operator=(T const& value) const;
319 an |ArgumentPack|_ containing a single |tagged reference| to
320 ``value`` with |kw|_ ``Tag``
327 template <class T> *tagged default* operator|(T& x) const;
328 template <class T> *tagged default* operator|(T const& x) const;
330 :Returns: a |tagged default| with *value* ``x`` and |kw|_ ``Tag``.
337 template <class F> *tagged lazy default* operator||(F const& g) const;
339 :Requires: ``g()`` is valid, with type ``boost::``\ |result_of|_\
340 ``<F()>::type``. [#no_result_of]_
343 :Returns: a |tagged lazy default| with *value* ``g`` and |kw|_ ``Tag``.
350 static keyword<Tag>& get\();
352 :Returns: a “singleton instance”: the same object will be
353 returned on each invocation of ``get()``.
355 :Thread Safety: ``get()`` can be called from multiple threads
361 Provides an interface for assembling the actual arguments to a
362 `forwarding function` into an |ArgumentPack|, in which any
363 |positional| arguments will be tagged according to the
364 corresponding template argument to ``parameters``.
366 .. _forwarding function: `forwarding functions`_
368 :Defined in: `boost/parameter/parameters.hpp`__
370 __ ../../../../boost/parameter/parameters.hpp
374 template <class P0 = *unspecified*, class P1 = *unspecified*, …class P\ β = *unspecified*>
377 template <class A0, class A1 = *unspecified*, …class A\ β = *unspecified*>
384 |ArgumentPack|_ `operator()`_\(A0& a0) const;
386 template <class A0, class A1>
387 |ArgumentPack|_ `operator()`_\(A0& a0, A1& a1) const;
391 template <class A0, class A1, …class A\ β>
392 |ArgumentPack|_ `operator()`_\(A0& a0, A1& a1, …A\ β& a\ β) const;
396 :Requires: ``P0``, ``P1``, … ``P``\ β are models of |ParameterSpec|_.
401 In this section, ``R``\ *i* and ``K``\ *i* are defined as
402 follows, for any argument type ``A``\ *i*:
405 | let ``D0`` the set [d0, …, d\ *j*] of all **deduced** *parameter specs* in [``P0``, …, ``P``\ β]
406 | ``R``\ *i* is ``A``\ *i*\ 's |intended argument type|
408 | if ``A``\ *i* is a result type of ``keyword<T>::``\ |operator=|_
410 | ``K``\ *i* is ``T``
412 | if some ``A``\ *j* where *j*\ ≤\ *i* is a result type of ``keyword<T>::``\ |operator=|_
413 | *or* some ``P``\ *j* in *j*\ ≤\ *i* is **deduced**
415 | if some *parameter spec* ``d``\ *j* in ``D``\ *i* matches ``A``\ *i*
417 | ``K``\ *i* is ``d``\ *j*\ 's |keyword tag type|.
418 | ``D``\ :sub:`i+1` is ``D``\ *i* - [``d``\ *j*]
420 | ``K``\ *i* is ``P``\ *i*\ 's |keyword tag type|.
426 A |Metafunction|_ used to remove a `forwarding function`_ from overload resolution.
428 :Returns: if ``P0``, ``P1``, …\ ``P``\ β are *satisfied* (see
429 below), then ``parameters<P0,P1,…Pβ>``. Otherwise,
430 ``match<A0,A1,…Aβ>::type`` is not defined.
432 ``P0``, ``P1``, …\ ``P``\ β are **satisfied** if, for
433 every *j* in 0…β, either:
435 * ``P``\ *j* is the *unspecified* default
436 * **or**, ``P``\ *j* is a *keyword tag type*
438 * **or**, ``P``\ *j* is |optional|_ ``<X,F>`` and either
440 - ``X`` is not ``K``\ *i* for any *i*,
441 - **or** ``X`` is some ``K``\ *i* and ``mpl::apply<F,R``\ *i*\
442 ``>::type::value`` is ``true``
444 * **or**, ``P``\ *j* is |required|_ ``<X,F>``, and
446 - ``X`` is some ``K``\ *i*, **and**
447 - ``mpl::apply<F,R``\ *i*\ ``>::type::value`` is ``true``
454 template <class A0> |ArgumentPack|_ operator()(A0 const& a0) const;
458 template <class A0, …class A\ β> |ArgumentPack|_ `operator()`_\(A0 const& a0, …A\ β const& a\ β) const;
461 An |ArgumentPack|_ containing, for each ``a``\ *i*,
463 - if ``a``\ *i*, is a single-element |ArgumentPack|, its element
464 - Otherwise, a |tagged reference| with |kw|_ ``K``\ *i* and *value* ``a``\ *i*
467 .. |optional| replace:: ``optional``
468 .. |required| replace:: ``required``
473 ``optional``, ``required``
474 --------------------------
476 These templates describe the requirements on a function parameter.
478 :Defined in: `boost/parameter/parameters.hpp`__
480 __ ../../../../boost/parameter/parameters.hpp
482 :Specializations model: |ParameterSpec|_
486 template <class Tag, class Predicate = *unspecified*>
489 template <class Tag, class Predicate = *unspecified*>
492 The default value of ``Predicate`` is an unspecified |Metafunction|_ that returns
493 ``mpl::true_`` for any argument.
495 .. |Metafunction| replace:: :concept:`Metafunction`
496 .. _Metafunction: ../../../mpl/doc/refmanual/metafunction.html
502 This template is used to wrap the *keyword tag* argument to
503 ``optional`` or ``required``.
505 :Defined in: `boost/parameter/parameters.hpp`__
507 __ ../../../../boost/parameter/parameters.hpp
515 //////////////////////////////////////////////////////////////////////////////
520 A |Metafunction|_ is conceptually a function that operates on, and
526 Returns the result type of indexing an argument pack with a
527 |keyword tag type| or with a |tagged default|.
529 :Defined n: `boost/parameter/binding.hpp`__
531 __ ../../../../boost/parameter/binding.hpp
535 template <class A, class K, class D = void>
541 :Requires: ``A`` is a model of |ArgumentPack|_.
543 :Returns: the reference type of the |tagged reference| in ``A``
544 having |keyword tag type| ``K``, if any. If no such |tagged
545 reference| exists, returns ``D``.
550 Returns the result type of indexing an argument pack with a |tagged
554 `boost/parameter/binding.hpp`__
556 __ ../../../../boost/parameter/binding.hpp
560 template <class A, class K, class F>
566 :Requires: ``A`` is a model of |ArgumentPack|_.
568 :Returns: the reference type of the |tagged reference| in ``A``
569 having |keyword tag type| ``K``, if any. If no such |tagged
570 reference| exists, returns ``boost::``\ |result_of|_\ ``<F()>::type``. [#no_result_of]_
576 Returns the result type of indexing an argument pack with a
577 |keyword tag type| or with a |tagged default|.
579 :Defined n: `boost/parameter/value_type.hpp`__
581 __ ../../../../boost/parameter/value_type.hpp
585 template <class A, class K, class D = void>
591 :Requires: ``A`` is a model of |ArgumentPack|_.
593 :Returns: the type of the |tagged reference| in ``A``
594 having |keyword tag type| ``K``, if any. If no such |tagged
595 reference| exists, returns ``D``. Equivalent to::
597 typename remove_reference<
598 typename binding<A, K, D>::type
601 … when ``D`` is not a reference type.
604 //////////////////////////////////////////////////////////////////////////////
606 Code Generation Macros
607 ======================
609 Macros in this section can be used to ease the writing of code
610 using the Parameter libray by eliminating repetitive boilerplate.
613 ``BOOST_PARAMETER_FUNCTION(result,name,tag_namespace,arguments)``
614 -----------------------------------------------------------------
616 :Defined in: `boost/parameter/preprocessor.hpp`__
618 __ ../../../../boost/parameter/preprocessor.hpp
620 :Requires: ``result`` is the parenthesized return type of the function.
621 ``name`` is the base name of the function, this is the name of the
622 generated forwarding functions. ``tag_namespace`` is the namespace in
623 which the keywords used by the function resides. ``arguments`` is
624 a list of *argument specifiers*, as defined below.
627 :Argument specifiers syntax:
630 argument-specifiers ::= *specifier-group* {*specifier-group*}
632 specifier-group0 ::= *specifier-group1* |
633 ( '**(**' '**deduced**' *specifier-group1* {*specifier-group1*} '**)**' )
635 specifier-group1 ::= ( '**(**' '**optional**' *optional-specifier* {*optional-specifier*} '**)**' ) |
636 ( '**(**' '**required**' *required-specifier* {*required-specifier*} '**)**' )
638 optional-specifier ::= '**(**' *name* '**,**' *restriction* '**,**' *default-value* ')'
639 required-specifier ::= '**(**' *name* '**,**' *restriction* ')'
641 restriction ::= ('*****' '**(**' *lambda-expression* '**)**' ) |
642 ( '**(**' *typename* '**)**' ) |
645 ``name`` is any valid C++ identifier. ``default-value`` is any valid
646 C++ expression. ``typename`` is the name of a type.
647 ``lambda-expression`` is an `MPL lambda expression`_.
649 .. _`MPL lambda expression`: ../../../mpl/doc/refmanual/lambda-expression.html
651 :Generated names in enclosing scope:
652 * ``boost_param_result_ ## __LINE__ ## name``
653 * ``boost_param_params_ ## __LINE__ ## name``
654 * ``boost_param_parameters_ ## __LINE__ ## name``
655 * ``boost_param_impl ## name``
656 * ``boost_param_default_ ## __LINE__ ## name``
659 Approximate expansion:
662 * ``n`` denotes the *minimum* arity, as determined from ``arguments``.
663 * ``m`` denotes the *maximum* arity, as determined from ``arguments``.
668 struct boost_param_result\_ ## __LINE__ ## **name**
670 typedef **result** type;
673 struct boost_param_params\_ ## __LINE__ ## **name**
674 : boost::parameter::parameters<
675 *list of parameter specifications, based on arguments*
679 typedef boost_param_params\_ ## __LINE__ ## **name**
680 boost_param_parameters\_ ## __LINE__ ## **name**;
682 template <class A0, …, class A\ **n**>
683 *result type* **name**\ (
684 A0 *cv*\ & a0, …, A\ **n** *cv*\ & a\ **n**
685 , typename boost_param_parameters\_ ## __LINE__ ## **name**::match<
686 A0 *cv*, …, A\ **n** *cv*
687 >::type = boost_param_parameters\_ ## __LINE__ ## **name**\ ()
690 *… forward to implementation …*
695 template <class A0, …, class A\ **m**>
696 *result type* **name**\ (
697 A0 *cv*\ & a0, …, A\ **m** *cv*\ & a\ **m**
698 , typename boost_param_parameters\_ ## __LINE__ ## **name**::match<
699 A0 *cv*, …, A\ **m** *cv*
700 >::type = boost_param_parameters\_ ## __LINE__ ## **name**\ ()
703 *… forward to implementation …*
708 , class *argument name*\ **0** ## _type
710 , class *argument name*\ **m** ## _type
712 ResultType boost_param_default\_ ## __LINE__ ## **name**\ (
714 , *argument name*\ **0** ## _type& *argument name*\ **0**
716 , *argument name*\ **m** ## _type& *argument name*\ **m**
721 ``BOOST_PARAMETER_MEMBER_FUNCTION(result,name,tag_namespace,arguments)``
722 ------------------------------------------------------------------------
724 :Defined in: `boost/parameter/preprocessor.hpp`__
726 __ ../../../../boost/parameter/preprocessor.hpp
728 See ``BOOST_PARAMETER_FUNCTION(result,name,tag_namespace,arguments)``
732 ``BOOST_PARAMETER_CONSTRUCTOR(cls, impl, tag_namespace, arguments)``
733 --------------------------------------------------------------------
735 :Defined in: `boost/parameter/preprocessor.hpp`__
737 __ ../../../../boost/parameter/preprocessor.hpp
739 :Requires: ``cls`` is the name of this class. ``impl`` is the
740 parenthesized implementation base class for ``cls``.
741 ``tag_namespace`` is the namespace in which the keywords
742 used by the function resides. ``arguments`` is
743 a list of *argument specifiers*, as defined in
744 ``BOOST_PARAMETER_FUNCTION(result,name,tag_namespace,arguments)``.
746 :Generated names in enclosing scope:
747 * ``boost_param_params_ ## __LINE__ ## ctor``
748 * ``constructor_parameters ## __LINE__``
750 Approximate expansion:
753 * ``n`` denotes the *minimum* arity, as determined from ``arguments``.
754 * ``m`` denotes the *maximum* arity, as determined from ``arguments``.
758 struct boost_param_params\_ ## __LINE__ ## ctor
759 : boost::parameter::parameters<
760 *list of parameter specifications, based on arguments*
764 typedef boost_param_params\_ ## __LINE__ ## **name**
765 constructor_parameters ## __LINE__;
767 template <class A0, …, class A\ **n**>
768 *cls*\ (A0 const& a0, …, A\ **n** const& a\ **n**)
769 : *impl*\ (constructor_parameters ## __LINE__(a0, …, a\ **n**))
774 template <class A0, …, class A\ **m**>
775 *cls*\ (A0 const& a0, …, A\ **n** const& a\ **m**)
776 : *impl*\ (constructor_parameters ## __LINE__(a0, …, a\ **m**))
780 ``BOOST_PARAMETER_NAME(name)``
781 ------------------------------
783 Declares a tag-type and keyword object.
787 **If** *name* is of the form:
791 (*tag-name*, *namespace-name*) *object-name*
797 namespace *namespace-name*
801 static char const* keyword_name()
803 return ##\ *tag-name*;
806 typedef *unspecified* _;
807 typedef *unspecified* _1;
811 ::boost::parameter::keyword<*tag-namespace*\ ::\ *tag-name*\ > const& *object-name*
812 = ::boost::parameter::keyword<*tag-namespace*\ ::\ *tag-name*\ >::instance;
822 static char const* keyword_name()
827 typedef *unspecified* _;
828 typedef *unspecified* _1;
832 ::boost::parameter::keyword<tag::\ *name*\ > const& _\ *name*
833 = ::boost::parameter::keyword<tag::\ *name*\ >::instance;
836 ``BOOST_PARAMETER_TEMPLATE_KEYWORD(name)``
837 ------------------------------------------
850 : ::boost::parameter::template_keyword<tag::\ *name*, T>
854 ``BOOST_PARAMETER_FUN(r,n,l,h,p)``
855 ----------------------------------
857 .. admonition:: Deprecated
859 This macro has been deprecated in favor of
860 ``BOOST_PARAMETER_FUNCTION``.
862 Generates a sequence of `forwarding function`_ templates named
863 ``n``, with arities ranging from ``l`` to ``h`` , returning ``r``,
864 and using ``p`` to control overload resolution and assign tags to
865 positional arguments.
867 :Defined in: `boost/parameter/macros.hpp`__
869 __ ../../../../boost/parameter/macros.hpp
871 :Requires: ``l`` and ``h`` are nonnegative integer tokens such
877 template <class A1, class A2, …class A##\ **l**>
879 A1 const& a1, A2 const& a2, …A\ **l** const& x\ **l**
880 , typename **p**::match<A1,A2,…A\ **l**>::type p = **p**\ ())
882 return **name**\ _with_named_params(**p**\ (x1,x2,…x\ **l**));
885 template <class A1, class A2, …class A\ **l**, class A\ ##\ BOOST_PP_INC_\ (**l**)>
887 A1 const& a1, A2 const& a2, …A\ **l** const& x\ **l**
888 , A\ ##\ BOOST_PP_INC_\ (**l**) const& x\ ##\ BOOST_PP_INC_\ (**l**)
889 , typename **p**::match<A1,A2,…A\ **l**,A\ ##\ BOOST_PP_INC_\ (**l**)>::type p = **p**\ ())
891 return **name**\ _with_named_params(**p**\ (x1,x2,…x\ **l**,x\ ##\ BOOST_PP_INC_\ (**l**)));
896 template <class A1, class A2, …class A\ **h**>
898 A1 const& a1, A2 const& a2, …A\ **h** const& x\ **h**
899 , typename **p**::match<A1,A2,…A\ **h**>::type p = **p**\ ())
901 return **name**\ _with_named_params(**p**\ (a1,a2,…a\ **h**));
905 .. _BOOST_PP_INC: ../../../preprocessor/doc/ref/inc.html
907 ``BOOST_PARAMETER_KEYWORD(n,k)``
908 --------------------------------
910 .. admonition:: Deprecated
912 This macro has been deprecated in favor of
913 ``BOOST_PARAMETER_NAME``.
915 Generates the declaration of a |keyword tag type| named ``k`` in
916 namespace ``n``, and a corresponding |keyword object| definition in
917 the enclosing namespace.
919 :Defined in: `boost/parameter/keyword.hpp`__
921 __ ../../../../boost/parameter/keyword.hpp
926 namespace **n** { struct **k**; }
928 boost::parameter::keyword<*tag-namespace*::**k**>& **k**
929 = boost::parameter::keyword<*tag-namespace*::**k**>::get();
932 ``BOOST_PARAMETER_MATCH(p,a,x)``
933 --------------------------------
935 Generates a defaulted parameter declaration for a `forwarding
938 :Defined in: `boost/parameter/match.hpp`__
940 __ ../../../../boost/parameter/match.hpp
942 :Requires: ``a`` is a `Boost.Preprocessor sequence`__
949 __ http://www.boost.org/libs/preprocessor/doc/data.html
954 typename **p**::match<**A0**\ ,\ **A1**\ …,\ **A**\ *n*>::type **x** = **p**\ ()
960 ``BOOST_PARAMETER_MAX_ARITY``
961 -----------------------------
963 Determines the maximum number of arguments supported by the
964 library. Will only be ``#defined`` by the library if it is not
965 already ``#defined``.
967 .. |BOOST_PARAMETER_MAX_ARITY| replace:: ``BOOST_PARAMETER_MAX_ARITY``
969 :Defined in: `boost/parameter/config.hpp`__
971 __ ../../../../boost/parameter/config.hpp
973 :Default Value: ``8``
978 Follow `this link`__ to the Boost.Parameter tutorial
981 __ index.html#tutorial
983 //////////////////////////////////////////////////////////////
985 .. [#thread] References to tag objects may be initialized multiple
986 times. This scenario can only occur in the presence of
987 threading. Because the C++ standard doesn't consider threading,
988 it doesn't explicitly allow or forbid multiple initialization of
989 references. That said, it's hard to imagine an implementation
990 where it could make a difference.
992 .. [#no_result_of] Where |BOOST_NO_RESULT_OF|_ is ``#defined``,
993 ``boost::``\ |result_of|_\ ``<F()>::type`` is replaced by
996 .. |result_of| replace:: ``result_of``
997 .. _result_of: ../../../utility/utility.htm#result_of
999 .. |BOOST_NO_RESULT_OF| replace:: ``BOOST_NO_RESULT_OF``
1000 .. _BOOST_NO_RESULT_OF: ../../../utility/utility.htm#BOOST_NO_RESULT_OF