Added boost header

test/external/boost/parameter/aux_/arg_list.hpp

@@ -0,0 +1,459 @@
+// Copyright Daniel Wallin, David Abrahams 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 ARG_LIST_050329_HPP
+#define ARG_LIST_050329_HPP
+
+#include <boost/parameter/aux_/void.hpp>
+#include <boost/parameter/aux_/result_of0.hpp>
+#include <boost/parameter/aux_/default.hpp>
+#include <boost/parameter/aux_/parameter_requirements.hpp>
+#include <boost/parameter/aux_/yesno.hpp>
+#include <boost/parameter/aux_/is_maybe.hpp>
+#include <boost/parameter/config.hpp>
+
+#include <boost/mpl/apply.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/begin.hpp>
+#include <boost/mpl/end.hpp>
+#include <boost/mpl/iterator_tags.hpp>
+
+#include <boost/type_traits/add_reference.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/facilities/intercept.hpp>
+
+namespace boost { namespace parameter {
+
+// 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
+// terminated by an empty_arg_list.
+//
+// Each specialization of arg_list is derived from its successor in
+// the list type.  This feature is used along with using
+// declarations to build member function overload sets that can
+// match against keywords.
+//
+
+// MPL sequence support
+struct arg_list_tag;
+
+// Terminates arg_list<> and represents an empty list.  Since this
+// is just the terminating case you might want to look at arg_list
+// first, to get a feel for what's really happening here.
+
+struct empty_arg_list
+{
+    empty_arg_list() {}
+
+    // Constructor taking BOOST_PARAMETER_MAX_ARITY empty_arg_list
+    // arguments; this makes initialization
+    empty_arg_list(
+        BOOST_PP_ENUM_PARAMS(
+            BOOST_PARAMETER_MAX_ARITY, void_ BOOST_PP_INTERCEPT
+        ))
+    {}
+
+    // 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 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*);
+#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
+    struct key_owner
+    {
+        template<class KW>
+        struct apply
+        {
+            typedef empty_arg_list type;
+        };
+    };
+
+    template <class K, class T>
+    T& get(default_<K,T> x) const
+    {
+        return x.value;
+    }
+
+    template <class K, class F>
+    typename result_of0<F>::type
+    get(lazy_default<K,F> x) const
+    {
+        return x.compute_default();
+    }
+#endif
+
+    // If this function is called, it means there is no argument
+    // in the list that matches the supplied keyword. Just return
+    // the default value.
+    template <class K, class Default>
+    Default& operator[](default_<K, Default> x) const
+    {
+        return x.value;
+    }
+
+    // If this function is called, it means there is no argument
+    // in the list that matches the supplied keyword. Just evaluate
+    // and return the default value.
+    template <class K, class F>
+    typename result_of0<F>::type
+    operator[](
+        BOOST_PARAMETER_lazy_default_fallback<K,F> x) const
+    {
+        return x.compute_default();
+    }
+
+    // No argument corresponding to ParameterRequirements::key_type
+    // 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>
+    static typename ParameterRequirements::has_default
+    satisfies(ParameterRequirements*, ArgPack*);
+
+    // MPL sequence support
+    typedef empty_arg_list type;   // convenience
+    typedef arg_list_tag tag; // For dispatching to sequence intrinsics
+};
+
+#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>
+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;
+
+    TaggedArg arg;      // Stores the argument
+
+    // Store the arguments in successive nodes of this list
+    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)
+    )
+      : Next( // a1, a2, ...
+            BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PARAMETER_MAX_ARITY, a)
+          , void_reference()
+        )
+      , arg(a0)
+    {}
+
+    // 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)
+      : Next(tail)
+      , arg(head)
+    {}
+
+    // 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::apply_wrap3<typename Next::binding, KW, Default, Reference>
+          >::type type;
+        };
+    };
+
+#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(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(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
+
+    // A metafunction class that, given a keyword, returns the base
+    // sublist whose get() function can produce the value for that
+    // key.
+    struct key_owner
+    {
+        template<class KW>
+        struct apply
+        {
+          typedef typename mpl::eval_if<
+                boost::is_same<KW, key_type>
+              , mpl::identity<arg_list<TaggedArg,Next> >
+              , mpl::apply_wrap1<typename Next::key_owner,KW>
+          >::type type;
+        };
+    };
+
+    // 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
+    operator[](keyword<KW> const& x) const
+    {
+        typename mpl::apply_wrap1<key_owner, KW>::type const& sublist = *this;
+        return sublist.get(x);
+    }
+
+    template <class KW, class Default>
+    typename mpl::apply_wrap3<binding, KW, Default&, mpl::true_>::type
+    operator[](default_<KW, Default> x) const
+    {
+        typename mpl::apply_wrap1<key_owner, KW>::type const& sublist = *this;
+        return sublist.get(x);
+    }
+
+    template <class KW, class F>
+    typename mpl::apply_wrap3<
+        binding,KW
+      , typename result_of0<F>::type
+      , mpl::true_
+    >::type
+    operator[](lazy_default<KW,F> x) const
+    {
+        typename mpl::apply_wrap1<key_owner, KW>::type const& sublist = *this;
+        return sublist.get(x);
+    }
+
+    // These just return the stored value; when empty_arg_list is
+    // reached, indicating no matching argument was passed, the
+    // default is returned, or if no default_ or lazy_default was
+    // passed, compilation fails.
+    reference get(keyword<key_type> const&) const
+    {
+        BOOST_MPL_ASSERT_NOT((holds_maybe));
+        return arg.value;
+    }
+
+    template <class Default>
+    reference get(default_<key_type,Default> const& d) const
+    {
+        return get_default(d, holds_maybe());
+    }
+
+    template <class Default>
+    reference get(lazy_default<key_type, Default>) const
+    {
+        return arg.value;
+    }
+
+#else
+
+    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
+    {
+        return get_default(d, holds_maybe());
+    }
+
+    template <class Default>
+    reference operator[](lazy_default<key_type, Default>) const
+    {
+        return arg.value;
+    }
+
+    // Builds an overload set including operator[]s defined in base
+    // classes.
+    using Next::operator[];
+
+    //
+    // End of indexing support
+    //
+
+
+    //
+    // For parameter_requirements matching this node's key_type,
+    // return a bool constant wrapper indicating whether the
+    // requirements are satisfied by TaggedArg.  Used only for
+    // 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
+    satisfies(
+        parameter_requirements<key_type,Predicate,HasDefault>*
+      , ArgPack*
+    );
+
+    // Builds an overload set including satisfies functions defined
+    // in base classes.
+    using Next::satisfies;
+#endif
+
+    // 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
+    {
+        return arg_list<tagged_argument<KW,T2>, self>(x, *this);
+    }
+
+    // MPL sequence support
+    typedef self type;             // Convenience for users
+    typedef Next tail_type;        // For the benefit of iterators
+    typedef arg_list_tag tag; // For dispatching to sequence intrinsics
+};
+
+#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
+{
+    typedef mpl::forward_iterator_tag category;
+
+    // The incremented iterator
+    typedef arg_list_iterator<typename ArgumentPack::tail_type> next;
+
+    // dereferencing yields the key type
+    typedef typename ArgumentPack::key_type type;
+};
+
+template <>
+struct arg_list_iterator<empty_arg_list> {};
+
+}} // namespace parameter::aux
+
+// MPL sequence support
+namespace mpl
+{
+  template <>
+  struct begin_impl<parameter::aux::arg_list_tag>
+  {
+      template <class S>
+      struct apply
+      {
+          typedef parameter::aux::arg_list_iterator<S> type;
+      };
+  };
+
+  template <>
+  struct end_impl<parameter::aux::arg_list_tag>
+  {
+      template <class>
+      struct apply
+      {
+          typedef parameter::aux::arg_list_iterator<parameter::aux::empty_arg_list> type;
+      };
+  };
+}
+
+} // namespace boost
+
+#endif // ARG_LIST_050329_HPP
+

