Every ArgumentPack is now a valid MPL Forward Sequence.

[SVN r32442]

.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 {
@@ -18,16 +13,6 @@ img {
   vertical-align: middle
 }
 
-span.vellipsis {
-  display: block;
-  width: 5px;
-  height: 22px;
-  background: url("vellipsis.gif");
-  margin-left: 3em;
-  text-indent: -1000px;
-}
-
-
 PRE
 {
     FONT-FAMILY: monospace ;

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
 
 
 //////////////////////////////////////////////////////////////////////////////
@@ -42,8 +42,9 @@ __ ../../../../index.htm
 .. |ForwardSequence| replace:: :concept:`Forward Sequence`
 .. |ParameterSpec| replace:: :concept:`ParameterSpec`
 
-.. role:: vellipsis
-   :class: vellipsis
+
+.. role:: large
+   :class: doublesize
 
 .. section-numbering::
     :depth: 2
@@ -174,7 +175,7 @@ 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|
 --------------
@@ -253,7 +254,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 +382,13 @@ __ ../../../../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;
+           :large:`⋮`
         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 +401,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 +423,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 +441,8 @@ __ ../../../../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;
+         :large:`⋮`
       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
@@ -890,9 +583,7 @@ Generates
     {
        return **name**\ _with_named_params(**p**\ (x1,x2,…x\ **l**,x\ ##\ BOOST_PP_INC_\ (**l**)));
     }
-
-    :vellipsis:`⋮`
-
+       :large:`⋮`
     template <class A1, class A2, …class A\ **h**>
     r name(
         A1 const& a1, A2 const& a2, …A\ **h** const& x\ **h**
@@ -907,11 +598,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 +656,7 @@ already ``#defined``.
 
 __ ../../../../boost/parameter/config.hpp
 
-:Default Value: ``8``
+:Default Value: ``5``
 
 Tutorial
 ========
@@ -997,5 +683,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

@@ -1,21 +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)
-
-//  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

@@ -11,7 +11,7 @@
 #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/aux_/maybe_fwd.hpp>
 #include <boost/parameter/config.hpp>
 
 #include <boost/mpl/apply.hpp>
@@ -22,20 +22,19 @@
 
 #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 {
+#include <boost/optional.hpp>
+
+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,7 +45,7 @@ struct lambda_tag;
 // declarations to build member function overload sets that can
 // match against keywords.
 //
-
+  
 // MPL sequence support
 struct arg_list_tag;
 
@@ -71,22 +70,26 @@ 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;
         };
     };
 
+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
     // 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))
-
+#endif
+    
+#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,25 +140,24 @@ 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*);
+    satisfies(ParameterRequirements*);
 
     // MPL sequence support
     typedef empty_arg_list type;   // convenience
     typedef arg_list_tag tag; // For dispatching to sequence intrinsics
 };
 
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+template<class KW>
+no_tag operator*(empty_arg_list, KW*);
+#endif
+
 // 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>
@@ -163,20 +165,8 @@ 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 +174,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 +187,56 @@ 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))
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && !BOOST_WORKAROUND(__GNUC__, == 2)
+# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+    friend yes_tag operator*(arg_list, key_type*);
+#  define BOOST_PARAMETER_CALL_HAS_KEY(next, key) (*(next*)0 * (key*)0)
+# else
     // 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;
+    
+#  define BOOST_PARAMETER_CALL_HAS_KEY(next, key) next::has_key((key*)0)  
+# endif
 
     BOOST_MPL_ASSERT_MSG(
-        sizeof(Next::has_key((key_type*)0)) == sizeof(no_tag)
+        sizeof(BOOST_PARAMETER_CALL_HAS_KEY(Next,key_type)) == sizeof(no_tag)
       , duplicate_keyword, (key_type)
     );
 
+# undef BOOST_PARAMETER_CALL_HAS_KEY
 #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 +260,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 +268,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 +276,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
     {
@@ -306,14 +292,13 @@ struct arg_list : Next
     // 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
+    reference get(default_<key_type,Default>) const
     {
-        return get_default(d, holds_maybe());
+        return arg.value;
     }
 
     template <class Default>
@@ -321,25 +306,41 @@ struct arg_list : Next
     {
         return arg.value;
     }
-
+    
 #else
 
+    typedef typename mpl::eval_if<
+        is_maybe<value_type>
+      , get_reference<value_type>
+      , mpl::identity<reference>
+    >::type default_reference;
+    
     reference operator[](keyword<key_type> const&) const
     {
-        BOOST_MPL_ASSERT_NOT((holds_maybe));
         return arg.value;
     }
 
-    template <class Default>
-    reference operator[](default_<key_type, Default> const& d) const
+    template <class T, class D>
+    default_reference get_value(T&, D&) const
     {
-        return get_default(d, holds_maybe());
+        return arg.value;
+    }
+
+    template <class T, class D>
+    default_reference get_value(maybe<T>&, D& x) const
+    {
+        return arg.value ? arg.value.get() : x;
+    }
+
+    template <class Default>
+    default_reference operator[](default_<key_type, Default> const& x) const
+    {
+        return get_value(arg.value, x.value);
     }
 
     template <class Default>
     reference operator[](lazy_default<key_type, Default>) const
     {
-        BOOST_MPL_ASSERT_NOT((holds_maybe));
         return arg.value;
     }
 
@@ -359,14 +360,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
@@ -377,8 +374,8 @@ struct arg_list : Next
     // 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>, self> 
+    operator,(tagged_argument<KW,T2> x)
     {
         return arg_list<tagged_argument<KW,T2>, self>(x, *this);
     }
@@ -389,6 +386,10 @@ struct arg_list : Next
     typedef arg_list_tag tag; // For dispatching to sequence intrinsics
 };
 
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)  // ETI workaround
+template <> struct arg_list<int,int> {};
+#endif 
+
 // MPL sequence support
 template <class ArgumentPack>
 struct arg_list_iterator
@@ -397,7 +398,7 @@ struct arg_list_iterator
 
     // The incremented iterator
     typedef arg_list_iterator<typename ArgumentPack::tail_type> next;
-
+    
     // dereferencing yields the key type
     typedef typename ArgumentPack::key_type type;
 };

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,99 +1,38 @@
-// Copyright Daniel Wallin 2006. Use, modification and distribution is
+// 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)
 
