This commit was manufactured by cvs2svn to create tag

'Version_1_33_0'.

[SVN r30532]

.travis.yml

@@ -1,136 +0,0 @@
-# Copyright 2016 Edward Diener
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
-
-language: cpp
-
-sudo: false
-
-python: "2.7"
-
-branches:
-  only:
-    - master
-    - develop
-    - /feature\/.*/
-
-env:
-  matrix:
-    - BOGUS_JOB=true
-
-matrix:
-
-  exclude:
-    - env: BOGUS_JOB=true
-
-  include:
-    - os: linux
-      compiler: g++
-      env: TOOLSET=gcc COMPILER=g++ CXXSTD=03,11
-
-    - os: linux
-      compiler: g++-4.4
-      env: TOOLSET=gcc COMPILER=g++-4.4 CXXSTD=98,0x
-      addons:
-        apt:
-          packages:
-            - g++-4.4
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-4.6
-      env: TOOLSET=gcc COMPILER=g++-4.6 CXXSTD=03,0x
-      addons:
-        apt:
-          packages:
-            - g++-4.6
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-5
-      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - g++-5
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-6
-      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - g++-6
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      dist: trusty
-      compiler: g++-7
-      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=03,11,14,17
-      addons:
-        apt:
-          packages:
-            - g++-7
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-8
-      env: TOOLSET=gcc COMPILER=g++-8 CXXSTD=03,11,14,17
-      addons:
-        apt:
-          packages:
-            - g++-8
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - libstdc++-5-dev
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++-libc++
-      env: TOOLSET=clang COMPILER=clang++-libc++ CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - libc++-dev
-
-    - os: osx
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
-
-install:
-  - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
-  - cd ..
-  - git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
-  - cd boost-root
-  - git submodule update --init tools/build
-  - git submodule update --init libs/config
-  - git submodule update --init tools/boostdep
-  - git submodule update --init libs/parameter_python
-  - cp -r $TRAVIS_BUILD_DIR/* libs/parameter
-  - python tools/boostdep/depinst/depinst.py parameter
-  - ./bootstrap.sh
-  - ./b2 headers
-
-script:
-  - |-
-    echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
-  - ./b2 --verbose-test libs/config/test//config_info toolset=$TOOLSET cxxstd=$CXXSTD || true
-  - ./b2 -j3 libs/parameter/test toolset=$TOOLSET cxxstd=$CXXSTD
-
-notifications:
-  email:
-    on_success: always

appveyor.yml

@@ -1,37 +0,0 @@
-# Copyright 2017 Edward Diener
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
-
-version: 1.0.{build}-{branch}
-
-shallow_clone: true
-
-branches:
-  only:
-    - master
-    - develop
-
-environment:
-  matrix:
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      TOOLSET: msvc-9.0,msvc-10.0,msvc-11.0,msvc-12.0,msvc-14.0
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      TOOLSET: msvc-14.1
-
-install:
-  - cd ..
-  - git clone -b %APPVEYOR_REPO_BRANCH% https://github.com/boostorg/boost.git boost-root
-  - cd boost-root
-  - git submodule update --init tools/build
-  - git submodule update --init libs/config
-  - git submodule update --init tools/boostdep
-  - git submodule update --init libs/parameter_python
-  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\parameter
-  - python tools/boostdep/depinst/depinst.py parameter
-  - bootstrap
-  - b2 headers
-
-build: off
-
-test_script:
-  - b2 libs/parameter/test toolset=%TOOLSET%

doc/Jamfile.v2

@@ -1,12 +1,9 @@
-# Copyright David Abrahams 2006. 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)
-
 import docutils ;
 
-sources = [ glob *.rst ] ;
+import path ;
+sources = [ path.glob . : *.rst ] ;
 bases = $(sources:S=) ;
-
+  
 # This is a path relative to the html/ subdirectory where the
 # generated output will eventually be moved.
 stylesheet = "--stylesheet=rst.css" ;
@@ -16,15 +13,9 @@ for local b in $(bases)
     html $(b) : $(b).rst : 
       
       # 
-      <docutils-html>"-gdt --link-stylesheet --traceback --trim-footnote-reference-space --footnote-references=superscript "$(stylesheet)
+      <docutils-html>"-gdt --traceback --trim-footnote-reference-space --footnote-references=superscript "$(stylesheet)
   ;
 }
 
 alias htmls : $(bases) ;
 stage html : $(bases) ;
-
-###############################################################################
-alias boostdoc ;
-explicit boostdoc ;
-alias boostrelease : html ;
-explicit boostrelease ;

doc/README.txt

@@ -1,17 +0,0 @@
-.. -*-rst-*-
-
-.. Copyright David Abrahams 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)
-
-To build the html::
-
-  bjam html
-
-To test the code in this documentation:
-
-.. parsed-literal::
-
-  python ../../../tools/litre/tool.py `pwd`/index.rst --dump_dir=../test/literate
-  cd ../test/literate
-  bjam

doc/html/rst.css

@@ -1,8 +1,3 @@
-/* Copyright David Abrahams 2006. 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) 
-*/
-
 @import "../../../../rst.css";
 
 div.section div.section div.section dl {
@@ -19,12 +14,8 @@ img {
 }
 
 span.vellipsis {
-  display: block;
-  width: 5px;
-  height: 22px;
-  background: url("vellipsis.gif");
-  margin-left: 3em;
-  text-indent: -1000px;
+  line-height: 30% ;
+  font-size: 200% ;
 }
 
 

doc/reference.rst

@@ -2,16 +2,6 @@
  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
@@ -19,7 +9,17 @@
 
 __ ../../../../index.htm
 
-.. _`BoostPro Computing`: http://www.boostpro.com
+:Authors:       David Abrahams, Daniel Wallin
+:Contact:       dave@boost-consulting.com, dalwan01@student.umu.se
+:organization:  `Boost Consulting`_
+:date:          $Date: 2005/07/17 19:53:01 $
+
+:copyright:     Copyright David Abrahams, Daniel Wallin
+                2005. 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)
+
+.. _`Boost Consulting`: http://www.boost-consulting.com
 
 
 //////////////////////////////////////////////////////////////////////////////
@@ -39,7 +39,6 @@ __ ../../../../index.htm
     :class: function
 
 .. |ArgumentPack| replace:: :concept:`ArgumentPack`
-.. |ForwardSequence| replace:: :concept:`Forward Sequence`
 .. |ParameterSpec| replace:: :concept:`ParameterSpec`
 
 .. role:: vellipsis
@@ -174,17 +173,13 @@ Concepts
 
 This section describes the generic type concepts_ used by the Parameter library. 
 
-.. _concepts: http://www.boost.org/more/generic_programming.html#concept
+.. _concepts: ../../../../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
+actual arguments passed to a function.
 
 Requirements
 ............
@@ -253,7 +248,7 @@ argument type. In each row,
    +----------------------+--------------+--------------------------------+
    |Type                  |``A`` required|Condition ``A`` must satisfy    |
    +======================+==============+================================+
-   |``K``                 |no            |*n/a*                           |
+   ||keyword|_\ ``<K>``   |no            |*n/a*                           |
    +----------------------+--------------+--------------------------------+
    ||optional|_\ ``<K,F>``|no            |``mpl::apply<F,A>::type::value``|
    |                      |              |is ``true``.                    |
@@ -381,15 +376,16 @@ __ ../../../../boost/parameter/parameters.hpp
         };
 
         template <class A0>
-        |ArgumentPack|_ `operator()`_\(A0& a0) const;
+        |ArgumentPack|_ `operator()`_\(A0 const& a0) const;
 
         template <class A0, class A1>
-        |ArgumentPack|_ `operator()`_\(A0& a0, A1& a1) const; 
-
-        :vellipsis:`⋮`
-
+        |ArgumentPack|_ `operator()`_\(A0 const& a0, A1 const& a1) const; :vellipsis:`\ 
+       .
+       .
+       .
+     `
         template <class A0, class A1, …class A\ β>
-        |ArgumentPack|_ `operator()`_\(A0& a0, A1& a1, …A\ β& a\ β) const;
+        |ArgumentPack|_ `operator()`_\(A0 const& a0, A1 const& a1, …A\ β const& a\ β) const;
     };
 
 
@@ -402,22 +398,13 @@ __ ../../../../boost/parameter/parameters.hpp
   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|.
+     |  if ``A``\ *i* is a result type of ``keyword<T>::``\ |operator=|_
+     |  then 
+     |      ``K``\ *i* is ``T``
+     |  else 
+     |      ``K``\ *i* is ``P``\ *i*\ 's |keyword tag type|.
 
 
 .. _match:
@@ -433,7 +420,7 @@ __ ../../../../boost/parameter/parameters.hpp
   every *j* in 0…β, either:
 
   * ``P``\ *j* is the *unspecified* default
-  * **or**, ``P``\ *j* is a *keyword tag type*
+  * **or**, ``P``\ *j* is a specialization of |keyword|_,
 
   * **or**, ``P``\ *j* is |optional|_ ``<X,F>`` and either
 
@@ -451,10 +438,11 @@ __ ../../../../boost/parameter/parameters.hpp
 ``operator()``
   .. parsed-literal::
 
-      template <class A0> |ArgumentPack|_ operator()(A0 const& a0) const; 
-
-      :vellipsis:`⋮`
-
+      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:
@@ -495,23 +483,6 @@ The default value of ``Predicate`` is an unspecified |Metafunction|_ that return
 .. |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
@@ -570,37 +541,6 @@ __ ../../../../boost/parameter/binding.hpp
   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
@@ -609,256 +549,9 @@ 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
@@ -889,10 +582,11 @@ Generates
       , 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:`⋮`
-
+    } :vellipsis:`\ 
+      .
+      .
+      .
+     `
     template <class A1, class A2, …class A\ **h**>
     r name(
         A1 const& a1, A2 const& a2, …A\ **h** const& x\ **h**
@@ -907,11 +601,6 @@ Generates
 ``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.
@@ -970,7 +659,7 @@ already ``#defined``.
 
 __ ../../../../boost/parameter/config.hpp
 
-:Default Value: ``8``
+:Default Value: ``5``
 
 Tutorial
 ========
@@ -997,5 +686,4 @@ __ index.html#tutorial
 .. _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
-
+.. _BOOST_NO_RESULT_OF: ../../../utility/utility.htm#BOOST_NO_RESULT_OF

include/boost/parameter.hpp

@@ -3,19 +3,14 @@
 // (See accompanying file LICENSE_1_0.txt or copy at 
 // http://www.boost.org/LICENSE_1_0.txt)
 
-//  See www.boost.org/libs/parameter for documentation.
-
 #ifndef BOOST_PARAMETER_050401_HPP
 #define BOOST_PARAMETER_050401_HPP
 
 #include <boost/parameter/parameters.hpp>
 #include <boost/parameter/keyword.hpp>
 #include <boost/parameter/binding.hpp>
-#include <boost/parameter/value_type.hpp>
 #include <boost/parameter/macros.hpp>
 #include <boost/parameter/match.hpp>
-#include <boost/parameter/name.hpp>
-#include <boost/parameter/preprocessor.hpp>
 
 #endif // BOOST_PARAMETER_050401_HPP
 

include/boost/parameter/aux_/arg_list.hpp

@@ -6,36 +6,25 @@
 #ifndef ARG_LIST_050329_HPP
 #define ARG_LIST_050329_HPP
 
+#include <boost/mpl/apply.hpp>
+#include <boost/type_traits/add_reference.hpp>
+
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/facilities/intercept.hpp>
+
 #include <boost/parameter/aux_/void.hpp>
 #include <boost/parameter/aux_/result_of0.hpp>
 #include <boost/parameter/aux_/default.hpp>
 #include <boost/parameter/aux_/parameter_requirements.hpp>
-#include <boost/parameter/aux_/yesno.hpp>
-#include <boost/parameter/aux_/is_maybe.hpp>
 #include <boost/parameter/config.hpp>
 
-#include <boost/mpl/apply.hpp>
-#include <boost/mpl/assert.hpp>
-#include <boost/mpl/begin.hpp>
-#include <boost/mpl/end.hpp>
-#include <boost/mpl/iterator_tags.hpp>
-
-#include <boost/type_traits/add_reference.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/repetition/enum_binary_params.hpp>
-#include <boost/preprocessor/facilities/intercept.hpp>
-
-namespace boost { namespace parameter {
+namespace boost { namespace parameter { 
 
 // Forward declaration for aux::arg_list, below.
 template<class T> struct keyword;
 
 namespace aux {
 
-// Tag type passed to MPL lambda.
-struct lambda_tag;
-
 //
 // Structures used to build the tuple of actual arguments.  The
 // tuple is a nested cons-style list of arg_list specializations
@@ -46,14 +35,10 @@ struct lambda_tag;
 // declarations to build member function overload sets that can
 // match against keywords.
 //
-
-// MPL sequence support
-struct arg_list_tag;
-
+  
 // Terminates arg_list<> and represents an empty list.  Since this
 // is just the terminating case you might want to look at arg_list
 // first, to get a feel for what's really happening here.
-
 struct empty_arg_list
 {
     empty_arg_list() {}
@@ -71,22 +56,20 @@ struct empty_arg_list
     // lookup given that default
     struct binding
     {
-        template<class KW, class Default, class Reference>
+        template<class KW, class Default>
         struct apply
         {
             typedef Default type;
         };
     };
 
-    // Terminator for has_key, indicating that the keyword is unique
-    template <class KW>
-    static no_tag has_key(KW*);
-
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
+    || (BOOST_WORKAROUND(__GNUC__, < 3)) \
+    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+    
     // The overload set technique doesn't work with these older
     // compilers, so they need some explicit handholding.
-
+      
     // A metafunction class that, given a keyword, returns the type
     // of the base sublist whose get() function can produce the
     // value for that key
@@ -137,46 +120,23 @@ struct empty_arg_list
     // was found if we match this overload, so unless that parameter
     // has a default, we indicate that the actual arguments don't
     // match the function's requirements.
-    template <class ParameterRequirements, class ArgPack>
+    template <class ParameterRequirements>
     static typename ParameterRequirements::has_default
-    satisfies(ParameterRequirements*, ArgPack*);
-
-    // MPL sequence support
-    typedef empty_arg_list type;   // convenience
-    typedef arg_list_tag tag; // For dispatching to sequence intrinsics
+    satisfies(ParameterRequirements*);
 };
 
 // Forward declaration for arg_list::operator,
 template <class KW, class T>
 struct tagged_argument;
 
-template <class T>
-struct get_reference
-{
-    typedef typename T::reference type;
-};
-
 // A tuple of tagged arguments, terminated with empty_arg_list.
 // Every TaggedArg is an instance of tagged_argument<>.
 template <class TaggedArg, class Next = empty_arg_list>
 struct arg_list : Next
 {
-    typedef arg_list<TaggedArg,Next> self;
     typedef typename TaggedArg::key_type key_type;
-
-    typedef typename is_maybe<typename TaggedArg::value_type>::type holds_maybe;
-
-    typedef typename mpl::eval_if<
-        holds_maybe
-      , get_reference<typename TaggedArg::value_type>
-      , get_reference<TaggedArg>
-    >::type reference;
-
-    typedef typename mpl::if_<
-        holds_maybe
-      , reference
-      , typename TaggedArg::value_type
-    >::type value_type;
+    typedef typename TaggedArg::value_type value_type;
+    typedef typename TaggedArg::reference reference;
 
     TaggedArg arg;      // Stores the argument
 
@@ -184,12 +144,12 @@ struct arg_list : Next
     template< // class A0, class A1, ...
         BOOST_PP_ENUM_PARAMS(BOOST_PARAMETER_MAX_ARITY, class A)
     >
-    arg_list( // A0& a0, A1& a1, ...
-        BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PARAMETER_MAX_ARITY, A, & a)
+    arg_list( // A0 const& a0, A1 const& a1, ...
+        BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PARAMETER_MAX_ARITY, A, const & a)
     )
       : Next( // a1, a2, ...
             BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PARAMETER_MAX_ARITY, a)
-          , void_reference()
+          , void_()
         )
       , arg(a0)
     {}
@@ -197,59 +157,36 @@ struct arg_list : Next
     // Create a new list by prepending arg to a copy of tail.  Used
     // when incrementally building this structure with the comma
     // operator.
-    arg_list(TaggedArg head, Next const& tail)
+    arg_list(TaggedArg arg, Next const& tail)
       : Next(tail)
-      , arg(head)
+      , arg(arg)
     {}
 
+
     // A metafunction class that, given a keyword and a default
     // type, returns the appropriate result type for a keyword
     // lookup given that default
     struct binding
     {
-        template <class KW, class Default, class Reference>
+        template <class KW, class Default>
         struct apply
         {
           typedef typename mpl::eval_if<
                 boost::is_same<KW, key_type>
-              , mpl::if_<Reference, reference, value_type>
-              , mpl::apply_wrap3<typename Next::binding, KW, Default, Reference>
+              , mpl::identity<reference>
+              , mpl::apply_wrap2<typename Next::binding, KW, Default>
           >::type type;
         };
     };
 
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-    // Overload for key_type, so the assert below will fire if the
-    // same keyword is used again
-    static yes_tag has_key(key_type*);
-    using Next::has_key;
-
-    BOOST_MPL_ASSERT_MSG(
-        sizeof(Next::has_key((key_type*)0)) == sizeof(no_tag)
-      , duplicate_keyword, (key_type)
-    );
-
-#endif
     //
     // Begin implementation of indexing operators for looking up
     // specific arguments by name
     //
 
-    // Helpers that handle the case when TaggedArg is
-    // empty<T>.
-    template <class D>
-    reference get_default(D const&, mpl::false_) const
-    {
-        return arg.value;
-    }
-
-    template <class D>
-    reference get_default(D const& d, mpl::true_) const
-    {
-        return arg.value ? arg.value.get() : arg.value.construct(d.value);
-    }
-
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
+    || BOOST_WORKAROUND(__GNUC__, < 3) \
+    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
     // These older compilers don't support the overload set creation
     // idiom well, so we need to do all the return type calculation
     // for the compiler and dispatch through an outer function template
@@ -273,7 +210,7 @@ struct arg_list : Next
     // Outer indexing operators that dispatch to the right node's
     // get() function.
     template <class KW>
-    typename mpl::apply_wrap3<binding, KW, void_, mpl::true_>::type
+    typename mpl::apply_wrap2<binding, KW, void_>::type
     operator[](keyword<KW> const& x) const
     {
         typename mpl::apply_wrap1<key_owner, KW>::type const& sublist = *this;
@@ -281,7 +218,7 @@ struct arg_list : Next
     }
 
     template <class KW, class Default>
-    typename mpl::apply_wrap3<binding, KW, Default&, mpl::true_>::type
+    typename mpl::apply_wrap2<binding, KW, Default&>::type
     operator[](default_<KW, Default> x) const
     {
         typename mpl::apply_wrap1<key_owner, KW>::type const& sublist = *this;
@@ -289,10 +226,9 @@ struct arg_list : Next
     }
 
     template <class KW, class F>
-    typename mpl::apply_wrap3<
+    typename mpl::apply_wrap2<
         binding,KW
       , typename result_of0<F>::type
-      , mpl::true_
     >::type
     operator[](lazy_default<KW,F> x) const
     {
@@ -304,42 +240,39 @@ struct arg_list : Next
     // reached, indicating no matching argument was passed, the
     // default is returned, or if no default_ or lazy_default was
     // passed, compilation fails.
-    reference get(keyword<key_type> const&) const
-    {
-        BOOST_MPL_ASSERT_NOT((holds_maybe));
-        return arg.value;
-    }
-
-    template <class Default>
-    reference get(default_<key_type,Default> const& d) const
-    {
-        return get_default(d, holds_maybe());
-    }
-
-    template <class Default>
-    reference get(lazy_default<key_type, Default>) const
+    reference get(keyword<key_type> const& x) const
     {
         return arg.value;
     }
 
+    template <class Default>
+    reference get(default_<key_type,Default> x) const
+    {
+        return arg.value;
+    }
+
+    template <class Default>
+    reference get(lazy_default<key_type, Default> x) const
+    {
+        return arg.value;
+    }
+    
 #else
 
-    reference operator[](keyword<key_type> const&) const
+    reference operator[](keyword<key_type> const& x) const
     {
-        BOOST_MPL_ASSERT_NOT((holds_maybe));
         return arg.value;
     }
 
     template <class Default>
-    reference operator[](default_<key_type, Default> const& d) const
+    reference operator[](default_<key_type, Default> x) const
     {
-        return get_default(d, holds_maybe());
+        return arg.value;
     }
 
     template <class Default>
-    reference operator[](lazy_default<key_type, Default>) const
+    reference operator[](lazy_default<key_type, Default> x) const
     {
-        BOOST_MPL_ASSERT_NOT((holds_maybe));
         return arg.value;
     }
 
@@ -359,14 +292,10 @@ struct arg_list : Next
     // compile-time computation and never really called, so a
     // declaration is enough.
     //
-    template <class HasDefault, class Predicate, class ArgPack>
-    static typename mpl::apply_wrap2<
-        typename mpl::lambda<Predicate, lambda_tag>::type
-      , value_type, ArgPack
-    >::type
+    template <class HasDefault, class Predicate>
+    static typename mpl::apply1<Predicate, value_type>::type
     satisfies(
         parameter_requirements<key_type,Predicate,HasDefault>*
-      , ArgPack*
     );
 
     // Builds an overload set including satisfies functions defined
@@ -374,64 +303,23 @@ struct arg_list : Next
     using Next::satisfies;
 #endif
 
+#if !BOOST_WORKAROUND(__BORLANDC__,BOOST_TESTED_AT(0x564))
     // Comma operator to compose argument list without using parameters<>.
     // Useful for argument lists with undetermined length.
     template <class KW, class T2>
-    arg_list<tagged_argument<KW, T2>, self>
-    operator,(tagged_argument<KW,T2> x) const
+    arg_list<tagged_argument<KW, T2>, arg_list> 
+    operator,(tagged_argument<KW, T2> x) const
     {
-        return arg_list<tagged_argument<KW,T2>, self>(x, *this);
+        return arg_list<tagged_argument<KW, T2>, arg_list>(x, *this);
     }
-
-    // MPL sequence support
-    typedef self type;             // Convenience for users
-    typedef Next tail_type;        // For the benefit of iterators
-    typedef arg_list_tag tag; // For dispatching to sequence intrinsics
+#endif 
 };
 
-// MPL sequence support
-template <class ArgumentPack>
-struct arg_list_iterator
-{
-    typedef mpl::forward_iterator_tag category;
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)  // ETI workaround
+template <> struct arg_list<int,int> {};
+#endif 
 
-    // The incremented iterator
-    typedef arg_list_iterator<typename ArgumentPack::tail_type> next;
-
-    // dereferencing yields the key type
-    typedef typename ArgumentPack::key_type type;
-};
-
-template <>
-struct arg_list_iterator<empty_arg_list> {};
-
-}} // namespace parameter::aux
-
-// MPL sequence support
-namespace mpl
-{
-  template <>
-  struct begin_impl<parameter::aux::arg_list_tag>
-  {
-      template <class S>
-      struct apply
-      {
-          typedef parameter::aux::arg_list_iterator<S> type;
-      };
-  };
-
-  template <>
-  struct end_impl<parameter::aux::arg_list_tag>
-  {
-      template <class>
-      struct apply
-      {
-          typedef parameter::aux::arg_list_iterator<parameter::aux::empty_arg_list> type;
-      };
-  };
-}
-
-} // namespace boost
+}}} // namespace boost::parameter::aux
 
 #endif // ARG_LIST_050329_HPP
 

include/boost/parameter/aux_/cast.hpp