test/external/boost/parameter/aux_/cast.hpp

@@ -0,0 +1,131 @@
+// 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 !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
+  && !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 defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
+  || 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>
+struct cast;
+
+template <>
+struct cast<void*>
+{
+    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>
+struct cast<voidstar(T)>
+  : cast<void*>
+{
+};
+
+#else
+
+template <class T>
+struct cast<void*(T)>
+  : cast<void*>
+{
+};
+
+#endif
+
+template <class T>
+struct cast<void(T)>
+{
+    typedef typename boost::add_reference<
+        typename boost::remove_const<T>::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 T execute(T 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) \
+    boost::parameter::aux::cast<void predicate>::remove_const( \
+        boost::parameter::aux::cast<void predicate>::execute(value) \
+    )
+
+# endif
+
+}}} // namespace boost::parameter::aux
+
+#endif // BOOST_PARAMETER_CAST_060902_HPP
+

test/external/boost/parameter/aux_/default.hpp

@@ -0,0 +1,69 @@
+// Copyright Daniel Wallin, David Abrahams 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 DEFAULT_050329_HPP
+# define DEFAULT_050329_HPP
+
+# include <boost/detail/workaround.hpp>
+
+namespace boost { namespace parameter { namespace aux {
+
+// A wrapper for the default value passed by the user when resolving
+// the value of the parameter with the given Keyword
+template <class Keyword, class Value>
+struct default_
+{
+    default_(Value& x)
+      : value(x)
+    {}
+
+    Value& value;
+};
+
+//
+// lazy_default -- 
+//
+//    A wrapper for the default value computation function passed by
+//    the user when resolving the value of the parameter with the
+//    given keyword
+//
+# 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.
+template <class KW, class DefaultComputer>
+struct lazy_default_base
+{
+    lazy_default_base(DefaultComputer const& x)
+      : compute_default(x)
+    {}
+    DefaultComputer const& compute_default;
+};
+
+template <class KW, class DefaultComputer>
+struct lazy_default
+  : lazy_default_base<KW,DefaultComputer>
+  {
+      lazy_default(DefaultComputer const & x)
+        : lazy_default_base<KW,DefaultComputer>(x)
+      {}
+  };
+#  define BOOST_PARAMETER_lazy_default_fallback lazy_default_base
+# else 
+template <class KW, class DefaultComputer>
+struct lazy_default
+{
+    lazy_default(const DefaultComputer& x)
+      : compute_default(x)
+    {}
+    DefaultComputer const& compute_default;
+};
+#  define BOOST_PARAMETER_lazy_default_fallback lazy_default
+# endif 
+
+}}} // namespace boost::parameter::aux
+
+#endif // DEFAULT_050329_HPP
+

test/external/boost/parameter/aux_/is_maybe.hpp

@@ -0,0 +1,26 @@
+// 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

test/external/boost/parameter/aux_/maybe.hpp

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

test/external/boost/parameter/aux_/overloads.hpp

@@ -0,0 +1,88 @@
+// 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)
+
+// This file generates overloads in this format:
+//
+//     template<class A0, class A1>
+//     typename mpl::apply_wrap1<
+//         aux::make_arg_list<
+//             PS0,A0
+//           , aux::make_arg_list<
+//                 PS1,A1
+//               , mpl::identity<aux::empty_arg_list>
+//             >
+//         >
+//      , unnamed_list
+//     >::type
+//     operator()(A0 const& a0, A1 const& a1) const
+//     {
+//         typedef typename mpl::apply_wrap1<
+//             aux::make_arg_list<
+//                 PS0,A0
+//               , aux::make_arg_list<
+//                     PS1,A1
+//                   , mpl::identity<aux::empty_arg_list>
+//                 >
+//             >
+//         >::type arg_tuple;
+//
+//         return arg_tuple(
+//             a0
+//           , a1
+//           , aux::void_()
+//             ...
+//         );
+//     }
+//
+
+#if !defined(BOOST_PP_IS_ITERATING)
+# error Boost.Parameters - do not include this file!
+#endif
+
+#define N BOOST_PP_ITERATION()
+
+#define BOOST_PARAMETER_open_list(z, n, text) \
+    aux::item< \
+        BOOST_PP_CAT(PS, n), BOOST_PP_CAT(A, n)
+
+#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))
+
+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
+{
+    typedef typename BOOST_PARAMETER_arg_list(N)::type result;
+
+    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))
+        BOOST_PP_ENUM_TRAILING_PARAMS(
+            BOOST_PP_SUB(BOOST_PARAMETER_MAX_ARITY, N)
+          , aux::void_reference() BOOST_PP_INTERCEPT
+        ));
+}
+
+#undef BOOST_PARAMETER_arg_list
+#undef BOOST_PARAMETER_open_list
+#undef BOOST_PARAMETER_close_list
+#undef N
+

test/external/boost/parameter/aux_/parameter_requirements.hpp