-//
-// 2009.10.21 TDS remove depenency on boost::python::detail::referent_storage
-//
-#ifndef BOOST_PARAMETER_MAYBE_091021_HPP
-# define BOOST_PARAMETER_MAYBE_091021_HPP
+#ifndef BOOST_PARAMETER_MAYBE_051212_HPP
+# define BOOST_PARAMETER_MAYBE_051212_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>
+# include <boost/optional.hpp>
+# include <boost/mpl/if.hpp>
 
 namespace boost { namespace parameter { namespace aux {
 
-template <class T> struct referent_size;
+struct empty_maybe_tag {};
 
 template <class T>
-struct referent_size<T&>
+struct maybe
 {
-  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
+    typedef typename mpl::if_<
+        is_reference<T>
+      , T
+      , typename add_reference<typename add_const<T>::type>::type
     >::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();
-    }
+    explicit maybe(reference x)
+      : value(x)
+    {}
 
     typedef reference(maybe<T>::*safe_bool)() const;
-
+    
     operator safe_bool() const
     {
         return value ? &maybe<T>::get : 0 ;
@@ -104,17 +43,10 @@ struct maybe : maybe_base
         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
+#endif // BOOST_PARAMETER_MAYBE_051212_HPP
 

include/boost/parameter/aux_/maybe_fwd.hpp

@@ -0,0 +1,26 @@
+// 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_MAYBE_FWD_051212_HPP
+# define BOOST_PARAMETER_MAYBE_FWD_051212_HPP
+
+# include <boost/detail/is_xxx.hpp>
+
+namespace boost { namespace parameter { namespace aux {
+
+template <class T>
+struct maybe;
+
+BOOST_DETAIL_IS_XXX_DEF(maybe,maybe,1)
+
+template <class T>
+struct get_reference
+{
+    typedef typename T::reference type;
+};
+    
+}}} // namespace boost::parameter::aux
+
+#endif // BOOST_PARAMETER_MAYBE_FWD_051212_HPP
+

include/boost/parameter/aux_/overloads.hpp

@@ -44,40 +44,29 @@
 #define N BOOST_PP_ITERATION()
 
 #define BOOST_PARAMETER_open_list(z, n, text) \
-    aux::item< \
+    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))
+    mpl::apply_wrap1< \
+    BOOST_PP_ENUM(N, BOOST_PARAMETER_open_list, _) \
+  , mpl::always<aux::empty_arg_list> \
+    BOOST_PP_REPEAT(N, BOOST_PARAMETER_close_list, _) \
+  , unnamed_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_/tagged_argument.hpp

@@ -3,32 +3,20 @@
 // 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>
+#include <boost/detail/is_xxx.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 +24,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 +41,20 @@ 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))
+#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
+#endif 
 };
 
 // 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_DETAIL_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, < 1300)  // 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, < 1300)  // 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,41 +92,42 @@ 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.
 
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+
+# define BOOST_PARAMETER_KEYWORD(tag_namespace,name)                \
+    namespace tag_namespace { struct name; }                        \
+    static ::boost::parameter::keyword<tag_namespace::name>& name   \
+       = ::boost::parameter::keyword<tag_namespace::name>::get();
+
+#else
+
 #define BOOST_PARAMETER_KEYWORD(tag_namespace,name)                 \
-    namespace tag_namespace                                         \
-    {                                                               \
-      struct name                                                   \
-      {                                                             \
-          static char const* keyword_name()                         \
-          {                                                         \
-              return #name;                                         \
-          }                                                         \
-      };                                                            \
-    }                                                               \
+    namespace tag_namespace { struct name; }                        \
     namespace                                                       \
     {                                                               \
-       ::boost::parameter::keyword<tag_namespace::name> const& name \
-       = ::boost::parameter::keyword<tag_namespace::name>::instance;\
+       ::boost::parameter::keyword<tag_namespace::name>& name       \
+       = ::boost::parameter::keyword<tag_namespace::name>::get();   \
     }
 
+#endif
+
 }} // namespace boost::parameter
 
 #endif // KEYWORD_050328_HPP

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  \

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/python/aux_/invoker.hpp

@@ -0,0 +1,103 @@
+// 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_INVOKER_051210_HPP
+# define BOOST_PARAMETER_INVOKER_051210_HPP
+
+# include <boost/mpl/begin.hpp>
+# include <boost/mpl/next.hpp>
+# include <boost/mpl/deref.hpp>
+# include <boost/parameter/keyword.hpp>
+# include <boost/preprocessor/iteration/iterate.hpp>
+
+namespace boost { namespace parameter { namespace python { namespace aux {
+
+template <long Arity, class M, class R, class Args>
+struct invoker;
+
+template <class M, class R>
+struct make_invoker
+{
+    template <class Args>
+    struct apply
+    {
+        typedef invoker<
+            mpl::size<Args>::value, M, R, Args
+        > type;
+    };
+};
+
+template <long Arity, class T, class R, class Args>
+struct call_invoker;
+
+template <class T, class R>
+struct make_call_invoker
+{
+    template <class Args>
+    struct apply
+    {
+        typedef call_invoker<
+            mpl::size<Args>::value, T, R, Args
+        > type;
+    };
+};
+
+template <long Arity, class T, class Args>
+struct init_invoker;
+
+template <class T>
+struct make_init_invoker
+{
+    template <class Args>
+    struct apply
+    {
+        typedef init_invoker<
+            mpl::size<Args>::value, T, Args
+        > type;
+    };
+};
+
+template <class M, class R, class Args>
+struct invoker<0, M, R, Args>
+{
+    static R execute()
+    {
+        return M()(boost::type<R>());
+    }
+};
+
+template <class T, class R, class Args>
+struct call_invoker<0, T, R, Args>
+{
+    static R execute(T& self)
+    {
+        return self();
+    }
+};
+
+template <class T, class Args>
+struct init_invoker<0, T, Args>
+{
+    static T* execute(T& self)
+    {
+        return new T;
+    }
+};
+
+# define BOOST_PP_ITERATION_PARAMS_1 (4, \
+    (1, BOOST_PARAMETER_MAX_ARITY, <boost/parameter/python/aux_/invoker_iterate.hpp>, 1))
+# include BOOST_PP_ITERATE()
+
+# define BOOST_PP_ITERATION_PARAMS_1 (4, \
+    (1, BOOST_PARAMETER_MAX_ARITY, <boost/parameter/python/aux_/invoker_iterate.hpp>, 2))
+# include BOOST_PP_ITERATE()
+
+# define BOOST_PP_ITERATION_PARAMS_1 (4, \
+    (1, BOOST_PARAMETER_MAX_ARITY, <boost/parameter/python/aux_/invoker_iterate.hpp>, 3))
+# include BOOST_PP_ITERATE()
+
+}}}} // namespace boost::parameter::python::aux
+
+#endif // BOOST_PARAMETER_INVOKER_051210_HPP
+

include/boost/parameter/python/aux_/invoker_iterate.hpp

@@ -0,0 +1,87 @@
+// 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/preprocessor/cat.hpp>
+#include <boost/preprocessor/dec.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/repetition/repeat_from_to.hpp>
+
+#define N BOOST_PP_ITERATION()
+
+#define BOOST_PARAMETER_PY_ARG_TYPES(z, n, _) \
+    typedef typename mpl::next< \
+        BOOST_PP_CAT(iter,BOOST_PP_DEC(n)) \
+    >::type BOOST_PP_CAT(iter,n); \
+    \
+    typedef typename mpl::deref<BOOST_PP_CAT(iter,n)>::type BOOST_PP_CAT(spec,n); \
+    typedef typename mpl::if_< \
+        mpl::and_< \
+            mpl::not_<typename BOOST_PP_CAT(spec,n)::required> \
+          , typename BOOST_PP_CAT(spec,n)::optimized_default \
+        > \
+      , parameter::aux::maybe<typename BOOST_PP_CAT(spec,n)::type> \
+      , typename BOOST_PP_CAT(spec,n)::type \
+    >::type BOOST_PP_CAT(arg,n); \
+    typedef typename BOOST_PP_CAT(spec,n)::keyword BOOST_PP_CAT(kw,n);
+
+#if BOOST_PP_ITERATION_FLAGS() == 1
+template <class M, class R, class Args>
+struct invoker<N, M, R, Args>
+#elif BOOST_PP_ITERATION_FLAGS() == 2
+template <class T, class R, class Args>
+struct call_invoker<N, T, R, Args>
+#elif BOOST_PP_ITERATION_FLAGS() == 3
+template <class T, class Args>
+struct init_invoker<N, T, Args>
+#endif
+{
+    typedef typename mpl::begin<Args>::type iter0;
+    typedef typename mpl::deref<iter0>::type spec0;
+    typedef typename mpl::if_<
+        mpl::and_<
+            mpl::not_<typename spec0::required>
+          , typename spec0::optimized_default
+        >
+      , parameter::aux::maybe<typename spec0::type>
+      , typename spec0::type
+    >::type arg0;
+    typedef typename spec0::keyword kw0;
+
+    BOOST_PP_REPEAT_FROM_TO(1, N, BOOST_PARAMETER_PY_ARG_TYPES, ~)
+
+    static
+#if BOOST_PP_ITERATION_FLAGS() == 1 || BOOST_PP_ITERATION_FLAGS() == 2
+    R
+#else
+    T*
+#endif 
+    execute(
+#if BOOST_PP_ITERATION_FLAGS() == 2
+        T& self
+      ,
+#endif
+        BOOST_PP_ENUM_BINARY_PARAMS(N, arg, a)
+    )
+    {
+        return
+#if BOOST_PP_ITERATION_FLAGS() == 1
+         M()(
+              boost::type<R>()
+            , BOOST_PP_ENUM_BINARY_PARAMS(N, keyword<kw, >::get() = a)
+         );
+#elif BOOST_PP_ITERATION_FLAGS() == 2
+         self(
+            BOOST_PP_ENUM_BINARY_PARAMS(N, keyword<kw, >::get() = a)
+         );
+#elif BOOST_PP_ITERATION_FLAGS() == 3
+         new T(
+             BOOST_PP_ENUM_BINARY_PARAMS(N, keyword<kw, >::get() = a)
+         );
+#endif
+    }
+};
+
+#undef BOOST_PARAMETER_PY_ARG_TYPES
+#undef N
+