@@ -1,141 +0,0 @@
-// Copyright Daniel Wallin 2006. Use, modification and distribution is
-// subject to 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)
-
-#ifndef BOOST_PARAMETER_CAST_060902_HPP
-# define BOOST_PARAMETER_CAST_060902_HPP
-
-# include <boost/detail/workaround.hpp>
-
-# if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-#  include <boost/type_traits/add_reference.hpp>
-#  include <boost/type_traits/remove_const.hpp>
-# endif
-
-namespace boost { namespace parameter { namespace aux {
-
-struct use_default_tag {};
-
-# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-
-#  define BOOST_PARAMETER_FUNCTION_CAST(value, predicate) value
-
-# else
-
-// Handles possible implicit casts. Used by preprocessor.hpp to
-// normalize user input.
-//
-// cast<void*>::execute() is identity
-// cast<void*(X)>::execute() is identity
-// cast<void(X)>::execute() casts to X
-//
-// preprocessor.hpp uses this like this:
-//
-//   #define X(value, predicate)
-//      cast<void predicate>::execute(value)
-//
-//   X(something, *)
-//   X(something, *(predicate))
-//   X(something, (int))
-
-template <class T, class Args>
-struct cast;
-
-template <class Args>
-struct cast<void*, Args>
-{
-    static use_default_tag execute(use_default_tag)
-    {
-        return use_default_tag();
-    }
-
-    static use_default_tag remove_const(use_default_tag)
-    {
-        return use_default_tag();
-    }
-
-    template <class U>
-    static U& execute(U& value)
-    {
-        return value;
-    }
-
-    template <class U>
-    static U& remove_const(U& x)
-    {
-        return x;
-    }
-};
-
-#if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x580))
-
-typedef void* voidstar;
-
-template <class T, class Args>
-struct cast<voidstar(T), Args>
-  : cast<void*, Args>
-{
-};
-
-#else
-
-template <class T, class Args>
-struct cast<void*(T), Args>
-  : cast<void*, Args>
-{
-};
-
-#endif
-
-// This is a hack used in cast<> to turn the user supplied type,
-// which may or may not be a placeholder expression into one, so
-// that it will be properly evaluated by mpl::apply.
-template <class T, class Dummy = mpl::_1>
-struct as_placeholder_expr
-{
-    typedef T type;
-};
-
-template <class T, class Args>
-struct cast<void(T), Args>
-{
-    typedef typename mpl::apply2<
-        as_placeholder_expr<T>, Args, Args>::type type0;
-
-    typedef typename boost::add_reference<
-        typename boost::remove_const<type0>::type 
-    >::type reference;
-
-    static use_default_tag execute(use_default_tag)
-    {
-        return use_default_tag();
-    }
-
-    static use_default_tag remove_const(use_default_tag)
-    {
-        return use_default_tag();
-    }
-
-    static type0 execute(type0 value)
-    {
-        return value;
-    }
-
-    template <class U>
-    static reference remove_const(U const& x)
-    {
-        return const_cast<reference>(x);
-    }
-};
-
-#  define BOOST_PARAMETER_FUNCTION_CAST(value, predicate, args) \
-    boost::parameter::aux::cast<void predicate, args>::remove_const( \
-        boost::parameter::aux::cast<void predicate, args>::execute(value) \
-    )
-
-# endif
-
-}}} // namespace boost::parameter::aux
-
-#endif // BOOST_PARAMETER_CAST_060902_HPP
-

include/boost/parameter/aux_/default.hpp

@@ -4,9 +4,7 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 
 #ifndef DEFAULT_050329_HPP
-# define DEFAULT_050329_HPP
-
-# include <boost/detail/workaround.hpp>
+#define DEFAULT_050329_HPP
 
 namespace boost { namespace parameter { namespace aux {
 
@@ -29,7 +27,7 @@ struct default_
 //    the user when resolving the value of the parameter with the
 //    given keyword
 //
-# if BOOST_WORKAROUND(__EDG_VERSION__, <= 300)
+#if BOOST_WORKAROUND(__EDG_VERSION__, <= 300)
 // These compilers need a little extra help with overload
 // resolution; we have empty_arg_list's operator[] accept a base
 // class to make that overload less preferable.
@@ -50,8 +48,8 @@ struct lazy_default
         : lazy_default_base<KW,DefaultComputer>(x)
       {}
   };
-#  define BOOST_PARAMETER_lazy_default_fallback lazy_default_base
-# else 
+# define BOOST_PARAMETER_lazy_default_fallback lazy_default_base
+#else 
 template <class KW, class DefaultComputer>
 struct lazy_default
 {
@@ -60,8 +58,8 @@ struct lazy_default
     {}
     DefaultComputer const& compute_default;
 };
-#  define BOOST_PARAMETER_lazy_default_fallback lazy_default
-# endif 
+# define BOOST_PARAMETER_lazy_default_fallback lazy_default
+#endif 
 
 }}} // namespace boost::parameter::aux
 

include/boost/parameter/aux_/is_maybe.hpp

@@ -1,26 +0,0 @@
-// Copyright Daniel Wallin, David Abrahams 2010. Use, modification and
-// distribution is subject to 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)
-
-#ifndef BOOST_PARAMETER_IS_MAYBE_050329_HPP
-#define BOOST_PARAMETER_IS_MAYBE_050329_HPP
-
-#include <boost/type_traits/is_base_and_derived.hpp>
-
-namespace boost {
-namespace parameter {
-namespace aux {
-
-struct maybe_base {};
-
-template <class T>
-struct is_maybe
-  : is_base_and_derived<maybe_base, T>
-{};
-
-} // namespace aux
-} // namespace parameter
-} // namespace boost
-
-#endif // BOOST_PARAMETER_IS_MAYBE_050329_HPP

include/boost/parameter/aux_/maybe.hpp

@@ -1,120 +0,0 @@
-// Copyright Daniel Wallin 2006. Use, modification and distribution is
-// subject to 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)
-
-//
-// 2009.10.21 TDS remove depenency on boost::python::detail::referent_storage
-//
-#ifndef BOOST_PARAMETER_MAYBE_091021_HPP
-# define BOOST_PARAMETER_MAYBE_091021_HPP
-
-# include <boost/mpl/if.hpp>
-# include <boost/mpl/identity.hpp>
-# include <boost/type_traits/is_reference.hpp>
-# include <boost/type_traits/add_reference.hpp>
-# include <boost/optional.hpp>
-# include <boost/aligned_storage.hpp>
-# include <boost/type_traits/remove_cv.hpp>
-# include <boost/type_traits/add_const.hpp>
-# include <boost/parameter/aux_/is_maybe.hpp>
-
-namespace boost { namespace parameter { namespace aux {
-
-template <class T> struct referent_size;
-
-template <class T>
-struct referent_size<T&>
-{
-  BOOST_STATIC_CONSTANT(std::size_t, value = sizeof(T));
-};
-
-// A metafunction returning a POD type which can store U, where T ==
-// U&. If T is not a reference type, returns a POD which can store T.
-template <class T>
-struct referent_storage
-{
-  typedef typename boost::aligned_storage<
-    referent_size<T>::value
-    >::type type;
-};
-
-template <class T>
-struct maybe : maybe_base
-{
-    typedef typename add_reference<
-# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-        T const
-# else
-        typename add_const<T>::type
-# endif
-    >::type reference;
-
-    typedef typename remove_cv<
-        BOOST_DEDUCED_TYPENAME remove_reference<reference>::type
-    >::type non_cv_value;
-
-    explicit maybe(T value_)
-      : value(value_)
-      , constructed(false)
-    {}
-
-    maybe()
-      : constructed(false)
-    {}
-
-    ~maybe()
-    {
-        if (constructed)
-            this->destroy();
-    }
-
-    reference construct(reference value_) const
-    {
-        return value_;
-    }
-
-    template <class U>
-    reference construct2(U const& value_) const
-    {
-        new (m_storage.address()) non_cv_value(value_);
-        constructed = true;
-        return *(non_cv_value*)m_storage.address();
-    }
-
-    template <class U>
-    reference construct(U const& value_) const
-    {
-        return this->construct2(value_);
-    }
-
-    void destroy()
-    {
-        ((non_cv_value*)m_storage.address())->~non_cv_value();
-    }
-
-    typedef reference(maybe<T>::*safe_bool)() const;
-
-    operator safe_bool() const
-    {
-        return value ? &maybe<T>::get : 0 ;
-    }
-
-    reference get() const
-    {
-        return value.get();
-    }
-
-private:
-    boost::optional<T> value;
-    mutable bool constructed;
-
-
-    mutable typename referent_storage<
-        reference
-    >::type m_storage;
-};
-
-}}} // namespace boost::parameter::aux
-
-#endif // BOOST_PARAMETER_MAYBE_060211_HPP
-

include/boost/parameter/aux_/overloads.hpp

@@ -6,26 +6,21 @@
 // This file generates overloads in this format:
 //
 //     template<class A0, class A1>
-//     typename mpl::apply_wrap1<
-//         aux::make_arg_list<
+//     typename aux::make_arg_list<
+//         PS0,A0
+//       , aux::make_arg_list<
+//             PS1,A1
+//           , mpl::identity<aux::empty_arg_list>
+//         >
+//     >::type
+//     operator()(A0 const& a0, A1 const& a1) const
+//     {
+//         typedef typename aux::make_arg_list<
 //             PS0,A0
 //           , aux::make_arg_list<
 //                 PS1,A1
 //               , mpl::identity<aux::empty_arg_list>
 //             >
-//         >
-//      , unnamed_list
-//     >::type
-//     operator()(A0 const& a0, A1 const& a1) const
-//     {
-//         typedef typename mpl::apply_wrap1<
-//             aux::make_arg_list<
-//                 PS0,A0
-//               , aux::make_arg_list<
-//                     PS1,A1
-//                   , mpl::identity<aux::empty_arg_list>
-//                 >
-//             >
 //         >::type arg_tuple;
 //
 //         return arg_tuple(
@@ -44,40 +39,27 @@
 #define N BOOST_PP_ITERATION()
 
 #define BOOST_PARAMETER_open_list(z, n, text) \
-    aux::item< \
-        BOOST_PP_CAT(PS, n), BOOST_PP_CAT(A, n)
+    aux::make_arg_list< \
+        BOOST_PP_CAT(PS, n), BOOST_PP_CAT(A, n) \
 
 #define BOOST_PARAMETER_close_list(z, n, text) > 
 
 #define BOOST_PARAMETER_arg_list(n) \
-    aux::make_arg_list< \
-        BOOST_PP_ENUM(N, BOOST_PARAMETER_open_list, _) \
-      , void_ \
-        BOOST_PP_REPEAT(N, BOOST_PARAMETER_close_list, _) \
-      , deduced_list \
-      , aux::tag_keyword_arg \
-    >
-
-#define BOOST_PARAMETER_arg_pack_init(z, n, limit) \
-    BOOST_PP_CAT(a, BOOST_PP_SUB(limit,n))
+    BOOST_PP_ENUM(N, BOOST_PARAMETER_open_list, _) \
+  , mpl::identity<aux::empty_arg_list> \
+    BOOST_PP_REPEAT(N, BOOST_PARAMETER_close_list, _) 
 
 template<BOOST_PP_ENUM_PARAMS(N, class A)>
-typename mpl::first<
-    typename BOOST_PARAMETER_arg_list(N)::type
->::type
-operator()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, & a)) const
+typename BOOST_PARAMETER_arg_list(N)::type
+operator()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& a)) const
 {
-    typedef typename BOOST_PARAMETER_arg_list(N)::type result;
+    typedef typename BOOST_PARAMETER_arg_list(N)::type arg_tuple;
 
-    typedef typename mpl::first<result>::type result_type;
-    typedef typename mpl::second<result>::type error;
-    error();
-
-    return result_type(
-        BOOST_PP_ENUM(N, BOOST_PARAMETER_arg_pack_init, BOOST_PP_DEC(N))
+    return arg_tuple(
+        BOOST_PP_ENUM_PARAMS(N, a)
         BOOST_PP_ENUM_TRAILING_PARAMS(
             BOOST_PP_SUB(BOOST_PARAMETER_MAX_ARITY, N)
-          , aux::void_reference() BOOST_PP_INTERCEPT
+          , aux::void_() BOOST_PP_INTERCEPT
         ));
 }
 

include/boost/parameter/aux_/parenthesized_type.hpp

@@ -1,35 +0,0 @@
-// Copyright David Abrahams 2006. 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)
-#ifndef BOOST_PARAMETER_AUX_PARENTHESIZED_TYPE_DWA2006414_HPP
-# define BOOST_PARAMETER_AUX_PARENTHESIZED_TYPE_DWA2006414_HPP
-
-# include <boost/config.hpp>
-# include <boost/detail/workaround.hpp>
-
-namespace boost { namespace parameter { namespace aux { 
-
-// A macro that takes a parenthesized C++ type name (T) and transforms
-// it into an un-parenthesized type expression equivalent to T.
-#  define BOOST_PARAMETER_PARENTHESIZED_TYPE(x)                    \
-    boost::parameter::aux::unaryfunptr_arg_type< void(*)x >::type
-
-// A metafunction that transforms void(*)(T) -> T
-template <class UnaryFunctionPointer>
-struct unaryfunptr_arg_type;
-
-template <class Arg>
-struct unaryfunptr_arg_type<void(*)(Arg)>
-{
-    typedef Arg type;
-};
-
-template <>
-struct unaryfunptr_arg_type<void(*)(void)>
-{
-    typedef void type;
-};
-    
-}}} // namespace boost::parameter::aux
-
-#endif // BOOST_PARAMETER_AUX_PARENTHESIZED_TYPE_DWA2006414_HPP

include/boost/parameter/aux_/preprocessor/flatten.hpp

@@ -1,115 +0,0 @@
-// Copyright Daniel Wallin 2005. Use, modification and distribution is
-// subject to 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)
-
-#ifndef BOOST_PARAMETER_FLATTEN_051217_HPP
-# define BOOST_PARAMETER_FLATTEN_051217_HPP
-
-# include <boost/preprocessor/tuple/elem.hpp>
-# include <boost/preprocessor/tuple/rem.hpp>
-# include <boost/preprocessor/cat.hpp>
-# include <boost/preprocessor/seq/for_each.hpp>
-# include <boost/preprocessor/seq/for_each_i.hpp>
-# include <boost/preprocessor/identity.hpp>
-# include <boost/preprocessor/selection/max.hpp>
-# include <boost/preprocessor/arithmetic/sub.hpp>
-# include <boost/preprocessor/repetition/enum_trailing.hpp>
-# include <boost/parameter/aux_/preprocessor/for_each.hpp>
-
-# define BOOST_PARAMETER_FLATTEN_SPLIT_required required,
-# define BOOST_PARAMETER_FLATTEN_SPLIT_optional optional,
-# define BOOST_PARAMETER_FLATTEN_SPLIT_deduced deduced,
-
-# define BOOST_PARAMETER_FLATTEN_SPLIT(sub) \
-    BOOST_PP_CAT(BOOST_PARAMETER_FLATTEN_SPLIT_, sub)
-
-# define BOOST_PARAMETER_FLATTEN_QUALIFIER(sub) \
-    BOOST_PP_SPLIT(0, BOOST_PARAMETER_FLATTEN_SPLIT(sub))
-
-# define BOOST_PARAMETER_FLATTEN_ARGS(sub) \
-    BOOST_PP_SPLIT(1, BOOST_PARAMETER_FLATTEN_SPLIT(sub))
-
-# define BOOST_PARAMETER_FLATTEN_ARITY_optional(arities) \
-    BOOST_PP_TUPLE_ELEM(3,0,arities)
-
-# define BOOST_PARAMETER_FLATTEN_ARITY_required(arities) \
-    BOOST_PP_TUPLE_ELEM(3,1,arities)
-
-# define BOOST_PARAMETER_FLATTEN_SPEC0_DUMMY_ELEM(z, n, data) ~
-# define BOOST_PARAMETER_FLATTEN_SPEC0(r, n, elem, data) \
-    (( \
-        BOOST_PP_TUPLE_ELEM(3,2,data) \
-      , BOOST_PP_TUPLE_REM(BOOST_PP_TUPLE_ELEM(3,0,data)) elem \
-        BOOST_PP_ENUM_TRAILING( \
-            BOOST_PP_SUB( \
-                BOOST_PP_TUPLE_ELEM(3,1,data) \
-              , BOOST_PP_TUPLE_ELEM(3,0,data) \
-            ) \
-          , BOOST_PARAMETER_FLATTEN_SPEC0_DUMMY_ELEM \
-          , ~ \
-        ) \
-    ))
-
-# define BOOST_PARAMETER_FLATTEN_SPEC_AUX(r, arity, max_arity, spec, transform) \
-    BOOST_PARAMETER_FOR_EACH_R( \
-        r \
-      , arity \
-      , BOOST_PARAMETER_FLATTEN_ARGS(spec) \
-      , (arity, max_arity, transform(BOOST_PARAMETER_FLATTEN_QUALIFIER(spec))) \
-      , BOOST_PARAMETER_FLATTEN_SPEC0 \
-    )
-
-# define BOOST_PARAMETER_FLATTEN_IDENTITY(x) x
-
-# define BOOST_PARAMETER_FLATTEN_SPEC_optional(r, arities, spec) \
-    BOOST_PARAMETER_FLATTEN_SPEC_AUX( \
-        r \
-      , BOOST_PP_CAT( \
-            BOOST_PARAMETER_FLATTEN_ARITY_, BOOST_PARAMETER_FLATTEN_QUALIFIER(spec) \
-        )(arities) \
-      , BOOST_PP_TUPLE_ELEM(3,2,arities) \
-      , spec \
-      , BOOST_PARAMETER_FLATTEN_IDENTITY \
-    )
-
-# define BOOST_PARAMETER_FLATTEN_SPEC_required(r, arities, spec) \
-    BOOST_PARAMETER_FLATTEN_SPEC_optional(r, arities, spec)
-
-# define BOOST_PARAMETER_FLATTEN_SPEC_AS_DEDUCED(x) BOOST_PP_CAT(deduced_,x)
-
-# define BOOST_PARAMETER_FLATTEN_SPEC_deduced_M(r, arities, n, spec) \
-    BOOST_PARAMETER_FLATTEN_SPEC_AUX( \
-        r \
-      , BOOST_PP_CAT( \
-            BOOST_PARAMETER_FLATTEN_ARITY_, BOOST_PARAMETER_FLATTEN_QUALIFIER(spec) \
-        )(arities) \
-      , BOOST_PP_TUPLE_ELEM(3,2,arities) \
-      , spec \
-      , BOOST_PARAMETER_FLATTEN_SPEC_AS_DEDUCED \
-    )
-
-# define BOOST_PARAMETER_FLATTEN_SPEC_deduced(r, arities, spec) \
-    BOOST_PP_SEQ_FOR_EACH_I_R( \
-        r \
-      , BOOST_PARAMETER_FLATTEN_SPEC_deduced_M \
-      , arities \
-      , BOOST_PARAMETER_FLATTEN_ARGS(spec) \
-    )
-
-# define BOOST_PARAMETER_FLATTEN_SPEC(r, arities, spec) \
-    BOOST_PP_CAT( \
-        BOOST_PARAMETER_FLATTEN_SPEC_, BOOST_PARAMETER_FLATTEN_QUALIFIER(spec) \
-    )(r, arities, spec)
-
-# define BOOST_PARAMETER_FLATTEN(optional_arity, required_arity, wanted_arity, specs) \
-    BOOST_PP_SEQ_FOR_EACH( \
-        BOOST_PARAMETER_FLATTEN_SPEC \
-      , ( \
-            optional_arity, required_arity \
-          , wanted_arity \
-        ) \
-      , specs \
-    )
-
-#endif // BOOST_PARAMETER_FLATTEN_051217_HPP
-

include/boost/parameter/aux_/preprocessor/for_each.hpp

@@ -1,103 +0,0 @@
-// Copyright Daniel Wallin 2005. Use, modification and distribution is
-// subject to 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)
-
-#ifndef BOOST_PARAMETER_FOR_EACH_051217_HPP
-# define BOOST_PARAMETER_FOR_EACH_051217_HPP
-
-# include <boost/preprocessor/cat.hpp>
-# include <boost/preprocessor/detail/split.hpp>
-# include <boost/preprocessor/logical/not.hpp>
-# include <boost/preprocessor/facilities/is_empty.hpp>
-# include <boost/preprocessor/tuple/eat.hpp>
-# include <boost/preprocessor/arithmetic/inc.hpp>
-# include <boost/preprocessor/repeat.hpp>
-# include <boost/preprocessor/punctuation/comma_if.hpp>
-# include <boost/preprocessor/for.hpp>
-# include <boost/preprocessor/repetition/deduce_r.hpp>
-
-# define BOOST_PARAMETER_FOR_EACH_head_aux2(x,y) (x,y), ~
-# define BOOST_PARAMETER_FOR_EACH_head_aux3(x,y,z) (x,y,z), ~
-# define BOOST_PARAMETER_FOR_EACH_head_aux4(x,y,z,u) (x,y,z,u), ~
-# define BOOST_PARAMETER_FOR_EACH_head(n,x) \
-    BOOST_PP_SPLIT(0, BOOST_PP_CAT(BOOST_PARAMETER_FOR_EACH_head_aux,n) x)
-
-# define BOOST_PARAMETER_FOR_EACH_pred_aux_BOOST_PARAMETER_FOR_EACH_END_SENTINEL
-# define BOOST_PARAMETER_FOR_EACH_pred_aux_check(x) \
-    BOOST_PP_NOT(BOOST_PP_IS_EMPTY( \
-        BOOST_PP_CAT(BOOST_PARAMETER_FOR_EACH_pred_aux_, x) \
-    )), ~
-
-# define BOOST_PARAMETER_FOR_EACH_pred_aux2(x,y) \
-    BOOST_PARAMETER_FOR_EACH_pred_aux_check(x)
-# define BOOST_PARAMETER_FOR_EACH_pred_aux3(x,y,z) \
-    BOOST_PARAMETER_FOR_EACH_pred_aux_check(x)
-# define BOOST_PARAMETER_FOR_EACH_pred_aux4(x,y,z,u) \
-    BOOST_PARAMETER_FOR_EACH_pred_aux_check(x)
-
-# define BOOST_PARAMETER_FOR_EACH_pred_aux0(n,x) \
-    BOOST_PP_CAT(BOOST_PARAMETER_FOR_EACH_pred_aux,n) x
-
-# if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC()
-#  define BOOST_PARAMETER_FOR_EACH_pred_SPLIT_FIRST(x) \
-    BOOST_PP_SPLIT(0, x)
-
-#  define BOOST_PARAMETER_FOR_EACH_pred(r, state) \
-    BOOST_PARAMETER_FOR_EACH_pred_SPLIT_FIRST( \
-        BOOST_PARAMETER_FOR_EACH_pred_aux0( \
-            BOOST_PP_TUPLE_ELEM(5,3,state) \
-          , BOOST_PP_TUPLE_ELEM(5,0,state) \
-        ) \
-    )
-# else
-#  define BOOST_PARAMETER_FOR_EACH_pred(r, state) \
-    BOOST_PP_SPLIT( \
-        0 \
-      , BOOST_PARAMETER_FOR_EACH_pred_aux0( \
-            BOOST_PP_TUPLE_ELEM(5,3,state) \
-          , BOOST_PP_TUPLE_ELEM(5,0,state) \
-        ) \
-    )
-# endif
-
-# define BOOST_PARAMETER_FOR_EACH_op(r, state) \
-    ( \
-        BOOST_PP_TUPLE_EAT(BOOST_PP_TUPLE_ELEM(5,3,state)) \
-          BOOST_PP_TUPLE_ELEM(5,0,state) \
-      , BOOST_PP_TUPLE_ELEM(5,1,state) \
-      , BOOST_PP_TUPLE_ELEM(5,2,state) \
-      , BOOST_PP_TUPLE_ELEM(5,3,state) \
-      , BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(5,4,state)) \
-    )
-
-# define BOOST_PARAMETER_FOR_EACH_macro(r, state) \
-    BOOST_PP_TUPLE_ELEM(5,2,state)( \
-        r \
-      , BOOST_PP_TUPLE_ELEM(5,4,state) \
-      , BOOST_PARAMETER_FOR_EACH_head( \
-            BOOST_PP_TUPLE_ELEM(5,3,state) \
-          , BOOST_PP_TUPLE_ELEM(5,0,state) \
-        ) \
-      , BOOST_PP_TUPLE_ELEM(5,1,state) \
-    )
-
-# define BOOST_PARAMETER_FOR_EACH_build_end_sentinel(z,n,text) \
-    BOOST_PP_COMMA_IF(n) BOOST_PARAMETER_FOR_EACH_END_SENTINEL
-# define BOOST_PARAMETER_FOR_EACH_build_end_sentinel_tuple(arity) \
-    ( \
-        BOOST_PP_REPEAT(arity, BOOST_PARAMETER_FOR_EACH_build_end_sentinel, _) \
-    )
-
-# define BOOST_PARAMETER_FOR_EACH_R(r, arity, list, data, macro) \
-    BOOST_PP_CAT(BOOST_PP_FOR_, r)( \
-        (list BOOST_PARAMETER_FOR_EACH_build_end_sentinel_tuple(arity), data, macro, arity, 0) \
-      , BOOST_PARAMETER_FOR_EACH_pred \
-      , BOOST_PARAMETER_FOR_EACH_op \
-      , BOOST_PARAMETER_FOR_EACH_macro \
-    )
-
-# define BOOST_PARAMETER_FOR_EACH(arity, list, data, macro) \
-    BOOST_PARAMETER_FOR_EACH_R(BOOST_PP_DEDUCE_R(), arity, list, data, macro)
-
-#endif // BOOST_PARAMETER_FOR_EACH_051217_HPP
-

include/boost/parameter/aux_/set.hpp