@@ -0,0 +1,25 @@
+// Copyright Daniel Wallin, David Abrahams 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 PARAMETER_REQUIREMENTS_050331_HPP
+#define PARAMETER_REQUIREMENTS_050331_HPP
+
+namespace boost { namespace parameter { namespace aux {
+
+// Used to pass static information about parameter requirements
+// through the satisfies() overload set (below).  The
+// matched function is never invoked, but its type indicates whether
+// a parameter matches at compile-time
+template <class Keyword, class Predicate, class HasDefault>
+struct parameter_requirements
+{
+    typedef Keyword keyword;
+    typedef Predicate predicate;
+    typedef HasDefault has_default;
+};
+
+}}} // namespace boost::parameter::aux
+
+#endif // PARAMETER_REQUIREMENTS_050331_HPP

test/external/boost/parameter/aux_/parenthesized_type.hpp

@@ -0,0 +1,119 @@
+// 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;
+
+# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+
+template <class Arg>
+struct unaryfunptr_arg_type<void(*)(Arg)>
+{
+    typedef Arg type;
+};
+
+# else
+
+// Use the "native typeof" bugfeatures of older versions of MSVC to
+// accomplish what we'd normally do with partial specialization.  This
+// capability was discovered by Igor Chesnokov.
+
+#  if BOOST_WORKAROUND(BOOST_MSVC, != 1300)
+
+// This version applies to VC6.5 and VC7.1 (except that we can just
+// use partial specialization for the latter in this case).
+
+// This gets used as a base class.  
+template<typename Address>
+struct msvc_type_memory
+{
+    // A nullary metafunction that will yield the Value type "stored"
+    // at this Address.
+    struct storage;
+};
+
+template<typename Value, typename Address>
+struct msvc_store_type : msvc_type_memory<Address>
+{
+    // VC++ somehow lets us define the base's nested storage
+    // metafunction here, where we have the Value type we'd like to
+    // "store" in it.  Later we can come back to the base class and
+    // extract the "stored type."
+    typedef msvc_type_memory<Address> location;
+    struct location::storage 
+    {
+        typedef Value type;
+    };
+};
+
+#  else
+
+// This slightly more complicated version of the same thing is
+// required for msvc-7.0
+template<typename Address>
+struct msvc_type_memory
+{
+    template<bool>
+    struct storage_impl;
+
+    typedef storage_impl<true> storage;
+};
+
+template<typename Value, typename Address>
+struct msvc_store_type : msvc_type_memory<Address>
+{
+    // Rather than supplying a definition for the base class' nested
+    // class, we specialize the base class' nested template
+    template<>
+    struct storage_impl<true>  
+    {
+        typedef Value type;
+    };
+};
+
+#  endif
+
+// Function template argument deduction does many of the same things
+// as type matching during partial specialization, so we call a
+// function template to "store" T into the type memory addressed by
+// void(*)(T).
+template <class T>
+msvc_store_type<T,void(*)(T)>
+msvc_store_argument_type(void(*)(T));
+
+template <class FunctionPointer>
+struct unaryfunptr_arg_type
+{
+    // We don't want the function to be evaluated, just instantiated,
+    // so protect it inside of sizeof.
+    enum { dummy = sizeof(msvc_store_argument_type((FunctionPointer)0)) };
+
+    // Now pull the type out of the instantiated base class
+    typedef typename msvc_type_memory<FunctionPointer>::storage::type type;
+};
+
+# endif
+
+template <>
+struct unaryfunptr_arg_type<void(*)(void)>
+{
+    typedef void type;
+};
+    
+}}} // namespace boost::parameter::aux
+
+#endif // BOOST_PARAMETER_AUX_PARENTHESIZED_TYPE_DWA2006414_HPP

test/external/boost/parameter/aux_/preprocessor/flatten.hpp

@@ -0,0 +1,115 @@
+// 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
+

test/external/boost/parameter/aux_/preprocessor/for_each.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_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
+

test/external/boost/parameter/aux_/python/invoker.hpp

@@ -0,0 +1,132 @@
+// 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/mpl/size.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 M, class R, class T, class Args>
+struct member_invoker;
+
+template <class M, class R, class T>
+struct make_member_invoker
+{
+    template <class Args>
+    struct apply
+    {
+        typedef member_invoker<
+            mpl::size<Args>::value, M, R, T, 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 M, class R, class T, class Args>
+struct member_invoker<0, M, R, T, Args>
+{
+    static R execute(T& self)
+    {
+        return M()(boost::type<R>(), self);
+    }
+};
+
+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/aux_/python/invoker_iterate.hpp>, 1))
+# include BOOST_PP_ITERATE()
+
+# define BOOST_PP_ITERATION_PARAMS_1 (4, \
+    (1, BOOST_PARAMETER_MAX_ARITY, <boost/parameter/aux_/python/invoker_iterate.hpp>, 2))
+# include BOOST_PP_ITERATE()
+
+# define BOOST_PP_ITERATION_PARAMS_1 (4, \
+    (1, BOOST_PARAMETER_MAX_ARITY, <boost/parameter/aux_/python/invoker_iterate.hpp>, 3))
+# include BOOST_PP_ITERATE()
+
+# define BOOST_PP_ITERATION_PARAMS_1 (4, \
+    (1, BOOST_PARAMETER_MAX_ARITY, <boost/parameter/aux_/python/invoker_iterate.hpp>, 4))
+# include BOOST_PP_ITERATE()
+
+}}}} // namespace boost::parameter::python::aux
+
+#endif // BOOST_PARAMETER_INVOKER_051210_HPP
+

test/external/boost/parameter/aux_/python/invoker_iterate.hpp

@@ -0,0 +1,93 @@
+// 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>
+#elif BOOST_PP_ITERATION_FLAGS() == 4
+template <class M, class R, class T, class Args>
+struct member_invoker<N, M, R, 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() == 3
+    T*
+#else
+    R
+#endif 
+    execute(
+#if BOOST_PP_ITERATION_FLAGS() == 2 || BOOST_PP_ITERATION_FLAGS() == 4
+        T& self
+      ,
+#endif
+        BOOST_PP_ENUM_BINARY_PARAMS(N, arg, a)
+    )
+    {
+        return
+#if BOOST_PP_ITERATION_FLAGS() == 1 || BOOST_PP_ITERATION_FLAGS() == 4
+         M()(
+              boost::type<R>()
+# if BOOST_PP_ITERATION_FLAGS() == 4
+            , self
+# endif
+            , BOOST_PP_ENUM_BINARY_PARAMS(N, parameter::keyword<kw, >::get() = a)
+         );
+#elif BOOST_PP_ITERATION_FLAGS() == 2
+         self(
+            BOOST_PP_ENUM_BINARY_PARAMS(N, parameter::keyword<kw, >::get() = a)
+         );
+#elif BOOST_PP_ITERATION_FLAGS() == 3
+         new T(
+             BOOST_PP_ENUM_BINARY_PARAMS(N, parameter::keyword<kw, >::get() = a)
+         );
+#endif
+    }
+};
+
+#undef BOOST_PARAMETER_PY_ARG_TYPES
+#undef N
+

