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
+