include/boost/parameter/python/function.hpp

@@ -0,0 +1,494 @@
+// 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_FUNCTION_051130_HPP
+# define BOOST_PARAMETER_FUNCTION_051130_HPP
+
+# include <boost/preprocessor/cat.hpp>
+# include <boost/preprocessor/for.hpp>
+# include <boost/preprocessor/detail/split.hpp>
+# include <boost/preprocessor/facilities/is_empty.hpp>
+# include <boost/preprocessor/tuple/eat.hpp>
+# include <boost/preprocessor/logical/not.hpp>
+# include <boost/preprocessor/repeat.hpp>
+# include <boost/preprocessor/punctuation/comma_if.hpp>
+# include <boost/preprocessor/seq/for_each.hpp>
+# include <boost/preprocessor/seq/for_each_i.hpp>
+# include <boost/preprocessor/seq/fold_left.hpp>
+# include <boost/preprocessor/arithmetic/inc.hpp>
+# include <boost/preprocessor/arithmetic/add.hpp>
+# include <boost/preprocessor/control/if.hpp>
+# include <boost/preprocessor/repetition/repeat_from_to.hpp>
+# include <boost/preprocessor/repetition/enum_params.hpp>
+# include <boost/preprocessor/repetition/enum_binary_params.hpp>
+
+# include <boost/implicit_cast.hpp>
+# include <boost/parameter.hpp>
+# include <boost/type_traits/is_convertible.hpp>
+# include <boost/mpl/vector.hpp>
+# include <boost/mpl/bool.hpp>
+
+# define ZKB_KEYWORD(tag_namespace,name) \
+    BOOST_PARAMETER_KEYWORD(tag_namespace,name) \
+    namespace tag_namespace \
+    { \
+      struct name \
+      { \
+          static inline char const* keyword() \
+          { \
+              return #name; \
+          } \
+      }; \
+    }
+
+//
+// A ``spec`` is a 4-tuple defined as:
+//
+// ( qualifier , name , type, default )
+//
+// Where qualifier is one of ``required`` or ``optional``.
+//
+// Below are access macros to the different components of a spec
+//
+
+# define ZKB_spec_qualifier(spec) BOOST_PP_TUPLE_ELEM(4,0,spec)
+# define ZKB_spec_name(spec) BOOST_PP_TUPLE_ELEM(4,1,spec)
+# define ZKB_spec_type(spec) BOOST_PP_TUPLE_ELEM(4,2,spec)
+# define ZKB_spec_default(spec) BOOST_PP_TUPLE_ELEM(4,3,spec)
+
+//
+// Split a sublist into qualifier and arg-list.
+// The form for the sublist w is:
+//
+//    [optional|required] (x,y ..)
+//
+// ZKB_sublist_qualifier(w) will return 'optional' or 'required'
+// ZKB_sublist_args(w) will return (x,y ..)
+//
+
+# define ZKB_sublist_required(args)
+# define ZKB_sublist_optional(args)
+
+# define ZKB_sublist_split_required required,
+# define ZKB_sublist_split_optional optional,
+
+# define ZKB_sublist_split(sub) \
+    BOOST_PP_CAT(ZKB_sublist_split_, sub)
+
+# define ZKB_sublist_qualifier(sub) \
+    BOOST_PP_SPLIT(0, ZKB_sublist_split(sub))
+
+# define ZKB_sublist_args(sub) \
+    BOOST_PP_SPLIT(1, ZKB_sublist_split(sub))
+
+# define ZKB_sublist(sub) \
+    [ ZKB_sublist_qualifier(sub) : ZKB_sublist_args(sub) ]
+
+//
+// Iteration through n-ary tuples seqs
+//
+
+# define ZKB_for_each_head_aux2(x,y) (x,y), ~
+# define ZKB_for_each_head_aux3(x,y,z) (x,y,z), ~
+# define ZKB_for_each_head_aux4(x,y,z,u) (x,y,z,u), ~
+# define ZKB_for_each_head(n,x) \
+    BOOST_PP_SPLIT(0, BOOST_PP_CAT(ZKB_for_each_head_aux,n) x)
+
+# define ZKB_for_each_pred_aux_ZKB_END_SENTINEL
+# define ZKB_for_each_pred_aux_check(x) \
+    BOOST_PP_NOT(BOOST_PP_IS_EMPTY(BOOST_PP_CAT(ZKB_for_each_pred_aux_, x))), ~
+
+# define ZKB_for_each_pred_aux2(x,y) ZKB_for_each_pred_aux_check(x)
+# define ZKB_for_each_pred_aux3(x,y,z) ZKB_for_each_pred_aux_check(x)
+# define ZKB_for_each_pred_aux4(x,y,z,u) ZKB_for_each_pred_aux_check(x)
+
+# define ZKB_for_each_pred_aux0(n,x) BOOST_PP_CAT(ZKB_for_each_pred_aux,n) x
+
+# define ZKB_for_each_pred(r, state) \
+    BOOST_PP_SPLIT( \
+        0 \
+      , ZKB_for_each_pred_aux0( \
+            BOOST_PP_TUPLE_ELEM(5,3,state) \
+          , BOOST_PP_TUPLE_ELEM(5,0,state) \
+        ) \
+    )
+
+# define ZKB_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 ZKB_for_each_macro(r, state) \
+    BOOST_PP_TUPLE_ELEM(5,2,state)( \
+        r \
+      , BOOST_PP_TUPLE_ELEM(5,4,state) \
+      , ZKB_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 ZKB_for_each_build_end_sentinel(z,n,text) BOOST_PP_COMMA_IF(n) ZKB_END_SENTINEL
+# define ZKB_for_each_build_end_sentinel_tuple(arity) \
+    ( \
+        BOOST_PP_REPEAT(arity, ZKB_for_each_build_end_sentinel, _) \
+    )
+
+# define ZKB_for_each_seq(arity, list, data, macro) \
+    BOOST_PP_FOR( \
+        (list ZKB_for_each_build_end_sentinel_tuple(arity), data, macro, arity, 0) \
+      , ZKB_for_each_pred \
+      , ZKB_for_each_op \
+      , ZKB_for_each_macro \
+    )
+
+//
+// ZKB_build_parameters
+//
+// Build a parameters<> specialization. tag_namespace is the namespace
+// where the keywords reside. args is a sequence of spec's.
+//
+# define ZKB_build_parameters_aux(r,tag_namespace,i,elem) \
+    BOOST_PP_COMMA_IF(i) \
+    boost::parameter::ZKB_spec_qualifier(elem)< \
+        tag_namespace::ZKB_spec_name(elem) \
+      , boost::is_convertible<boost::mpl::_, ZKB_spec_type(elem)> \
+    >
+
+# define ZKB_build_parameters(tag_namespace, args) \
+    boost::parameter::parameters< \
+        BOOST_PP_SEQ_FOR_EACH_I(ZKB_build_parameters_aux, tag_namespace, args) \
+    >
+
+# define ZKB_formal_args(r, data, i, elem) \
+    BOOST_PP_COMMA_IF(i) ZKB_spec_type(elem) ZKB_spec_name(elem)
+
+# define ZKB_build_function_declaration(result,name,args) \
+    result name( \
+        BOOST_PP_SEQ_FOR_EACH_I(ZKB_formal_args, _, args) \
+    )
+
+# define ZKB_build_fwd_declaration(result,name,args) \
+    ZKB_build_function_declaration(result,name,args);
+
+# define ZKB_actual_args_maybe_default_optional(spec) | ZKB_spec_default(spec)
+# define ZKB_actual_args_maybe_default_required(spec)
+# define ZKB_actual_args_maybe_default(spec) \
+    BOOST_PP_CAT( \
+        ZKB_actual_args_maybe_default_ \
+      , ZKB_spec_qualifier(spec) \
+    )(spec)
+
+# define ZKB_actual_args(r, data, i, elem) \
+    BOOST_PP_COMMA_IF(i) \
+    boost::implicit_cast<ZKB_spec_type(elem)>( \
+        args[ZKB_spec_name(elem) ZKB_actual_args_maybe_default(elem)] \
+    )
+
+# define ZKB_build_dispatch(result,name,args_) \
+    template <class Args> \
+    result BOOST_PP_CAT(name,_dispatch)(Args const& args) \
+    { \
+        return name( \
+            BOOST_PP_SEQ_FOR_EACH_I(ZKB_actual_args, _, args_) \
+        ); \
+    }
+
+# define ZKB_calculate_arity_range_op_required 1
+# define ZKB_calculate_arity_range_op_optional 0
+# define ZKB_calculate_arity_range_op(s, state, spec) \
+    BOOST_PP_IF( \
+        BOOST_PP_CAT(ZKB_calculate_arity_range_op_, ZKB_spec_qualifier(spec)) \
+      , BOOST_PP_INC(state) \
+      , state \
+    )
+
+# define ZKB_calculate_arity_range(args) \
+    ( \
+        BOOST_PP_SEQ_FOLD_LEFT(ZKB_calculate_arity_range_op, 0, args) \
+      , BOOST_PP_SEQ_SIZE(args) \
+    )
+
+# define ZKB_build_forwarding_functions_arity_nullary(n,data) \
+    inline BOOST_PP_TUPLE_ELEM(2,0,data) BOOST_PP_TUPLE_ELEM(2,1,data)() \
+    { \
+        return BOOST_PP_CAT( \
+            BOOST_PP_TUPLE_ELEM(2,1,data) \
+          , _dispatch \
+        )( \
+            BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2,1,data), _parameters)() \
+        ); \
+    }
+
+# define ZKB_build_forwarding_functions_arity_nary(n,data) \
+    template<BOOST_PP_ENUM_PARAMS(n, class A)> \
+    BOOST_PP_TUPLE_ELEM(2,0,data) BOOST_PP_TUPLE_ELEM(2,1,data)( \
+        BOOST_PP_ENUM_BINARY_PARAMS(n, A, const& a) \
+    ) \
+    { \
+        return BOOST_PP_CAT( \
+            BOOST_PP_TUPLE_ELEM(2,1,data) \
+          , _dispatch \
+        )( \
+            BOOST_PP_CAT( \
+                BOOST_PP_TUPLE_ELEM(2,1,data) \
+              , _parameters \
+            )()(BOOST_PP_ENUM_PARAMS(n, a)) \
+        ); \
+    }
+
+# define ZKB_build_forwarding_functions_arity(z,n,data) \
+    BOOST_PP_IF( \
+        n \
+      , ZKB_build_forwarding_functions_arity_nary \
+      , ZKB_build_forwarding_functions_arity_nullary \
+    )(n,data)
+
+# define ZKB_build_forwarding_functions0(result,name,arity_tuple) \
+    BOOST_PP_REPEAT_FROM_TO( \
+        BOOST_PP_TUPLE_ELEM(2,0,arity_tuple) \
+      , BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(2,1,arity_tuple)) \
+      , ZKB_build_forwarding_functions_arity \
+      , (result,name) \
+    )
+
+# define ZKB_build_forwarding_functions(result,name,args) \
+    ZKB_build_forwarding_functions0(result,name,ZKB_calculate_arity_range(args))
+
+# define ZKB_build_meta_arg(r,data,i,spec) \
+    BOOST_PP_COMMA_IF(i) ZKB_spec_type(spec) BOOST_PP_CAT(a,i)
+
+# define ZKB_build_meta_is_required_optional 0
+# define ZKB_build_meta_is_required_required 1
+# define ZKB_build_meta_is_required(spec) \
+    BOOST_PP_CAT(ZKB_build_meta_is_required_, ZKB_spec_qualifier(spec))
+
+# define ZKB_build_meta_keywords(r,tag_namespace,i,spec) \
+    BOOST_PP_COMMA_IF(i) boost::mpl::pair< \
+        boost::mpl::bool_<ZKB_build_meta_is_required(spec)> \
+      , tag_namespace::ZKB_spec_name(spec) \
+    >
+
+# define ZKB_build_meta_types(r,data,spec) , ZKB_spec_type(spec)
+
+# define ZKB_build_meta_default(tag_namespace,spec) \
+    static ZKB_spec_type(spec) default_(tag_namespace::ZKB_spec_name(spec)) \
+    { \
+        return ZKB_spec_default(spec); \
+    }
+                               
+# define ZKB_build_meta_defaults(r,tag_namespace,spec) \
+    BOOST_PP_IF( \
+        ZKB_build_meta_is_required(spec) \
+      , BOOST_PP_TUPLE_EAT(2) \
+      , ZKB_build_meta_default \
+    )(tag_namespace,spec)
+                                   
+# define ZKB_build_meta(result,name,meta_name,tag_namespace,args) \
+    struct meta_name \
+    { \
+        result operator()(BOOST_PP_SEQ_FOR_EACH_I(ZKB_build_meta_arg, ~, args)) const \
+        { \
+            return name(BOOST_PP_ENUM_PARAMS(BOOST_PP_SEQ_SIZE(args), a)); \
+        } \
+\
+        typedef BOOST_PP_CAT(boost::mpl::vector, BOOST_PP_SEQ_SIZE(args))< \
+            BOOST_PP_SEQ_FOR_EACH_I(ZKB_build_meta_keywords, tag_namespace, args) \
+        > keywords; \
+\
+        typedef BOOST_PP_CAT(boost::mpl::vector, BOOST_PP_INC(BOOST_PP_SEQ_SIZE(args)))< \
+            result BOOST_PP_SEQ_FOR_EACH(ZKB_build_meta_types, ~, args) \
+        > signature; \
+\
+        BOOST_PP_SEQ_FOR_EACH(ZKB_build_meta_defaults, tag_namespace, args) \
+    };
+
+# define ZKB_FUNCTION_IMPL_AUX(result,name,meta_name,args,tag_namespace,with_fwd_declaration) \
+    BOOST_PP_IF( \
+        with_fwd_declaration \
+      , ZKB_build_fwd_declaration \
+      , BOOST_PP_TUPLE_EAT(3) \
+    )(result,name,args) \
+    typedef ZKB_build_parameters(tag_namespace,args) BOOST_PP_CAT(name,_parameters); \
+    ZKB_build_dispatch(result,name,args) \
+    ZKB_build_forwarding_functions(result,name,args) \
+    ZKB_build_meta(result,name,meta_name,tag_namespace,args) \
+    ZKB_build_function_declaration(result,name,args)
+                                   
+# define ZKB_FUNCTION_IMPL(result,name,meta_name,args,tag_namespace,with_fwd_declaration) \
+    ZKB_FUNCTION_IMPL_AUX( \
+        result \
+      , name \
+      , meta_name \
+      , ZKB_flatten_arg_spec(args) \
+      , tag_namespace \
+      , with_fwd_declaration \
+    )
+
+# define ZKB_FUNCTION(result,name,meta_name,tag_namespace,args) \
+    ZKB_FUNCTION_IMPL(result,name,meta_name,args,tag_namespace,1)
+
+# define ZKB_MEMBER(class_,result,name,meta_name,tag_namespace,args) \
+    ZKB_FUNCTION_IMPL(result,name,meta_name,args,tag_namespace,0)
+
+//
+// ZKB_flatten_arg_spec
+//
+// Flattens an argument list into normalized 4 arity tuple sequence form:
+//
+// (qualifier, name, type, default)
+//
+// Example:
+//
+// (required (x, int) (y, float))
+// (optional (z, int, 0))
+//
+// Is converted to:
+//
+// ((required, x, int, ~)) ((required, y, float, ~)) ((optional, z, int, 0))
+//
+// This makes processing much simpler.
+//
+
+# define ZKB_qualifier_arity_required 2
+# define ZKB_qualifier_arity_optional 3
+# define ZKB_qualifier_arity(q) BOOST_PP_CAT(ZKB_qualifier_arity_,q)
+
+# define ZKB_flatten_arg_spec_aux_required(r,n,elem,_) \
+    (( \
+        required \
+      , BOOST_PP_TUPLE_REM(2) elem \
+      , ~ \
+    ))
+ 
+# define ZKB_flatten_arg_spec_aux_optional(r,n,elem,_) \
+    (( \
+        optional \
+      , BOOST_PP_TUPLE_REM(3) elem \
+    ))
+
+# define ZKB_flatten_arg_spec_aux0(z,data,elem) \
+    ZKB_for_each_seq( \
+        ZKB_qualifier_arity(ZKB_sublist_qualifier(elem)) \
+      , ZKB_sublist_args(elem) \
+      , ~ \
+      , BOOST_PP_CAT(ZKB_flatten_arg_spec_aux_, ZKB_sublist_qualifier(elem)) \
+    )
+
+# define ZKB_flatten_arg_spec(args) \
+    BOOST_PP_SEQ_FOR_EACH(ZKB_flatten_arg_spec_aux0, _, args)
+                                  
+// ?_FUNCTION() generates
+//
+// void f(int value, char const* name, float scale);
+//
+// template<class Args>
+// void f_dispatch(Args const& args)
+// {
+//     f(args[value], args[name], args[scale | 20.f]);
+// }
+//
+// template<class A0>
+// void f(A0 const& a0)
+// {
+//     f_dispatch(f_parameters()(a0));
+// }
+//
+// template<class A0, class A1>
+// void f(A0 const& a0, A1 const& a1)
+// {
+//     f_dispatch(f_parameters()(a0,a1));
+// }
+//
+// template<class A0, class A1, class A2>
+// void f(A0 const& a0, A1 const& a1, A2 const& a2)
+// {
+//     f_dispatch(f_parameters()(a0,a1,a2));
+// }
+//
+// void f(int value, char const* name, float scale)
+//
+// ---------------------------------------------------------------------------
+//
+// _MEMBER() generates
+//
+// template<class Args>
+// void f_dispatch(Args const& args)
+// {
+//     f(args[value], args[name], args[scale | 20.f]);
+// }
+//
+// template<class A0>
+// void f(A0 const& a0)
+// {
+//     f_dispatch(f_parameters()(a0));
+// }
+//
+// template<class A0, class A1>
+// void f(A0 const& a0, A1 const& a1)
+// {
+//     f_dispatch(f_parameters()(a0,a1));
+// }
+//
+// template<class A0, class A1, class A2>
+// void f(A0 const& a0, A1 const& a1, A2 const& a2)
+// {
+//     f_dispatch(f_parameters()(a0,a1,a2));
+// }
+//
+// void f(int value, char const* name, float scale)
+//
+// ---------------------------------------------------------------------------
+//
+// _CONSTRUCTOR() generates
+//
+// template<class A0>
+// type(A0 const& a0)
+// {
+//     this->init_dispatch(f_parameters()(a0));
+// }
+//
+// template<class A0, class A1>
+// type(A0 const& a0, A1 const& a1)
+// {
+//     this->init_dispatch(f_parameters()(a0,a1));
+// }
+//
+// template<class Args>
+// void init_dispatch(Args const& args)
+// {
+//     this->init(args[value], args[name], args[scale | 20.f]);
+// }
+//
+// private:
+//   void init(int value, char const* name, float scale)
+//
+// *** OR ***
+//
+// template<class A0>
+// type(A0 const& a0)
+//   : base(
+//         f_parameters()(a0)[value]
+//       , f_parameters()(a0)[name]
+//       , f_parameters()(a0)[scale | 20.f]
+//     )
+// {}
+//
+// template<class A0, class A1>
+// type(A0 const& a0, A1 const& a1)
+//   : base(
+//         f_parameters()(a0,a1)[value]
+//       , f_parameters()(a0,a1)[name]
+//       , f_parameters()(a0,a1)[scale | 20.f]
+//     )
+// {}
+
+#endif // BOOST_PARAMETER_FUNCTION_051130_HPP
+