test/external/boost/parameter/aux_/result_of0.hpp

@@ -0,0 +1,36 @@
+// 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)
+#ifndef BOOST_PARAMETER_AUX_RESULT_OF0_DWA2005511_HPP
+# define BOOST_PARAMETER_AUX_RESULT_OF0_DWA2005511_HPP
+
+# include <boost/utility/result_of.hpp>
+
+// A metafunction returning the result of invoking a nullary function
+// object of the given type.
+
+#ifndef BOOST_NO_RESULT_OF
+
+# include <boost/utility/result_of.hpp>
+namespace boost { namespace parameter { namespace aux { 
+template <class F>
+struct result_of0 : result_of<F()>
+{};
+
+}}} // namespace boost::parameter::aux_
+
+#else
+
+namespace boost { namespace parameter { namespace aux { 
+template <class F>
+struct result_of0
+{
+    typedef typename F::result_type type;
+};
+
+}}} // namespace boost::parameter::aux_
+
+#endif 
+
+
+#endif // BOOST_PARAMETER_AUX_RESULT_OF0_DWA2005511_HPP

test/external/boost/parameter/aux_/set.hpp

@@ -0,0 +1,67 @@
+// 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)) \
+  && !BOOST_WORKAROUND(__GNUC__, < 3)
+#  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
+

test/external/boost/parameter/aux_/tag.hpp

@@ -0,0 +1,38 @@
+// 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)
+#ifndef BOOST_PARAMETER_AUX_TAG_DWA2005610_HPP
+# define BOOST_PARAMETER_AUX_TAG_DWA2005610_HPP
+
+# include <boost/parameter/aux_/unwrap_cv_reference.hpp>
+# include <boost/parameter/aux_/tagged_argument.hpp>
+
+namespace boost { namespace parameter { namespace aux { 
+
+template <class Keyword, class ActualArg
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+        , class = typename is_cv_reference_wrapper<ActualArg>::type
+#endif 
+          >
+struct tag
+{
+    typedef tagged_argument<
+        Keyword
+      , typename unwrap_cv_reference<ActualArg>::type
+    > type;
+};
+
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+template <class Keyword, class ActualArg>
+struct tag<Keyword,ActualArg,mpl::false_>
+{
+    typedef tagged_argument<
+        Keyword
+      , ActualArg
+    > type;
+};
+#endif 
+
+}}} // namespace boost::parameter::aux_
+
+#endif // BOOST_PARAMETER_AUX_TAG_DWA2005610_HPP

test/external/boost/parameter/aux_/tagged_argument.hpp

@@ -0,0 +1,188 @@
+// Copyright Daniel Wallin, David Abrahams 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_TAGGED_ARGUMENT_050328_HPP
+# define BOOST_PARAMETER_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>
+
+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
+{
+    typedef Keyword key_type;
+    typedef Arg value_type;
+    typedef Arg& reference;
+
+    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>
+    arg_list<
+        tagged_argument<Keyword, Arg>
+      , arg_list<tagged_argument<Keyword2, Arg2> > 
+    >
+    operator,(tagged_argument<Keyword2, Arg2> x) const
+    {
+        return arg_list<
+            tagged_argument<Keyword, Arg>
+          , arg_list<tagged_argument<Keyword2, Arg2> > 
+        >(
+            *this
+          , 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& x) const
+    {
+        return value;
+    }
+
+    template <class F>
+    reference operator[](lazy_default<key_type,F> const& x) const
+    {
+        return value;
+    }
+
+    template <class KW, class Default>
+    Default& operator[](default_<KW,Default> const& x) const
+    {
+        return x.value;
+    }
+
+    template <class KW, class F>
+    typename result_of0<F>::type operator[](lazy_default<KW,F> const& x) const
+    {
+        return x.compute_default();
+    }
+
+    template <class ParameterRequirements>
+    static typename ParameterRequirements::has_default
+    satisfies(ParameterRequirements*);
+
+    template <class HasDefault, class Predicate>
+    static typename mpl::apply1<Predicate, value_type>::type
+    satisfies(
+        parameter_requirements<key_type,Predicate,HasDefault>*
+    );
+# endif
+
+    reference value;
+# if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
+    // warning suppression
+ private:
+    void operator=(tagged_argument const&);
+ public:    
+# endif
+    // MPL sequence support
+    typedef tagged_argument type;            // Convenience for users
+    typedef empty_arg_list tail_type;        // For the benefit of iterators
+    typedef arg_list_tag tag; // For dispatching to sequence intrinsics
+};
+
+// Defines a metafunction, is_tagged_argument, that identifies
+// tagged_argument specializations and their derived classes.
+template <class T>
+struct is_tagged_argument_aux
+  : is_convertible<T*,tagged_argument_base const*>
+{};
+
+template <class T>
+struct is_tagged_argument
+  : mpl::and_<
+        mpl::not_<is_reference<T> >
+      , is_tagged_argument_aux<T>
+    >
+{};
+
+}}} // namespace boost::parameter::aux
+
+#endif // BOOST_PARAMETER_TAGGED_ARGUMENT_050328_HPP
+

test/external/boost/parameter/aux_/template_keyword.hpp

@@ -0,0 +1,47 @@
+// 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
+

test/external/boost/parameter/aux_/unwrap_cv_reference.hpp