@@ -1,66 +0,0 @@
-// Copyright Daniel Wallin 2006. Use, modification and distribution is
-// subject to 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)
-
-#ifndef BOOST_PARAMETER_SET_060912_HPP
-# define BOOST_PARAMETER_SET_060912_HPP
-
-# include <boost/detail/workaround.hpp>
-
-# if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-#  include <boost/mpl/insert.hpp>
-#  include <boost/mpl/set/set0.hpp>
-#  include <boost/mpl/has_key.hpp>
-
-namespace boost { namespace parameter { namespace aux {
-
-typedef mpl::set0<> set0;
-
-template <class Set, class K>
-struct insert_
-{
-    typedef typename mpl::insert<Set, K>::type type;
-};
-
-template <class Set, class K>
-struct has_key_
-{
-    typedef typename mpl::has_key<Set, K>::type type;
-};
-
-}}} // namespace boost::parameter::aux
-
-# else
-
-#  include <boost/mpl/list.hpp>
-#  include <boost/mpl/end.hpp>
-#  include <boost/mpl/find.hpp>
-#  include <boost/mpl/not.hpp>
-#  include <boost/mpl/push_front.hpp>
-
-namespace boost { namespace parameter { namespace aux {
-
-typedef mpl::list0<> set0;
-
-template <class Set, class K>
-struct insert_
-{
-    typedef typename mpl::push_front<Set, K>::type type;
-};
-
-template <class Set, class K>
-struct has_key_
-{
-    typedef typename mpl::find<Set, K>::type iter;
-    typedef mpl::not_<
-        is_same<iter, typename mpl::end<Set>::type> 
-    > type;
-};
-
-}}} // namespace boost::parameter::aux
-
-# endif
-
-
-#endif // BOOST_PARAMETER_SET_060912_HPP
-

include/boost/parameter/aux_/tag.hpp

@@ -5,10 +5,12 @@
 # define BOOST_PARAMETER_AUX_TAG_DWA2005610_HPP
 
 # include <boost/parameter/aux_/unwrap_cv_reference.hpp>
-# include <boost/parameter/aux_/tagged_argument.hpp>
 
 namespace boost { namespace parameter { namespace aux { 
 
+template <class Keyword, class Arg>
+struct tagged_argument;
+
 template <class Keyword, class ActualArg
 #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
         , class = typename is_cv_reference_wrapper<ActualArg>::type

include/boost/parameter/aux_/tagged_argument.hpp

@@ -3,32 +3,19 @@
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef BOOST_PARAMETER_TAGGED_ARGUMENT_050328_HPP
-# define BOOST_PARAMETER_TAGGED_ARGUMENT_050328_HPP
+#ifndef TAGGED_ARGUMENT_050328_HPP
+#define TAGGED_ARGUMENT_050328_HPP
 
-# include <boost/parameter/aux_/void.hpp>
-# include <boost/parameter/aux_/arg_list.hpp>
-# include <boost/parameter/aux_/result_of0.hpp>
-# include <boost/mpl/if.hpp>
-# include <boost/mpl/apply_wrap.hpp>
-# include <boost/mpl/and.hpp>
-# include <boost/mpl/not.hpp>
-# include <boost/type_traits/is_same.hpp>
-# include <boost/type_traits/is_convertible.hpp>
-# include <boost/type_traits/is_reference.hpp>
+#include <boost/parameter/aux_/void.hpp>
+#include <boost/parameter/aux_/arg_list.hpp>
 
 namespace boost { namespace parameter { namespace aux {
 
-struct empty_arg_list;
-struct arg_list_tag;
-
-struct tagged_argument_base {};
-
 // Holds a reference to an argument of type Arg associated with
 // keyword Keyword
     
 template <class Keyword, class Arg>
-struct tagged_argument : tagged_argument_base
+struct tagged_argument
 {
     typedef Keyword key_type;
     typedef Arg value_type;
@@ -36,22 +23,6 @@ struct tagged_argument : tagged_argument_base
 
     tagged_argument(reference x) : value(x) {}
 
-    // A metafunction class that, given a keyword and a default
-    // type, returns the appropriate result type for a keyword
-    // lookup given that default
-    struct binding
-    {
-        template <class KW, class Default, class Reference>
-        struct apply
-        {
-          typedef typename mpl::eval_if<
-                boost::is_same<KW, key_type>
-              , mpl::if_<Reference, reference, value_type>
-              , mpl::identity<Default>
-          >::type type;
-        };
-    };
-
     // Comma operator to compose argument list without using parameters<>.
     // Useful for argument lists with undetermined length.
     template <class Keyword2, class Arg2>
@@ -69,120 +40,15 @@ struct tagged_argument : tagged_argument_base
           , arg_list<tagged_argument<Keyword2, Arg2> >(x, empty_arg_list())
         );
     }
-
-    reference operator[](keyword<Keyword> const&) const
-    {
-        return value;
-    }
-
-# if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-    template <class KW, class Default>
-    Default& get_with_default(default_<KW,Default> const& x, int) const
-    {
-        return x.value;
-    }
-
-    template <class Default>
-    reference get_with_default(default_<key_type,Default> const&, long) const
-    {
-        return value;
-    }
-
-    template <class KW, class Default>
-    typename mpl::apply_wrap3<binding, KW, Default&, mpl::true_>::type
-    operator[](default_<KW,Default> const& x) const
-    {
-        return get_with_default(x, 0L);
-    }
-
-    template <class KW, class F>
-    typename result_of0<F>::type 
-    get_with_lazy_default(lazy_default<KW,F> const& x, int) const
-    {
-        return x.compute_default();
-    }
-
-    template <class F>
-    reference get_with_lazy_default(lazy_default<key_type,F> const&, long) const
-    {
-        return value;
-    }
-
-    template <class KW, class F>
-    typename mpl::apply_wrap3<
-        binding,KW
-      , typename result_of0<F>::type
-      , mpl::true_
-    >::type
-    operator[](lazy_default<KW,F> const& x) const
-    {
-        return get_with_lazy_default(x, 0L);
-    }
-# else
-    template <class Default>
-    reference operator[](default_<key_type,Default> const& ) const
-    {
-        return value;
-    }
-
-    template <class F>
-    reference operator[](lazy_default<key_type,F> const& ) const
-    {
-        return value;
-    }
-
-    template <class KW, class Default>
-    Default& operator[](default_<KW,Default> const& x) const
-    {
-        return x.value;
-    }
-
-    template <class KW, class F>
-    typename result_of0<F>::type operator[](lazy_default<KW,F> const& x) const
-    {
-        return x.compute_default();
-    }
-
-    template <class ParameterRequirements>
-    static typename ParameterRequirements::has_default
-    satisfies(ParameterRequirements*);
-
-    template <class HasDefault, class Predicate>
-    static typename mpl::apply1<Predicate, value_type>::type
-    satisfies(
-        parameter_requirements<key_type,Predicate,HasDefault>*
-    );
-# endif
-
+    
     reference value;
-# if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
-    // warning suppression
- private:
-    void operator=(tagged_argument const&);
- public:    
-# endif
-    // MPL sequence support
-    typedef tagged_argument type;            // Convenience for users
-    typedef empty_arg_list tail_type;        // For the benefit of iterators
-    typedef arg_list_tag tag; // For dispatching to sequence intrinsics
 };
 
 // Defines a metafunction, is_tagged_argument, that identifies
-// tagged_argument specializations and their derived classes.
-template <class T>
-struct is_tagged_argument_aux
-  : is_convertible<T*,tagged_argument_base const*>
-{};
-
-template <class T>
-struct is_tagged_argument
-  : mpl::and_<
-        mpl::not_<is_reference<T> >
-      , is_tagged_argument_aux<T>
-    >
-{};
+// tagged_argument specializations.
+BOOST_PYTHON_IS_XXX_DEF(tagged_argument,tagged_argument,2)
 
 }}} // namespace boost::parameter::aux
 
-#endif // BOOST_PARAMETER_TAGGED_ARGUMENT_050328_HPP
+#endif // TAGGED_ARGUMENT_050328_HPP
 

include/boost/parameter/aux_/template_keyword.hpp

@@ -1,47 +0,0 @@
-// Copyright Daniel Wallin 2006. Use, modification and distribution is
-// subject to 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)
-
-#ifndef BOOST_PARAMETER_TEMPLATE_KEYWORD_060203_HPP
-# define BOOST_PARAMETER_TEMPLATE_KEYWORD_060203_HPP
-
-# include <boost/mpl/and.hpp>
-# include <boost/mpl/not.hpp>
-# include <boost/type_traits/is_convertible.hpp>
-# include <boost/type_traits/is_reference.hpp>
-
-namespace boost { namespace parameter { 
-
-namespace aux 
-{
-
-  struct template_keyword_tag {}; 
-
-  template <class T, class U>
-  struct is_pointer_convertible
-    : is_convertible<T*, U*>
-  {};
-
-  template <class T>
-  struct is_template_keyword
-    : mpl::and_<
-          mpl::not_<is_reference<T> >
-        , is_pointer_convertible<T, template_keyword_tag>
-      >
-  {};
-
-} // namespace aux
-
-template <class Tag, class T>
-struct template_keyword
-  : aux::template_keyword_tag
-{
-    typedef Tag key_type;
-    typedef T value_type;
-    typedef value_type reference;
-};
-
-}} // namespace boost::parameter
-
-#endif // BOOST_PARAMETER_TEMPLATE_KEYWORD_060203_HPP
-

include/boost/parameter/aux_/unwrap_cv_reference.hpp

@@ -44,6 +44,12 @@ struct is_cv_reference_wrapper
     value> type;
 };
 
+#if BOOST_WORKAROUND(MSVC, == 1200)
+template <>
+struct is_cv_reference_wrapper<int>
+  : mpl::false_ {};
+#endif
+
 // Needed for unwrap_cv_reference below. T might be const, so
 // eval_if might fail because of deriving from T const on EDG.
 template <class T>

include/boost/parameter/aux_/void.hpp

@@ -3,27 +3,16 @@
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef BOOST_PARAMETER_VOID_050329_HPP
-#define BOOST_PARAMETER_VOID_050329_HPP
+#ifndef VOID_050329_HPP
+#define VOID_050329_HPP
 
-namespace boost { namespace parameter { 
+namespace boost { namespace parameter { namespace aux {
 
 // A placemarker for "no argument passed."
 // MAINTAINER NOTE: Do not make this into a metafunction
 struct void_ {}; 
 
-namespace aux 
-{
+}}} // namespace boost::parameter::aux
 
-  inline void_& void_reference()
-  {
-      static void_ instance;
-      return instance;
-  }
-
-} // namespace aux
-
-}} // namespace boost::parameter
-
-#endif // BOOST_PARAMETER_VOID_050329_HPP
+#endif // VOID_050329_HPP
 

include/boost/parameter/binding.hpp

@@ -5,59 +5,37 @@
 # define BOOST_PARAMETER_BINDING_DWA200558_HPP
 
 # include <boost/mpl/apply.hpp>
-# include <boost/mpl/assert.hpp>
-# include <boost/mpl/and.hpp>
 # include <boost/parameter/aux_/result_of0.hpp>
-# include <boost/parameter/aux_/void.hpp>
-# include <boost/type_traits/is_same.hpp>
+
+#  include <boost/parameter/aux_/void.hpp>
+
+# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+#  include <boost/parameter/aux_/void.hpp>
+#  include <boost/type_traits/is_same.hpp>
+# endif 
 
 namespace boost { namespace parameter { 
 
 // A metafunction that, given an argument pack, returns the type of
 // the parameter identified by the given keyword.  If no such
 // parameter has been specified, returns Default
-
-# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-template <class Parameters, class Keyword, class Default>
-struct binding0
-{
-    typedef typename mpl::apply_wrap3<
-        typename Parameters::binding,Keyword,Default,mpl::true_
-    >::type type;
-
-    BOOST_MPL_ASSERT_NOT((
-        mpl::and_<
-            is_same<Default, void_>
-          , is_same<type, void_>
-        >
-    ));
-};
-# endif
-
-template <class Parameters, class Keyword, class Default = void_>
+# if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+template <class Parameters, class Keyword, class Default = void>
+struct binding
+  : mpl::apply_wrap2<
+        typename Parameters::binding,Keyword,Default
+    >
+{};
+# else
+template <class Parameters, class Keyword, class Default = aux::void_>
 struct binding
 {
-# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-    typedef typename mpl::eval_if<
-        mpl::is_placeholder<Parameters>
-      , mpl::identity<int>
-      , binding0<Parameters,Keyword,Default>
+    typedef typename mpl::apply_wrap2<
+        typename Parameters::binding,Keyword,
+        typename mpl::if_<is_same<Default,aux::void_>,void,Default>::type
     >::type type;
-# else
-    typedef typename mpl::apply_wrap3<
-        typename Parameters::binding,Keyword,Default,mpl::true_
-    >::type type;
-
-    BOOST_MPL_ASSERT_NOT((
-        mpl::and_<
-            is_same<Default, void_>
-          , is_same<type, void_>
-        >
-    ));
-# endif
-
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(3,binding,(Parameters,Keyword,Default))
 };
+# endif
 
 // A metafunction that, given an argument pack, returns the type of
 // the parameter identified by the given keyword.  If no such
@@ -66,11 +44,10 @@ struct binding
 template <class Parameters, class Keyword, class DefaultFn>
 struct lazy_binding
 {
-  typedef typename mpl::apply_wrap3<
+  typedef typename mpl::apply_wrap2<
       typename Parameters::binding
     , Keyword
     , typename aux::result_of0<DefaultFn>::type
-    , mpl::true_
   >::type type;
 };
 

include/boost/parameter/config.hpp

@@ -7,7 +7,7 @@
 #define BOOST_PARAMETER_CONFIG_050403_HPP
 
 #ifndef BOOST_PARAMETER_MAX_ARITY
-# define BOOST_PARAMETER_MAX_ARITY 8
+# define BOOST_PARAMETER_MAX_ARITY 5
 #endif
 
 #endif // BOOST_PARAMETER_CONFIG_050403_HPP

include/boost/parameter/keyword.hpp

@@ -9,6 +9,7 @@
 #include <boost/parameter/aux_/unwrap_cv_reference.hpp>
 #include <boost/parameter/aux_/tag.hpp>
 #include <boost/parameter/aux_/default.hpp>
+#include <boost/noncopyable.hpp>
 
 namespace boost { namespace parameter {
 
@@ -28,10 +29,10 @@ namespace boost { namespace parameter {
 //    f(rate = 1, skew = 2.4);
 //
 template <class Tag>
-struct keyword
+struct keyword : noncopyable
 {
     template <class T>
-    typename aux::tag<Tag, T>::type const
+    typename aux::tag<Tag, T>::type
     operator=(T& x) const
     {
         typedef typename aux::tag<Tag, T>::type result;
@@ -52,17 +53,23 @@ struct keyword
         return aux::lazy_default<Tag, Default>(default_);
     }
 
+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1200)  // avoid partial ordering bugs
     template <class T>
-    typename aux::tag<Tag, T const>::type const
+    typename aux::tag<Tag, T const>::type
     operator=(T const& x) const
     {
         typedef typename aux::tag<Tag, T const>::type result;
         return result(x);
     }
+#endif 
 
+#if !BOOST_WORKAROUND(BOOST_MSVC, == 1200)  // avoid partial ordering bugs
     template <class Default>
     aux::default_<Tag, const Default>
     operator|(const Default& default_) const
+#if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
+        volatile
+#endif 
     {
         return aux::default_<Tag, const Default>(default_);
     }
@@ -70,9 +77,13 @@ struct keyword
     template <class Default>
     aux::lazy_default<Tag, Default>
     operator||(Default const& default_) const
+#if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
+        volatile
+#endif 
     {
         return aux::lazy_default<Tag, Default>(default_);
     }
+#endif
 
  public: // Insurance against ODR violations
     
@@ -81,40 +92,26 @@ struct keyword
     // every instantiation of a function template is the same object.
     // We provide a reference to a common instance of each keyword
     // object and prevent construction by users.
-    static keyword<Tag> const instance;
-
-    // This interface is deprecated
+    
     static keyword<Tag>& get()
     {
-        return const_cast<keyword<Tag>&>(instance);
+        static keyword<Tag> result;
+        return result;
     }
+    
+ private:
+    keyword() {}
 };
 
-template <class Tag>
-keyword<Tag> const keyword<Tag>::instance = {};
-
 // Reduces boilerplate required to declare and initialize keywords
 // without violating ODR.  Declares a keyword tag type with the given
-// name in namespace tag_namespace, and declares and initializes a
-// reference in an anonymous namespace to a singleton instance of that
-// type.
+// name in namespace tag_namespace, and declares and initializes a 
+// 
+#define BOOST_PARAMETER_KEYWORD(tag_namespace,name)             \
+   namespace tag_namespace { struct name; }                     \
+   ::boost::parameter::keyword<tag_namespace::name>& name       \
+   = ::boost::parameter::keyword<tag_namespace::name>::get();
 
-#define BOOST_PARAMETER_KEYWORD(tag_namespace,name)                 \
-    namespace tag_namespace                                         \
-    {                                                               \
-      struct name                                                   \
-      {                                                             \
-          static char const* keyword_name()                         \
-          {                                                         \
-              return #name;                                         \
-          }                                                         \
-      };                                                            \
-    }                                                               \
-    namespace                                                       \
-    {                                                               \
-       ::boost::parameter::keyword<tag_namespace::name> const& name \
-       = ::boost::parameter::keyword<tag_namespace::name>::instance;\
-    }
 
 }} // namespace boost::parameter
 

include/boost/parameter/macros.hpp

@@ -15,14 +15,13 @@
 #include <boost/preprocessor/repetition/enum_params.hpp>
 #include <boost/preprocessor/repetition/enum_binary_params.hpp>
 #include <boost/preprocessor/cat.hpp>
-#include <boost/detail/workaround.hpp>
 
 #define BOOST_PARAMETER_FUN_TEMPLATE_HEAD1(n) \
     template<BOOST_PP_ENUM_PARAMS(n, class T)>
 
 #define BOOST_PARAMETER_FUN_TEMPLATE_HEAD0(n)
 
-#if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592)) 
+#ifndef BOOST_NO_SFINAE
 
 # define BOOST_PARAMETER_MATCH_TYPE(n, param)           \
             BOOST_PP_EXPR_IF(n, typename) param::match  \
@@ -79,7 +78,7 @@
 #define BOOST_PARAMETER_FUN(ret, name, lo, hi, parameters)                          \
                                                                                     \
     template<class Params>                                                          \
-    ret BOOST_PP_CAT(name, _with_named_params)(Params const& p);                    \
+    ret BOOST_PP_CAT(name, _with_named_params)(Params const&);                      \
                                                                                     \
     BOOST_PP_REPEAT_FROM_TO(                                                        \
         lo, BOOST_PP_INC(hi), BOOST_PARAMETER_FUN_DECL, (ret, name, parameters))    \

include/boost/parameter/match.hpp

@@ -29,7 +29,7 @@
                 BOOST_PARAMETER_MAX_ARITY                       \
               , BOOST_PP_SEQ_SIZE(ArgTypes)                     \
             )                                                   \
-          , ::boost::parameter::void_ BOOST_PP_INTERCEPT   \
+          , ::boost::parameter::aux::void_ BOOST_PP_INTERCEPT   \
         )
 
 # else

include/boost/parameter/name.hpp

@@ -1,146 +0,0 @@
-// Copyright Daniel Wallin 2006. Use, modification and distribution is
-// subject to 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)
-
-#ifndef BOOST_PARAMETER_NAME_060806_HPP
-# define BOOST_PARAMETER_NAME_060806_HPP
-
-# include <boost/parameter/keyword.hpp>
-# include <boost/parameter/value_type.hpp>
-# include <boost/detail/workaround.hpp>
-# include <boost/preprocessor/cat.hpp>
-# include <boost/preprocessor/stringize.hpp>
-# include <boost/preprocessor/control/iif.hpp>
-# include <boost/preprocessor/tuple/eat.hpp>
-# include <boost/preprocessor/tuple/elem.hpp>
-# include <boost/mpl/placeholders.hpp>
-
-# if !defined(BOOST_NO_SFINAE) \
-  && !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
-
-#  include <boost/utility/enable_if.hpp>
-#  include <boost/mpl/lambda.hpp>
-
-namespace boost { namespace parameter { namespace aux {
-
-// Tag type passed to MPL lambda.
-struct lambda_tag;
-
-struct name_tag_base
-{};
-
-template <class Tag>
-struct name_tag
-{};
-
-template <class T>
-struct is_name_tag
-  : mpl::false_
-{};
-
-}}} // namespace boost::parameter::aux
-
-namespace boost { namespace mpl {
-
-template <class T>
-struct lambda<
-    T
-  , typename boost::enable_if<
-        parameter::aux::is_name_tag<T>, parameter::aux::lambda_tag
-    >::type
->
-{
-    typedef true_ is_le;
-    typedef bind3< quote3<parameter::value_type>, arg<2>, T, void> result_;
-    typedef result_ type;
-};
-
-}} // namespace boost::mpl
-
-# endif
-
-# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-# include <boost/preprocessor/detail/split.hpp>
-// From Paul Mensonides
-#  define BOOST_PARAMETER_IS_BINARY(x) \
-    BOOST_PP_SPLIT(1, BOOST_PARAMETER_IS_BINARY_C x BOOST_PP_COMMA() 0) \
-    /**/
-#  define BOOST_PARAMETER_IS_BINARY_C(x,y) \
-    ~, 1 BOOST_PP_RPAREN() \
-    BOOST_PP_TUPLE_EAT(2) BOOST_PP_LPAREN() ~ \
-    /**/
-# else
-#  include <boost/preprocessor/detail/is_binary.hpp>
-#  define BOOST_PARAMETER_IS_BINARY(x) BOOST_PP_IS_BINARY(x)
-# endif
-
-# define BOOST_PARAMETER_BASIC_NAME(tag_namespace, tag, name)       \
-    namespace tag_namespace                                         \
-    {                                                               \
-      struct tag                                                    \
-      {                                                             \
-          static char const* keyword_name()                         \
-          {                                                         \
-              return BOOST_PP_STRINGIZE(tag);                       \
-          }                                                         \
-                                                                    \
-          typedef boost::parameter::value_type<                     \
-              boost::mpl::_2, tag, boost::parameter::void_          \
-          > _;                                                      \
-                                                                    \
-          typedef boost::parameter::value_type<                     \
-              boost::mpl::_2, tag, boost::parameter::void_          \
-          > _1;                                                     \
-      };                                                            \
-    }                                                               \
-    namespace                                                       \
-    {                                                               \
-       ::boost::parameter::keyword<tag_namespace::tag> const& name  \
-       = ::boost::parameter::keyword<tag_namespace::tag>::instance; \
-    }
-
-# define BOOST_PARAMETER_COMPLEX_NAME_TUPLE1(tag,namespace)         \
-    (tag, namespace), ~
-
-# define BOOST_PARAMETER_COMPLEX_NAME_TUPLE(name)                   \
-    BOOST_PP_TUPLE_ELEM(2, 0, (BOOST_PARAMETER_COMPLEX_NAME_TUPLE1 name))
-
-# define BOOST_PARAMETER_COMPLEX_NAME_TAG(name)                     \
-    BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PARAMETER_COMPLEX_NAME_TUPLE(name))
-
-# define BOOST_PARAMETER_COMPLEX_NAME_NAMESPACE(name)               \
-    BOOST_PP_TUPLE_ELEM(2, 1, BOOST_PARAMETER_COMPLEX_NAME_TUPLE(name))
-
-# define BOOST_PARAMETER_COMPLEX_NAME(name)                         \
-    BOOST_PARAMETER_BASIC_NAME(                                     \
-        BOOST_PARAMETER_COMPLEX_NAME_NAMESPACE(name)                \
-      , BOOST_PP_TUPLE_EAT(2) name                                  \
-      , BOOST_PARAMETER_COMPLEX_NAME_TAG(name)                      \
-    )                                                               \
-/**/
-
-# define BOOST_PARAMETER_SIMPLE_NAME(name)                          \
-    BOOST_PARAMETER_BASIC_NAME(tag, name, BOOST_PP_CAT(_, name))
-
-# define BOOST_PARAMETER_NAME(name)                                 \
-    BOOST_PP_IIF(                                                   \
-        BOOST_PARAMETER_IS_BINARY(name)                             \
-      , BOOST_PARAMETER_COMPLEX_NAME                                \
-      , BOOST_PARAMETER_SIMPLE_NAME                                 \
-    )(name)                                                         \
-/**/
-
-
-# define BOOST_PARAMETER_TEMPLATE_KEYWORD(name)                     \
-    namespace tag                                                   \
-    {                                                               \
-      struct name;                                                  \
-    }                                                               \
-    template <class T>                                              \
-    struct name                                                     \
-      : boost::parameter::template_keyword<tag::name, T>            \
-    {};                                                             \
-/**/
-
-#endif // BOOST_PARAMETER_NAME_060806_HPP
-

include/boost/parameter/parameters.hpp

@@ -6,10 +6,6 @@
 #ifndef BOOST_PARAMETERS_031014_HPP
 #define BOOST_PARAMETERS_031014_HPP
 
-#include <boost/detail/is_xxx.hpp>
-
-#include <boost/type_traits/is_const.hpp>
-
 #include <boost/mpl/lambda.hpp>
 #include <boost/mpl/apply.hpp>
 #include <boost/mpl/always.hpp>