include/boost/parameter/python/general.hpp

@@ -0,0 +1,606 @@
+// 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_GENERAL_051210_HPP
+# define BOOST_PARAMETER_GENERAL_051210_HPP
+
+# include <boost/mpl/vector.hpp>
+# include <boost/mpl/fold.hpp>
+# include <boost/mpl/prior.hpp>
+# include <boost/mpl/shift_right.hpp>
+# include <boost/mpl/shift_left.hpp>
+# include <boost/mpl/bitand.hpp>
+# include <boost/mpl/pair.hpp>
+# include <boost/mpl/size.hpp>
+# include <boost/mpl/push_back.hpp>
+# include <boost/mpl/or.hpp>
+# include <boost/mpl/count_if.hpp>
+# include <boost/mpl/transform.hpp>
+# include <boost/mpl/front.hpp>
+# include <boost/mpl/iterator_range.hpp>
+# include <boost/mpl/next.hpp>
+# include <boost/mpl/begin_end.hpp>
+# include <boost/mpl/not.hpp>
+# include <boost/type.hpp>
+# include <boost/python/def.hpp>
+# include <boost/parameter/python/aux_/invoker.hpp>
+# include <boost/parameter/aux_/maybe.hpp>
+
+namespace boost { namespace parameter { namespace python {
+
+PyObject* init_sentinel()
+{
+    static PyTypeObject sentinel_type  = {
+        PyObject_HEAD_INIT(NULL)
+        0,                                /* ob_size        */
+        "Boost.Parameter.Unspecified",    /* tp_name        */
+        PyType_Type.tp_basicsize,         /* tp_basicsize   */
+        0,                                /* tp_itemsize    */
+        0,                                /* tp_dealloc     */
+        0,                                /* tp_print       */
+        0,                                /* tp_getattr     */
+        0,                                /* tp_setattr     */
+        0,                                /* tp_compare     */
+        0,                                /* tp_repr        */
+        0,                                /* tp_as_number   */
+        0,                                /* tp_as_sequence */
+        0,                                /* tp_as_mapping  */
+        0,                                /* tp_hash        */
+        0,                                /* tp_call        */
+        0,                                /* tp_str         */
+        0,                                /* tp_getattro    */
+        0,                                /* tp_setattro    */
+        0,                                /* tp_as_buffer   */
+        Py_TPFLAGS_DEFAULT,               /* tp_flags       */
+        0,                                /* tp_doc         */
+    };
+
+    assert(PyType_Ready(&sentinel_type) == 0);
+    return boost::python::upcast<PyObject>(&sentinel_type);
+}
+
+inline boost::python::handle<>& sentinel_value()
+{
+    static boost::python::handle<> x;
+    return x;
+}
+
+struct empty_tag_to_python
+{
+    empty_tag_to_python()
+    {
+        boost::python::to_python_converter<
+            boost::parameter::aux::empty_maybe_tag, empty_tag_to_python
+        >();
+
+        sentinel_value() = boost::python::handle<>(init_sentinel());
+    }
+
+    static PyObject* convert(boost::parameter::aux::empty_maybe_tag)
+    {
+        return boost::python::xincref(sentinel_value().get());
+    }
+};
+
+}}} // namespace boost::parameter::python
+
+namespace boost { namespace python 
+{
+
+  // Converts a Python value to a maybe<T>
+  template <class T>
+  struct arg_from_python<parameter::aux::maybe<T> >
+    : arg_from_python<T>
+  {
+      arg_from_python(PyObject* p)
+        : arg_from_python<T>(p)
+        , empty(false)
+      {
+          if (parameter::python::sentinel_value().get() == p)
+          {
+              empty = true;
+          }
+      }
+
+      bool convertible() const
+      {
+          if (empty) return true;
+          
+          return arg_from_python<T>::convertible();
+      }
+
+      boost::parameter::aux::maybe<T> operator()()
+      {
+          if (empty)
+          {
+              return boost::parameter::aux::maybe<T>();
+          }
+          else
+          {
+              return boost::parameter::aux::maybe<T>(
+                  arg_from_python<T>::operator()()
+              );
+          }
+      }
+
+      bool empty;
+  };
+
+}} // namespace boost::python
+
+namespace boost { namespace parameter { namespace python {
+
+namespace aux
+{
+
+  template <class K>
+  struct is_optional
+    : mpl::not_<
+          mpl::or_<typename K::required, typename K::optimized_default>
+      >
+  {};
+
+  template <class K, class Required, class Optimized, class T>
+  struct arg_spec
+  {
+      typedef K keyword;
+      typedef Required required;
+      typedef T type;
+      typedef Optimized optimized_default;
+  };
+  
+  template <class K, class T, class Optimized = mpl::false_>
+  struct make_arg_spec_impl
+  {
+      typedef arg_spec<
+          typename K::first, typename K::second, Optimized, T
+      > type;
+  };
+
+  template <class K, class T>
+  struct make_arg_spec_impl<K, T, typename K::third>
+  {
+      typedef arg_spec<
+          typename K::first, typename K::second, typename K::third, T
+      > type;
+  };
+
+  template <class K, class T>
+  struct make_arg_spec
+    : make_arg_spec_impl<K, T>
+  {
+  };
+
+  template <class Spec, class State>
+  struct combinations_op
+  {
+      typedef typename State::second bits;
+      typedef typename State::first result0;
+
+      typedef typename mpl::if_<
+          mpl::or_<
+              typename Spec::required
+            , typename Spec::optimized_default
+            , mpl::bitand_<bits, mpl::long_<1> >
+          >
+        , typename mpl::push_back<result0, Spec>::type
+        , result0
+      >::type result;
+
+      typedef typename mpl::if_<
+          mpl::or_<
+              typename Spec::required
+            , typename Spec::optimized_default
+          >
+        , bits
+        , typename mpl::shift_right<bits, mpl::long_<1> >::type
+      >::type next_bits;
+
+      typedef mpl::pair<
+          result
+        , next_bits
+      > type;
+  };
+
+  // Used as start value in the recursive arg() composition below.
+  struct no_keywords
+  {
+      template <class T>
+      T const& operator,(T const& x) const
+      {
+          return x;
+      }
+  };
+
+  template <class K>
+  char const* keyword_name(K*)
+  {
+      return K::keyword();
+  }
+  
+  template <class Def, class F, class Iter, class End, class Keywords>
+  void def_combination_aux0(
+      Def def, F f, Iter, End, Keywords const& keywords, mpl::false_)
+  {
+      typedef typename mpl::deref<Iter>::type spec;
+      typedef typename spec::keyword kw;
+
+      def_combination_aux(
+          def, f, typename mpl::next<Iter>::type(), End()
+        , (
+              keywords, boost::python::arg(keyword_name((kw*)0))
+          )
+      );
+  }
+
+  template <class Def, class F, class Iter, class End, class Keywords>
+  void def_combination_aux0(
+      Def def, F f, Iter, End, Keywords const& keywords, mpl::true_)
+  {
+      typedef typename mpl::deref<Iter>::type spec;
+      typedef typename spec::keyword kw;
+
+      def_combination_aux(
+          def, f, typename mpl::next<Iter>::type(), End()
+        , (
+              keywords, boost::python::arg(kw::keyword()) 
+                = boost::parameter::aux::empty_maybe_tag()
+          )
+      );
+  }
+
+  inline void initialize_converter()
+  {
+      static empty_tag_to_python cv;
+  }
+
+  template <class Def, class F, class Iter, class End, class Keywords>
+  void def_combination_aux(
+      Def def, F f, Iter, End, Keywords const& keywords)
+  {
+      typedef typename mpl::deref<Iter>::type spec;
+
+      initialize_converter();
+
+      typedef typename mpl::and_<
+          typename spec::optimized_default
+        , mpl::not_<typename spec::required>
+      >::type optimized_default;
+      
+      def_combination_aux0(
+          def, f, Iter(), End(), keywords, optimized_default()
+      );
+  }
+
+  template <class Def, class F, class End, class Keywords>
+  void def_combination_aux(
+      Def def, F f, End, End, Keywords const& keywords)
+  {
+      def(f, keywords);
+  } 
+
+  template <class Def, class F, class End>
+  void def_combination_aux(
+      Def def, F f, End, End, no_keywords const&)
+  {
+      def(f);
+  }
+
+  template <
+      class Def, class Specs, class Bits, class Invoker
+  >
+  void def_combination(
+      Def def, Specs*, Bits, Invoker*)
+  {
+      typedef typename mpl::fold<
+          Specs
+        , mpl::pair<mpl::vector0<>, Bits>
+        , combinations_op<mpl::_2, mpl::_1>
+      >::type combination0;
+
+      typedef typename combination0::first combination;
+
+      typedef typename mpl::apply_wrap1<
+          Invoker, combination
+      >::type invoker;
+
+      def_combination_aux(
+          def
+        , &invoker::execute
+        , typename mpl::begin<combination>::type()
+        , typename mpl::end<combination>::type()
+        , no_keywords()
+      );
+  }
+
+  template <
+      class Def, class Specs, class Bits, class End, class Invoker
+  >
+  void def_combinations(
+      Def def, Specs*, Bits, End, Invoker*)
+  {
+      def_combination(def, (Specs*)0, Bits(), (Invoker*)0);
+
+      def_combinations(
+          def
+        , (Specs*)0
+        , mpl::long_<Bits::value + 1>()
+        , End()
+        , (Invoker*)0
+      );
+  }
+
+  template <
+      class Def, class Specs, class End, class Invoker
+  >
+  void def_combinations(
+      Def, Specs*, End, End, Invoker*)
+  {}
+
+  template <class Class>
+  struct def_class
+  {
+      def_class(Class& cl, char const* name)
+        : cl(cl)
+        , name(name)
+      {}
+
+      template <class F>
+      void operator()(F f) const
+      {
+          cl.def(name, f);
+      }
+
+      template <class F, class Keywords>
+      void operator()(F f, Keywords const& keywords) const
+      {
+          cl.def(name, f, keywords);
+      }
+
+      Class& cl;
+      char const* name;
+  };
+
+  template <class Class>
+  struct def_init
+  {
+      def_init(Class& cl)
+        : cl(cl)
+      {}
+
+      template <class F>
+      void operator()(F f) const
+      {
+          cl.def(
+              "__init__"
+            , boost::python::make_constructor(f)
+          );
+      }
+
+      template <class F, class Keywords>
+      void operator()(F f, Keywords const& keywords) const
+      {
+          cl.def(
+              "__init__"
+            , boost::python::make_constructor(
+                  f, boost::python::default_call_policies(), keywords
+              )
+          );
+      }
+
+      Class& cl;
+  };
+
+  struct def_function
+  {
+      def_function(char const* name)
+        : name(name)
+      {}
+      
+      template <class F>
+      void operator()(F f) const
+      {
+          boost::python::def(name, f);
+      }
+
+      template <class F, class Keywords>
+      void operator()(F f, Keywords const& keywords) const
+      {
+          boost::python::def(name, f, keywords);
+      }
+
+      char const* name;
+  };  
+  
+} // namespace aux
+
+template <class M, class Signature>
+void def(char const* name, Signature)
+{
+    typedef mpl::iterator_range<
+        typename mpl::next<
+            typename mpl::begin<Signature>::type
+        >::type
+      , typename mpl::end<Signature>::type
+    > arg_types;
+
+    typedef typename mpl::transform<
+        typename M::keywords
+      , arg_types
+      , aux::make_arg_spec<mpl::_1, mpl::_2>
+    >::type arg_specs;
+
+    typedef typename mpl::count_if<
+        arg_specs
+      , aux::is_optional<mpl::_1>
+    >::type optional_arity;
+    
+    typedef typename mpl::front<Signature>::type result_type;
+    typedef typename mpl::shift_left<mpl::long_<1>, optional_arity>::type upper;
+
+    aux::def_combinations(
+        aux::def_function(name)
+      , (arg_specs*)0
+      , mpl::long_<0>()
+      , mpl::long_<upper::value>()
+      , (aux::make_invoker<M, result_type>*)0
+    );
+}
+
+template <class M, class Class, class Signature>
+void def(Class& cl, char const* name, Signature)
+{
+    typedef mpl::iterator_range<
+        typename mpl::next<
+            typename mpl::begin<Signature>::type
+        >::type
+      , typename mpl::end<Signature>::type
+    > arg_types;
+
+    typedef typename mpl::transform<
+        typename M::keywords
+      , arg_types
+      , aux::make_arg_spec<mpl::_1, mpl::_2>
+    >::type arg_specs;
+
+    typedef typename mpl::count_if<
+        arg_specs
+      , aux::is_optional<mpl::_1>
+    >::type optional_arity;
+    
+    typedef typename mpl::front<Signature>::type result_type;
+    typedef typename mpl::shift_left<mpl::long_<1>, optional_arity>::type upper;
+
+    aux::def_combinations(
+        aux::def_class<Class>(cl, name)
+      , (arg_specs*)0
+      , mpl::long_<0>()
+      , mpl::long_<upper::value>()
+      , (aux::make_invoker<M, result_type>*)0
+    );
+}
+
+namespace aux
+{
+
+  template <class K>
+  struct keyword
+  {
+      typedef K type;
+  };
+
+  template <class K>
+  struct keyword<K*>
+    : keyword<K>
+  {};
+
+  template <class K>
+  struct required
+  {
+      typedef mpl::true_ type;
+  };
+
+  template <class K>
+  struct required<K*>
+  {
+      typedef mpl::false_ type;
+  };
+
+  template <class K>
+  struct optimized
+  {
+      typedef mpl::true_ type;
+  };
+
+  template <class K>
+  struct optimized<K**>
+  {
+      typedef mpl::false_ type;
+  };
+  
+  template <class K, class T>
+  struct make_kw_spec
+  {
+      typedef arg_spec<
+          typename keyword<K>::type
+        , typename required<K>::type
+        , typename optimized<K>::type
+        , T
+      > type;    
+  };
+
+} // namespace aux
+
+template <class Keywords, class Signature>
+struct init 
+  : boost::python::def_visitor<init<Keywords, Signature> >
+{
+    template <class Class>
+    void visit(Class& cl) const
+    {
+        typedef typename mpl::transform<
+            Keywords
+          , Signature
+          , aux::make_kw_spec<mpl::_1, mpl::_2>
+        >::type arg_specs;
+
+        typedef typename mpl::count_if<
+            arg_specs
+          , aux::is_optional<mpl::_1>
+        >::type optional_arity;
+
+        typedef typename mpl::shift_left<mpl::long_<1>, optional_arity>::type upper;
+
+        aux::def_combinations(
+            aux::def_init<Class>(cl)
+          , (arg_specs*)0
+          , mpl::long_<0>()
+          , mpl::long_<upper::value>()
+          , (aux::make_init_invoker<typename Class::wrapped_type>*)0
+        );
+    }
+};
+
+template <class Keywords, class Signature>
+struct call 
+  : boost::python::def_visitor<call<Keywords, Signature> >
+{
+    template <class Class>
+    void visit(Class& cl) const
+    {
+        typedef mpl::iterator_range<
+            typename mpl::next<
+                typename mpl::begin<Signature>::type
+            >::type
+          , typename mpl::end<Signature>::type
+        > arg_types;
+
+        typedef typename mpl::transform<
+            Keywords
+          , arg_types
+          , aux::make_kw_spec<mpl::_1, mpl::_2>
+        >::type arg_specs;
+
+        typedef typename mpl::count_if<
+            arg_specs
+          , aux::is_optional<mpl::_1>
+        >::type optional_arity;
+
+        typedef typename mpl::front<Signature>::type result_type;
+        typedef typename mpl::shift_left<mpl::long_<1>, optional_arity>::type upper;
+
+        aux::def_combinations(
+            aux::def_class<Class>(cl, "__call__")
+          , (arg_specs*)0
+          , mpl::long_<0>()
+          , mpl::long_<upper::value>()
+          , (aux::make_call_invoker<typename Class::wrapped_type, result_type>*)0
+        );
+    }
+};
+
+}}} // namespace boost::parameter::python
+
+#endif // BOOST_PARAMETER_GENERAL_051210_HPP
+