@@ -0,0 +1,97 @@
+// Copyright Daniel Wallin, David Abrahams 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 UNWRAP_CV_REFERENCE_050328_HPP
+#define UNWRAP_CV_REFERENCE_050328_HPP
+
+#include <boost/parameter/aux_/yesno.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/eval_if.hpp>
+
+namespace boost { template<class T> class reference_wrapper; }
+
+namespace boost { namespace parameter { namespace aux {
+
+//
+// reference_wrapper support -- because of the forwarding problem,
+// when passing arguments positionally by non-const reference, we
+// ask users of named parameter interfaces to use ref(x) to wrap
+// them.
+//
+
+// is_cv_reference_wrapper returns mpl::true_ if T is of type
+// reference_wrapper<U> cv
+template <class U>
+yes_tag is_cv_reference_wrapper_check(reference_wrapper<U> const volatile*);
+no_tag is_cv_reference_wrapper_check(...);
+
+template <class T>
+struct is_cv_reference_wrapper
+{
+    BOOST_STATIC_CONSTANT(
+        bool, value = (
+            sizeof(is_cv_reference_wrapper_check((T*)0)) == sizeof(yes_tag)
+        )
+    );
+
+    typedef mpl::bool_<
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+        is_cv_reference_wrapper::
+#endif 
+    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>
+struct get_type
+{
+    typedef typename T::type type;
+};
+
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+template <class T, class is_reference_wrapper = typename is_cv_reference_wrapper<T>::type>
+struct unwrap_cv_reference
+{
+    typedef T type;
+};
+
+template <class T>
+struct unwrap_cv_reference<T const, mpl::false_>
+{
+    typedef T const type;
+};
+
+template <class T>
+struct unwrap_cv_reference<T, mpl::true_>
+  : T
+{};
+
+#else 
+// Produces the unwrapped type to hold a reference to in named<>
+// Can't use boost::unwrap_reference<> here because it
+// doesn't handle the case where T = reference_wrapper<U> cv
+template <class T>
+struct unwrap_cv_reference
+{
+    typedef typename mpl::eval_if<
+        is_cv_reference_wrapper<T>
+      , get_type<T>
+      , mpl::identity<T>
+    >::type type;
+};
+#endif
+
+}}} // namespace boost::parameter::aux
+
+#endif // UNWRAP_CV_REFERENCE_050328_HPP
+

test/external/boost/parameter/aux_/void.hpp

@@ -0,0 +1,29 @@
+// Copyright Daniel Wallin, David Abrahams 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_VOID_050329_HPP
+#define BOOST_PARAMETER_VOID_050329_HPP
+
+namespace boost { namespace parameter { 
+
+// A placemarker for "no argument passed."
+// MAINTAINER NOTE: Do not make this into a metafunction
+struct void_ {}; 
+
+namespace aux 
+{
+
+  inline void_& void_reference()
+  {
+      static void_ instance;
+      return instance;
+  }
+
+} // namespace aux
+
+}} // namespace boost::parameter
+
+#endif // BOOST_PARAMETER_VOID_050329_HPP
+

test/external/boost/parameter/aux_/yesno.hpp

@@ -0,0 +1,26 @@
+// Copyright Daniel Wallin, David Abrahams 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 YESNO_050328_HPP
+#define YESNO_050328_HPP
+
+#include <boost/mpl/bool.hpp>
+
+namespace boost { namespace parameter { namespace aux {
+
+// types used with the "sizeof trick" to capture the results of
+// overload resolution at compile-time.
+typedef char yes_tag;
+typedef char (&no_tag)[2];
+
+// mpl::true_ and mpl::false_ are not distinguishable by sizeof(),
+// so we pass them through these functions to get a type that is.
+yes_tag to_yesno(mpl::true_);
+no_tag to_yesno(mpl::false_);
+
+}}} // namespace boost::parameter::aux
+
+#endif // YESNO_050328_HPP
+

test/external/boost/parameter/binding.hpp

@@ -0,0 +1,106 @@
+// 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)
+#ifndef BOOST_PARAMETER_BINDING_DWA200558_HPP
+# 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>
+
+# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+#  include <boost/mpl/eval_if.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(BOOST_MSVC, <= 1300) \
+  || 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)
+struct binding
+# else
+struct binding_eti
+# endif
+{
+# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
+  || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+    typedef typename mpl::eval_if<
+        mpl::is_placeholder<Parameters>
+      , mpl::identity<int>
+      , binding0<Parameters,Keyword,Default>
+    >::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
+
+# if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(3,binding,(Parameters,Keyword,Default))
+# endif
+};
+
+# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+template <class Parameters, class Keyword, class Default = void_>
+struct binding
+{
+    typedef typename mpl::eval_if<
+        is_same<Parameters, int>
+      , mpl::identity<int>
+      , binding_eti<Parameters, Keyword, Default>
+    >::type type;
+
+    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
+// parameter has been specified, returns the type returned by invoking
+// DefaultFn
+template <class Parameters, class Keyword, class DefaultFn>
+struct lazy_binding
+{
+  typedef typename mpl::apply_wrap3<
+      typename Parameters::binding
+    , Keyword
+    , typename aux::result_of0<DefaultFn>::type
+    , mpl::true_
+  >::type type;
+};
+
+
+}} // namespace boost::parameter
+
+#endif // BOOST_PARAMETER_BINDING_DWA200558_HPP

test/external/boost/parameter/config.hpp

@@ -0,0 +1,14 @@
+// Copyright Daniel Wallin, David Abrahams 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_CONFIG_050403_HPP
+#define BOOST_PARAMETER_CONFIG_050403_HPP
+
+#ifndef BOOST_PARAMETER_MAX_ARITY
+# define BOOST_PARAMETER_MAX_ARITY 5
+#endif
+
+#endif // BOOST_PARAMETER_CONFIG_050403_HPP
+

test/external/boost/parameter/keyword.hpp

@@ -0,0 +1,152 @@
+// Copyright Daniel Wallin, David Abrahams 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 KEYWORD_050328_HPP
+#define KEYWORD_050328_HPP
+
+#include <boost/parameter/aux_/unwrap_cv_reference.hpp>
+#include <boost/parameter/aux_/tag.hpp>
+#include <boost/parameter/aux_/default.hpp>
+
+namespace boost { namespace parameter {
+
+// Instances of unique specializations of keyword<...> serve to
+// associate arguments with parameter names.  For example:
+//
+//    struct rate_;           // parameter names
+//    struct skew_;
+//    namespace
+//    {
+//      keyword<rate_> rate;  // keywords
+//      keyword<skew_> skew;
+//    }
+//
+//    ...
+//
+//    f(rate = 1, skew = 2.4);
+//
+template <class Tag>
+struct keyword
+{
+    template <class T>
+    typename aux::tag<Tag, T>::type const
+    operator=(T& x) const
+    {
+        typedef typename aux::tag<Tag, T>::type result;
+        return result(x);
+    }
+
+    template <class Default>
+    aux::default_<Tag, Default>
+    operator|(Default& default_) const
+    {
+        return aux::default_<Tag, Default>(default_);
+    }
+
+    template <class Default>
+    aux::lazy_default<Tag, Default>
+    operator||(Default& default_) const
+    {
+        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
+    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_);
+    }
+
+    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
+    
+    // People will need to define these keywords in header files.  To
+    // prevent ODR violations, it's important that the keyword used in
+    // 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);
+    }
+};
+
+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 char const* keyword_name()                             \
+          {                                                             \
+              return #name;                                             \
+          }                                                             \
+      };                                                                \
+    }                                                                   \
+    static ::boost::parameter::keyword<tag_namespace::name> const& name \
+       = ::boost::parameter::keyword<tag_namespace::name>::instance;
+
+#else
+
+#define BOOST_PARAMETER_KEYWORD(tag_namespace,name)                 \
+    namespace tag_namespace                                         \
+    {                                                               \
+      struct name                                                   \
+      {                                                             \
+          static char const* keyword_name()                         \
+          {                                                         \
+              return #name;                                         \
+          }                                                         \
+      };                                                            \
+    }                                                               \
+    namespace                                                       \
+    {                                                               \
+       ::boost::parameter::keyword<tag_namespace::name> const& name \
+       = ::boost::parameter::keyword<tag_namespace::name>::instance;\
+    }
+
+#endif
+
+}} // namespace boost::parameter
+
+#endif // KEYWORD_050328_HPP
+