@@ -19,16 +15,16 @@
 #include <boost/mpl/identity.hpp>
 #include <boost/mpl/not.hpp>
 #include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/pair.hpp>
 
 #include <boost/type_traits/is_same.hpp>
 #include <boost/type_traits/remove_reference.hpp>
+#include <boost/iterator/detail/config_def.hpp>
+#include <boost/python/detail/is_xxx.hpp>
 
 #include <boost/preprocessor/repetition/enum.hpp>
 #include <boost/preprocessor/repetition/enum_params.hpp>
 #include <boost/preprocessor/repetition/enum_trailing_params.hpp>
 #include <boost/preprocessor/arithmetic/sub.hpp>
-#include <boost/preprocessor/repetition/repeat.hpp>
 #include <boost/preprocessor/repetition/enum_shifted.hpp>
 #include <boost/preprocessor/repetition/enum_binary_params.hpp>
 #include <boost/preprocessor/repetition/enum_shifted_params.hpp>
@@ -44,20 +40,8 @@
 #include <boost/parameter/aux_/unwrap_cv_reference.hpp>
 #include <boost/parameter/aux_/tagged_argument.hpp>
 #include <boost/parameter/aux_/tag.hpp>
-#include <boost/parameter/aux_/template_keyword.hpp>
-#include <boost/parameter/aux_/set.hpp>
 #include <boost/parameter/config.hpp>
 
-namespace parameter_
-{
-  template <class T>
-  struct unmatched_argument
-  {
-      BOOST_MPL_ASSERT((boost::is_same<T,void>));
-      typedef int type;
-  }; 
-} // namespace parameter_
-
 namespace boost {
 
 template<class T> class reference_wrapper;
@@ -81,9 +65,6 @@ namespace aux { struct use_default {}; }
 // required<...>, wrapper, it is treated as though optional<k> were
 // specified.
 //
-// If a keyword k is specified with deduced<...>, that keyword
-// will be automatically deduced from the argument list.
-//
 template <class Tag, class Predicate = aux::use_default>
 struct required
 {
@@ -99,7 +80,7 @@ struct optional
 };
 
 template <class Tag>
-struct deduced
+struct unnamed
 {
     typedef Tag key_type;
 };
@@ -107,28 +88,9 @@ struct deduced
 namespace aux
 {
   // Defines metafunctions, is_required and is_optional, that
-  // identify required<...>, optional<...> and deduced<...> specializations.
-  BOOST_DETAIL_IS_XXX_DEF(required, required, 2)
-  BOOST_DETAIL_IS_XXX_DEF(optional, optional, 2)
-  BOOST_DETAIL_IS_XXX_DEF(deduced_aux, deduced, 1)
-
-  template <class S>
-  struct is_deduced0
-    : is_deduced_aux<
-          typename S::key_type
-      >::type
-  {};
-
-  template <class S>
-  struct is_deduced
-    : mpl::eval_if<
-          mpl::or_<
-              is_optional<S>, is_required<S>
-          >
-        , is_deduced0<S>
-        , mpl::false_
-      >::type
-  {};
+  // identify required<...> and optional<...> specializations.
+  BOOST_PYTHON_IS_XXX_DEF(required, required, 2)
+  BOOST_PYTHON_IS_XXX_DEF(optional, optional, 2)
 
   //
   // key_type, has_default, and predicate --
@@ -139,41 +101,32 @@ namespace aux
   // argument type is required match.
   //
   // a ParameterSpec is a specialization of either keyword<...>,
-  // required<...>, optional<...>
+  // required<...> or optional<...>.
   //
-
+  
   // helper for key_type<...>, below.
   template <class T>
-  struct get_tag_type0
-  {
-      typedef typename T::key_type type;
-  };
+  struct get_key_type
+  { typedef typename T::key_type type; };
 
   template <class T>
-  struct get_tag_type
-    : mpl::eval_if<
-          is_deduced_aux<typename T::key_type>
-        , get_tag_type0<typename T::key_type>
-        , mpl::identity<typename T::key_type>
-      >
-  {};
-
-  template <class T>
-  struct tag_type
+  struct key_type
     : mpl::eval_if<
           mpl::or_<
               is_optional<T>
             , is_required<T>
           >
-        , get_tag_type<T>
+        , get_key_type<T>
         , mpl::identity<T>
       >
-  {};
+  {
+  };
 
   template <class T>
   struct has_default
-    : mpl::not_<is_required<T> >
-  {};
+    : mpl::not_<typename is_required<T>::type>
+  {
+  };
 
   // helper for get_predicate<...>, below
   template <class T>
@@ -213,26 +166,37 @@ namespace aux
 
   // Converts a ParameterSpec into a specialization of
   // parameter_requirements.  We need to do this in order to get the
-  // tag_type into the type in a way that can be conveniently matched
+  // key_type into the type in a way that can be conveniently matched
   // by a satisfies(...) member function in arg_list.
   template <class ParameterSpec>
   struct as_parameter_requirements
   {
       typedef parameter_requirements<
-          typename tag_type<ParameterSpec>::type
+          typename key_type<ParameterSpec>::type
         , typename predicate<ParameterSpec>::type
         , typename has_default<ParameterSpec>::type
       > type;
   };
 
-  template <class T>
-  struct is_named_argument
-    : mpl::or_<
-          is_template_keyword<T>
-        , is_tagged_argument<T>
+  // Labels Arg with default keyword tag DefaultTag if it is not
+  // already a tagged_argument
+  template <class DefaultTag, class Arg>
+  struct as_tagged_argument
+    : mpl::eval_if<
+          is_tagged_argument<Arg>
+        , mpl::identity<Arg>
+        , tag<typename key_type<DefaultTag>::type, Arg const>
       >
   {};
   
+#if BOOST_WORKAROUND(BOOST_MSVC, == 1200)  // ETI workaround
+  template <>
+  struct as_tagged_argument<int,int>
+  {
+      typedef int type;
+  };
+#endif
+
   // Returns mpl::true_ iff the given ParameterRequirements are
   // satisfied by ArgList.
   template <class ArgList, class ParameterRequirements>
@@ -241,22 +205,18 @@ namespace aux
 #if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
       // VC7.1 can't handle the sizeof() implementation below,
       // so we use this instead.
-      typedef typename mpl::apply_wrap3<
+      typedef typename mpl::apply_wrap2<
           typename ArgList::binding
         , typename ParameterRequirements::keyword
         , void_
-        , mpl::false_
       >::type bound;
 
       typedef typename mpl::eval_if<
           is_same<bound, void_>
         , typename ParameterRequirements::has_default
-        , mpl::apply_wrap2<
-              typename mpl::lambda<
-                  typename ParameterRequirements::predicate, lambda_tag
-              >::type
-            , bound
-            , ArgList
+        , mpl::apply1<
+              typename ParameterRequirements::predicate
+            , typename remove_reference<bound>::type
           >
       >::type type;
 #else
@@ -264,7 +224,7 @@ namespace aux
           bool, value = (
               sizeof(
                   aux::to_yesno(
-                      ArgList::satisfies((ParameterRequirements*)0, (ArgList*)0)
+                      ArgList::satisfies((ParameterRequirements*)0)
                   )
               ) == sizeof(yes_tag)
           )
@@ -284,368 +244,34 @@ namespace aux
       >
   {};
 
-  // Tags a deduced argument Arg with the keyword tag of Spec using TagFn.
-  // Returns the tagged argument and the mpl::set<> UsedArgs with the
-  // tag of Spec inserted.
-  template <class UsedArgs, class Spec, class Arg, class TagFn>
-  struct tag_deduced
+  // Helper for make_partial_arg_list, below.  Produce an arg_list
+  // node for the given ParameterSpec and ArgumentType, whose tail is
+  // determined by invoking the nullary metafunction TailFn.
+  template <class ParameterSpec, class ArgumentType, class TailFn>
+  struct make_arg_list
   {
-      typedef mpl::pair<
-          typename mpl::apply_wrap2<TagFn, typename tag_type<Spec>::type, Arg>::type
-        , typename aux::insert_<UsedArgs, typename tag_type<Spec>::type>::type
+      typedef arg_list<
+          typename as_tagged_argument<ParameterSpec,ArgumentType>::type
+        , typename TailFn::type
       > type;
   };
 
+  // Just like make_arg_list, except if ArgumentType is void_, the
+  // result is empty_arg_list.  Used to build arg_lists whose length
+  // depends on the number of non-default (void_) arguments passed to
+  // a class template.
   template <
-      class Argument
-    , class ArgumentPack
-    , class DeducedArgs
-    , class UsedArgs
-    , class TagFn
+      class ParameterSpec
+    , class ArgumentType
+    , class TailFn
   >
-  struct deduce_tag;
-
-  // Tag type passed to MPL lambda.
-  struct lambda_tag;
-
-  // Helper for deduce_tag<> below.
-  template <
-      class Argument
-    , class ArgumentPack
-    , class DeducedArgs
-    , class UsedArgs
-    , class TagFn
-  >
-  struct deduce_tag0
-  {
-      typedef typename DeducedArgs::spec spec;
-
-      typedef typename mpl::apply_wrap2<
-          typename mpl::lambda<
-              typename spec::predicate, lambda_tag
-          >::type
-        , Argument
-        , ArgumentPack
-      >::type condition;
-
-      // Deduced parameter matches several arguments.
-
-      BOOST_MPL_ASSERT((
-          mpl::not_<mpl::and_<
-              condition
-            , aux::has_key_<UsedArgs, typename tag_type<spec>::type>
-          > >
-      ));
-
-      typedef typename mpl::eval_if<
-          condition
-        , tag_deduced<UsedArgs, spec, Argument, TagFn>
-        , deduce_tag<Argument, ArgumentPack, typename DeducedArgs::tail, UsedArgs, TagFn>
-      >::type type;
-  };
-
-  // Tries to deduced a keyword tag for a given Argument.
-  // Returns an mpl::pair<> consisting of the tagged_argument<>, 
-  // and an mpl::set<> where the new tag has been inserted.
-  //
-  //  Argument: The argument type to be tagged.
-  //
-  //  ArgumentPack: The ArgumentPack built so far.
-  //
-  //  DeducedArgs: A specialization of deduced_item<> (see below).
-  //               A list containing only the deduced ParameterSpecs.
-  //
-  //  UsedArgs: An mpl::set<> containing the keyword tags used so far.
-  //
-  //  TagFn: A metafunction class used to tag positional or deduced
-  //         arguments with a keyword tag.
-
-  template <
-      class Argument
-    , class ArgumentPack
-    , class DeducedArgs
-    , class UsedArgs
-    , class TagFn
-  >
-  struct deduce_tag
-  {
-      typedef typename mpl::eval_if<
-          is_same<DeducedArgs, void_>
-        , mpl::pair<void_, UsedArgs>
-        , deduce_tag0<Argument, ArgumentPack, DeducedArgs, UsedArgs, TagFn>
-      >::type type;
-  };
-
-  template <
-      class List
-    , class DeducedArgs
-    , class TagFn
-    , class Positional
-    , class UsedArgs
-    , class ArgumentPack
-    , class Error
-  >
-  struct make_arg_list_aux;
-
-  // Inserts Tagged::key_type into the UserArgs set.
-  // Extra indirection to lazily evaluate Tagged::key_type.
-  template <class UsedArgs, class Tagged>
-  struct insert_tagged
-  {
-      typedef typename aux::insert_<
-          UsedArgs, typename Tagged::key_type
-      >::type type;
-  };
-
-  // Borland needs the insane extra-indirection workaround below
-  // so that it doesn't magically drop the const qualifier from
-  // the argument type.
-
-  template <
-      class List
-    , class DeducedArgs
-    , class TagFn
-    , class Positional
-    , class UsedArgs
-    , class ArgumentPack
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-    , class argument
-#endif
-    , class Error
-  >
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-  struct make_arg_list00
-#else
-  struct make_arg_list0
-#endif
-  {
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-      typedef typename List::arg argument;
-#endif
-      typedef typename List::spec parameter_spec;
-      typedef typename tag_type<parameter_spec>::type tag_;
-
-      typedef is_named_argument<argument> is_tagged;
-
-      // If this argument is either explicitly tagged or a deduced
-      // parameter, we turn off positional matching.
-      typedef mpl::and_<
-          mpl::not_<
-              mpl::or_<is_deduced<parameter_spec>, is_tagged> 
-          > 
-        , Positional
-      > positional;
-
-      // If this parameter is explicitly tagged we add it to the
-      // used-parmeters set. We only really need to add parameters
-      // that are deduced, but we would need a way to check if
-      // a given tag corresponds to a deduced parameter spec.
-      typedef typename mpl::eval_if<
-          is_tagged
-        , insert_tagged<UsedArgs, argument>
-        , mpl::identity<UsedArgs>
-      >::type used_args;
-
-      // If this parameter is neither explicitly tagged, nor
-      // positionally matched; deduce the tag from the deduced
-      // parameter specs.
-      typedef typename mpl::eval_if<
-          mpl::or_<is_tagged, positional>
-        , mpl::pair<void_, used_args>
-        , deduce_tag<argument, ArgumentPack, DeducedArgs, used_args, TagFn>
-      >::type deduced_data;
-
-      // If this parameter is explicitly tagged..
-      typedef typename mpl::eval_if<
-          is_tagged
-        , mpl::identity<argument>                        // .. just use it
-        , mpl::eval_if<                                  // .. else, if positional matching is turned on..
-                positional
-              , mpl::apply_wrap2<TagFn, tag_, argument>  // .. tag it positionally
-              , mpl::first<deduced_data>                 // .. else, use the deduced tag
-          >
-      >::type tagged;
-
-      // We build the arg_list incrementally as we go, prepending new
-      // nodes.
-
-      typedef typename mpl::if_<
-          mpl::and_<
-              is_same<Error, void_>
-            , is_same<tagged, void_>
-          >
-        , parameter_::unmatched_argument<argument>
-        , void_
-      >::type error;
-
-      typedef typename mpl::if_<
-          is_same<tagged, void_>
-        , ArgumentPack
-        , arg_list<tagged, ArgumentPack>
-      >::type argument_pack;
-
-      typedef typename make_arg_list_aux<
-          typename List::tail
-        , DeducedArgs
-        , TagFn
-        , positional
-        , typename deduced_data::second
-        , argument_pack
-        , error
-      >::type type;
-  };
-
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-  template <
-      class List
-    , class DeducedArgs
-    , class TagFn
-    , class Positional
-    , class UsedArgs
-    , class ArgumentPack
-    , class Error
-  >
-  struct make_arg_list0
-  {
-      typedef typename mpl::eval_if<
-          typename List::is_arg_const
-        , make_arg_list00<
-              List
-            , DeducedArgs
-            , TagFn
-            , Positional
-            , UsedArgs
-            , ArgumentPack
-            , typename List::arg const
-            , Error
-          >
-        , make_arg_list00<
-              List
-            , DeducedArgs
-            , TagFn
-            , Positional
-            , UsedArgs
-            , ArgumentPack
-            , typename List::arg
-            , Error
-          >
-      >::type type;
-  };
-#endif
-
-  // Returns an ArgumentPack where the list of arguments has
-  // been tagged with keyword tags.
-  //
-  //   List: A specialization of item<> (see below). Contains
-  //         both the ordered ParameterSpecs, and the given arguments.
-  //
-  //   DeducedArgs: A specialization of deduced_item<> (see below).
-  //                A list containing only the deduced ParameterSpecs.
-  //
-  //   TagFn: A metafunction class used to tag positional or deduced
-  //          arguments with a keyword tag.
-  //
-  //   Position: An mpl::bool_<> specialization indicating if positional
-  //             matching is to be performed.
-  //
-  //   DeducedSet: An mpl::set<> containing the keyword tags used so far.
-  //
-  //   ArgumentPack: The ArgumentPack built so far. This is initially an
-  //                 empty_arg_list and is built incrementally.
-  //
-
-  template <
-      class List
-    , class DeducedArgs
-    , class TagFn
-    , class Positional
-    , class DeducedSet
-    , class ArgumentPack
-    , class Error
-  >
-  struct make_arg_list_aux
-  {
-      typedef typename mpl::eval_if<
-          is_same<List, void_>
-        , mpl::identity<mpl::pair<ArgumentPack, Error> >
-        , make_arg_list0<List, DeducedArgs, TagFn, Positional, DeducedSet, ArgumentPack, Error>
-      >::type type;
-  };
-
-  // VC6.5 was choking on the default parameters for make_arg_list_aux, so
-  // this just forwards to that adding in the defaults.
-  template <
-      class List
-    , class DeducedArgs
-    , class TagFn
-    , class EmitErrors = mpl::true_
-  >
-  struct make_arg_list
-  {
-      typedef typename make_arg_list_aux<
-          List, DeducedArgs, TagFn, mpl::true_, aux::set0, empty_arg_list, void_
-      >::type type;
-  };
-
-  // A parameter spec item typelist.
-  template <class Spec, class Arg, class Tail = void_>
-  struct item
-  {
-      typedef Spec spec;
-
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-      typedef is_const<Arg> is_arg_const;
-#endif
-
-      typedef Arg arg;
-      typedef Tail tail;
-  };
-
-  template <class Spec, class Arg, class Tail>
-  struct make_item
-  {
-      typedef item<Spec, Arg, typename Tail::type> type;
-  };
-
-  // Creates a item typelist.
-  template <class Spec, class Arg, class Tail>
-  struct make_items
-  {
-      typedef typename mpl::eval_if<
-          is_same<Arg, void_>
-        , mpl::identity<void_>
-        , make_item<Spec, Arg, Tail>
-      >::type type;
-  };
-
-  // A typelist that stored deduced parameter specs.
-  template <class ParameterSpec, class Tail = void_>
-  struct deduced_item
-  {
-      typedef ParameterSpec spec;
-      typedef Tail tail;
-  };
-
-  // Evaluate Tail and construct deduced_item list.
-  template <class Spec, class Tail>
-  struct make_deduced_item
-  {
-      typedef deduced_item<Spec, typename Tail::type> type;
-  };
-
-  template <class Spec, class Tail>
-  struct make_deduced_items
-  {
-      typedef typename mpl::eval_if<
-          is_same<Spec, void_>
-        , mpl::identity<void_>
-        , mpl::eval_if<
-              is_deduced<Spec>
-            , make_deduced_item<Spec, Tail>
-            , Tail
-          >
-      >::type type;
-  };
+  struct make_partial_arg_list
+    : mpl::eval_if<
+          is_same<ArgumentType,void_>
+        , mpl::identity<empty_arg_list>
+        , make_arg_list<ParameterSpec, ArgumentType, TailFn>
+      >
+  {};
 
   // Generates:
   //
@@ -659,53 +285,19 @@ namespace aux
 #define BOOST_PARAMETER_make_arg_list(z, n, names)      \
       BOOST_PP_SEQ_ELEM(0,names)<                       \
           BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(1,names), n),  \
-          BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(2,names), n), 
-
-#define BOOST_PARAMETER_right_angle(z, n, text) >
+          BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(2,names), n),
 
+#define BOOST_PARAMETER_right_angle(z, n, text)    >
+    
 #define BOOST_PARAMETER_build_arg_list(n, make, parameter_spec, argument_type)      \
   BOOST_PP_REPEAT(                                                                  \
       n, BOOST_PARAMETER_make_arg_list, (make)(parameter_spec)(argument_type))      \
-      mpl::identity<void_>                                                          \
+  mpl::identity<aux::empty_arg_list>                                                \
   BOOST_PP_REPEAT(n, BOOST_PARAMETER_right_angle, _)
 
-#define BOOST_PARAMETER_make_deduced_list(z, n, names)  \
-      BOOST_PP_SEQ_ELEM(0,names)<                       \
-          BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(1,names), n),
-
-#define BOOST_PARAMETER_build_deduced_list(n, make, parameter_spec)                 \
-  BOOST_PP_REPEAT(                                                                  \
-      n, BOOST_PARAMETER_make_deduced_list, (make)(parameter_spec))                 \
-  mpl::identity<void_>                                                              \
-  BOOST_PP_REPEAT(n, BOOST_PARAMETER_right_angle, _)
-
-  struct tag_keyword_arg
-  {
-      template <class K, class T>
-      struct apply
-        : tag<K,T>
-      {};
-  };
-
-  struct tag_template_keyword_arg
-  {
-      template <class K, class T>
-      struct apply
-      {
-          typedef template_keyword<K,T> type;
-      };
-  };
-
 } // namespace aux
 
-#define BOOST_PARAMETER_FORWARD_TYPEDEF(z, i, names) \
-    typedef BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(0,names),i) BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(1,names),i);
-
-#define BOOST_PARAMETER_FORWARD_TYPEDEFS(n, src, dest) \
-    BOOST_PP_REPEAT(n, BOOST_PARAMETER_FORWARD_TYPEDEF, (src)(dest))
-
-
-#define BOOST_PARAMETER_TEMPLATE_ARGS(z, n, text) class BOOST_PP_CAT(PS, n) = void_
+#define BOOST_PARAMETER_TEMPLATE_ARGS(z, n, text) class BOOST_PP_CAT(PS, n) = aux::void_
 
 template<
      class PS0
@@ -715,21 +307,17 @@ struct parameters
 {
 #undef BOOST_PARAMETER_TEMPLATE_ARGS
 
-    typedef typename BOOST_PARAMETER_build_deduced_list(
-        BOOST_PARAMETER_MAX_ARITY, aux::make_deduced_items, PS
-    )::type deduced_list;
-
     // if the elements of NamedList match the criteria of overload
     // resolution, returns a type which can be constructed from
     // parameters.  Otherwise, this is not a valid metafunction (no nested
     // ::type).
 
 
-#if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
+#ifndef BOOST_NO_SFINAE
     // If NamedList satisfies the PS0, PS1, ..., this is a
     // metafunction returning parameters.  Otherwise it 
     // has no nested ::type.
-    template <class ArgumentPackAndError>
+    template <class NamedList>
     struct match_base
       : mpl::if_<
             // mpl::and_<
@@ -739,23 +327,18 @@ struct parameters
             //           ..., mpl::true_
             // ...> >
             
-# define BOOST_PARAMETER_satisfies(z, n, text)                                      \
+# define BOOST_PARAMETER_satisfies(z, n, text)                                   \
             mpl::and_<                                                              \
-                aux::satisfies_requirements_of<                                     \
-                    typename mpl::first<ArgumentPackAndError>::type                 \
-                  , BOOST_PP_CAT(PS, n)>                                            \
-                  ,
-            mpl::and_<
-                is_same<typename mpl::second<ArgumentPackAndError>::type, void_>
-              , BOOST_PP_REPEAT(BOOST_PARAMETER_MAX_ARITY, BOOST_PARAMETER_satisfies, _)
-                mpl::true_
-                BOOST_PP_REPEAT(BOOST_PARAMETER_MAX_ARITY, BOOST_PARAMETER_right_angle, _)
-            >
+                aux::satisfies_requirements_of<NamedList, BOOST_PP_CAT(PS, n)> ,
+      
+            BOOST_PP_REPEAT(BOOST_PARAMETER_MAX_ARITY, BOOST_PARAMETER_satisfies, _)
+            mpl::true_
+            BOOST_PP_REPEAT(BOOST_PARAMETER_MAX_ARITY, BOOST_PARAMETER_right_angle, _)
 
 # undef BOOST_PARAMETER_satisfies
 
           , mpl::identity<parameters>
-          , void_
+          , aux::void_
         >
     {};
 #endif
@@ -770,21 +353,16 @@ struct parameters
         BOOST_PP_ENUM_PARAMS(BOOST_PARAMETER_MAX_ARITY, class A)
 #else 
         BOOST_PP_ENUM_BINARY_PARAMS(
-            BOOST_PARAMETER_MAX_ARITY, class A, = void_ BOOST_PP_INTERCEPT
+            BOOST_PARAMETER_MAX_ARITY, class A, = aux::void_ BOOST_PP_INTERCEPT
         )
-#endif
+#endif            
     >
     struct match
-# if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
+# ifndef BOOST_NO_SFINAE
       : match_base<
-            typename aux::make_arg_list<
-                typename BOOST_PARAMETER_build_arg_list(
-                    BOOST_PARAMETER_MAX_ARITY, aux::make_items, PS, A
-                )::type
-              , deduced_list
-              , aux::tag_keyword_arg
-              , mpl::false_ // Don't emit errors when doing SFINAE
-            >::type
+            typename BOOST_PARAMETER_build_arg_list(
+                BOOST_PARAMETER_MAX_ARITY, aux::make_partial_arg_list, PS, A
+            )::type
         >::type
     {};
 # else
@@ -795,123 +373,64 @@ struct parameters
     };
 # endif
 