include/boost/parameter/python/make_function.hpp

@@ -0,0 +1,94 @@
+// 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_MAKE_FUNCTION_051130_HPP
+# define BOOST_PARAMETER_MAKE_FUNCTION_051130_HPP
+
+#include <boost/mpl/next.hpp>
+#include <boost/mpl/deref.hpp>
+#include <boost/mpl/begin_end.hpp>
+
+#include <boost/python/args.hpp>
+#include <boost/python/make_function.hpp>
+#include <boost/python/default_call_policies.hpp>
+
+namespace boost { namespace parameter { namespace python {
+
+namespace detail
+{
+
+  // Used as start value in the recursive arg() composition below.
+  struct no_keywords
+  {
+      template <class T>
+      T const& operator,(T const& x) const
+      {
+          return x;
+      }
+  };
+
+  template <class T, class Iter, class End, class Keywords, class K>
+  boost::python::object make_function_aux0(
+      T* p, Iter, End e, Keywords const& keywords, mpl::pair<mpl::true_,K>)
+  {
+      return make_function_aux(
+          p, typename mpl::next<Iter>::type(), e
+        , (
+              keywords, boost::python::arg(K::keyword())
+          )
+      );
+  }
+
+  template <class T, class Iter, class End, class Keywords, class K>
+  boost::python::object make_function_aux0(
+      T* p, Iter, End e, Keywords const& keywords, mpl::pair<mpl::false_,K>)
+  {
+      return make_function_aux(
+          p, typename mpl::next<Iter>::type(), e
+        , (
+              keywords, boost::python::arg(K::keyword()) = T::default_(K())
+          )
+      );
+  }
+
+  template <class T, class Iter, class End, class Keywords>
+  boost::python::object make_function_aux(
+      T* p, Iter i, End e, Keywords const& keywords)
+  {
+      return make_function_aux0(
+          p, i, e, keywords, typename mpl::deref<Iter>::type()
+      );
+  }
+
+  template <class T, class End, class Keywords>
+  boost::python::object make_function_aux(
+      T*, End, End, Keywords const& keywords)
+  {
+      return boost::python::make_function(
+          T()
+        , boost::python::default_call_policies()
+        , keywords
+        , typename T::signature()
+      );
+  }
+
+} // namespace detail
+
+template <class T>
+boost::python::object make_function()
+{
+    typedef typename T::keywords keywords;
+
+    return detail::make_function_aux(
+        (T*)0
+      , typename mpl::begin<keywords>::type()
+      , typename mpl::end<keywords>::type()
+      , detail::no_keywords()
+    );
+}
+
+}}} // namespace boost::parameter::python
+
+#endif // BOOST_PARAMETER_MAKE_FUNCTION_051130_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
-