test/external/boost/parameter/macros.hpp

@@ -0,0 +1,99 @@
+// 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_PARAMETER_MACROS_050412_HPP
+#define BOOST_PARAMETER_MACROS_050412_HPP
+
+#include <boost/preprocessor/tuple/elem.hpp>
+#include <boost/preprocessor/repetition/repeat_from_to.hpp>
+#include <boost/preprocessor/arithmetic/inc.hpp>
+#include <boost/preprocessor/logical/bool.hpp>
+#include <boost/preprocessor/punctuation/comma_if.hpp>
+#include <boost/preprocessor/control/expr_if.hpp>
+#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)) 
+
+# define BOOST_PARAMETER_MATCH_TYPE(n, param)           \
+            BOOST_PP_EXPR_IF(n, typename) param::match  \
+            <                                           \
+                BOOST_PP_ENUM_PARAMS(n, T)              \
+            >::type 
+
+#else
+
+# define BOOST_PARAMETER_MATCH_TYPE(n, param) param
+
+#endif
+
+#define BOOST_PARAMETER_FUN_DECL(z, n, params)                                      \
+                                                                                    \
+    BOOST_PP_CAT(BOOST_PARAMETER_FUN_TEMPLATE_HEAD, BOOST_PP_BOOL(n))(n)            \
+                                                                                    \
+    BOOST_PP_TUPLE_ELEM(3, 0, params)                                               \
+        BOOST_PP_TUPLE_ELEM(3, 1, params)(                                          \
+            BOOST_PP_ENUM_BINARY_PARAMS(n, T, const& p)                             \
+            BOOST_PP_COMMA_IF(n)                                                    \
+            BOOST_PARAMETER_MATCH_TYPE(n,BOOST_PP_TUPLE_ELEM(3, 2, params))         \
+            kw = BOOST_PP_TUPLE_ELEM(3, 2, params)()                                \
+        )                                                                           \
+    {                                                                               \
+        return BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3, 1, params), _with_named_params)( \
+            kw(BOOST_PP_ENUM_PARAMS(n, p))                                          \
+        );                                                                          \
+    }
+
+// Generates:
+//
+// template<class Params>
+// ret name ## _with_named_params(Params const&);
+//
+// template<class T0>
+// ret name(T0 const& p0, typename parameters::match<T0>::type kw = parameters())
+// {
+//     return name ## _with_named_params(kw(p0));
+// }
+//
+// template<class T0, ..., class TN>
+// ret name(T0 const& p0, ..., TN const& PN
+//    , typename parameters::match<T0, ..., TN>::type kw = parameters())
+// {
+//     return name ## _with_named_params(kw(p0, ..., pN));
+// }
+//
+// template<class Params>
+// ret name ## _with_named_params(Params const&)
+//
+// lo and hi determines the min and max arity of the generated functions.
+
+#define BOOST_PARAMETER_FUN(ret, name, lo, hi, parameters)                          \
+                                                                                    \
+    template<class Params>                                                          \
+    ret BOOST_PP_CAT(name, _with_named_params)(Params const& p);                    \
+                                                                                    \
+    BOOST_PP_REPEAT_FROM_TO(                                                        \
+        lo, BOOST_PP_INC(hi), BOOST_PARAMETER_FUN_DECL, (ret, name, parameters))    \
+                                                                                    \
+    template<class Params>                                                          \
+    ret BOOST_PP_CAT(name, _with_named_params)(Params const& p)
+
+#define BOOST_PARAMETER_MEMFUN(ret, name, lo, hi, parameters)                       \
+                                                                                    \
+    BOOST_PP_REPEAT_FROM_TO(                                                        \
+        lo, BOOST_PP_INC(hi), BOOST_PARAMETER_FUN_DECL, (ret, name, parameters))    \
+                                                                                    \
+    template<class Params>                                                          \
+    ret BOOST_PP_CAT(name, _with_named_params)(Params const& p)
+
+#endif // BOOST_PARAMETER_MACROS_050412_HPP
+

test/external/boost/parameter/match.hpp

@@ -0,0 +1,55 @@
+// 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)
+#ifndef BOOST_PARAMETER_MATCH_DWA2005714_HPP
+# define BOOST_PARAMETER_MATCH_DWA2005714_HPP
+
+# include <boost/detail/workaround.hpp>
+# include <boost/preprocessor/seq/enum.hpp>
+
+# if BOOST_WORKAROUND(__MWERKS__, <= 0x3003)
+// Temporary version of BOOST_PP_SEQ_ENUM until Paul M. integrates the workaround.
+#  define BOOST_PARAMETER_SEQ_ENUM_I(size,seq) BOOST_PP_CAT(BOOST_PP_SEQ_ENUM_, size) seq
+#  define BOOST_PARAMETER_SEQ_ENUM(seq) BOOST_PARAMETER_SEQ_ENUM_I(BOOST_PP_SEQ_SIZE(seq), seq)
+# else
+#  define BOOST_PARAMETER_SEQ_ENUM(seq) BOOST_PP_SEQ_ENUM(seq)
+# endif 
+
+# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+
+#  include <boost/parameter/config.hpp>
+#  include <boost/parameter/aux_/void.hpp>
+#  include <boost/preprocessor/arithmetic/sub.hpp>
+#  include <boost/preprocessor/facilities/intercept.hpp>
+#  include <boost/preprocessor/repetition/enum_trailing_params.hpp>
+
+#  define BOOST_PARAMETER_MATCH_DEFAULTS(ArgTypes)              \
+        BOOST_PP_ENUM_TRAILING_PARAMS(                          \
+            BOOST_PP_SUB(                                       \
+                BOOST_PARAMETER_MAX_ARITY                       \
+              , BOOST_PP_SEQ_SIZE(ArgTypes)                     \
+            )                                                   \
+          , ::boost::parameter::void_ BOOST_PP_INTERCEPT   \
+        )
+
+# else
+
+#  define BOOST_PARAMETER_MATCH_DEFAULTS(ArgTypes)
+
+# endif 
+
+//
+// Generates, e.g.
+//
+//    typename dfs_params::match<A1,A2>::type name = dfs_params()
+//
+// with workarounds for Borland compatibility.
+//
+
+# define BOOST_PARAMETER_MATCH(ParameterSpec, ArgTypes, name)   \
+    typename ParameterSpec ::match<                             \
+        BOOST_PARAMETER_SEQ_ENUM(ArgTypes)                      \
+        BOOST_PARAMETER_MATCH_DEFAULTS(ArgTypes)                \
+    >::type name = ParameterSpec ()
+
+#endif // BOOST_PARAMETER_MATCH_DWA2005714_HPP