-    // Metafunction that returns an ArgumentPack.
-
-    // TODO, bind has to instantiate the error type in the result
-    // of make_arg_list.
-
-    template <
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-        // Borland simply can't handle default arguments in member
-        // class templates.  People wishing to write portable code can
-        // explicitly specify BOOST_PARAMETER_MAX_ARITY arguments
-        BOOST_PP_ENUM_PARAMS(BOOST_PARAMETER_MAX_ARITY, class A)
-#else 
-        BOOST_PP_ENUM_BINARY_PARAMS(
-            BOOST_PARAMETER_MAX_ARITY, class A, = void_ BOOST_PP_INTERCEPT
-        )
-#endif            
-    >
-    struct bind
-    {
-        typedef typename aux::make_arg_list<
-            typename BOOST_PARAMETER_build_arg_list(
-                BOOST_PARAMETER_MAX_ARITY, aux::make_items, PS, A
-            )::type
-          , deduced_list
-          , aux::tag_template_keyword_arg
-        >::type result;
-
-        typedef typename mpl::first<result>::type type;
-    };
-
-    BOOST_PARAMETER_FORWARD_TYPEDEFS(BOOST_PARAMETER_MAX_ARITY, PS, parameter_spec)
-
     //
     // The function call operator is used to build an arg_list that
     // labels the positional parameters and maintains whatever other
     // tags may have been specified by the caller.
     //
-    // !!!NOTE!!!
-    //
-    // The make_arg_list<> produces a reversed arg_list, so
-    // we need to pass the arguments to its constructor
-    // reversed.
-    //
     aux::empty_arg_list operator()() const
     {
        return aux::empty_arg_list();
     }
 
     template<class A0>
-    typename mpl::first<
-        typename aux::make_arg_list<
-            aux::item<
-                PS0,A0
-            >
-          , deduced_list
-          , aux::tag_keyword_arg
-        >::type
-    >::type
-    operator()(A0& a0) const
+    typename
+      aux::make_arg_list<PS0,A0, mpl::identity<aux::empty_arg_list> >
+    ::type
+    operator()( A0 const& a0) const
     {
-        typedef typename aux::make_arg_list<
-            aux::item<
-                PS0,A0
-            >
-          , deduced_list
-          , aux::tag_keyword_arg
-        >::type result;
-
-        typedef typename mpl::first<result>::type result_type;
-        typedef typename mpl::second<result>::type error;
-        error();
+        typedef typename
+          aux::make_arg_list<PS0, A0, mpl::identity<aux::empty_arg_list> >
+        ::type result_type;
 
         return result_type(
             a0
             // , void_(), void_(), void_() ...
             BOOST_PP_ENUM_TRAILING_PARAMS(
                 BOOST_PP_SUB(BOOST_PARAMETER_MAX_ARITY, 1)
-              , aux::void_reference() BOOST_PP_INTERCEPT)
+              , aux::void_() BOOST_PP_INTERCEPT)
         );
     }
 
     template<class A0, class A1>
-    typename mpl::first<
-        typename aux::make_arg_list<
-            aux::item<
-                PS0,A0
-              , aux::item<
-                    PS1,A1
-                >
-            >
-          , deduced_list
-          , aux::tag_keyword_arg
-        >::type
-    >::type
-    operator()(A0& a0, A1& a1) const
+    typename
+      aux::make_arg_list<
+          PS0,A0
+        , aux::make_arg_list<
+              PS1,A1
+            , mpl::identity<aux::empty_arg_list>
+          >
+      >
+    ::type
+    operator()(A0 const& a0, A1 const& a1) const
     {
-        typedef typename aux::make_arg_list<
-            aux::item<
-                PS0,A0
-              , aux::item<
-                    PS1,A1
-                >
-            >
-          , deduced_list
-          , aux::tag_keyword_arg
-        >::type result;
+        typedef typename
+          aux::make_arg_list<
+              PS0,A0
+            , aux::make_arg_list<
+                  PS1,A1
+                , mpl::identity<aux::empty_arg_list>
+              >
+          >
+        ::type result_type;
 
-        typedef typename mpl::first<result>::type result_type;
-        typedef typename mpl::second<result>::type error;
-        error();
 
         return result_type(
-            a1,a0
+            a0, a1
             // , void_(), void_() ...
             BOOST_PP_ENUM_TRAILING_PARAMS(
                 BOOST_PP_SUB(BOOST_PARAMETER_MAX_ARITY, 2)
-              , aux::void_reference() BOOST_PP_INTERCEPT)
+              , aux::void_() BOOST_PP_INTERCEPT)
         );
     }
 
@@ -920,6 +439,10 @@ struct parameters
         3,BOOST_PARAMETER_MAX_ARITY,<boost/parameter/aux_/overloads.hpp> \
     ))
 #include BOOST_PP_ITERATE()
+    
+#undef BOOST_PARAMETER_build_arg_list
+#undef BOOST_PARAMETER_make_arg_list
+#undef BOOST_PARAMETER_right_angle
 
 };
 
@@ -927,5 +450,7 @@ struct parameters
 
 } // namespace boost
 
+#include <boost/iterator/detail/config_undef.hpp>
+ 
 #endif // BOOST_PARAMETERS_031014_HPP
 

include/boost/parameter/value_type.hpp

@@ -1,82 +0,0 @@
-// Copyright Daniel Wallin 2006. Use, modification and distribution is
-// subject to 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)
-
-#ifndef BOOST_PARAMETER_VALUE_TYPE_060921_HPP
-# define BOOST_PARAMETER_VALUE_TYPE_060921_HPP
-
-# include <boost/mpl/apply.hpp>
-# include <boost/mpl/assert.hpp>
-# include <boost/mpl/and.hpp>
-# include <boost/parameter/aux_/result_of0.hpp>
-# include <boost/parameter/aux_/void.hpp>
-# include <boost/type_traits/is_same.hpp>
-
-namespace boost { namespace parameter { 
-
-// A metafunction that, given an argument pack, returns the type of
-// the parameter identified by the given keyword.  If no such
-// parameter has been specified, returns Default
-
-# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-template <class Parameters, class Keyword, class Default>
-struct value_type0
-{
-    typedef typename mpl::apply_wrap3<
-        typename Parameters::binding,Keyword,Default,mpl::false_
-    >::type type;
-
-    BOOST_MPL_ASSERT_NOT((
-        mpl::and_<
-            is_same<Default, void_>
-          , is_same<type, void_>
-        >
-    ));
-};
-# endif
-
-template <class Parameters, class Keyword, class Default = void_>
-struct value_type
-{
-# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-    typedef typename mpl::eval_if<
-        mpl::is_placeholder<Parameters>
-      , mpl::identity<int>
-      , value_type0<Parameters,Keyword,Default>
-    >::type type;
-# else
-    typedef typename mpl::apply_wrap3<
-        typename Parameters::binding,Keyword,Default,mpl::false_
-    >::type type;
-
-    BOOST_MPL_ASSERT_NOT((
-        mpl::and_<
-            is_same<Default, void_>
-          , is_same<type, void_>
-        >
-    ));
-# endif
-
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(3,value_type,(Parameters,Keyword,Default))
-};
-
-// A metafunction that, given an argument pack, returns the type of
-// the parameter identified by the given keyword.  If no such
-// parameter has been specified, returns the type returned by invoking
-// DefaultFn
-template <class Parameters, class Keyword, class DefaultFn>
-struct lazy_value_type
-{
-  typedef typename mpl::apply_wrap3<
-      typename Parameters::binding
-    , Keyword
-    , typename aux::result_of0<DefaultFn>::type
-    , mpl::false_
-  >::type type;
-};
-
-
-}} // namespace boost::parameter
-
-#endif // BOOST_PARAMETER_VALUE_TYPE_060921_HPP
-

meta/libraries.json

@@ -1,17 +0,0 @@
-{
-    "key": "parameter",
-    "name": "Parameter",
-    "authors": [
-        "David Abrahams",
-        "Daniel Wallin"
-    ],
-    "description": "Boost.Parameter Library - Write functions that accept arguments by name.",
-    "category": [
-        "Emulation",
-        "Programming"
-    ],
-    "maintainers": [
-        "David Abrahams <dave -at- boost-consulting.com>",
-        "Daniel Wallin <daniel -at- boostpro.com>"
-    ]
-}

test/Jamfile

@@ -0,0 +1,14 @@
+# Boost Parameter Library test Jamfile
+
+subproject libs/parameter/test ;
+
+# bring in rules for testing
+import testing ;
+
+test-suite "parameter"
+  :  [ run basics.cpp ]
+     [ run sfinae.cpp ]
+     [ run macros.cpp ]
+     [ compile unwrap_cv_reference.cpp ]
+  ;
+

test/Jamfile.v2

@@ -1,38 +1,8 @@
-# Copyright David Abrahams, Daniel Wallin 2006. 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)
-
 # Boost Parameter Library test Jamfile
 
-import python ;
-
-project boost/parameter
-  : default-build <warnings>off
-  ;
-
-build-project literate ;
-  
 test-suite "parameter"
   :  [ run basics.cpp ]
      [ run sfinae.cpp ]
      [ run macros.cpp ]
-     [ run earwicker.cpp ]
-     [ run tutorial.cpp ]
-     [ run singular.cpp ]
-     [ run mpl.cpp ]
-     [ run preprocessor.cpp ]
-     [ run preprocessor_deduced.cpp ]
-     [ run efficiency.cpp : : : : : <variant>release ]
-     [ run maybe.cpp ]
-     [ run deduced.cpp ]
-     [ run optional_deduced_sfinae.cpp ]
-     [ run deduced_dependent_predicate.cpp ]
-     [ run normalized_argument_types.cpp ]
-     [ compile ntp.cpp ]
      [ compile unwrap_cv_reference.cpp ]
-     [ compile-fail duplicates.cpp ]
-     [ compile-fail deduced_unmatched_arg.cpp ]
-     [ compile compose.cpp ]
-     [ bpl-test python_test ]
   ;
-

test/basics.cpp

@@ -11,6 +11,7 @@
 
 #include "basics.hpp"
 
+
 namespace test
 {
   // A separate function for getting the "value" key, so we can deduce
@@ -106,7 +107,6 @@ int main()
 #endif
    
    //f(index = 56, name = 55); // won't compile
-
-   return boost::report_errors();
+   return 0;
 }
 

test/basics.hpp

@@ -6,13 +6,8 @@
 #ifndef BASICS_050424_HPP
 #define BASICS_050424_HPP
 
+#include <boost/static_assert.hpp>
 #include <boost/parameter/keyword.hpp>
-#include <boost/parameter/parameters.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/assert.hpp>
-#include <boost/mpl/assert.hpp>
-#include <cstring>
-#include <boost/detail/lightweight_test.hpp>
 
 namespace test {
 
@@ -45,14 +40,12 @@ inline bool equal(T const& x, T const& y)
 
 inline bool equal(char const* s1, char const* s2)
 {
-    using namespace std;
     return !strcmp(s1,s2);
 }
 
 #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
 inline bool equal(char* s1, char* s2)
 {
-    using namespace std;
     return !strcmp(s1,s2);
 }
 #endif 
@@ -76,13 +69,13 @@ struct values_t
             || BOOST_WORKAROUND(BOOST_MSVC, < 1310))                    \
             || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
 # else 
-        BOOST_MPL_ASSERT((boost::is_same<Index,Index_>));
-        BOOST_MPL_ASSERT((boost::is_same<Value,Value_>));
-        BOOST_MPL_ASSERT((boost::is_same<Name,Name_>));
+        BOOST_STATIC_ASSERT((boost::is_same<Index,Index_>::value));
+        BOOST_STATIC_ASSERT((boost::is_same<Value,Value_>::value));
+        BOOST_STATIC_ASSERT((boost::is_same<Name,Name_>::value));
 #endif
-        BOOST_TEST(equal(n, n_));
-        BOOST_TEST(equal(v, v_));
-        BOOST_TEST(equal(i, i_));
+        assert(equal(n, n_));
+        assert(equal(v, v_));
+        assert(equal(i, i_));
     }
 
     Name const& n;

test/compose.cpp

@@ -1,43 +0,0 @@
-//~ Copyright Rene Rivera 2006.
-//~ Use, modification and distribution is subject to 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)
-
-#include <boost/parameter.hpp>
-
-namespace param
-{
-    BOOST_PARAMETER_KEYWORD(Tag,a0)
-    BOOST_PARAMETER_KEYWORD(Tag,a1)
-    BOOST_PARAMETER_KEYWORD(Tag,a2)
-}
-
-namespace test
-{
-    struct A
-    {
-        int i;
-        int j;
-        
-        template <typename ArgPack> A(ArgPack const & args)
-        {
-            i = args[param::a0];
-            j = args[param::a1];
-        }
-    };
-
-    struct B : A
-    {
-        template <typename ArgPack> B(ArgPack const & args)
-            : A((args, param::a0 = 1))
-        {
-        }
-    };
-}
-
-int main()
-{
-    test::A a((param::a0 = 1, param::a1 = 13, param::a2 = 6));
-    test::B b0((param::a1 = 13));
-    test::B b1((param::a1 = 13, param::a2 = 6));
-}

test/deduced.cpp

@@ -1,114 +0,0 @@
-// Copyright Daniel Wallin 2006. Use, modification and distribution is
-// subject to 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)
-
-#include <boost/parameter/parameters.hpp>
-#include <boost/parameter/name.hpp>
-#include <boost/parameter/binding.hpp>
-#include "deduced.hpp"
-
-namespace parameter = boost::parameter;
-namespace mpl = boost::mpl;
-
-BOOST_PARAMETER_NAME(x)
-BOOST_PARAMETER_NAME(y)
-BOOST_PARAMETER_NAME(z)
-
-int main()
-{
-    using namespace parameter;
-
-    check<
-        parameters<
-            tag::x
-          , tag::y
-        >
-    >(
-        (_x = 0, _y = 1)
-      , 0
-      , 1
-    );
-
-    check<
-        parameters<
-            tag::x
-          , required<deduced<tag::y>, boost::is_convertible<mpl::_, int> >
-          , optional<deduced<tag::z>, boost::is_convertible<mpl::_, char const*> >
-        >
-    >(
-        (_x = 0, _y = not_present, _z = "foo")
-      , _x = 0
-      , "foo"
-    );
-
-    check<
-        parameters<
-            tag::x
-          , required<deduced<tag::y>, boost::is_convertible<mpl::_, int> >
-          , optional<deduced<tag::z>, boost::is_convertible<mpl::_, char const*> >
-        >
-    >(
-        (_x = 0, _y = 1, _z = "foo")
-      , 0
-      , "foo"
-      , 1
-    );
-
-    check<
-        parameters<
-            tag::x
-          , required<deduced<tag::y>, boost::is_convertible<mpl::_, int> >
-          , optional<deduced<tag::z>, boost::is_convertible<mpl::_, char const*> >
-        >
-    >(
-        (_x = 0, _y = 1, _z = "foo")
-      , 0
-      , 1
-      , "foo"
-    );
-
-    check<
-        parameters<
-            tag::x
-          , required<deduced<tag::y>, boost::is_convertible<mpl::_, int> >
-          , optional<deduced<tag::z>, boost::is_convertible<mpl::_, char const*> >
-        >
-    >(
-        (_x = 0, _y = 1, _z = "foo")
-      , 0
-      , _y = 1
-      , "foo"
-    );
-
-    check<
-        parameters<
-            tag::x
-          , required<deduced<tag::y>, boost::is_convertible<mpl::_, int> >
-          , optional<deduced<tag::z>, boost::is_convertible<mpl::_, char const*> >
-        >
-    >(
-        (_x = 0, _y = 1, _z = "foo")
-      , _z = "foo"
-      , _x = 0
-      , 1
-    );
-
-    // Fails becasue of parameters.hpp:428
-/*
-    check<
-        parameters<
-            tag::x
-          , required<deduced<tag::y>, boost::is_convertible<mpl::_, int> >
-          , optional<deduced<tag::z>, boost::is_convertible<mpl::_, char const*> >
-        >
-    >(
-        (_x = 0, _y = 1, _z = "foo")
-      , _x = 0
-      , (long*)0
-      , 1
-    );
-*/
-
-    return 0;
-};
-

test/deduced.hpp

@@ -1,77 +0,0 @@
-// Copyright Daniel Wallin 2006. Use, modification and distribution is
-// subject to 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)
-
-#ifndef BOOST_DEDUCED_060920_HPP
-# define BOOST_DEDUCED_060920_HPP
-
-# include <boost/mpl/for_each.hpp>
-# include "basics.hpp"
-
-struct not_present_tag {};
-not_present_tag not_present;
-
-template <class E, class ArgPack>
-struct assert_expected
-{
-    assert_expected(E const& e, ArgPack const& args)
-      : expected(e)
-      , args(args)
-    {}
-
-    template <class T>
-    bool check_not_present(T const&) const
-    {
-        BOOST_MPL_ASSERT((boost::is_same<T,not_present_tag>));
-        return true;
-    }
-
-    template <class K>
-    bool check1(K const& k, not_present_tag const&, long) const
-    {
-        return check_not_present(args[k | not_present]);
-    }
-
-    template <class K, class Expected>
-    bool check1(K const& k, Expected const& expected, int) const
-    {
-        return test::equal(args[k], expected);
-    }
-
-    template <class K>
-    void operator()(K) const
-    {
-        boost::parameter::keyword<K> const& k = boost::parameter::keyword<K>::get();
-        assert(check1(k, expected[k], 0L));
-    }
-
-    E const& expected;
-    ArgPack const& args;
-};
-
-template <class E, class ArgPack>
-void check0(E const& e, ArgPack const& args)
-{
-    boost::mpl::for_each<E>(assert_expected<E,ArgPack>(e, args));
-}
-
-template <class P, class E, class A0>
-void check(E const& e, A0 const& a0)
-{
-    check0(e, P()(a0));
-}
-
-template <class P, class E, class A0, class A1>
-void check(E const& e, A0 const& a0, A1 const& a1)
-{
-    check0(e, P()(a0,a1));
-}
-
-template <class P, class E, class A0, class A1, class A2>
-void check(E const& e, A0 const& a0, A1 const& a1, A2 const& a2)
-{
-    check0(e, P()(a0,a1,a2));
-}
-
-#endif // BOOST_DEDUCED_060920_HPP
-

test/deduced_dependent_predicate.cpp

@@ -1,109 +0,0 @@
-// Copyright Daniel Wallin 2006. Use, modification and distribution is
-// subject to 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)
-
-#include <boost/parameter/parameters.hpp>
-#include <boost/parameter/name.hpp>
-#include <boost/parameter/binding.hpp>
-#include <boost/type_traits.hpp>
-#include "deduced.hpp"
-
-namespace parameter = boost::parameter;
-namespace mpl = boost::mpl;
-
-BOOST_PARAMETER_NAME(x)
-BOOST_PARAMETER_NAME(y)
-BOOST_PARAMETER_NAME(z)
-
-int main()
-{
-    using namespace parameter;
-    using boost::is_same;
-    using boost::remove_reference;
-    using boost::add_reference;
-
-    check<
-        parameters<
-            tag::x
-          , optional<
-                deduced<tag::y>
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))    
-              , is_same<
-                    mpl::_1
-                  , remove_reference<binding<mpl::_2,tag::x> >
-                > 
-#else
-              , is_same<
-                    add_reference<mpl::_1>
-                  , binding<mpl::_2,tag::x>
-                > 
-#endif
-            >
-        >
-    >(
-        (_x = 0, _y = 1)
-      , 0
-      , 1
-    );
-
-    check<
-        parameters<
-            tag::x
-          , optional<
-                deduced<tag::y>
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))    
-              , is_same<
-                    mpl::_1
-                  , remove_reference<binding<mpl::_2,tag::x> >
-                > 
-#else
-              , is_same<
-                    add_reference<mpl::_1>
-                  , binding<mpl::_2,tag::x>
-                > 
-#endif
-            >
-        >
-    >(
-        (_x = 0U, _y = 1U)
-      , 0U
-      , 1U
-    );
-
-    check<
-        parameters<
-            tag::x
-          , optional<
-                deduced<tag::y>
-              , is_same<
-                    mpl::_1
-                  , tag::x::_
-                > 
-            >
-        >
-    >(
-        (_x = 0U, _y = 1U)
-      , 0U
-      , 1U
-    );
-
-    check<
-        parameters<
-            tag::x
-          , optional<
-                deduced<tag::y>
-              , is_same<
-                    mpl::_1
-                  , tag::x::_1
-                > 
-            >
-        >
-    >(
-        (_x = 0U, _y = 1U)
-      , 0U
-      , 1U
-    );
-
-    return 0;
-}
-

test/deduced_unmatched_arg.cpp

@@ -1,25 +0,0 @@
-// Copyright Daniel Wallin 2006. Use, modification and distribution is
-// subject to 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)
-
-#include <boost/parameter/parameters.hpp>
-#include <boost/parameter/name.hpp>
-
-namespace parameter = boost::parameter;
-namespace mpl = boost::mpl;
-
-BOOST_PARAMETER_NAME(x)
-
-int main()
-{
-    using namespace parameter;
-    using boost::is_convertible;
-    using mpl::_;
-
-    parameters<
-        optional<
-            deduced<tag::x>, is_convertible<_,int>
-        >
-    >()("foo");
-}
-

test/duplicates.cpp

@@ -1,24 +0,0 @@
-// Copyright Daniel Wallin 2005. Use, modification and distribution is
-// subject to 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)
-
-#include <boost/parameter.hpp>
-#include <string.h>
-#include "basics.hpp"
-
-namespace test
-{
-  template <class Params>
-  void f(Params const &) {}
-}
-
-int main()
-{
-   using namespace test;
-
-   f((name = 1, value = 1, test::index = 1, tester = 1,
-      value = 1 // repeated keyword: should not compile
-   ));
-   return 0;
-}
-

test/earwicker.cpp

@@ -1,56 +0,0 @@
-// Copyright David Abrahams, Daniel Wallin 2005. Use, modification and 
-// distribution is subject to 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)
-
-#include <boost/parameter.hpp>
-#include <boost/type_traits/is_convertible.hpp>
-#include <boost/mpl/placeholders.hpp>
-#include <iostream>
-
-namespace test {
-
-BOOST_PARAMETER_KEYWORD(tag, x)
-BOOST_PARAMETER_KEYWORD(tag, y)
-BOOST_PARAMETER_KEYWORD(tag, z)
-
-using namespace boost::parameter;
-using namespace boost::mpl::placeholders;
-
-struct f_parameters // vc6 is happier with inheritance than with a typedef
-  : parameters<
-        optional<tag::x,boost::is_convertible<_,int> >
-      , optional<tag::y,boost::is_convertible<_,int> >
-      , optional<tag::z,boost::is_convertible<_,int> >
-    >
-{};
-
-#ifdef BOOST_NO_VOID_RETURNS
-BOOST_PARAMETER_FUN(int, f, 0, 3, f_parameters)
-#else 
-BOOST_PARAMETER_FUN(void, f, 0, 3, f_parameters)
-#endif 
-{
-    std::cout << "x = " << p[x | -1] << std::endl;
-    std::cout << "y = " << p[y | -2] << std::endl;
-    std::cout << "z = " << p[z | -3] << std::endl;
-    std::cout <<  "================" << std::endl;
-#ifdef BOOST_NO_VOID_RETURNS
-    return 0;
-#endif 
-}
-
-}
-
-
-int main()
-{
-    using namespace test;
-    f(x = 1, y = 2, z = 3);
-    f(x = 1);
-    f(y = 2);
-    f(z = 3);
-    f(z = 3, x = 1);
-}
-
-

test/efficiency.cpp

