diff -r 000000000000 -r e4d67989cc36 ossrv_pub/boost_apis/boost/parameter/parameters.hpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/ossrv_pub/boost_apis/boost/parameter/parameters.hpp	Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,931 @@
+// Copyright David Abrahams, Daniel Wallin 2003. 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_PARAMETERS_031014_HPP
+#define BOOST_PARAMETERS_031014_HPP
+
+#include <boost/detail/is_xxx.hpp>
+
+#include <boost/type_traits/is_const.hpp>
+
+#include <boost/mpl/lambda.hpp>
+#include <boost/mpl/apply.hpp>
+#include <boost/mpl/always.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/pair.hpp>
+
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+#include <boost/preprocessor/repetition/enum.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
+#include <boost/preprocessor/arithmetic/sub.hpp>
+#include <boost/preprocessor/repetition/repeat.hpp>
+#include <boost/preprocessor/repetition/enum_shifted.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/repetition/enum_shifted_params.hpp>
+#include <boost/preprocessor/seq/elem.hpp>
+#include <boost/preprocessor/iteration/iterate.hpp>
+#include <boost/preprocessor/facilities/intercept.hpp>
+#include <boost/preprocessor/cat.hpp>
+
+#include <boost/parameter/aux_/arg_list.hpp>
+#include <boost/parameter/aux_/yesno.hpp>
+#include <boost/parameter/aux_/void.hpp>
+#include <boost/parameter/aux_/default.hpp>
+#include <boost/parameter/aux_/unwrap_cv_reference.hpp>
+#include <boost/parameter/aux_/tagged_argument.hpp>
+#include <boost/parameter/aux_/tag.hpp>
+#include <boost/parameter/aux_/template_keyword.hpp>
+#include <boost/parameter/aux_/set.hpp>
+#include <boost/parameter/config.hpp>
+
+namespace parameter_
+{
+  template <class T>
+  struct unmatched_argument
+  {
+      BOOST_MPL_ASSERT((boost::is_same<T,void>));
+      typedef int type;
+  }; 
+} // namespace parameter_
+
+namespace boost {
+
+template<class T> class reference_wrapper;
+
+namespace parameter {
+
+namespace aux { struct use_default {}; }
+
+// These templates can be used to describe the treatment of particular
+// named parameters for the purposes of overload elimination with
+// SFINAE, by placing specializations in the parameters<...> list.  In
+// order for a treated function to participate in overload resolution:
+//
+//   - all keyword tags wrapped in required<...> must have a matching
+//     actual argument
+//
+//   - The actual argument type matched by every keyword tag
+//     associated with a predicate must satisfy that predicate
+//
+// If a keyword k is specified without an optional<...> or
+// required<...>, wrapper, it is treated as though optional<k> were
+// specified.
+//
+// If a keyword k is specified with deduced<...>, that keyword
+// will be automatically deduced from the argument list.
+//
+template <class Tag, class Predicate = aux::use_default>
+struct required
+{
+    typedef Tag key_type;
+    typedef Predicate predicate;
+};
+
+template <class Tag, class Predicate = aux::use_default>
+struct optional
+{
+    typedef Tag key_type;
+    typedef Predicate predicate;
+};
+
+template <class Tag>
+struct deduced
+{
+    typedef Tag key_type;
+};
+
+namespace aux
+{
+  // Defines metafunctions, is_required and is_optional, that
+  // identify required<...>, optional<...> and deduced<...> specializations.
+  BOOST_DETAIL_IS_XXX_DEF(required, required, 2)
+  BOOST_DETAIL_IS_XXX_DEF(optional, optional, 2)
+  BOOST_DETAIL_IS_XXX_DEF(deduced_aux, deduced, 1)
+
+  template <class S>
+  struct is_deduced0
+    : is_deduced_aux<
+          typename S::key_type
+      >::type
+  {};
+
+  template <class S>
+  struct is_deduced
+    : mpl::eval_if<
+          mpl::or_<
+              is_optional<S>, is_required<S>
+          >
+        , is_deduced0<S>
+        , mpl::false_
+      >::type
+  {};
+
+  //
+  // key_type, has_default, and predicate --
+  //
+  // These metafunctions accept a ParameterSpec and extract the
+  // keyword tag, whether or not a default is supplied for the
+  // parameter, and the predicate that the corresponding actual
+  // argument type is required match.
+  //
+  // a ParameterSpec is a specialization of either keyword<...>,
+  // required<...>, optional<...>
+  //
+
+  // helper for key_type<...>, below.
+  template <class T>
+  struct get_tag_type0
+  {
+      typedef typename T::key_type type;
+  };
+
+  template <class T>
+  struct get_tag_type
+    : mpl::eval_if<
+          is_deduced_aux<typename T::key_type>
+        , get_tag_type0<typename T::key_type>
+        , mpl::identity<typename T::key_type>
+      >
+  {};
+
+  template <class T>
+  struct tag_type
+    : mpl::eval_if<
+          mpl::or_<
+              is_optional<T>
+            , is_required<T>
+          >
+        , get_tag_type<T>
+        , mpl::identity<T>
+      >
+  {};
+
+  template <class T>
+  struct has_default
+    : mpl::not_<is_required<T> >
+  {};
+
+  // helper for get_predicate<...>, below
+  template <class T>
+  struct get_predicate_or_default
+  {
+      typedef T type;
+  };
+
+  template <>
+  struct get_predicate_or_default<use_default>
+  {
+      typedef mpl::always<mpl::true_> type;
+  };
+
+  // helper for predicate<...>, below
+  template <class T>
+  struct get_predicate
+  {
+      typedef typename
+          get_predicate_or_default<typename T::predicate>::type
+      type;
+  };
+
+  template <class T>
+  struct predicate
+    : mpl::eval_if<
+         mpl::or_<
+              is_optional<T>
+            , is_required<T>
+          >
+        , get_predicate<T>
+        , mpl::identity<mpl::always<mpl::true_> >
+      >
+  {
+  };
+
+
+  // Converts a ParameterSpec into a specialization of
+  // parameter_requirements.  We need to do this in order to get the
+  // tag_type into the type in a way that can be conveniently matched
+  // by a satisfies(...) member function in arg_list.
+  template <class ParameterSpec>
+  struct as_parameter_requirements
+  {
+      typedef parameter_requirements<
+          typename tag_type<ParameterSpec>::type
+        , typename predicate<ParameterSpec>::type
+        , typename has_default<ParameterSpec>::type
+      > type;
+  };
+
+  template <class T>
+  struct is_named_argument
+    : mpl::or_<
+          is_template_keyword<T>
+        , is_tagged_argument<T>
+      >
+  {};
+  
+  // Returns mpl::true_ iff the given ParameterRequirements are
+  // satisfied by ArgList.
+  template <class ArgList, class ParameterRequirements>
+  struct satisfies
+  {
+#if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
+      // VC7.1 can't handle the sizeof() implementation below,
+      // so we use this instead.
+      typedef typename mpl::apply_wrap3<
+          typename ArgList::binding
+        , typename ParameterRequirements::keyword
+        , void_
+        , mpl::false_
+      >::type bound;
+
+      typedef typename mpl::eval_if<
+          is_same<bound, void_>
+        , typename ParameterRequirements::has_default
+        , mpl::apply_wrap2<
+              typename mpl::lambda<
+                  typename ParameterRequirements::predicate, lambda_tag
+              >::type
+            , bound
+            , ArgList
+          >
+      >::type type;
+#else
+      BOOST_STATIC_CONSTANT(
+          bool, value = (
+              sizeof(
+                  aux::to_yesno(
+                      ArgList::satisfies((ParameterRequirements*)0, (ArgList*)0)
+                  )
+              ) == sizeof(yes_tag)
+          )
+      );
+
+      typedef mpl::bool_<satisfies::value> type;
+#endif
+  };
+
+  // Returns mpl::true_ if the requirements of the given ParameterSpec
+  // are satisfied by ArgList.
+  template <class ArgList, class ParameterSpec>
+  struct satisfies_requirements_of
+    : satisfies<
+          ArgList
+        , typename as_parameter_requirements<ParameterSpec>::type
+      >
+  {};
+
+  // Tags a deduced argument Arg with the keyword tag of Spec using TagFn.
+  // Returns the tagged argument and the mpl::set<> UsedArgs with the
+  // tag of Spec inserted.
+  template <class UsedArgs, class Spec, class Arg, class TagFn>
+  struct tag_deduced
+  {
+      typedef mpl::pair<
+          typename mpl::apply_wrap2<TagFn, typename tag_type<Spec>::type, Arg>::type
+        , typename aux::insert_<UsedArgs, typename tag_type<Spec>::type>::type
+      > type;
+  };
+
+  template <
+      class Argument
+    , class ArgumentPack
+    , class DeducedArgs
+    , class UsedArgs
+    , class TagFn
+  >
+  struct deduce_tag;
+
+  // Tag type passed to MPL lambda.
+  struct lambda_tag;
+
+  // Helper for deduce_tag<> below.
+  template <
+      class Argument
+    , class ArgumentPack
+    , class DeducedArgs
+    , class UsedArgs
+    , class TagFn
+  >
+  struct deduce_tag0
+  {
+      typedef typename DeducedArgs::spec spec;
+
+      typedef typename mpl::apply_wrap2<
+          typename mpl::lambda<
+              typename spec::predicate, lambda_tag
+          >::type
+        , Argument
+        , ArgumentPack
+      >::type condition;
+
+      // Deduced parameter matches several arguments.
+
+      BOOST_MPL_ASSERT((
+          mpl::not_<mpl::and_<
+              condition
+            , aux::has_key_<UsedArgs, typename tag_type<spec>::type>
+          > >
+      ));
+
+      typedef typename mpl::eval_if<
+          condition
+        , tag_deduced<UsedArgs, spec, Argument, TagFn>
+        , deduce_tag<Argument, ArgumentPack, typename DeducedArgs::tail, UsedArgs, TagFn>
+      >::type type;
+  };
+
+  // Tries to deduced a keyword tag for a given Argument.
+  // Returns an mpl::pair<> consisting of the tagged_argument<>, 
+  // and an mpl::set<> where the new tag has been inserted.
+  //
+  //  Argument: The argument type to be tagged.
+  //
+  //  ArgumentPack: The ArgumentPack built so far.
+  //
+  //  DeducedArgs: A specialization of deduced_item<> (see below).
+  //               A list containing only the deduced ParameterSpecs.
+  //
+  //  UsedArgs: An mpl::set<> containing the keyword tags used so far.
+  //
+  //  TagFn: A metafunction class used to tag positional or deduced
+  //         arguments with a keyword tag.
+
+  template <
+      class Argument
+    , class ArgumentPack
+    , class DeducedArgs
+    , class UsedArgs
+    , class TagFn
+  >
+  struct deduce_tag
+  {
+      typedef typename mpl::eval_if<
+          is_same<DeducedArgs, void_>
+        , mpl::pair<void_, UsedArgs>
+        , deduce_tag0<Argument, ArgumentPack, DeducedArgs, UsedArgs, TagFn>
+      >::type type;
+  };
+
+  template <
+      class List
+    , class DeducedArgs
+    , class TagFn
+    , class Positional
+    , class UsedArgs
+    , class ArgumentPack
+    , class Error
+  >
+  struct make_arg_list_aux;
+
+  // Inserts Tagged::key_type into the UserArgs set.
+  // Extra indirection to lazily evaluate Tagged::key_type.
+  template <class UsedArgs, class Tagged>
+  struct insert_tagged
+  {
+      typedef typename aux::insert_<
+          UsedArgs, typename Tagged::key_type
+      >::type type;
+  };
+
+  // Borland needs the insane extra-indirection workaround below
+  // so that it doesn't magically drop the const qualifier from
+  // the argument type.
+
+  template <
+      class List
+    , class DeducedArgs
+    , class TagFn
+    , class Positional
+    , class UsedArgs
+    , class ArgumentPack
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+    , class argument
+#endif
+    , class Error
+  >
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+  struct make_arg_list00
+#else
+  struct make_arg_list0
+#endif
+  {
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+      typedef typename List::arg argument;
+#endif
+      typedef typename List::spec parameter_spec;
+      typedef typename tag_type<parameter_spec>::type tag_;
+
+      typedef is_named_argument<argument> is_tagged;
+
+      // If this argument is either explicitly tagged or a deduced
+      // parameter, we turn off positional matching.
+      typedef mpl::and_<
+          mpl::not_<
+              mpl::or_<is_deduced<parameter_spec>, is_tagged> 
+          > 
+        , Positional
+      > positional;
+
+      // If this parameter is explicitly tagged we add it to the
+      // used-parmeters set. We only really need to add parameters
+      // that are deduced, but we would need a way to check if
+      // a given tag corresponds to a deduced parameter spec.
+      typedef typename mpl::eval_if<
+          is_tagged
+        , insert_tagged<UsedArgs, argument>
+        , mpl::identity<UsedArgs>
+      >::type used_args;
+
+      // If this parameter is neither explicitly tagged, nor
+      // positionally matched; deduce the tag from the deduced
+      // parameter specs.
+      typedef typename mpl::eval_if<
+          mpl::or_<is_tagged, positional>
+        , mpl::pair<void_, used_args>
+        , deduce_tag<argument, ArgumentPack, DeducedArgs, used_args, TagFn>
+      >::type deduced_data;
+
+      // If this parameter is explicitly tagged..
+      typedef typename mpl::eval_if<
+          is_tagged
+        , mpl::identity<argument>                        // .. just use it
+        , mpl::eval_if<                                  // .. else, if positional matching is turned on..
+                positional
+              , mpl::apply_wrap2<TagFn, tag_, argument>  // .. tag it positionally
+              , mpl::first<deduced_data>                 // .. else, use the deduced tag
+          >
+      >::type tagged;
+
+      // We build the arg_list incrementally as we go, prepending new
+      // nodes.
+
+      typedef typename mpl::if_<
+          mpl::and_<
+              is_same<Error, void_>
+            , is_same<tagged, void_>
+          >
+        , parameter_::unmatched_argument<argument>
+        , void_
+      >::type error;
+
+      typedef typename mpl::if_<
+          is_same<tagged, void_>
+        , ArgumentPack
+        , arg_list<tagged, ArgumentPack>
+      >::type argument_pack;
+
+      typedef typename make_arg_list_aux<
+          typename List::tail
+        , DeducedArgs
+        , TagFn
+        , positional
+        , typename deduced_data::second
+        , argument_pack
+        , error
+      >::type type;
+  };
+
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+  template <
+      class List
+    , class DeducedArgs
+    , class TagFn
+    , class Positional
+    , class UsedArgs
+    , class ArgumentPack
+    , class Error
+  >
+  struct make_arg_list0
+  {
+      typedef typename mpl::eval_if<
+          typename List::is_arg_const
+        , make_arg_list00<
+              List
+            , DeducedArgs
+            , TagFn
+            , Positional
+            , UsedArgs
+            , ArgumentPack
+            , typename List::arg const
+            , Error
+          >
+        , make_arg_list00<
+              List
+            , DeducedArgs
+            , TagFn
+            , Positional
+            , UsedArgs
+            , ArgumentPack
+            , typename List::arg
+            , Error
+          >
+      >::type type;
+  };
+#endif
+
+  // Returns an ArgumentPack where the list of arguments has
+  // been tagged with keyword tags.
+  //
+  //   List: A specialization of item<> (see below). Contains
+  //         both the ordered ParameterSpecs, and the given arguments.
+  //
+  //   DeducedArgs: A specialization of deduced_item<> (see below).
+  //                A list containing only the deduced ParameterSpecs.
+  //
+  //   TagFn: A metafunction class used to tag positional or deduced
+  //          arguments with a keyword tag.
+  //
+  //   Position: An mpl::bool_<> specialization indicating if positional
+  //             matching is to be performed.
+  //
+  //   DeducedSet: An mpl::set<> containing the keyword tags used so far.
+  //
+  //   ArgumentPack: The ArgumentPack built so far. This is initially an
+  //                 empty_arg_list and is built incrementally.
+  //
+
+  template <
+      class List
+    , class DeducedArgs
+    , class TagFn
+    , class Positional
+    , class DeducedSet
+    , class ArgumentPack
+    , class Error
+  >
+  struct make_arg_list_aux
+  {
+      typedef typename mpl::eval_if<
+          is_same<List, void_>
+        , mpl::identity<mpl::pair<ArgumentPack, Error> >
+        , make_arg_list0<List, DeducedArgs, TagFn, Positional, DeducedSet, ArgumentPack, Error>
+      >::type type;
+  };
+
+  // VC6.5 was choking on the default parameters for make_arg_list_aux, so
+  // this just forwards to that adding in the defaults.
+  template <
+      class List
+    , class DeducedArgs
+    , class TagFn
+    , class EmitErrors = mpl::true_
+  >
+  struct make_arg_list
+  {
+      typedef typename make_arg_list_aux<
+          List, DeducedArgs, TagFn, mpl::true_, aux::set0, empty_arg_list, void_
+      >::type type;
+  };
+
+  // A parameter spec item typelist.
+  template <class Spec, class Arg, class Tail = void_>
+  struct item
+  {
+      typedef Spec spec;
+
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+      typedef is_const<Arg> is_arg_const;
+#endif
+
+      typedef Arg arg;
+      typedef Tail tail;
+  };
+
+  template <class Spec, class Arg, class Tail>
+  struct make_item
+  {
+      typedef item<Spec, Arg, typename Tail::type> type;
+  };
+
+  // Creates a item typelist.
+  template <class Spec, class Arg, class Tail>
+  struct make_items
+  {
+      typedef typename mpl::eval_if<
+          is_same<Arg, void_>
+        , mpl::identity<void_>
+        , make_item<Spec, Arg, Tail>
+      >::type type;
+  };
+
+  // A typelist that stored deduced parameter specs.
+  template <class ParameterSpec, class Tail = void_>
+  struct deduced_item
+  {
+      typedef ParameterSpec spec;
+      typedef Tail tail;
+  };
+
+  // Evaluate Tail and construct deduced_item list.
+  template <class Spec, class Tail>
+  struct make_deduced_item
+  {
+      typedef deduced_item<Spec, typename Tail::type> type;
+  };
+
+  template <class Spec, class Tail>
+  struct make_deduced_items
+  {
+      typedef typename mpl::eval_if<
+          is_same<Spec, void_>
+        , mpl::identity<void_>
+        , mpl::eval_if<
+              is_deduced<Spec>
+            , make_deduced_item<Spec, Tail>
+            , Tail
+          >
+      >::type type;
+  };
+
+  // Generates:
+  //
+  //   make<
+  //       parameter_spec#0, argument_type#0
+  //     , make<
+  //           parameter_spec#1, argument_type#1
+  //         , ... mpl::identity<aux::empty_arg_list>
+  //    ...>
+  //   >
+#define BOOST_PARAMETER_make_arg_list(z, n, names)      \
+      BOOST_PP_SEQ_ELEM(0,names)<                       \
+          BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(1,names), n),  \
+          BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(2,names), n), 
+
+#define BOOST_PARAMETER_right_angle(z, n, text) >
+
+#define BOOST_PARAMETER_build_arg_list(n, make, parameter_spec, argument_type)      \
+  BOOST_PP_REPEAT(                                                                  \
+      n, BOOST_PARAMETER_make_arg_list, (make)(parameter_spec)(argument_type))      \
+      mpl::identity<void_>                                                          \
+  BOOST_PP_REPEAT(n, BOOST_PARAMETER_right_angle, _)
+
+#define BOOST_PARAMETER_make_deduced_list(z, n, names)  \
+      BOOST_PP_SEQ_ELEM(0,names)<                       \
+          BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(1,names), n),
+
+#define BOOST_PARAMETER_build_deduced_list(n, make, parameter_spec)                 \
+  BOOST_PP_REPEAT(                                                                  \
+      n, BOOST_PARAMETER_make_deduced_list, (make)(parameter_spec))                 \
+  mpl::identity<void_>                                                              \
+  BOOST_PP_REPEAT(n, BOOST_PARAMETER_right_angle, _)
+
+  struct tag_keyword_arg
+  {
+      template <class K, class T>
+      struct apply
+        : tag<K,T>
+      {};
+  };
+
+  struct tag_template_keyword_arg
+  {
+      template <class K, class T>
+      struct apply
+      {
+          typedef template_keyword<K,T> type;
+      };
+  };
+
+} // namespace aux
+
+#define BOOST_PARAMETER_FORWARD_TYPEDEF(z, i, names) \
+    typedef BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(0,names),i) BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(1,names),i);
+
+#define BOOST_PARAMETER_FORWARD_TYPEDEFS(n, src, dest) \
+    BOOST_PP_REPEAT(n, BOOST_PARAMETER_FORWARD_TYPEDEF, (src)(dest))
+
+
+#define BOOST_PARAMETER_TEMPLATE_ARGS(z, n, text) class BOOST_PP_CAT(PS, n) = void_
+
+template<
+     class PS0
+   , BOOST_PP_ENUM_SHIFTED(BOOST_PARAMETER_MAX_ARITY, BOOST_PARAMETER_TEMPLATE_ARGS, _)
+>
+struct parameters
+{
+#undef BOOST_PARAMETER_TEMPLATE_ARGS
+
+    typedef typename BOOST_PARAMETER_build_deduced_list(
+        BOOST_PARAMETER_MAX_ARITY, aux::make_deduced_items, PS
+    )::type deduced_list;
+
+    // if the elements of NamedList match the criteria of overload
+    // resolution, returns a type which can be constructed from
+    // parameters.  Otherwise, this is not a valid metafunction (no nested
+    // ::type).
+
+
+#ifndef BOOST_NO_SFINAE
+    // If NamedList satisfies the PS0, PS1, ..., this is a
+    // metafunction returning parameters.  Otherwise it 
+    // has no nested ::type.
+    template <class ArgumentPackAndError>
+    struct match_base
+      : mpl::if_<
+            // mpl::and_<
+            //    aux::satisfies_requirements_of<NamedList,PS0>
+            //  , mpl::and_<
+            //       aux::satisfies_requirements_of<NamedList,PS1>...
+            //           ..., mpl::true_
+            // ...> >
+            
+# define BOOST_PARAMETER_satisfies(z, n, text)                                      \
+            mpl::and_<                                                              \
+                aux::satisfies_requirements_of<                                     \
+                    typename mpl::first<ArgumentPackAndError>::type                 \
+                  , BOOST_PP_CAT(PS, n)>                                            \
+                  ,
+            mpl::and_<
+                is_same<typename mpl::second<ArgumentPackAndError>::type, void_>
+              , BOOST_PP_REPEAT(BOOST_PARAMETER_MAX_ARITY, BOOST_PARAMETER_satisfies, _)
+                mpl::true_
+                BOOST_PP_REPEAT(BOOST_PARAMETER_MAX_ARITY, BOOST_PARAMETER_right_angle, _)
+            >
+
+# undef BOOST_PARAMETER_satisfies
+
+          , mpl::identity<parameters>
+          , void_
+        >
+    {};
+#endif
+    
+    // Specializations are to be used as an optional argument to
+    // eliminate overloads via SFINAE
+    template<
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+        // Borland simply can't handle default arguments in member
+        // class templates.  People wishing to write portable code can
+        // explicitly specify BOOST_PARAMETER_MAX_ARITY arguments
+        BOOST_PP_ENUM_PARAMS(BOOST_PARAMETER_MAX_ARITY, class A)
+#else 
+        BOOST_PP_ENUM_BINARY_PARAMS(
+            BOOST_PARAMETER_MAX_ARITY, class A, = void_ BOOST_PP_INTERCEPT
+        )
+#endif
+    >
+    struct match
+# ifndef BOOST_NO_SFINAE
+      : match_base<
+            typename aux::make_arg_list<
+                typename BOOST_PARAMETER_build_arg_list(
+                    BOOST_PARAMETER_MAX_ARITY, aux::make_items, PS, A
+                )::type
+              , deduced_list
+              , aux::tag_keyword_arg
+              , mpl::false_ // Don't emit errors when doing SFINAE
+            >::type
+        >::type
+    {};
+# else
+    { 
+        typedef parameters<
+            BOOST_PP_ENUM_PARAMS(BOOST_PARAMETER_MAX_ARITY, PS)
+        > type; 
+    };
+# endif
+
+    // Metafunction that returns an ArgumentPack.
+
+    // TODO, bind has to instantiate the error type in the result
+    // of make_arg_list.
+
+    template <
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+        // Borland simply can't handle default arguments in member
+        // class templates.  People wishing to write portable code can
+        // explicitly specify BOOST_PARAMETER_MAX_ARITY arguments
+        BOOST_PP_ENUM_PARAMS(BOOST_PARAMETER_MAX_ARITY, class A)
+#else 
+        BOOST_PP_ENUM_BINARY_PARAMS(
+            BOOST_PARAMETER_MAX_ARITY, class A, = void_ BOOST_PP_INTERCEPT
+        )
+#endif            
+    >
+    struct bind
+    {
+        typedef typename aux::make_arg_list<
+            typename BOOST_PARAMETER_build_arg_list(
+                BOOST_PARAMETER_MAX_ARITY, aux::make_items, PS, A
+            )::type
+          , deduced_list
+          , aux::tag_template_keyword_arg
+        >::type result;
+
+        typedef typename mpl::first<result>::type type;
+    };
+
+    BOOST_PARAMETER_FORWARD_TYPEDEFS(BOOST_PARAMETER_MAX_ARITY, PS, parameter_spec)
+
+    //
+    // The function call operator is used to build an arg_list that
+    // labels the positional parameters and maintains whatever other
+    // tags may have been specified by the caller.
+    //
+    // !!!NOTE!!!
+    //
+    // The make_arg_list<> produces a reversed arg_list, so
+    // we need to pass the arguments to it's constructor
+    // reversed.
+    //
+    aux::empty_arg_list operator()() const
+    {
+       return aux::empty_arg_list();
+    }
+
+    template<class A0>
+    typename mpl::first<
+        typename aux::make_arg_list<
+            aux::item<
+                PS0,A0
+            >
+          , deduced_list
+          , aux::tag_keyword_arg
+        >::type
+    >::type
+    operator()(A0& a0) const
+    {
+        typedef typename aux::make_arg_list<
+            aux::item<
+                PS0,A0
+            >
+          , deduced_list
+          , aux::tag_keyword_arg
+        >::type result;
+
+        typedef typename mpl::first<result>::type result_type;
+        typedef typename mpl::second<result>::type error;
+        error();
+
+        return result_type(
+            a0
+            // , void_(), void_(), void_() ...
+            BOOST_PP_ENUM_TRAILING_PARAMS(
+                BOOST_PP_SUB(BOOST_PARAMETER_MAX_ARITY, 1)
+              , aux::void_reference() BOOST_PP_INTERCEPT)
+        );
+    }
+
+    template<class A0, class A1>
+    typename mpl::first<
+        typename aux::make_arg_list<
+            aux::item<
+                PS0,A0
+              , aux::item<
+                    PS1,A1
+                >
+            >
+          , deduced_list
+          , aux::tag_keyword_arg
+        >::type
+    >::type
+    operator()(A0& a0, A1& a1) const
+    {
+        typedef typename aux::make_arg_list<
+            aux::item<
+                PS0,A0
+              , aux::item<
+                    PS1,A1
+                >
+            >
+          , deduced_list
+          , aux::tag_keyword_arg
+        >::type result;
+
+        typedef typename mpl::first<result>::type result_type;
+        typedef typename mpl::second<result>::type error;
+        error();
+
+        return result_type(
+            a1,a0
+            // , void_(), void_() ...
+            BOOST_PP_ENUM_TRAILING_PARAMS(
+                BOOST_PP_SUB(BOOST_PARAMETER_MAX_ARITY, 2)
+              , aux::void_reference() BOOST_PP_INTERCEPT)
+        );
+    }
+
+    // Higher arities are handled by the preprocessor
+#define BOOST_PP_ITERATION_PARAMS_1 (3,( \
+        3,BOOST_PARAMETER_MAX_ARITY,<boost/parameter/aux_/overloads.hpp> \
+    ))
+#include BOOST_PP_ITERATE()
+
+};
+
+} // namespace parameter
+
+} // namespace boost
+
+#endif // BOOST_PARAMETERS_031014_HPP
+