index.html

@@ -1,12 +1,9 @@
-<!-- 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) -->
 <html>
 <head>
 <meta http-equiv="refresh" content="0; URL=doc/html/index.html">
 </head>
 <body>
 Automatically loading index page... if nothing happens, please go to
-<a href="doc/html/index.html">doc/html/index.html</a>.
+<a href="doc/index.html">doc/html/index.html</a>.
 </body>
 </html>

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,19 @@
+# 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 ]
+     [ run unnamed.cpp ]
+     [ run earwicker.cpp ]
+     [ run tutorial.cpp ]
+     [ run mpl.cpp ]
+     [ run efficiency.cpp : : : : : release ]
+     [ compile unwrap_cv_reference.cpp ]
+     [ compile-fail duplicates.cpp ]
+  ;

test/Jamfile.v2

@@ -1,38 +1,18 @@
-# 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 unnamed.cpp ]
      [ run tutorial.cpp ]
-     [ run singular.cpp ]
+     [ run earwicker.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 ]
+     [ run efficiency.cpp : : : <variant>release ]
      [ 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

@@ -8,11 +8,12 @@
 
 #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 +46,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 
@@ -80,9 +79,9 @@ struct values_t
         BOOST_MPL_ASSERT((boost::is_same<Value,Value_>));
         BOOST_MPL_ASSERT((boost::is_same<Name,Name_>));
 #endif
-        BOOST_TEST(equal(n, n_));
-        BOOST_TEST(equal(v, v_));
-        BOOST_TEST(equal(i, i_));
+        BOOST_ASSERT(equal(n, n_));
+        BOOST_ASSERT(equal(v, v_));
+        BOOST_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

@@ -16,7 +16,7 @@ int main()
 {
    using namespace test;
 
-   f((name = 1, value = 1, test::index = 1, tester = 1,
+   f((name = 1, value = 1, index = 1, tester = 1,
       value = 1 // repeated keyword: should not compile
    ));
    return 0;

test/efficiency.cpp

@@ -45,11 +45,7 @@ namespace test
   struct plain_weight_running_total
   {
       plain_weight_running_total()
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-        : sum(T())
-#else
-        : sum()
-#endif 
+        : sum(0)
       {}
       
       void operator()(T w)
@@ -68,11 +64,7 @@ namespace test
   struct named_param_weight_running_total
   {
       named_param_weight_running_total()
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-        : sum(T())
-#else
-        : sum()
-#endif 
+        : sum(0)
       {}
 
       template <class ArgumentPack>
@@ -93,7 +85,7 @@ namespace test
   // 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)
+  void hammer(Arg const& x)
   {
       // Strategy: because the sum in an accumulator after each call
       // depends on the previous value of the sum, the CPU's pipeline
@@ -120,7 +112,7 @@ namespace test
       
       Accumulator a[number_of_accumulators];
       
-      for (long iteration = 0; iteration < repeats; ++iteration)
+      for (long iteration = 0; iteration < 1000000; ++iteration)
       {
           for (Accumulator* ap = a;  ap < a + number_of_accumulators; ++ap)
           {
@@ -139,19 +131,19 @@ namespace test
   // 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)
+  double measure(T const& x)
   {
       // 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);
+      hammer<Accumulator>(x);
+      hammer<Accumulator>(x);
 
       // Now start a timer
       boost::timer time;
-      hammer<Accumulator>(x, repeats);  // This time, we'll measure
+      hammer<Accumulator>(x);  // This time, we'll measure
       return time.elapsed();
   }
 }
@@ -159,32 +151,16 @@ namespace test
 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)
+        << measure<plain_weight_running_total<double> >(.1)
         << std::endl;
     
     std::cout
         << "named parameter time: "
         << measure<named_param_weight_running_total<double> >(
-            (weight = .1, value = .2), repeats
+            (weight = .1, value = .2)
         )
         << std::endl;
 

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

@@ -9,7 +9,9 @@
 #include <boost/mpl/size.hpp>
 #include <boost/type_traits/add_pointer.hpp>
 
-# include <boost/mpl/contains.hpp>
+# include <boost/type_traits/is_same.hpp>
+# include <boost/mpl/find.hpp>
+# include <boost/mpl/end.hpp>
 
 namespace test
 {
@@ -21,7 +23,13 @@ namespace test
       template <class T>
       void operator()(T*)
       {
-          BOOST_MPL_ASSERT((mpl::contains<Set,T>));
+#if 1 // mpl::set is too unreliable in this release.
+          typedef typename mpl::find<Set,T>::type pos;
+          typedef typename mpl::end<Set>::type not_found;
+          BOOST_MPL_ASSERT_NOT((boost::is_same<pos, not_found>));
+#else 
+          BOOST_MPL_ASSERT((mpl::has_key<Set,T>));
+#endif 
       }
   };
 
@@ -34,7 +42,7 @@ namespace test
         , ==
         , mpl::size<Params>::value
       );
-
+      
       mpl::for_each<Params, boost::add_pointer<mpl::_1> >(assert_in_set<Expected>());
   }
 
@@ -57,6 +65,7 @@ namespace test
       f_impl<Expected>(f_parameters()(t, name_));
   }
 
+
   void run()
   {
       typedef test::tag::tester tester_;
@@ -68,7 +77,6 @@ namespace test
       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);
   }
 }
 

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/Jamfile

@@ -0,0 +1,38 @@
+subproject libs/parameter/test/python ;
+
+SEARCH on python.jam = $(BOOST_BUILD_PATH) ;
+include python.jam ;
+
+STATS_ROOT ?= $(BOOST_ROOT) ;
+
+extension parameter
+  : simple.cpp
+    <template>@boost/libs/python/build/extension
+  ;
+
+boost-python-runtest test1
+  : test_simple.py
+    <pyd>parameter
+  ;
+
+extension general
+  : general.cpp
+    <template>@boost/libs/python/build/extension
+  ;
+
+boost-python-runtest test2
+  : test_general.py
+    <pyd>general
+  ;
+
+extension accumulator_set
+  : accumulator.cpp
+    <template>@boost/libs/python/build/extension
+  : <include>$(STATS_ROOT)
+  ;
+
+boost-python-runtest test3
+  : test_accumulator.py
+    <pyd>accumulator_set
+  ;
+

test/python/accumulator.cpp

@@ -0,0 +1,97 @@
+// 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 <iostream>
+#include <boost/python.hpp>
+#include <boost/parameter/python/general.hpp>
+
+#include <boost/accumulators/accumulators.hpp>
+#include <boost/accumulators/statistics/stats.hpp>
+#include <boost/accumulators/statistics/count.hpp>
+#include <boost/accumulators/statistics/min.hpp>
+#include <boost/accumulators/statistics/mean.hpp>
+#include <boost/accumulators/statistics/sum.hpp>
+#include <boost/accumulators/statistics/weighted_mean.hpp>
+#include <boost/accumulators/statistics/moment.hpp>
+#include <boost/accumulators/statistics/order.hpp>
+#include <boost/accumulators/statistics/order_variate.hpp>
+#include <boost/accumulators/statistics/with_error.hpp>
+#include <boost/accumulators/framework/parameters/weights.hpp>
+#include <boost/accumulators/statistics/variates/covariate.hpp>
+
+using namespace boost;
+using namespace boost::accumulators;
+
+typedef accumulator_set<
+    double
+  , stats<tag::order_variate<int, tag::covariate1> >
+> accumulator_type;
+
+template<typename Range>
+python::list listify_range(Range const &range)
+{
+    python::list l;
+    typedef typename boost::range_result_iterator<Range>::type iterator;
+    iterator begin = range.begin();
+    iterator end = range.end();
+
+    for(; begin != end; ++begin)
+        l.append(*begin);
+
+    return l;
+}
+
+python::list listify_covariate1(accumulator_type const& acc)
+{
+    return listify_range(order_variate<int, tag::covariate1>(acc));
+}
+
+namespace boost { namespace accumulators { namespace tag
+{
+  char const* keyword_name(sample*)
+  {
+      return "sample";
+  }
+
+  char const* keyword_name(covariate1*)
+  {
+      return "covariate1";
+  }
+}}} // namespace boost::accumulators::tag
+
+namespace boost { namespace accumulators { namespace detail
+{
+  char const* keyword_name(cache_size_tag*)
+  {
+      return "cache_size";
+  }
+}}} // namespace boost::accumulators::detail
+
+BOOST_PYTHON_MODULE(accumulator_set)
+{
+    using namespace boost::python;
+    namespace py = boost::parameter::python;
+
+    class_<accumulator_type>("accumulator_set", no_init)
+        .def(
+            py::init<
+                mpl::vector1<
+                    accumulators::detail::cache_size_tag
+                >
+              , mpl::vector1<unsigned>
+            >()
+        )
+        .def(
+            py::call<
+                mpl::vector2<
+                    tag::sample
+                  , tag::covariate1
+                >
+              , mpl::vector3<void, double, int>
+            >()
+        );
+
+    def("covariate1", listify_covariate1);
+}
+