@@ -1,195 +0,0 @@
-// Copyright David Abrahams, Matthias Troyer, Michael Gauckler
-// 2005. 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)
-
-#include <boost/parameter.hpp>
-#include <boost/timer.hpp>
-#include <iostream>
-
-namespace test
-{
-  //
-  // This test measures the abstraction overhead of using the named
-  // parameter interface.  Some actual test results have been recorded
-  // in timings.txt in this source file's directory, or
-  // http://www.boost.org/libs/parameter/test/timings.txt.
-  //
-  // Caveats:
-  //
-  //   1. This test penalizes the named parameter library slightly, by
-  //      passing two arguments through the named interface, while
-  //      only passing one through the plain C++ interface.
-  //
-  //   2. This test does not measure the case where an ArgumentPack is
-  //      so large that it doesn't fit in the L1 cache.
-  //
-  //   3. Although we've tried to make this test as general as
-  //      possible, we are targeting it at a specific application.
-  //      Where that affects design decisions, we've noted it below in
-  //      ***...***.
-  //
-  //   4. The first time you run this program, the time may not be
-  //      representative because of disk and memory cache effects, so
-  //      always run it multiple times and ignore the first
-  //      measurement.  This approach will also allow you to estimate
-  //      the statistical error of your test by observing the
-  //      variation in the valid times.
-  //
-  //   5. Try to run this program on a machine that's otherwise idle,
-  //      or other processes and even device hardware interrupts may
-  //      interfere by causing caches to be flushed.
-  
-  // Accumulator function object with plain C++ interface 
-  template <class T>
-  struct plain_weight_running_total
-  {
-      plain_weight_running_total()
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-        : sum(T())
-#else
-        : sum()
-#endif 
-      {}
-      
-      void operator()(T w)
-      {
-          this->sum += w;
-      }
-
-      T sum;
-  };
-
-  BOOST_PARAMETER_KEYWORD(tag, weight)
-  BOOST_PARAMETER_KEYWORD(tag, value)
-      
-  // Accumulator function object with named parameter interface
-  template <class T>
-  struct named_param_weight_running_total
-  {
-      named_param_weight_running_total()
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-        : sum(T())
-#else
-        : sum()
-#endif 
-      {}
-
-      template <class ArgumentPack>
-      void operator()(ArgumentPack const& variates)
-      {
-          this->sum += variates[weight];
-      }
-
-      T sum;
-  };
-
-  // This value is required to ensure that a smart compiler's dead
-  // code elimination doesn't optimize away anything we're testing.
-  // We'll use it to compute the return code of the executable to make
-  // sure it's needed.
-  double live_code;
-
-  // Call objects of the given Accumulator type repeatedly with x as
-  // an argument.
-  template <class Accumulator, class Arg>
-  void hammer(Arg const& x, long const repeats)
-  {
-      // Strategy: because the sum in an accumulator after each call
-      // depends on the previous value of the sum, the CPU's pipeline
-      // might be stalled while waiting for the previous addition to
-      // complete.  Therefore, we allocate an array of accumulators,
-      // and update them in sequence, so that there's no dependency
-      // between adjacent addition operations.
-      //
-      // Additionally, if there were only one accumulator, the
-      // compiler or CPU might decide to update the value in a
-      // register rather that writing it back to memory.  we want each
-      // operation to at least update the L1 cache.  *** Note: This
-      // concern is specific to the particular application at which
-      // we're targeting the test. ***
-
-      // This has to be at least as large as the number of
-      // simultaneous accumulations that can be executing in the
-      // compiler pipeline.  A safe number here is larger than the
-      // machine's maximum pipeline depth. If you want to test the L2
-      // or L3 cache, or main memory, you can increase the size of
-      // this array.  1024 is an upper limit on the pipeline depth of
-      // current vector machines.
-      const std::size_t number_of_accumulators = 1024;
-      
-      Accumulator a[number_of_accumulators];
-      
-      for (long iteration = 0; iteration < repeats; ++iteration)
-      {
-          for (Accumulator* ap = a;  ap < a + number_of_accumulators; ++ap)
-          {
-              (*ap)(x);
-          }
-      }
-
-      // Accumulate all the partial sums to avoid dead code
-      // elimination.
-      for (Accumulator* ap = a;  ap < a + number_of_accumulators; ++ap)
-      {
-          live_code += ap->sum;
-      }
-  }
-
-  // Measure the time required to hammer accumulators of the given
-  // type with the argument x.
-  template <class Accumulator, class T>
-  double measure(T const& x, long const repeats)
-  {
-      // Hammer accumulators a couple of times to ensure the
-      // instruction cache is full of our test code, and that we don't
-      // measure the cost of a page fault for accessing the data page
-      // containing the memory where the accumulators will be
-      // allocated
-      hammer<Accumulator>(x, repeats);
-      hammer<Accumulator>(x, repeats);
-
-      // Now start a timer
-      boost::timer time;
-      hammer<Accumulator>(x, repeats);  // This time, we'll measure
-      return time.elapsed();
-  }
-}
-
-int main()
-{
-    using namespace test;
-
-    // first decide how many repetitions to measure
-    long repeats = 100;
-    double measured = 0;
-    while (measured < 1.0 && repeats <= 10000000)
-    {
-        repeats *= 10;
-        
-        boost::timer time;
-
-        hammer<plain_weight_running_total<double> >(.1, repeats);
-        hammer<named_param_weight_running_total<double> >(
-            (weight = .1, value = .2), repeats);
-
-        measured = time.elapsed();
-    }
-    
-    std::cout
-        << "plain time:           "
-        << measure<plain_weight_running_total<double> >(.1, repeats)
-        << std::endl;
-    
-    std::cout
-        << "named parameter time: "
-        << measure<named_param_weight_running_total<double> >(
-            (weight = .1, value = .2), repeats
-        )
-        << std::endl;
-
-    // This is ultimately responsible for preventing all the test code
-    // from being optimized away.  Change this to return 0 and you
-    // unplug the whole test's life support system.
-    return live_code < 0.;
-}

test/literate/Jamfile.v2

@@ -1,33 +0,0 @@
-
-import testing ;
-
-run extracting-parameter-types0.cpp ;
-run extracting-parameter-types1.cpp ;
-compile template-keywords0.cpp ;
-compile template-keywords1.cpp ;
-compile top-level0.cpp ;
-compile headers-and-namespaces0.cpp ;
-compile predicate-requirements0.cpp ;
-compile handling-out-parameters0.cpp ;
-compile writing-the-function0.cpp ;
-run building-argumentpacks0.cpp ;
-compile defining-the-keywords0.cpp ;
-compile defining-the-keywords1.cpp ;
-compile exercising-the-code-so-far0.cpp ;
-run lazy-default-computation0.cpp ;
-run lazy-default-computation1.cpp ;
-run namespaces0.cpp ;
-run namespaces1.cpp ;
-run namespaces2.cpp ;
-run namespaces3.cpp ;
-compile optional-parameters0.cpp ;
-compile static-member-functions0.cpp ;
-run parameter-enabled-constructors0.cpp ;
-compile required-parameters0.cpp ;
-compile class-template-skeleton0.cpp ;
-compile deduced-template-parameters0.cpp ;
-compile deduced-parameters0.cpp ;
-compile default-expression-evaluation0.cpp ;
-compile parameter-enabled-member-functions0.cpp ;
-compile parameter-enabled-member-functions1.cpp ;
-run fine-grained-name-control0.cpp ;

test/literate/README

@@ -1,6 +0,0 @@
-These tests were extracted from the Boost.Parameter documentation
-with:
-
-python ../../../../tools/litre/tool.py \
-       ../../../../libs/parameter/doc/index.rst \
-       --dump_dir=.

test/literate/building-argumentpacks0.cpp

@@ -1,47 +0,0 @@
-
-#include <boost/parameter.hpp>
-#include <iostream>
-BOOST_PARAMETER_NAME(index)
-
-template <class ArgumentPack>
-int print_index(ArgumentPack const& args)
-{
-    std::cout << "index = " << args[_index] << std::endl;
-    return 0;
-}
-
-int x = print_index(_index = 3);  // prints "index = 3"
-
-BOOST_PARAMETER_NAME(name)
-
-template <class ArgumentPack>
-int print_name_and_index(ArgumentPack const& args)
-{
-    std::cout << "name = " << args[_name] << "; ";
-    return print_index(args);
-}
-
-int y = print_name_and_index((_index = 3, _name = "jones"));
-
-
-namespace parameter = boost::parameter;
-using parameter::required;
-using parameter::optional;
-using boost::is_convertible;
-using boost::mpl::_;
-parameter::parameters<
-    required<tag::name, is_convertible<_,char const*> >
-  , optional<tag::index, is_convertible<_,int> >
-> spec;
-
-char const sam[] = "sam";
-int twelve = 12;
-
-int z0 = print_name_and_index( spec(sam, twelve) );
-
-int z1 = print_name_and_index(
-   spec(_index=12, _name="sam")
-);
-int main()
-{}
-

test/literate/class-template-skeleton0.cpp

@@ -1,16 +0,0 @@
-
-#include <boost/parameter.hpp>
-namespace boost { namespace python {
-
-template <
-    class A0
-  , class A1 = parameter::void_
-  , class A2 = parameter::void_
-  , class A3 = parameter::void_
->
-struct class_
-{
-    
-};
-
-}}

test/literate/deduced-parameters0.cpp

@@ -1,74 +0,0 @@
-
-#include <boost/parameter.hpp>
-
-BOOST_PARAMETER_NAME(name)
-BOOST_PARAMETER_NAME(func)
-BOOST_PARAMETER_NAME(docstring)
-BOOST_PARAMETER_NAME(keywords)
-BOOST_PARAMETER_NAME(policies)
-
-struct default_call_policies
-{};
-
-struct no_keywords
-{};
-
-struct keywords
-{};
-
-template <class T>
-struct is_keyword_expression
-  : boost::mpl::false_
-{};
-
-template <>
-struct is_keyword_expression<keywords>
-  : boost::mpl::true_
-{};
-
-default_call_policies some_policies;
-
-void f()
-{}
-namespace mpl = boost::mpl;
-
-BOOST_PARAMETER_FUNCTION(
-    (void), def, tag,
-
-    (required (name,(char const*)) (func,*) )   // nondeduced
-
-    (deduced
-      (optional
-        (docstring, (char const*), "")
-
-        (keywords
-           , *(is_keyword_expression<mpl::_>) // see 5
-           , no_keywords())
-
-        (policies
-           , *(mpl::not_<
-                 mpl::or_<
-                     boost::is_convertible<mpl::_, char const*>
-                   , is_keyword_expression<mpl::_> // see 5
-                 >
-             >)
-           , default_call_policies()
-         )
-       )
-     )
- )
- {
-    
- }
-
-
-int main()
-{
-def("f", &f, some_policies, "Documentation for f");
-def("f", &f, "Documentation for f", some_policies);
-
-def(
-    "f", &f
-   , _policies = some_policies, "Documentation for f");
-}
-

test/literate/deduced-template-parameters0.cpp

@@ -1,124 +0,0 @@
-
-#include <boost/parameter.hpp>
-#include <boost/mpl/is_sequence.hpp>
-#include <boost/noncopyable.hpp>
-#include <memory>
-#include <boost/config.hpp>
-
-using namespace boost::parameter;
-using boost::mpl::_;
-
-namespace boost { namespace python {
-
-BOOST_PARAMETER_TEMPLATE_KEYWORD(class_type)
-BOOST_PARAMETER_TEMPLATE_KEYWORD(base_list)
-BOOST_PARAMETER_TEMPLATE_KEYWORD(held_type)
-BOOST_PARAMETER_TEMPLATE_KEYWORD(copyable)
-
-}}
-namespace boost { namespace python {
-
-namespace detail { struct bases_base {}; }
-
-template <class A0 = void, class A1 = void, class A2 = void  >
-struct bases : detail::bases_base
-{};
-
-}}
-
-
-#include <boost/type_traits/is_class.hpp>
-namespace boost { namespace python {
-typedef parameter::parameters<
-    required<tag::class_type, is_class<_> >
-
-  , parameter::optional<
-        deduced<tag::base_list>
-      , is_base_and_derived<detail::bases_base,_>
-    >
-
-  , parameter::optional<
-        deduced<tag::held_type>
-      , mpl::not_<
-            mpl::or_<
-                is_base_and_derived<detail::bases_base,_>
-              , is_same<noncopyable,_>
-            >
-        >
-    >
-
-  , parameter::optional<deduced<tag::copyable>, is_same<noncopyable,_> >
-
-> class_signature;
-template <
-    class A0
-  , class A1 = parameter::void_
-  , class A2 = parameter::void_
-  , class A3 = parameter::void_
->
-struct class_
-{
-    // Create ArgumentPack
-    typedef typename
-      class_signature::bind<A0,A1,A2,A3>::type
-    args;
-
-    // Extract first logical parameter.
-    typedef typename parameter::value_type<
-      args, tag::class_type>::type class_type;
-
-    typedef typename parameter::value_type<
-      args, tag::base_list, bases<> >::type base_list;
-
-    typedef typename parameter::value_type<
-      args, tag::held_type, class_type>::type held_type;
-
-    typedef typename parameter::value_type<
-      args, tag::copyable, void>::type copyable;
-};
-
-}}
-
-
-
-struct B {};
-struct D {};
-
-using boost::python::bases;
-typedef boost::python::class_<B, boost::noncopyable> c1;
-
-#if defined(BOOST_NO_CXX11_SMART_PTR)
-
-typedef boost::python::class_<D, std::auto_ptr<D>, bases<B> > c2;
-
-#else
-
-typedef boost::python::class_<D, std::unique_ptr<D>, bases<B> > c2;
-
-#endif
-
-BOOST_MPL_ASSERT((boost::is_same<c1::class_type, B>));
-BOOST_MPL_ASSERT((boost::is_same<c1::base_list, bases<> >));
-BOOST_MPL_ASSERT((boost::is_same<c1::held_type, B>));
-BOOST_MPL_ASSERT((
-     boost::is_same<c1::copyable, boost::noncopyable>
-));
-
-BOOST_MPL_ASSERT((boost::is_same<c2::class_type, D>));
-BOOST_MPL_ASSERT((boost::is_same<c2::base_list, bases<B> >));
-
-#if defined(BOOST_NO_CXX11_SMART_PTR)
-
-BOOST_MPL_ASSERT((
-    boost::is_same<c2::held_type, std::auto_ptr<D> >
-));
-
-#else
-
-BOOST_MPL_ASSERT((
-    boost::is_same<c2::held_type, std::unique_ptr<D> >
-));
-
-#endif
-
-BOOST_MPL_ASSERT((boost::is_same<c2::copyable, void>));

test/literate/default-expression-evaluation0.cpp

@@ -1,39 +0,0 @@
-
-#include <boost/parameter.hpp>
-#include <iostream>
-
-BOOST_PARAMETER_NAME(graph)
-BOOST_PARAMETER_NAME(visitor)
-BOOST_PARAMETER_NAME(root_vertex)
-BOOST_PARAMETER_NAME(index_map)
-BOOST_PARAMETER_NAME(color_map)
-#include <boost/graph/depth_first_search.hpp> // for dfs_visitor
-
-BOOST_PARAMETER_FUNCTION(
-    (void), depth_first_search, tag
-    
-, (required
-    (graph, *)
-    (visitor, *)
-    (root_vertex, *)
-    (index_map, *)
-    (color_map, *)
-  )
-
-)
-{
-   std::cout << "graph=" << graph << std::endl;
-   std::cout << "visitor=" << visitor << std::endl;
-   std::cout << "root_vertex=" << root_vertex << std::endl;
-   std::cout << "index_map=" << index_map << std::endl;
-   std::cout << "color_map=" << color_map << std::endl;
-}
-
-int main()
-{
-    depth_first_search(1, 2, 3, 4, 5);
-
-    depth_first_search(
-        "1", '2', _color_map = '5',
-        _index_map = "4", _root_vertex = "3");
-}

test/literate/defining-the-keywords0.cpp

@@ -1,10 +0,0 @@
-#include <boost/parameter/name.hpp>
-
-namespace graphs
-{
-  BOOST_PARAMETER_NAME(graph)    // Note: no semicolon
-  BOOST_PARAMETER_NAME(visitor)
-  BOOST_PARAMETER_NAME(root_vertex)
-  BOOST_PARAMETER_NAME(index_map)
-  BOOST_PARAMETER_NAME(color_map)
-}

test/literate/defining-the-keywords1.cpp

@@ -1,13 +0,0 @@
-
-#include <boost/parameter/keyword.hpp>
-namespace graphs
-{
-  namespace tag { struct graph; } // keyword tag type
-
-  namespace // unnamed
-  {
-    // A reference to the keyword object
-    boost::parameter::keyword<tag::graph>& _graph
-    = boost::parameter::keyword<tag::graph>::get();
-  }
-}

test/literate/exercising-the-code-so-far0.cpp

@@ -1,118 +0,0 @@
-
-#include <boost/parameter.hpp>
-#include <boost/mpl/is_sequence.hpp>
-#include <boost/noncopyable.hpp>
-#include <boost/type_traits/is_class.hpp>
-#include <memory>
-#include <boost/config.hpp>
-
-using namespace boost::parameter;
-
-namespace boost { namespace python {
-
-BOOST_PARAMETER_TEMPLATE_KEYWORD(class_type)
-BOOST_PARAMETER_TEMPLATE_KEYWORD(base_list)
-BOOST_PARAMETER_TEMPLATE_KEYWORD(held_type)
-BOOST_PARAMETER_TEMPLATE_KEYWORD(copyable)
-
-template <class B = int>
-struct bases
-{};
-
-}}
-namespace boost { namespace python {
-
-using boost::mpl::_;
-
-typedef parameter::parameters<
-    required<tag::class_type, boost::is_class<_> >
-  , parameter::optional<tag::base_list, mpl::is_sequence<_> >
-  , parameter::optional<tag::held_type>
-  , parameter::optional<tag::copyable>
-> class_signature;
-
-}}
-
-namespace boost { namespace python {
-
-template <
-    class A0
-  , class A1 = parameter::void_
-  , class A2 = parameter::void_
-  , class A3 = parameter::void_
->
-struct class_
-{
-    // Create ArgumentPack
-    typedef typename
-      class_signature::bind<A0,A1,A2,A3>::type
-    args;
-
-    // Extract first logical parameter.
-    typedef typename parameter::value_type<
-      args, tag::class_type>::type class_type;
-
-    typedef typename parameter::value_type<
-      args, tag::base_list, bases<> >::type base_list;
-
-    typedef typename parameter::value_type<
-      args, tag::held_type, class_type>::type held_type;
-
-    typedef typename parameter::value_type<
-      args, tag::copyable, void>::type copyable;
-};
-
-}}
-
-
-using boost::python::class_type;
-using boost::python::copyable;
-using boost::python::held_type;
-using boost::python::base_list;
-using boost::python::bases;
-
-struct B {};
-struct D {};
-typedef boost::python::class_<
-    class_type<B>, copyable<boost::noncopyable>
-> c1;
-
-typedef boost::python::class_<
-
-#if defined(BOOST_NO_CXX11_SMART_PTR)
-
-    D, held_type<std::auto_ptr<D> >, base_list<bases<B> >
-    
-#else
-
-    D, held_type<std::unique_ptr<D> >, base_list<bases<B> >
-    
-#endif
-
-> c2;
-
-BOOST_MPL_ASSERT((boost::is_same<c1::class_type, B>));
-BOOST_MPL_ASSERT((boost::is_same<c1::base_list, bases<> >));
-BOOST_MPL_ASSERT((boost::is_same<c1::held_type, B>));
-BOOST_MPL_ASSERT((
-     boost::is_same<c1::copyable, boost::noncopyable>
-));
-
-BOOST_MPL_ASSERT((boost::is_same<c2::class_type, D>));
-BOOST_MPL_ASSERT((boost::is_same<c2::base_list, bases<B> >));
-
-#if defined(BOOST_NO_CXX11_SMART_PTR)
-
-BOOST_MPL_ASSERT((
-    boost::is_same<c2::held_type, std::auto_ptr<D> >
-));
-
-#else
-
-BOOST_MPL_ASSERT((
-    boost::is_same<c2::held_type, std::unique_ptr<D> >
-));
-
-#endif
-
-BOOST_MPL_ASSERT((boost::is_same<c2::copyable, void>));

test/literate/extracting-parameter-types0.cpp

@@ -1,28 +0,0 @@
-
-#include <boost/parameter.hpp>
-#include <cassert>
-BOOST_PARAMETER_NAME(name)
-BOOST_PARAMETER_NAME(index)
-
-template <class Name, class Index>
-int deduce_arg_types_impl(Name& name, Index& index)
-{
-    Name& n2 = name;  // we know the types
-    Index& i2 = index;
-    return index;
-}
-
-template <class ArgumentPack>
-int deduce_arg_types(ArgumentPack const& args)
-{
-    return deduce_arg_types_impl(args[_name], args[_index|42]);
-}
-int a1 = deduce_arg_types((_name = "foo"));
-int a2 = deduce_arg_types((_name = "foo", _index = 3));
-
-int main()
-{
-    assert(a1 == 42);
-    assert(a2 == 3);
-}
-

test/literate/extracting-parameter-types1.cpp

@@ -1,21 +0,0 @@
-
-#include <boost/parameter.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-#include <cassert>
-
-namespace parameter = boost::parameter;
-BOOST_PARAMETER_NAME(index)
-
-template <class ArgumentPack>
-typename parameter::value_type<ArgumentPack, tag::index, int>::type
-twice_index(ArgumentPack const& args)
-{
-    return 2 * args[_index|42];
-}
-
-int six = twice_index(_index = 3);
-int main()
-{
-    assert(six == 6);
-}
-

test/literate/fine-grained-name-control0.cpp

@@ -1,15 +0,0 @@
-
-#include <boost/parameter.hpp>
-BOOST_PARAMETER_NAME((pass_foo, keywords) foo)
-
-BOOST_PARAMETER_FUNCTION(
-  (int), f,
-  keywords, (required (foo, *)))
-{
-    return foo + 1;
-}
-
-int x = f(pass_foo = 41);
-int main()
-{}
-

test/literate/handling-out-parameters0.cpp

@@ -1,30 +0,0 @@
-
-#include <boost/parameter.hpp>
-
-namespace boost
-{
-  int vertex_index = 0;
-
-  template <class T = int>
-  struct dfs_visitor
-  {};
-}
-
-BOOST_PARAMETER_NAME(graph)
-
-BOOST_PARAMETER_NAME(visitor)
-BOOST_PARAMETER_NAME(root_vertex)
-BOOST_PARAMETER_NAME(index_map)
-BOOST_PARAMETER_NAME(color_map)
-
-BOOST_PARAMETER_FUNCTION((void), f, tag,
-  (required (graph, *))
-(optional
-    (visitor,            *, boost::dfs_visitor<>())
-    (root_vertex,        *, *vertices(graph).first)
-    (index_map,          *, get(boost::vertex_index,graph))
-    (in_out(color_map), *,
-      default_color_map(num_vertices(graph), index_map) )
-)
-) {}
-

test/literate/headers-and-namespaces0.cpp

@@ -1,3 +0,0 @@
-#include <boost/parameter/keyword.hpp>
-using boost::parameter::keyword;
-

test/literate/lazy-default-computation0.cpp

@@ -1,24 +0,0 @@
-
-#include <boost/parameter.hpp>
-#include <string>
-
-namespace parameter = boost::parameter;
-BOOST_PARAMETER_NAME(s1)
-BOOST_PARAMETER_NAME(s2)
-BOOST_PARAMETER_NAME(s3)
-
-template <class ArgumentPack>
-std::string f(ArgumentPack const& args)
-{
-    std::string const& s1 = args[_s1];
-    std::string const& s2 = args[_s2];
-    typename parameter::binding<
-        ArgumentPack,tag::s3,std::string
-    >::type s3 = args[_s3|(s1+s2)]; // always constructs s1+s2
-    return s3;
-}
-
-std::string x = f((_s1="hello,", _s2=" world", _s3="hi world"));
-int main()
-{}
-

test/literate/lazy-default-computation1.cpp

@@ -1,30 +0,0 @@
-
-#include <boost/bind.hpp>
-#include <boost/ref.hpp>
-#include <boost/parameter.hpp>
-#include <string>
-#include <functional>
-
-namespace parameter = boost::parameter;
-
-BOOST_PARAMETER_NAME(s1)
-BOOST_PARAMETER_NAME(s2)
-BOOST_PARAMETER_NAME(s3)
-
-template <class ArgumentPack>
-std::string f(ArgumentPack const& args)
-{
-    std::string const& s1 = args[_s1];
-    std::string const& s2 = args[_s2];
-typename parameter::binding<
-    ArgumentPack, tag::s3, std::string
->::type s3 = args[_s3
-    || boost::bind(std::plus<std::string>(), boost::ref(s1), boost::ref(s2)) ];
-    return s3;
-}
-
-std::string x = f((_s1="hello,", _s2=" world", _s3="hi world"));
-
-int main()
-{}
-

test/literate/namespaces0.cpp

@@ -1,20 +0,0 @@
-
-#include <boost/parameter.hpp>
-#include <iostream>
-namespace lib
-{
-  BOOST_PARAMETER_NAME(name)
-  BOOST_PARAMETER_NAME(index)
-
-  BOOST_PARAMETER_FUNCTION(
-    (int), f, tag,
-    (optional (name,*,"bob")(index,(int),1))
-  )
-  {
-      std::cout << name << ":" << index << std::endl;
-      return index;
-  }
-}
-int x = lib::f(lib::_name = "jill", lib::_index = 1);
-int main() {}
-

test/literate/namespaces1.cpp

@@ -1,23 +0,0 @@
-
-#include <boost/parameter.hpp>
-#include <iostream>
-namespace lib
-{
-  BOOST_PARAMETER_NAME(name)
-  BOOST_PARAMETER_NAME(index)
-
-  BOOST_PARAMETER_FUNCTION(
-    (int), f, tag,
-    (optional (name,*,"bob")(index,(int),1))
-  )
-  {
-      std::cout << name << ":" << index << std::endl;
-      return index;
-  }
-}
-using lib::_name;
-using lib::_index;
-
-int x = lib::f(_name = "jill", _index = 1);
-int main() {}
-

test/literate/namespaces2.cpp

@@ -1,21 +0,0 @@
-
-#include <boost/parameter.hpp>
-#include <iostream>
-namespace lib
-{
-  BOOST_PARAMETER_NAME(name)
-  BOOST_PARAMETER_NAME(index)
-
-  BOOST_PARAMETER_FUNCTION(
-    (int), f, tag,
-    (optional (name,*,"bob")(index,(int),1))
-  )
-  {
-      std::cout << name << ":" << index << std::endl;
-      return index;
-  }
-}
-using namespace lib;
-int x = f(_name = "jill", _index = 3);
-int main() {}
-

test/literate/namespaces3.cpp