test/external/boost/parameter/name.hpp

@@ -0,0 +1,156 @@
+// 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) \
+  && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
+  && !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 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
+
+# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+#  define BOOST_PARAMETER_NAME_OBJECT(tag, name)                    \
+    static ::boost::parameter::keyword<tag> const& name             \
+       = ::boost::parameter::keyword<tag>::instance;
+# else
+#  define BOOST_PARAMETER_NAME_OBJECT(tag, name)                    \
+    namespace                                                       \
+    {                                                               \
+       ::boost::parameter::keyword<tag> const& name                 \
+       = ::boost::parameter::keyword<tag>::instance;                \
+    }
+# 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;                                                     \
+      };                                                            \
+    }                                                               \
+    BOOST_PARAMETER_NAME_OBJECT(tag_namespace::tag, name)
+
+# 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
+

test/external/boost/parameter/parameters.hpp

@@ -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).
+
+
+#if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
+    // 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
+# if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
+      : 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 its constructor
+    // reversed.
+    //
+    aux::empty_arg_list operator()() const
+    {
+       return aux::empty_arg_list();
+    }
+
+    template<class A0>
+    typename mpl::first<
+        typename aux::make_arg_list<
+            aux::item<
+                PS0,A0
+            >
+          , deduced_list
+          , aux::tag_keyword_arg
+        >::type
+    >::type
+    operator()(A0& a0) const
+    {
+        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
+

test/external/boost/parameter/python.hpp

@@ -0,0 +1,735 @@
+// 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_PYTHON_060209_HPP
+# define BOOST_PARAMETER_PYTHON_060209_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/mpl/empty.hpp>
+# include <boost/python/def.hpp>
+# include <boost/python/make_constructor.hpp>
+# include <boost/python/init.hpp>
+# include <boost/python/to_python_converter.hpp>
+# include <boost/parameter/aux_/maybe.hpp>
+# include <boost/parameter/aux_/python/invoker.hpp>
+
+namespace boost { namespace parameter { namespace python 
+{
+  namespace python_ = boost::python;
+}}}
+
+namespace boost { namespace parameter { namespace python { namespace aux 
+{
+
+  inline PyObject* unspecified_type()
+  {
+      static PyTypeObject unspecified = {
+          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         */
+      };
+
+      if (unspecified.ob_type == 0)
+      {
+          unspecified.ob_type = &PyType_Type;
+          PyType_Ready(&unspecified);
+      }
+
+      return (PyObject*)&unspecified;
+  }
+
+  struct empty_tag {};
+
+  struct empty_tag_to_python
+  {
+      static PyObject* convert(empty_tag)
+      {
+          return python_::xincref(unspecified_type());
+      }
+  };
+
+}}}} // namespace boost::parameter::python::aux
+
+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(parameter::python::aux::unspecified_type() == p)
+      {}
+
+      bool convertible() const
+      {
+          return empty || arg_from_python<T>::convertible();
+      }
+
+      parameter::aux::maybe<T> operator()()
+      {
+          if (empty)
+          {
+              return parameter::aux::maybe<T>();
+          }
+          else
+          {
+              return 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 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(kw::keyword_name())
+          )
+      );
+  }
+
+  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_name()) = empty_tag()
+          )
+      );
+  }
+
+  inline void initialize_converter()
+  {
+      static python_::to_python_converter<empty_tag, empty_tag_to_python> x;
+  }
+
+  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;
+
+      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*)
+  {
+      initialize_converter();
+
+      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*)
+  {}
+
+  struct not_specified {};
+
+  template <class CallPolicies>
+  struct call_policies_as_options
+  {
+      call_policies_as_options(CallPolicies const& call_policies)
+        : call_policies(call_policies)
+      {}
+
+      CallPolicies const& policies() const
+      {
+          return call_policies;
+      }
+
+      char const* doc() const
+      {
+          return 0;
+      }
+
+      CallPolicies call_policies;
+  };
+
+  template <class Class, class Options = not_specified>
+  struct def_class
+  {
+      def_class(Class& cl, char const* name, Options options = Options())
+        : cl(cl)
+        , name(name)
+        , options(options)
+      {}
+
+      template <class F>
+      void def(F f, not_specified const*) const
+      {
+          cl.def(name, f);
+      }
+
+      template <class F>
+      void def(F f, void const*) const
+      {
+          cl.def(name, f, options.doc(), options.policies());
+      }
+      
+      template <class F>
+      void operator()(F f) const
+      {
+          this->def(f, &options);
+      }
+
+      template <class F, class Keywords>
+      void def(F f, Keywords const& keywords, not_specified const*) const
+      {
+          cl.def(name, f, keywords);
+      }
+
+      template <class F, class Keywords>
+      void def(F f, Keywords const& keywords, void const*) const
+      {
+          cl.def(name, f, keywords, options.doc(), options.policies());
+      }
+
+      template <class F, class Keywords>
+      void operator()(F f, Keywords const& keywords) const
+      {
+          this->def(f, keywords, &options);
+      }
+
+      Class& cl;
+      char const* name;
+      Options options;
+  };
+
+  template <class Class, class CallPolicies = boost::python::default_call_policies>
+  struct def_init
+  {
+      def_init(Class& cl, CallPolicies call_policies = CallPolicies())
+        : cl(cl)
+        , call_policies(call_policies)
+      {}
+
+      template <class F>
+      void operator()(F f) const
+      {
+          cl.def(
+              "__init__"
+            , boost::python::make_constructor(f, call_policies)
+          );
+      }
+
+      template <class F, class Keywords>
+      void operator()(F f, Keywords const& keywords) const
+      {
+          cl.def(
+              "__init__"
+            , boost::python::make_constructor(f, call_policies, keywords)
+          );
+      }
+
+      Class& cl;
+      CallPolicies call_policies;
+  };
+
+  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>
+      , mpl::back_inserter<mpl::vector0<> >
+    >::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>
+      , mpl::back_inserter<mpl::vector0<> >
+    >::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*>
+  {
+      typedef K type;
+  };
+
+  template <class K>
+  struct keyword<K**>
+  {
+      typedef K type;
+  };
+
+  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 T>
+  struct make_kw_spec;
+
+  template <class K, class T>
+  struct make_kw_spec<K(T)>
+  {
+      typedef arg_spec<
+          typename keyword<K>::type
+        , typename required<K>::type
+        , typename optimized<K>::type
+        , T
+      > type;
+  };
+
+} // namespace aux
+
+template <class ParameterSpecs, class CallPolicies = boost::python::default_call_policies>
+struct init 
+  : boost::python::def_visitor<init<ParameterSpecs, CallPolicies> >
+{
+    init(CallPolicies call_policies = CallPolicies())
+      : call_policies(call_policies)
+    {}
+
+    template <class CallPolicies1>
+    init<ParameterSpecs, CallPolicies1> 
+    operator[](CallPolicies1 const& call_policies) const
+    {
+        return init<ParameterSpecs, CallPolicies1>(call_policies);
+    }
+
+    template <class Class>
+    void visit_aux(Class& cl, mpl::true_) const
+    {
+        cl.def(boost::python::init<>()[call_policies]);
+    }
+
+    template <class Class>
+    void visit_aux(Class& cl, mpl::false_) const
+    {
+        typedef typename mpl::transform<
+            ParameterSpecs
+          , aux::make_kw_spec<mpl::_>
+          , mpl::back_inserter<mpl::vector0<> >
+        >::type arg_specs;
+
+        typedef typename mpl::count_if<
+            arg_specs
+          , aux::is_optional<mpl::_>
+        >::type optional_arity;
+
+        typedef typename mpl::shift_left<mpl::long_<1>, optional_arity>::type upper;
+
+        aux::def_combinations(
+            aux::def_init<Class, CallPolicies>(cl, call_policies)
+          , (arg_specs*)0
+          , mpl::long_<0>()
+          , mpl::long_<upper::value>()
+          , (aux::make_init_invoker<typename Class::wrapped_type>*)0
+        );
+    }
+
+    template <class Class>
+    void visit(Class& cl) const
+    {
+        visit_aux(cl, mpl::empty<ParameterSpecs>());
+    }
+
+    CallPolicies call_policies;
+};
+
+template <class ParameterSpecs, class CallPolicies = boost::python::default_call_policies>
+struct call 
+  : boost::python::def_visitor<call<ParameterSpecs, CallPolicies> >
+{
+    call(CallPolicies const& call_policies = CallPolicies())
+      : call_policies(call_policies)
+    {}
+
+    template <class CallPolicies1>
+    call<ParameterSpecs, CallPolicies1>
+    operator[](CallPolicies1 const& call_policies) const
+    {
+        return call<ParameterSpecs, CallPolicies1>(call_policies);
+    }
+
+    template <class Class>
+    void visit(Class& cl) const
+    {
+        typedef mpl::iterator_range<
+            typename mpl::next<
+                typename mpl::begin<ParameterSpecs>::type
+            >::type
+          , typename mpl::end<ParameterSpecs>::type
+        > arg_types;
+
+        typedef typename mpl::front<ParameterSpecs>::type result_type;
+
+        typedef typename mpl::transform<
+            arg_types
+          , aux::make_kw_spec<mpl::_>
+          , mpl::back_inserter<mpl::vector0<> >
+        >::type arg_specs;
+
+        typedef typename mpl::count_if<
+            arg_specs
+          , aux::is_optional<mpl::_>
+        >::type optional_arity;
+
+        typedef typename mpl::shift_left<mpl::long_<1>, optional_arity>::type upper;
+
+        typedef aux::call_policies_as_options<CallPolicies> options;
+
+        aux::def_combinations(
+            aux::def_class<Class, options>(cl, "__call__", options(call_policies))
+          , (arg_specs*)0
+          , mpl::long_<0>()
+          , mpl::long_<upper::value>()
+          , (aux::make_call_invoker<typename Class::wrapped_type, result_type>*)0
+        );
+    }
+
+    CallPolicies call_policies;
+};
+
+template <class Fwd, class ParameterSpecs>
+struct function 
+  : boost::python::def_visitor<function<Fwd, ParameterSpecs> >
+{
+    template <class Class, class Options>
+    void visit(Class& cl, char const* name, Options const& options) const
+    {
+        typedef mpl::iterator_range<
+            typename mpl::next<
+                typename mpl::begin<ParameterSpecs>::type
+            >::type
+          , typename mpl::end<ParameterSpecs>::type
+        > arg_types;
+
+        typedef typename mpl::front<ParameterSpecs>::type result_type;
+
+        typedef typename mpl::transform<
+            arg_types
+          , aux::make_kw_spec<mpl::_>
+          , mpl::back_inserter<mpl::vector0<> >
+        >::type arg_specs;
+
+        typedef typename mpl::count_if<
+            arg_specs
+          , aux::is_optional<mpl::_>
+        >::type optional_arity;
+
+        typedef typename mpl::shift_left<mpl::long_<1>, optional_arity>::type upper;
+
+        aux::def_combinations(
+            aux::def_class<Class, Options>(cl, name, options)
+          , (arg_specs*)0
+          , mpl::long_<0>()
+          , mpl::long_<upper::value>()
+          , (aux::make_member_invoker<
+                Fwd, result_type, typename Class::wrapped_type
+            >*)0
+        );
+    }
+};
+
+}}} // namespace boost::parameter::python
+
+#endif // BOOST_PARAMETER_PYTHON_060209_HPP
+

test/external/boost/parameter/value_type.hpp

@@ -0,0 +1,108 @@
+// 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>
+
+# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+#  include <boost/mpl/eval_if.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(BOOST_MSVC, <= 1300) \
+  || 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_>
+# if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+struct value_type
+# else
+struct value_type_eti
+# endif
+{
+# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
+  || 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
+
+# if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(3,value_type,(Parameters,Keyword,Default))
+# endif
+};
+
+# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+template <class Parameters, class Keyword, class Default = void_>
+struct value_type
+{
+    typedef typename mpl::eval_if<
+        is_same<Parameters, int>
+      , mpl::identity<int>
+      , value_type_eti<Parameters, Keyword, Default>
+    >::type type;
+
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(3,value_type,(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
+// 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
+