@@ -1,25 +0,0 @@
-
-#include <boost/parameter.hpp>
-#include <iostream>
-namespace lib
-{
-  namespace keywords
-  {
-     BOOST_PARAMETER_NAME(name)
-     BOOST_PARAMETER_NAME(index)
-  }
-
-  BOOST_PARAMETER_FUNCTION(
-    (int), f, keywords::tag,
-    (optional (name,*,"bob")(index,(int),1))
-  )
-  {
-      std::cout << name << ":" << index << std::endl;
-      return index;
-  }
-}
-
-using namespace lib::keywords;
-int y = lib::f(_name = "bob", _index = 2);
-int main() {}
-

test/literate/optional-parameters0.cpp

@@ -1,28 +0,0 @@
-
-#include <boost/parameter.hpp>
-
-namespace boost
-{
-  int vertex_index = 0;
-
-  template <class T = int>
-  struct dfs_visitor
-  {};
-}
-
-BOOST_PARAMETER_NAME(graph)
-BOOST_PARAMETER_NAME(visitor)
-BOOST_PARAMETER_NAME(root_vertex)
-BOOST_PARAMETER_NAME(index_map)
-BOOST_PARAMETER_NAME(color_map)
-
-BOOST_PARAMETER_FUNCTION((void), f, tag,
-  (required (graph, *))
-(optional     (visitor,           *, boost::dfs_visitor<>())
-    (root_vertex,       *, *vertices(graph).first)
-    (index_map,         *, get(boost::vertex_index,graph))
-    (in_out(color_map), *,
-      default_color_map(num_vertices(graph), index_map) )
-)
-) {}
-

test/literate/parameter-enabled-constructors0.cpp

@@ -1,31 +0,0 @@
-
-#include <boost/parameter.hpp>
-#include <iostream>
-BOOST_PARAMETER_NAME(name)
-BOOST_PARAMETER_NAME(index)
-
-struct myclass_impl
-{
-    template <class ArgumentPack>
-    myclass_impl(ArgumentPack const& args)
-    {
-        std::cout << "name = " << args[_name]
-                  << "; index = " << args[_index | 42]
-                  << std::endl;
-    }
-};
-
-struct myclass : myclass_impl
-{
-    BOOST_PARAMETER_CONSTRUCTOR(
-        myclass, (myclass_impl), tag
-      , (required (name,*)) (optional (index,*))) // no semicolon
-};
-
-
-int main() {
-myclass x("bob", 3);                     // positional
-myclass y(_index = 12, _name = "sally"); // named
-myclass z("june");                       // positional/defaulted
-}
-

test/literate/parameter-enabled-member-functions0.cpp

@@ -1,15 +0,0 @@
-
-#include <boost/parameter.hpp>
-#include <iostream>
-using namespace boost::parameter;
-BOOST_PARAMETER_NAME(arg1)
-BOOST_PARAMETER_NAME(arg2)
-
-struct callable2
-{
-    BOOST_PARAMETER_CONST_MEMBER_FUNCTION(
-        (void), call, tag, (required (arg1,(int))(arg2,(int))))
-    {
-        std::cout << arg1 << ", " << arg2 << std::endl;
-    }
-};

test/literate/parameter-enabled-member-functions1.cpp

@@ -1,16 +0,0 @@
-
-#include <boost/parameter.hpp>
-
-BOOST_PARAMETER_NAME(arg1)
-BOOST_PARAMETER_NAME(arg2)
-using namespace boost::parameter;
-struct callable2
-{
-    BOOST_PARAMETER_CONST_MEMBER_FUNCTION(
-        (void), call, tag, (required (arg1,(int))(arg2,(int))))
-    {
-        call_impl(arg1,arg2);
-    }
- private:
-    void call_impl(int, int); // implemented elsewhere.
-};

test/literate/predicate-requirements0.cpp

@@ -1,103 +0,0 @@
-
-#include <boost/parameter.hpp>
-#include <boost/graph/adjacency_list.hpp>
-#include <boost/graph/depth_first_search.hpp>
-
-BOOST_PARAMETER_NAME((_graph, graphs) graph)
-BOOST_PARAMETER_NAME((_visitor, graphs) visitor)
-BOOST_PARAMETER_NAME((_root_vertex, graphs) root_vertex)
-BOOST_PARAMETER_NAME((_index_map, graphs) index_map)
-BOOST_PARAMETER_NAME((_color_map, graphs) color_map)
-
-using boost::mpl::_;
-// We first need to define a few metafunction that we use in the
-// predicates below.
-
-template <class G>
-struct traversal_category
-{
-    typedef typename boost::graph_traits<G>::traversal_category type;
-};
-
-template <class G>
-struct vertex_descriptor
-{
-    typedef typename boost::graph_traits<G>::vertex_descriptor type;
-};
-
-template <class G>
-struct value_type
-{
-    typedef typename boost::property_traits<G>::value_type type;
-};
-
-template <class G>
-struct key_type
-{
-    typedef typename boost::property_traits<G>::key_type type;
-};
-
-template<class Size, class IndexMap>
-boost::iterator_property_map<
-    boost::default_color_type*, IndexMap
-  , boost::default_color_type, boost::default_color_type&
->
-default_color_map(Size num_vertices, IndexMap const& index_map)
-{
-   std::vector<boost::default_color_type> colors(num_vertices);
-   return &colors[0];
-}
-
-BOOST_PARAMETER_FUNCTION(
-    (void), depth_first_search, graphs
-
-  , (required
-      (graph
-       , *(boost::mpl::and_<
-               boost::is_convertible<
-                   traversal_category<_>, boost::incidence_graph_tag
-               >
-             , boost::is_convertible<
-                   traversal_category<_>, boost::vertex_list_graph_tag
-               >
-           >) ))
-
-    (optional
-      (visitor, *, boost::dfs_visitor<>()) // not checkable
-
-      (root_vertex
-        , (vertex_descriptor<graphs::graph::_>)
-        , *vertices(graph).first)
-
-      (index_map
-        , *(boost::mpl::and_<
-              boost::is_integral<value_type<_> >
-            , boost::is_same<
-                  vertex_descriptor<graphs::graph::_>, key_type<_>
-              >
-          >)
-        , get(boost::vertex_index,graph))
-
-      (in_out(color_map)
-        , *(boost::is_same<
-              vertex_descriptor<graphs::graph::_>, key_type<_>
-          >)
-       , default_color_map(num_vertices(graph), index_map) )
-    )
-)
-{}
-
-int main()
-{
-    typedef boost::adjacency_list<boost::vecS, boost::vecS, boost::directedS> G;
-
-    enum {u, v, w, x, y, z, N};
-    typedef std::pair<int, int> E;
-    E edges[] = {E(u, v), E(u, x), E(x, v), E(y, x), E(v, y), E(w, y),
-                 E(w,z), E(z, z)};
-    G g(edges, edges + sizeof(edges) / sizeof(E), N);
-
-    ::depth_first_search(g);
-    ::depth_first_search(g, _root_vertex = (int)x);
-}
-

test/literate/required-parameters0.cpp

@@ -1,9 +0,0 @@
-
-#include <boost/parameter.hpp>
-
-BOOST_PARAMETER_NAME(graph)
-
-BOOST_PARAMETER_FUNCTION((void), f, tag,
-(required (graph, *) )
-) {}
-

test/literate/static-member-functions0.cpp

@@ -1,14 +0,0 @@
-
-#include <boost/parameter.hpp>
-#include <iostream>
-using namespace boost::parameter;
-BOOST_PARAMETER_NAME(arg1)
-
-struct somebody
-{
-    BOOST_PARAMETER_MEMBER_FUNCTION(
-        (void), static f, tag, (optional (arg1,(int),0)))
-    {
-        std::cout << arg1 << std::endl;
-    }
-};

test/literate/template-keywords0.cpp

@@ -1,10 +0,0 @@
-
-#include <boost/parameter.hpp>
-namespace boost { namespace python {
-
-BOOST_PARAMETER_TEMPLATE_KEYWORD(class_type)
-BOOST_PARAMETER_TEMPLATE_KEYWORD(base_list)
-BOOST_PARAMETER_TEMPLATE_KEYWORD(held_type)
-BOOST_PARAMETER_TEMPLATE_KEYWORD(copyable)
-
-}}

test/literate/template-keywords1.cpp

@@ -1,11 +0,0 @@
-
-#include <boost/parameter.hpp>
-namespace boost { namespace python {
-
-namespace tag { struct class_type; } // keyword tag type
-template <class T>
-struct class_type
-  : parameter::template_keyword<tag::class_type,T>
-{};
-
-}}

test/literate/top-level0.cpp

@@ -1,38 +0,0 @@
-
-#include <boost/parameter.hpp>
-
-namespace test
-{
-  BOOST_PARAMETER_NAME(title)
-  BOOST_PARAMETER_NAME(width)
-  BOOST_PARAMETER_NAME(titlebar)
-
-  BOOST_PARAMETER_FUNCTION(
-     (int), new_window, tag, (required (title,*)(width,*)(titlebar,*)))
-  {
-     return 0;
-  }
-
-  BOOST_PARAMETER_TEMPLATE_KEYWORD(deleter)
-  BOOST_PARAMETER_TEMPLATE_KEYWORD(copy_policy)
-
-  template <class T> struct Deallocate {};
-  struct DeepCopy {};
-
-  namespace parameter = boost::parameter;
-
-  struct Foo {};
-  template <class T, class A0, class A1>
-  struct smart_ptr
-  {
-      smart_ptr(Foo*);
-  };
-}
-using namespace test;
-int x = 
-new_window("alert", _width=10, _titlebar=false);
-
-smart_ptr<
-   Foo
- , deleter<Deallocate<Foo> >
- , copy_policy<DeepCopy> > p(new Foo);

test/literate/writing-the-function0.cpp

@@ -1,43 +0,0 @@
-
-#include <boost/parameter/name.hpp>
-
-BOOST_PARAMETER_NAME(graph)
-BOOST_PARAMETER_NAME(visitor)
-BOOST_PARAMETER_NAME(root_vertex)
-BOOST_PARAMETER_NAME(index_map)
-BOOST_PARAMETER_NAME(color_map)
-
-namespace boost {
-
-template <class T = int>
-struct dfs_visitor
-{};
-
-int vertex_index = 0;
-
-}
-#include <boost/parameter/preprocessor.hpp>
-
-namespace graphs
-{
-  BOOST_PARAMETER_FUNCTION(
-      (void),                // 1. parenthesized return type
-      depth_first_search,    // 2. name of the function template
-
-      tag,                   // 3. namespace of tag types
-
-      (required (graph, *) ) // 4. one required parameter, and
-
-      (optional              //    four optional parameters, with defaults
-        (visitor,           *, boost::dfs_visitor<>())
-        (root_vertex,       *, *vertices(graph).first)
-        (index_map,         *, get(boost::vertex_index,graph))
-        (in_out(color_map), *,
-          default_color_map(num_vertices(graph), index_map) )
-      )
-  )
-  {
-      // ... body of function goes here...
-      // use graph, visitor, index_map, and color_map
-  }
-}

test/macros.cpp

@@ -52,6 +52,6 @@ int main()
      , index = boost::ref(x), name = "foo"
    );
 
-   return boost::report_errors();
+   return 0;
 }
 

test/maybe.cpp

@@ -1,35 +0,0 @@
-// Copyright Daniel Wallin 2006. Use, modification and distribution is
-// subject to 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)
-
-#include <boost/parameter/keyword.hpp>
-#include <boost/parameter/aux_/maybe.hpp>
-#include <cassert>
-
-namespace test {
-
-BOOST_PARAMETER_KEYWORD(tag, kw)
-BOOST_PARAMETER_KEYWORD(tag, unused)
-    
-template <class Args>
-int f(Args const& args)
-{
-    return args[kw | 1.f];
-}
-
-} // namespace test
-
-int main()
-{
-    using test::kw;
-    using test::unused;
-    using test::f;
-    using boost::parameter::aux::maybe;
-
-    assert(f((kw = 0, unused = 0)) == 0);
-    assert(f(unused = 0) == 1);
-    assert(f((kw = maybe<int>(), unused = 0)) == 1);
-    assert(f((kw = maybe<int>(2), unused = 0)) == 2);
-    return 0;
-}
-

test/mpl.cpp

@@ -1,80 +0,0 @@
-// Copyright David Abrahams 2006. 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)
-
-#include "basics.hpp"
-#include <boost/mpl/list.hpp>
-#include <boost/mpl/for_each.hpp>
-#include <boost/mpl/assert.hpp>
-#include <boost/mpl/size.hpp>
-#include <boost/type_traits/add_pointer.hpp>
-
-# include <boost/mpl/contains.hpp>
-
-namespace test
-{
-  namespace mpl = boost::mpl;
-
-  template <class Set>
-  struct assert_in_set
-  {
-      template <class T>
-      void operator()(T*)
-      {
-          BOOST_MPL_ASSERT((mpl::contains<Set,T>));
-      }
-  };
-
-  
-  template<class Expected, class Params>
-  void f_impl(Params const& p BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Expected))
-  {
-      BOOST_MPL_ASSERT_RELATION(
-          mpl::size<Expected>::value
-        , ==
-        , mpl::size<Params>::value
-      );
-
-      mpl::for_each<Params, boost::add_pointer<mpl::_1> >(assert_in_set<Expected>());
-  }
-
-  template<class Expected, class Tester, class Name, class Value, class Index>
-  void f(Tester const& t, const Name& name_, 
-      const Value& value_, const Index& index_ BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Expected))
-  {
-      f_impl<Expected>(f_parameters()(t, name_, value_, index_));
-  }
-
-  template<class Expected, class Tester, class Name, class Value>
-  void f(Tester const& t, const Name& name_, const Value& value_ BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Expected))
-  {
-      f_impl<Expected>(f_parameters()(t, name_, value_));
-  }
-
-  template<class Expected, class Tester, class Name>
-  void f(Tester const& t, const Name& name_ BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Expected))
-  {
-      f_impl<Expected>(f_parameters()(t, name_));
-  }
-
-  void run()
-  {
-      typedef test::tag::tester tester_;
-      typedef test::tag::name name_;
-      typedef test::tag::value value_;
-      typedef test::tag::index index_;
-
-      f<mpl::list4<tester_,name_,value_,index_> >(1, 2, 3, 4);
-      f<mpl::list3<tester_,name_,index_> >(1, 2, index = 3);
-      f<mpl::list3<tester_,name_,index_> >(1, index = 2, name = 3);
-      f<mpl::list2<name_,value_> >(name = 3, value = 4);
-      f_impl<mpl::list1<value_> >(value = 4);
-  }
-}
-
-int main()
-{
-    test::run();
-    return 0;
-}
-

test/normalized_argument_types.cpp

@@ -1,85 +0,0 @@
-// Copyright Daniel Wallin 2006. Use, modification and distribution is
-// subject to 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)
-
-#include <boost/parameter.hpp>
-#include <boost/mpl/assert.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <cassert>
-
-struct count_instances
-{
-    count_instances()
-    {
-        ++count;
-    }
-
-    count_instances(count_instances const&)
-    {
-        ++count;
-    }
-
-    template <class T>
-    count_instances(T const&)
-    {
-        ++count;
-    }
-
-    ~count_instances()
-    {
-        --count;
-    }
-
-    static std::size_t count;
-};
-
-std::size_t count_instances::count = 0;
-
-BOOST_PARAMETER_NAME(x)
-BOOST_PARAMETER_NAME(y)
-
-BOOST_PARAMETER_FUNCTION((int), f, tag,
-    (required
-       (x, (int))
-       (y, (int))
-    )
-)
-{
-    BOOST_MPL_ASSERT((boost::is_same<x_type,int>));
-    BOOST_MPL_ASSERT((boost::is_same<y_type,int>));
-    return 0;
-}
-
-BOOST_PARAMETER_FUNCTION((int), g, tag,
-    (required
-       (x, (count_instances))
-    )
-)
-{
-    BOOST_MPL_ASSERT((boost::is_same<x_type,count_instances>));
-    assert(count_instances::count > 0);
-    return 0;
-}
-
-BOOST_PARAMETER_FUNCTION((int), h, tag,
-    (required
-       (x, (count_instances const&))
-    )
-)
-{
-    BOOST_MPL_ASSERT((boost::is_same<x_type,count_instances const>));
-    assert(count_instances::count == 1);
-    return 0;
-}
-
-int main()
-{
-    f(1, 2);
-    f(1., 2.f);
-    f(1U, 2L);
-
-    g(0);
-
-    h(0);
-}
-

test/ntp.cpp

@@ -1,110 +0,0 @@
-// Copyright Daniel Wallin 2006. Use, modification and distribution is
-// subject to 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)
-
-#include <boost/parameter.hpp>
-#include <boost/mpl/assert.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/is_base_and_derived.hpp>
-
-namespace mpl = boost::mpl;
-namespace parameter = boost::parameter;
-
-template <class T = int>
-struct a0_is
-  : parameter::template_keyword<a0_is<>, T>
-{};
-
-template <class T = int>
-struct a1_is
-  : parameter::template_keyword<a1_is<>, T>
-{};
-
-template <class T = int>
-struct a2_is
-  : parameter::template_keyword<a2_is<>, T>
-{};
-
-template <class T = int>
-struct a3_is
-  : parameter::template_keyword<a3_is<>, T>
-{};
-
-struct X {};
-struct Y : X {};
-
-template <
-    class A0 = parameter::void_
-  , class A1 = parameter::void_
-  , class A2 = parameter::void_
-  , class A3 = parameter::void_
->
-struct with_ntp
-{
-    typedef typename parameter::parameters<
-        a0_is<>, a1_is<>, a2_is<>
-      , parameter::optional<
-            parameter::deduced<a3_is<> >
-          , boost::is_base_and_derived<X, mpl::_>
-        >
-    >::bind<A0,A1,A2,A3
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-          , parameter::void_
-#endif 
-            >::type args;
-
-    typedef typename parameter::binding<
-        args, a0_is<>, void*
-    >::type a0;
-
-    typedef typename parameter::binding<
-        args, a1_is<>, void*
-    >::type a1;
-
-    typedef typename parameter::binding<
-        args, a2_is<>, void*
-    >::type a2;
-
-    typedef typename parameter::binding<
-        args, a3_is<>, void*
-    >::type a3;
-
-    typedef void(*type)(a0,a1,a2,a3);
-};
-
-BOOST_MPL_ASSERT((boost::is_same<
-    with_ntp<>::type, void(*)(void*,void*,void*,void*)
->));
-
-BOOST_MPL_ASSERT((boost::is_same<
-    with_ntp<a2_is<int> >::type, void(*)(void*,void*,int,void*)
->));
-
-BOOST_MPL_ASSERT((boost::is_same<
-    with_ntp<a1_is<int> >::type, void(*)(void*,int,void*,void*)
->));
-
-BOOST_MPL_ASSERT((boost::is_same<
-    with_ntp<a2_is<int const>, a1_is<float> >::type, void(*)(void*,float,int const,void*)
->));
-
-BOOST_MPL_ASSERT((boost::is_same<
-    with_ntp<int const>::type, void(*)(int const, void*, void*,void*)
->));
-
-BOOST_MPL_ASSERT((boost::is_same<
-    with_ntp<int, float>::type, void(*)(int, float, void*,void*)
->));
-
-BOOST_MPL_ASSERT((boost::is_same<
-    with_ntp<int, float, char>::type, void(*)(int, float, char,void*)
->));
-
-BOOST_MPL_ASSERT((boost::is_same<
-    with_ntp<a0_is<int>, Y>::type, void(*)(int,void*,void*, Y)
->));
-
-BOOST_MPL_ASSERT((boost::is_same<
-    with_ntp<int&, a2_is<char>, Y>::type, void(*)(int&,void*,char, Y)
->));
-

test/optional_deduced_sfinae.cpp

@@ -1,73 +0,0 @@
-// Copyright Daniel Wallin 2006. Use, modification and distribution is
-// subject to 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)
-
-#include <boost/parameter/preprocessor.hpp>
-#include <boost/parameter/name.hpp>
-#include <boost/type_traits/is_convertible.hpp>
-#include <boost/tuple/tuple.hpp>
-#include <string>
-#include "basics.hpp"
-#include <boost/utility/enable_if.hpp>
-
-namespace test {
-
-namespace mpl = boost::mpl;
-
-using mpl::_;
-using boost::is_convertible;
-
-BOOST_PARAMETER_NAME(x)
-
-// Sun has problems with this syntax:
-//
-//   template1< r* ( template2<x> ) >
-//
-// Workaround: factor template2<x> into a separate typedef
-
-#if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x580))
-
-typedef is_convertible<_,char const*> predicate;
-
-BOOST_PARAMETER_FUNCTION((int), sfinae, tag,
-  (deduced
-     (optional (x, *(predicate), 0))
-  )
-)
-{
-    return 1;
-}
-
-#else
-
-BOOST_PARAMETER_FUNCTION((int), sfinae, tag,
-  (deduced
-     (optional (x, *(is_convertible<_,char const*>), 0))
-  )
-)
-{
-    return 1;
-}
-
-#endif
-
-template<class A0>
-typename boost::enable_if<boost::is_same<int,A0>, int>::type
-sfinae(A0 const& a0)
-{
-    return 0;
-}
-
-} // namespace test
-
-int main()
-{
-    using namespace test;
-
-    assert(sfinae() == 1);
-    assert(sfinae("foo") == 1);
-    assert(sfinae(1) == 0);
-
-    return 0;
-}
-

test/preprocessor.cpp

@@ -1,482 +0,0 @@
-// Copyright Daniel Wallin 2006. Use, modification and distribution is
-// subject to 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)
-
-#include <boost/parameter/preprocessor.hpp>
-#include <boost/parameter/keyword.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <string>
-#include "basics.hpp"
-
-#ifndef BOOST_NO_SFINAE
-# include <boost/utility/enable_if.hpp>
-#endif
-
-namespace test {
-
-BOOST_PARAMETER_BASIC_FUNCTION((int), f, tag,
-    (required
-      (tester, *)
-      (name, *)
-    )
-    (optional
-      (value, *)
-      (out(index), (int))
-    )
-)
-{
-    typedef typename boost::parameter::binding<
-        Args, tag::index, int&
-    >::type index_type;
-
-    BOOST_MPL_ASSERT((boost::is_same<index_type, int&>));
-
-    args[tester](
-        args[name]
-      , args[value | 1.f]
-      , args[index | 2]
-    );
-
-    return 1;
-}
-
-BOOST_PARAMETER_BASIC_FUNCTION((int), g, tag,
-    (required
-      (tester, *)
-      (name, *)
-    )
-    (optional
-      (value, *)
-      (out(index), (int))
-    )
-)
-{
-    typedef typename boost::parameter::binding<
-        Args, tag::index, int const&
-    >::type index_type;
-
-    BOOST_MPL_ASSERT((boost::is_same<index_type, int const&>));
-
-    args[tester](
-        args[name]
-      , args[value | 1.f]
-      , args[index | 2]
-    );
-
-    return 1;
-}
-
-BOOST_PARAMETER_FUNCTION((int), h, tag,
-    (required
-      (tester, *)
-      (name, *)
-    )
-    (optional
-      (value, *, 1.f)
-      (out(index), (int), 2)
-    )
-)
-{
-# if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) \
-  && !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-    BOOST_MPL_ASSERT((boost::is_same<index_type, int>));
-# endif
-
-    tester(
-        name
-      , value
-      , index
-    );
-
-    return 1;
-}
-
-BOOST_PARAMETER_FUNCTION((int), h2, tag,
-    (required
-      (tester, *)
-      (name, *)
-    )
-    (optional
-      (value, *, 1.f)
-      (out(index), (int), (int)value * 2)
-    )
-)
-{
-# if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) \
-  && !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-    BOOST_MPL_ASSERT((boost::is_same<index_type, int>));
-# endif
-
-    tester(
-        name
-      , value
-      , index
-    );
-
-    return 1;
-}
-
-struct base
-{
-    template <class Args>
-    base(Args const& args)
-    {
-        args[tester](
-            args[name]
-          , args[value | 1.f]
-          , args[index | 2]
-        );
-    }
-};
-
-struct class_ : base
-{
-    BOOST_PARAMETER_CONSTRUCTOR(class_, (base), tag,
-        (required
-          (tester, *)
-          (name, *)
-        )
-        (optional
-          (value, *)
-          (index, *)
-        )
-    )
-
-    BOOST_PARAMETER_BASIC_MEMBER_FUNCTION((int), f, tag,
-        (required
-          (tester, *)
-          (name, *)
-        )
-        (optional
-          (value, *)
-          (index, *)
-        )
-    )
-    {
-        args[tester](
-            args[name]
-          , args[value | 1.f]
-          , args[index | 2]
-        );
-
-        return 1;
-    }
-
-    BOOST_PARAMETER_BASIC_CONST_MEMBER_FUNCTION((int), f, tag,
-        (required
-          (tester, *)
-          (name, *)
-        )
-        (optional
-          (value, *)
-          (index, *)
-        )
-    )
-    {
-        args[tester](
-            args[name]
-          , args[value | 1.f]
-          , args[index | 2]
-        );
-
-        return 1;
-    }
-
-    BOOST_PARAMETER_MEMBER_FUNCTION((int), f2, tag,
-        (required
-          (tester, *)
-          (name, *)
-        )
-        (optional
-          (value, *, 1.f)
-          (index, *, 2)
-        )
-    )
-    {
-        tester(name, value, index);
-        return 1;
-    }
-
-    BOOST_PARAMETER_CONST_MEMBER_FUNCTION((int), f2, tag,
-        (required
-          (tester, *)
-          (name, *)
-        )
-        (optional
-          (value, *, 1.f)
-          (index, *, 2)
-        )
-    )
-    {
-        tester(name, value, index);
-        return 1;
-    }
-
-
-    BOOST_PARAMETER_MEMBER_FUNCTION((int), static f_static, tag,
-        (required
-          (tester, *)
-          (name, *)
-        )
-        (optional
-          (value, *, 1.f)
-          (index, *, 2)
-        )
-    )
-    {
-        tester(name, value, index);
-        return 1;
-    }
-};
-
-BOOST_PARAMETER_FUNCTION(
-    (int), sfinae, tag,
-    (required
-       (name, (std::string))
-    )
-)
-{
-    return 1;
-}
-
-#ifndef BOOST_NO_SFINAE
-// On compilers that actually support SFINAE, add another overload
-// that is an equally good match and can only be in the overload set
-// when the others are not.  This tests that the SFINAE is actually
-// working.  On all other compilers we're just checking that
-// everything about SFINAE-enabled code will work, except of course
-// the SFINAE.
-template<class A0>
-typename boost::enable_if<boost::is_same<int,A0>, int>::type
-sfinae(A0 const& a0)
-{
-    return 0;
-}
-#endif
-
-#if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x580))
-
-// Sun has problems with this syntax:
-//
-//   template1< r* ( template2<x> ) >
-//
-// Workaround: factor template2<x> into a separate typedef
-typedef boost::is_convertible<boost::mpl::_, std::string> predicate;
-
-BOOST_PARAMETER_FUNCTION(
-    (int), sfinae1, tag,
-    (required
-       (name, *(predicate))
-    )
-)
-{
-    return 1;
-}
-
-#else
-
-BOOST_PARAMETER_FUNCTION(
-    (int), sfinae1, tag,
-    (required
-       (name, *(boost::is_convertible<boost::mpl::_, std::string>))
-    )
-)
-{
-    return 1;
-}
-#endif 
-
-#ifndef BOOST_NO_SFINAE
-// On compilers that actually support SFINAE, add another overload
-// that is an equally good match and can only be in the overload set
-// when the others are not.  This tests that the SFINAE is actually
-// working.  On all other compilers we're just checking that
-// everything about SFINAE-enabled code will work, except of course
-// the SFINAE.
-template<class A0>
-typename boost::enable_if<boost::is_same<int,A0>, int>::type
-sfinae1(A0 const& a0)
-{
-    return 0;
-}
-#endif
-
-template <class T>
-T const& as_lvalue(T const& x)
-{
-    return x;
-}
-
-struct udt
-{
-    udt(int foo, int bar)
-      : foo(foo)
-      , bar(bar)
-    {}
-
-    int foo;
-    int bar;
-};
-
-BOOST_PARAMETER_FUNCTION((int), lazy_defaults, tag,
-    (required
-      (name, *)
-    )
-    (optional
-      (value, *, name.foo)
-      (index, *, name.bar)
-    )
-)
-{
-    return 0;
-}
-
-} // namespace test
-
-int main()
-{
-    using namespace test;
-
-    f(
-        values(S("foo"), 1.f, 2)
-      , S("foo")
-    );
-
-    f(
-        tester = values(S("foo"), 1.f, 2)
-      , name = S("foo")
-    );
-
-    int index_lvalue = 2;
-
-    f(
-        tester = values(S("foo"), 1.f, 2)
-      , name = S("foo")
-      , value = 1.f
-      , test::index = index_lvalue
-    );
-
-    f(
-        values(S("foo"), 1.f, 2)
-      , S("foo")
-      , 1.f
-      , index_lvalue
-    );
-
-    g(
-        values(S("foo"), 1.f, 2)
-      , S("foo")
-      , 1.f
-#if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
-      , as_lvalue(2)
-#else
-      , 2
-#endif
-    );
-
-    h(
-        values(S("foo"), 1.f, 2)
-      , S("foo")
-      , 1.f
-#if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
-      , as_lvalue(2)
-#else
-      , 2
-#endif
-    );
-
-    h2(
-        tester = values(S("foo"), 1.f, 2)
-      , name = S("foo")
-      , value = 1.f
-    );
-
-    class_ x(
-        values(S("foo"), 1.f, 2)
-      , S("foo"), test::index = 2
-    );
-
-    x.f(
-        values(S("foo"), 1.f, 2)
-      , S("foo")
-    );
-
-    x.f(
-        tester = values(S("foo"), 1.f, 2)
-      , name = S("foo")
-    );
-
-    x.f2(
-        values(S("foo"), 1.f, 2)
-      , S("foo")
-    );
-
-    x.f2(
-        tester = values(S("foo"), 1.f, 2)
-      , name = S("foo")
-    );
-
-    class_ const& x_const = x;
-
-    x_const.f(
-        values(S("foo"), 1.f, 2)
-      , S("foo")
-    );
-
-    x_const.f(
-        tester = values(S("foo"), 1.f, 2)
-      , name = S("foo")
-    );
-
-    x_const.f2(
-        values(S("foo"), 1.f, 2)
-      , S("foo")
-    );
-
-    x_const.f2(
-        tester = values(S("foo"), 1.f, 2)
-      , name = S("foo")
-    );
-
-    x_const.f2(
-        tester = values(S("foo"), 1.f, 2)
-      , name = S("foo")
-    );
-
-    class_::f_static(
-        values(S("foo"), 1.f, 2)
-      , S("foo")
-    );
-
-    class_::f_static(
-        tester = values(S("foo"), 1.f, 2)
-      , name = S("foo")
-    );
-
-#if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
-    assert(sfinae("foo") == 1);
-    assert(sfinae(1) == 0);
-
-# if !BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x580))
-    // Sun actually eliminates the desired overload for some reason.
-    // Disabling this part of the test because SFINAE abilities are
-    // not the point of this test.
-    assert(sfinae1("foo") == 1);
-# endif
-    
-    assert(sfinae1(1) == 0);
-#endif
-
-    lazy_defaults(
-        name = udt(0,1)
-    );
-
-    lazy_defaults(
-        name = 0
-      , value = 1
-      , test::index = 2
-    );
-
-    return boost::report_errors();
-}
-

test/preprocessor_deduced.cpp

@@ -1,171 +0,0 @@
-// Copyright Daniel Wallin 2006. Use, modification and distribution is
-// subject to 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)
-
-#include <boost/parameter/preprocessor.hpp>
-#include <boost/parameter/name.hpp>
-#include <boost/type_traits/is_convertible.hpp>
-#include <boost/tuple/tuple.hpp>
-#include <string>
-#include "basics.hpp"
-
-#ifndef BOOST_NO_SFINAE
-# include <boost/utility/enable_if.hpp>
-#endif
-
-namespace test {
-
-namespace mpl = boost::mpl;
-
-using mpl::_;
-using boost::is_convertible;
-
-BOOST_PARAMETER_NAME(expected)
-BOOST_PARAMETER_NAME(x)
-BOOST_PARAMETER_NAME(y)
-BOOST_PARAMETER_NAME(z)
-
-// Sun has problems with this syntax:
-//
-//   template1< r* ( template2<x> ) >
-//
-// Workaround: factor template2<x> into a separate typedef
-typedef is_convertible<_, int> predicate1;
-typedef is_convertible<_, std::string> predicate2;
-
-#if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x580))
-
-BOOST_PARAMETER_FUNCTION((int), f, tag,
-    (required
-       (expected, *)
-    )
-    (deduced
-       (required
-          (x, *(predicate1))
-          (y, *(predicate2))
-       )
-    )
-)
-#else
-BOOST_PARAMETER_FUNCTION((int), f, tag,
-    (required
-       (expected, *)
-    )
-    (deduced
-       (required
-          (x, *(is_convertible<_, int>))
-          (y, *(is_convertible<_, std::string>))
-       )
-    )
-)
-#endif 
-{
-    assert(equal(x, boost::tuples::get<0>(expected)));
-    assert(equal(y, boost::tuples::get<1>(expected)));
-    return 1;
-}
-
-struct X 
-{
-    X(int x = -1)
-      : x(x)
-    {}
-    
-    bool operator==(X const& other) const
-    {
-        return x == other.x;
-    }
-    
-    int x;
-};
-
-typedef is_convertible<_, X> predicate3;  // SunPro workaround; see above
-
-BOOST_PARAMETER_FUNCTION((int), g, tag,
-    (required
-      (expected, *)
-    )
-    (deduced
-       (required
-          (x, *(is_convertible<_, int>))
-          (y, *(is_convertible<_, std::string>))
-       )
-       (optional
-          (z, *(predicate3), X())
-       )
-    )
-)
-{
-    assert(equal(x, boost::tuples::get<0>(expected)));
-    assert(equal(y, boost::tuples::get<1>(expected)));
-    assert(equal(z, boost::tuples::get<2>(expected)));
-    return 1;
-}
-
-BOOST_PARAMETER_FUNCTION(
-    (int), sfinae, tag,
-    (deduced
-      (required
-        (x, *(predicate2))
-      )
-    )
-)
-{
-    return 1;
-}
-
-#ifndef BOOST_NO_SFINAE
-// On compilers that actually support SFINAE, add another overload
-// that is an equally good match and can only be in the overload set
-// when the others are not.  This tests that the SFINAE is actually
-// working.  On all other compilers we're just checking that
-// everything about SFINAE-enabled code will work, except of course
-// the SFINAE.
-template<class A0>
-typename boost::enable_if<boost::is_same<int,A0>, int>::type
-sfinae(A0 const& a0)
-{
-    return 0;
-}
-#endif
-
-} // namespace test
-
-using boost::make_tuple;
-
-// make_tuple doesn't work with char arrays.
-char const* str(char const* s)
-{
-    return s;
-}
-
-int main()
-{
-    using namespace test;
-
-    f(make_tuple(0, str("foo")), _x = 0, _y = "foo");
-    f(make_tuple(0, str("foo")), _x = 0, _y = "foo");
-    f(make_tuple(0, str("foo")), 0, "foo");
-    f(make_tuple(0, str("foo")), "foo", 0);
-    f(make_tuple(0, str("foo")), _y = "foo", 0);
-    f(make_tuple(0, str("foo")), _x = 0, "foo");
-    f(make_tuple(0, str("foo")), 0, _y = "foo");
-
-    g(make_tuple(0, str("foo"), X()), _x = 0, _y = "foo");
-    g(make_tuple(0, str("foo"), X()), 0, "foo");
-    g(make_tuple(0, str("foo"), X()), "foo", 0);
-    g(make_tuple(0, str("foo"), X()), _y = "foo", 0);   
-    g(make_tuple(0, str("foo"), X()), _x = 0, "foo");
-    g(make_tuple(0, str("foo"), X()), 0, _y = "foo");
-
-    g(make_tuple(0, str("foo"), X(1)), 0, _y = "foo", X(1));
-    g(make_tuple(0, str("foo"), X(1)), X(1), 0, _y = "foo");
-
-#ifndef BOOST_NO_SFINAE
-    assert(sfinae("foo") == 1);
-    assert(sfinae(0) == 0);
-#endif
-
-    return 0;
-}
-

test/python_test.cpp

@@ -1,172 +0,0 @@
-// Copyright Daniel Wallin 2006. Use, modification and distribution is
-// subject to 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)
-
-#include <math.h>
-#include <boost/python.hpp>
-#include <boost/parameter/preprocessor.hpp>
-#include <boost/parameter/keyword.hpp>
-#include <boost/parameter/python.hpp>
-#include <boost/utility/enable_if.hpp>
-
-namespace test {
-
-BOOST_PARAMETER_KEYWORD(tags, x)
-BOOST_PARAMETER_KEYWORD(tags, y)
-BOOST_PARAMETER_KEYWORD(tags, z)
-
-struct Xbase
-{
-    // We need the disable_if part for VC7.1/8.0.
-    template <class Args>
-    Xbase(
-        Args const& args
-      , typename boost::disable_if<
-            boost::is_base_and_derived<Xbase, Args>
-        >::type* = 0
-    )
-      : value(std::string(args[x | "foo"]) + args[y | "bar"])
-    {}
-
-    std::string value;
-};
-
-struct X : Xbase
-{
-    BOOST_PARAMETER_CONSTRUCTOR(X, (Xbase), tags,
-        (optional
-         (x, *)
-         (y, *)
-        )
-    )
-
-    BOOST_PARAMETER_BASIC_MEMBER_FUNCTION((int), f, tags,
-        (required
-         (x, *)
-         (y, *)
-        )
-        (optional
-         (z, *)
-        )
-    )
-    {
-        return args[x] + args[y] + args[z | 0];
-    }
-
-    BOOST_PARAMETER_BASIC_MEMBER_FUNCTION((std::string), g, tags,
-        (optional
-         (x, *)
-         (y, *)
-        )
-    )
-    {
-        return std::string(args[x | "foo"]) + args[y | "bar"];
-    }
-
-    BOOST_PARAMETER_MEMBER_FUNCTION((X&), h, tags,
-        (optional (x, *, "") (y, *, ""))
-    )
-    {
-        return *this;
-    }
-
-    template <class A0>
-    X& operator()(A0 const& a0)
-    {
-        return *this;
-    }
-};
-
-} // namespace test
-
-struct f_fwd
-{
-    template <class R, class T, class A0, class A1, class A2>
-    R operator()(boost::type<R>, T& self, A0 const& a0, A1 const& a1, A2 const& a2)
-    {
-        return self.f(a0,a1,a2);
-    }
-};
-
-struct g_fwd
-{
-    template <class R, class T, class A0, class A1>
-    R operator()(boost::type<R>, T& self, A0 const& a0, A1 const& a1)
-    {
-        return self.g(a0,a1);
-    }
-};
-
-struct h_fwd
-{
-    template <class R, class T>
-    R operator()(boost::type<R>, T& self)
-    {
-        return self.h();
-    }
-
-    template <class R, class T, class A0>
-    R operator()(boost::type<R>, T& self, A0 const& a0)
-    {
-        return self.h(a0);
-    }
-
-    template <class R, class T, class A0, class A1>
-    R operator()(boost::type<R>, T& self, A0 const& a0, A1 const& a1)
-    {
-        return self.h(a0,a1);
-    }
-};
-
-BOOST_PYTHON_MODULE(python_test_ext)
-{
-    namespace mpl = boost::mpl;
-    using namespace test;
-    using namespace boost::python;
-
-    class_<X>("X")
-        .def(
-            boost::parameter::python::init<
-                mpl::vector<
-                    tags::x*(std::string), tags::y*(std::string)
-                >
-            >()
-        )
-        .def(
-            "f"
-          , boost::parameter::python::function<
-                f_fwd
-              , mpl::vector<
-                    int, tags::x(int), tags::y(int), tags::z*(int)
-                >
-            >()
-        )
-        .def(
-            "g"
-          , boost::parameter::python::function<
-                g_fwd
-              , mpl::vector<
-                    std::string, tags::x*(std::string), tags::y*(std::string)
-                >
-            >()
-        )
-        .def(
-            "h"
-          , boost::parameter::python::function<
-                h_fwd
-              , mpl::vector<
-                    X&, tags::x**(std::string), tags::y**(std::string)
-                >
-            >()
-          , return_arg<>()
-        )
-        .def(
-            boost::parameter::python::call<
-                mpl::vector<
-                    X&, tags::x(int)
-                >
-            >() [ return_arg<>() ]
-        )
-        .def_readonly("value", &X::value);
-}
-

test/python_test.py

@@ -1,41 +0,0 @@
-# Copyright Daniel Wallin 2006. 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)
-
-'''
->>> from python_test_ext import X
->>> x = X(y = 'baz')
->>> x.value
-'foobaz'
->>> x.f(1,2)
-3
->>> x.f(1,2,3)
-6
->>> x.f(1,2, z = 3)
-6
->>> x.f(z = 3, y = 2, x = 1)
-6
->>> x.g()
-'foobar'
->>> x.g(y = "baz")
-'foobaz'
->>> x.g(x = "baz")
-'bazbar'
->>> x.g(y = "foo", x = "bar")
-'barfoo'
->>> y = x.h(x = "bar", y = "foo")
->>> assert x == y
->>> y = x(0)
->>> assert x == y
-'''
-
-def run(args = None):
-    if args is not None:
-        import sys
-        sys.argv = args
-    import doctest, python_test 
-    return doctest.testmod(python_test)
-
-if __name__ == '__main__':
-    import sys
-    sys.exit(run()[0])

test/sfinae.cpp

@@ -4,12 +4,12 @@
 // http://www.boost.org/LICENSE_1_0.txt
 
 #include <boost/parameter.hpp>
-#include <boost/parameter/match.hpp>
-#include <boost/detail/lightweight_test.hpp>
+#include <cassert>
 #include <string>
 #include <boost/type_traits/is_convertible.hpp>
+#include <iostream>
 
-#if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
+#ifndef BOOST_NO_SFINAE
 # include <boost/utility/enable_if.hpp>
 # include <boost/type_traits/is_same.hpp>
 #endif 
@@ -34,19 +34,16 @@ namespace test
       >
   {};
 
-  // The use of assert_equal_string is just a nasty workaround for a
-  // vc++ 6 ICE.
-  void assert_equal_string(std::string x, std::string y)
-  {
-        BOOST_TEST(x == y);
-  }
+  template <class T> struct not_implemented;
   
   template<class P>
   void f_impl(P const& p)
   {
+      std::string s = p[name | "bar"];
       float v = p[value | 3.f];
-      BOOST_TEST(v == 3.f);
-      assert_equal_string(p[name | "bar"], "foo");
+
+      assert(s == "foo");
+      assert(v == 3.f);
   }
 
   void f()
@@ -54,6 +51,8 @@ namespace test
       f_impl(f_parameters()());
   }
 
+  using boost::parameter::aux::void_;
+  
   template<class A0>
   void f(
       A0 const& a0
@@ -70,7 +69,7 @@ namespace test
       f_impl(args(a0, a1));
   }
 
-#if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
+#ifndef BOOST_NO_SFINAE
   // On compilers that actually support SFINAE, add another overload
   // that is an equally good match and can only be in the overload set
   // when the others are not.  This tests that the SFINAE is actually
@@ -96,9 +95,10 @@ int main()
     f("foo", 3.f);
     f(value = 3.f, name = "foo");
 
-#if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
-    BOOST_TEST(f(3, 4) == 0);
-#endif
-    return boost::report_errors();
+#ifndef BOOST_NO_SFINAE
+    return f(3, 4);
+#else 
+    return 0;
+#endif 
 }
 

test/singular.cpp

@@ -1,42 +0,0 @@
-// Copyright Daniel Wallin 2005. Use, modification and distribution is
-// subject to 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)
-
-#include <boost/parameter/keyword.hpp>
-#include <boost/detail/lightweight_test.hpp>
-
-BOOST_PARAMETER_KEYWORD(tag, x)
-BOOST_PARAMETER_KEYWORD(tag, y)
-    
-struct default_src
-{
-    typedef int result_type;
-
-    int operator()() const
-    {
-        return 0;
-    }
-};
-    
-template <class ArgumentPack, class K, class T>
-void check(ArgumentPack const& p, K const& kw, T const& value)
-{
-    BOOST_TEST(p[kw] == value);
-}
-
-int main()
-{
-    check(x = 20, x, 20);
-    check(y = 20, y, 20);
-
-    check(x = 20, x | 0, 20);
-    check(y = 20, y | 0, 20);
-
-    check(x = 20, x | default_src(), 20);
-    check(y = 20, y | default_src(), 20);
-    
-    check(y = 20, x | 0, 0);
-    check(y = 20, x || default_src(), 0);
-    return boost::report_errors();
-}
-

test/timings.txt

@@ -1,128 +0,0 @@
-# Copyright David Abrahams 2005. 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)
-
------------------ Test #1 ----------------
-Testers: 
-  Matthias Troyer, Michael Gauckler, David Abrahams
-
-Date:
-  2005-09-09
-
-Compiler: 
-  Cygwin g++-4.0.0
-
-Command lines:
-  g++ -c -o efficiency.o -ftemplate-depth-100 -funroll-loops \
-      -O3 -finline-functions -Wno-inline -DNDEBUG  efficiency.cpp
-
-  g++ -o efficiency.exe efficiency.o -Wl,--strip-all  
-
-  efficiency && efficiency && efficiency
-
-Machine:
-  Dell Inspiron 9300
-  Intel(R) Pentium(R) M processor 2.00GHz
-  Running on 230 volts AC power
-
-Timings:
-  Run #1 results discarded per standard practice
-
-  Run #2
-  plain time: 0.75
-  named parameter time: 0.734
-
-  Run #3
-  plain time: 0.781
-  named parameter time: 0.766
-
------------------ Test #2 ----------------
-
-Testers: 
-  Chris Frey
-
-Date:
-  2005-09-17
-
-Compiler: 
-  Linux kernel 2.4.27
-  gcc version 3.3.6 (Gentoo 3.3.6, ssp-3.3.6-1.0, pie-8.7.8)
-
-Command lines:
-  g++ -c -o efficiency.o -ftemplate-depth-100 -funroll-loops \
-      -O3 -finline-functions -Wno-inline -DNDEBUG  efficiency.cpp
-
-  g++ -o efficiency.exe efficiency.o -Wl,--strip-all  
-
-Machine:
-  IBM Thinkpad 770Z, running on AC power
-  Intel Pentium II 366Mhz
-
-Timings:
-  Run #1 results discarded per standard practice
-
-  Run #2
-  plain time:           6.42
-  named parameter time: 7.34
-
-  Run #3
-  plain time:           6.42
-  named parameter time: 7.34
-
------------------ Test #2 ----------------
-
-Testers: 
-  Stuar Dootson
-
-Date:
-  2005-09-18
-
-Machine:
-  Athlon 64 3500+ laptop, running on AC power
-  Windows XP SP2
-
-
-Compiler: Visual C++ 7.1
-
- command line: 
-   cl -O2 efficiency.cpp -EHsc -I\lib\boost\include\boost-1_33
-
- Results:
-   plain time:           <ignored>
-   named parameter time: <ignored>
-   plain time:           1.453
-   named parameter time: 1.437
-   plain time:           1.453
-   named parameter time: 1.453
-
-Compiler: Visual C++ 8.0
-
- command-line:
-   cl -O2 efficiency.cpp -EHsc -I\lib\boost\include\boost-1_33
-
- Results:
-   plain time:           <ignored>
-   named parameter time: <ignored>
-   plain time:           1.438
-   named parameter time: 1.453
-   plain time:           1.438
-   named parameter time: 1.437
-
-Compiler: Mingw gcc 3.4.2
-
- command-line:
-   g++ -c -o efficiency.o -ftemplate-depth-100 -funroll-loops -O3
-       -finline-functions -Wno-inline -DNDEBUG  efficiency.cpp
-       -I\lib\boost\include\boost-1_33
-   g++ -o efficiency.exe efficiency.o -Wl,--strip-all 
-
- Results:
-   plain time:           <ignored>
-   named parameter time: <ignored>
-   plain time:           1.14
-   named parameter time: 1.422
-   plain time:           1.125
-   named parameter time: 1.406
-
------------------------------------------
-

test/tutorial.cpp

@@ -1,38 +0,0 @@
-// Copyright David Abrahams 2005. 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)
-
-#include <iostream>
-#include <boost/parameter/keyword.hpp>
-
-namespace graphs
-{
-   BOOST_PARAMETER_KEYWORD(tag, graph)    // Note: no semicolon
-   BOOST_PARAMETER_KEYWORD(tag, visitor)
-   BOOST_PARAMETER_KEYWORD(tag, root_vertex)
-   BOOST_PARAMETER_KEYWORD(tag, index_map)
-   BOOST_PARAMETER_KEYWORD(tag, color_map)
-}
-
-namespace graphs { namespace core
-{
-   template <class ArgumentPack>
-   void depth_first_search(ArgumentPack const& args)
-   {
-       std::cout << "graph:\t" << args[graph] << std::endl;
-       std::cout << "visitor:\t" << args[visitor] << std::endl;
-       std::cout << "root_vertex:\t" << args[root_vertex] << std::endl;
-       std::cout << "index_map:\t" << args[index_map] << std::endl;
-       std::cout << "color_map:\t" << args[color_map] << std::endl;
-   }
-}} // graphs::core
-
-int main()
-{
-     using namespace graphs;
-
-     core::depth_first_search((
-       graph = 'G', visitor = 2, root_vertex = 3.5,
-       index_map = "hello, world", color_map = false));
-     return 0;
-}