uploading last boost libraries used in Kicad

include/boost/mpl/O1_size.hpp

@@ -0,0 +1,40 @@
+
+#ifndef BOOST_MPL_O1_SIZE_HPP_INCLUDED
+#define BOOST_MPL_O1_SIZE_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: O1_size.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/O1_size_fwd.hpp>
+#include <boost/mpl/sequence_tag.hpp>
+#include <boost/mpl/aux_/O1_size_impl.hpp>
+#include <boost/mpl/aux_/na_spec.hpp>
+#include <boost/mpl/aux_/lambda_support.hpp>
+
+namespace boost { namespace mpl {
+
+// returns sequence size if it's an O(1) operation; otherwise returns -1
+template<
+      typename BOOST_MPL_AUX_NA_PARAM(Sequence)
+    >
+struct O1_size
+    : O1_size_impl< typename sequence_tag<Sequence>::type >
+        ::template apply< Sequence >
+{
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(1, O1_size, (Sequence))
+};
+
+BOOST_MPL_AUX_NA_SPEC(1, O1_size)
+
+}}
+
+#endif // BOOST_MPL_O1_SIZE_HPP_INCLUDED

include/boost/mpl/O1_size_fwd.hpp

@@ -0,0 +1,24 @@
+
+#ifndef BOOST_MPL_O1_SIZE_FWD_HPP_INCLUDED
+#define BOOST_MPL_O1_SIZE_FWD_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: O1_size_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+namespace boost { namespace mpl {
+
+template< typename Tag > struct O1_size_impl;
+template< typename Sequence > struct O1_size;
+
+}}
+
+#endif // BOOST_MPL_O1_SIZE_FWD_HPP_INCLUDED

include/boost/mpl/accumulate.hpp

@@ -0,0 +1,39 @@
+
+#ifndef BOOST_MPL_ACCUMULATE_HPP_INCLUDED
+#define BOOST_MPL_ACCUMULATE_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2001-2004
+// Copyright David Abrahams 2001-2002
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: accumulate.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/fold.hpp>
+#include <boost/mpl/aux_/na_spec.hpp>
+#include <boost/mpl/aux_/lambda_support.hpp>
+
+namespace boost { namespace mpl {
+
+template<
+      typename BOOST_MPL_AUX_NA_PARAM(Sequence)
+    , typename BOOST_MPL_AUX_NA_PARAM(State)
+    , typename BOOST_MPL_AUX_NA_PARAM(ForwardOp)
+    >
+struct accumulate
+    : fold<Sequence,State,ForwardOp>
+{
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(3,accumulate,(Sequence,State,ForwardOp))
+};
+
+BOOST_MPL_AUX_NA_SPEC(3, accumulate)
+
+}}
+
+#endif // BOOST_MPL_ACCUMULATE_HPP_INCLUDED

include/boost/mpl/advance.hpp

@@ -0,0 +1,76 @@
+
+#ifndef BOOST_MPL_ADVANCE_HPP_INCLUDED
+#define BOOST_MPL_ADVANCE_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: advance.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/advance_fwd.hpp>
+#include <boost/mpl/less.hpp>
+#include <boost/mpl/negate.hpp>
+#include <boost/mpl/long.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/tag.hpp>
+#include <boost/mpl/apply_wrap.hpp>
+#include <boost/mpl/aux_/advance_forward.hpp>
+#include <boost/mpl/aux_/advance_backward.hpp>
+#include <boost/mpl/aux_/value_wknd.hpp>
+#include <boost/mpl/aux_/na_spec.hpp>
+#include <boost/mpl/aux_/nttp_decl.hpp>
+
+namespace boost { namespace mpl {
+
+// default implementation for forward/bidirectional iterators
+template< typename Tag >
+struct advance_impl
+{
+    template< typename Iterator, typename N > struct apply
+    {
+        typedef typename less< N,long_<0> >::type backward_;
+        typedef typename if_< backward_, negate<N>, N >::type offset_;
+
+        typedef typename if_<
+              backward_
+            , aux::advance_backward< BOOST_MPL_AUX_VALUE_WKND(offset_)::value >
+            , aux::advance_forward< BOOST_MPL_AUX_VALUE_WKND(offset_)::value >
+            >::type f_;
+
+        typedef typename apply_wrap1<f_,Iterator>::type type;
+    };
+};
+
+
+template<
+      typename BOOST_MPL_AUX_NA_PARAM(Iterator)
+    , typename BOOST_MPL_AUX_NA_PARAM(N)
+    >
+struct advance
+    : advance_impl< typename tag<Iterator>::type >
+        ::template apply<Iterator,N>
+{
+};
+
+template<
+      typename Iterator
+    , BOOST_MPL_AUX_NTTP_DECL(long, N)
+    >
+struct advance_c
+    : advance_impl< typename tag<Iterator>::type >
+        ::template apply<Iterator,long_<N> >
+{
+};
+
+BOOST_MPL_AUX_NA_SPEC(2, advance)
+
+}}
+
+#endif // BOOST_MPL_ADVANCE_HPP_INCLUDED

include/boost/mpl/advance_fwd.hpp

@@ -0,0 +1,28 @@
+
+#ifndef BOOST_MPL_ADVANCE_FWD_HPP_INCLUDED
+#define BOOST_MPL_ADVANCE_FWD_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: advance_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/aux_/common_name_wknd.hpp>
+
+namespace boost { namespace mpl {
+
+BOOST_MPL_AUX_COMMON_NAME_WKND(advance)
+
+template< typename Tag > struct advance_impl;
+template< typename Iterator, typename N > struct advance;
+
+}}
+
+#endif // BOOST_MPL_ADVANCE_FWD_HPP_INCLUDED

include/boost/mpl/alias.hpp

@@ -0,0 +1,21 @@
+
+#ifndef BOOST_MPL_ALIAS_HPP_INCLUDED
+#define BOOST_MPL_ALIAS_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: alias.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+namespace {
+namespace mpl = boost::mpl;
+}
+
+#endif // BOOST_MPL_ALIAS_HPP_INCLUDED

include/boost/mpl/always.hpp

@@ -0,0 +1,39 @@
+
+#ifndef BOOST_MPL_ALWAYS_HPP_INCLUDED
+#define BOOST_MPL_ALWAYS_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2001-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: always.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/aux_/preprocessor/def_params_tail.hpp>
+#include <boost/mpl/aux_/na.hpp>
+#include <boost/mpl/aux_/arity_spec.hpp>
+
+namespace boost { namespace mpl {
+
+template< typename Value > struct always
+{
+    template<
+          typename T
+        BOOST_MPL_PP_NESTED_DEF_PARAMS_TAIL(1, typename T, na)
+        >
+    struct apply
+    {
+        typedef Value type;
+    };
+};
+
+BOOST_MPL_AUX_ARITY_SPEC(1, always)
+
+}}
+
+#endif // BOOST_MPL_ALWAYS_HPP_INCLUDED

include/boost/mpl/and.hpp

@@ -0,0 +1,60 @@
+
+#ifndef BOOST_MPL_AND_HPP_INCLUDED
+#define BOOST_MPL_AND_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: and.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/aux_/config/use_preprocessed.hpp>
+
+#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE)
+
+#   include <boost/mpl/bool.hpp>
+#   include <boost/mpl/aux_/nested_type_wknd.hpp>
+#   include <boost/mpl/aux_/na_spec.hpp>
+#   include <boost/mpl/aux_/lambda_support.hpp>
+
+// agurt, 19/may/04: workaround a conflict with <iso646.h> header's 
+// 'or' and 'and' macros, see http://tinyurl.com/3et69; 'defined(and)'
+// has to be checked in a separate condition, otherwise GCC complains 
+// about 'and' being an alternative token
+#if defined(_MSC_VER) 
+#ifndef __GCCXML__
+#if defined(and) 
+#   pragma push_macro("and")
+#   undef and
+#   define and(x)
+#endif
+#endif
+#endif
+
+#   define BOOST_MPL_PREPROCESSED_HEADER and.hpp
+#   include <boost/mpl/aux_/include_preprocessed.hpp>
+
+#if defined(_MSC_VER)
+#ifndef __GCCXML__
+#if defined(and) 
+#   pragma pop_macro("and")
+#endif
+#endif
+#endif
+
+#else
+
+#   define AUX778076_OP_NAME and_
+#   define AUX778076_OP_VALUE1 false
+#   define AUX778076_OP_VALUE2 true
+#   include <boost/mpl/aux_/logical_op.hpp>
+
+#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS
+#endif // BOOST_MPL_AND_HPP_INCLUDED

include/boost/mpl/apply.hpp

@@ -0,0 +1,229 @@
+
+#if !defined(BOOST_PP_IS_ITERATING)
+
+///// header body
+
+#ifndef BOOST_MPL_APPLY_HPP_INCLUDED
+#define BOOST_MPL_APPLY_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: apply.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#if !defined(BOOST_MPL_PREPROCESSING_MODE)
+#   include <boost/mpl/apply_fwd.hpp>
+#   include <boost/mpl/apply_wrap.hpp>
+#   include <boost/mpl/placeholders.hpp>
+#   include <boost/mpl/lambda.hpp>
+#   include <boost/mpl/aux_/na.hpp>
+#   include <boost/mpl/aux_/lambda_support.hpp>
+#endif
+
+#include <boost/mpl/aux_/config/use_preprocessed.hpp>
+
+#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE)
+
+#   define BOOST_MPL_PREPROCESSED_HEADER apply.hpp
+#   include <boost/mpl/aux_/include_preprocessed.hpp>
+
+#else
+
+#   include <boost/mpl/limits/arity.hpp>
+#   include <boost/mpl/aux_/preprocessor/params.hpp>
+#   include <boost/mpl/aux_/preprocessor/default_params.hpp>
+#   include <boost/mpl/aux_/preprocessor/partial_spec_params.hpp>
+#   include <boost/mpl/aux_/preprocessor/enum.hpp>
+#   include <boost/mpl/aux_/config/lambda.hpp>
+#   include <boost/mpl/aux_/config/dtp.hpp>
+#   include <boost/mpl/aux_/nttp_decl.hpp>
+#   include <boost/mpl/aux_/config/eti.hpp>
+#   include <boost/mpl/aux_/config/msvc.hpp>
+#   include <boost/mpl/aux_/config/workaround.hpp>
+
+#   include <boost/preprocessor/comma_if.hpp>
+#   include <boost/preprocessor/inc.hpp>
+#   include <boost/preprocessor/iterate.hpp>
+#   include <boost/preprocessor/cat.hpp>
+
+namespace boost { namespace mpl {
+
+// local macros, #undef-ined at the end of the header
+#   define AUX778076_APPLY_PARAMS(param) \
+    BOOST_MPL_PP_PARAMS( \
+          BOOST_MPL_LIMIT_METAFUNCTION_ARITY \
+        , param \
+        ) \
+    /**/
+
+#   define AUX778076_APPLY_DEF_PARAMS(param, value) \
+    BOOST_MPL_PP_DEFAULT_PARAMS( \
+          BOOST_MPL_LIMIT_METAFUNCTION_ARITY \
+        , param \
+        , value \
+        ) \
+    /**/
+
+#   define AUX778076_APPLY_N_PARAMS(n, param) \
+    BOOST_MPL_PP_PARAMS(n, param) \
+    /**/
+
+#   define AUX778076_APPLY_N_COMMA_PARAMS(n, param) \
+    BOOST_PP_COMMA_IF(n) \
+    BOOST_MPL_PP_PARAMS(n, param) \
+    /**/
+
+#   define AUX778076_APPLY_N_PARTIAL_SPEC_PARAMS(n, param, def) \
+    BOOST_PP_COMMA_IF(n) \
+    BOOST_MPL_PP_PARTIAL_SPEC_PARAMS(n, param, def) \
+    /**/
+    
+#   define AUX778076_APPLY_N_SPEC_PARAMS(n, param) \
+    BOOST_MPL_PP_ENUM(BOOST_PP_INC(n), param) \
+    /**/
+
+
+#define BOOST_PP_ITERATION_PARAMS_1 \
+    (3,(0, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, <boost/mpl/apply.hpp>))
+#include BOOST_PP_ITERATE()
+
+#   if !defined(BOOST_MPL_CFG_NO_APPLY_TEMPLATE)
+// real C++ version is already taken care of
+#   if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+namespace aux {
+// apply_count_args
+#define AUX778076_COUNT_ARGS_PREFIX apply
+#define AUX778076_COUNT_ARGS_DEFAULT na
+#define AUX778076_COUNT_ARGS_ARITY BOOST_MPL_LIMIT_METAFUNCTION_ARITY
+#include <boost/mpl/aux_/count_args.hpp>
+}
+
+
+template<
+      typename F, AUX778076_APPLY_DEF_PARAMS(typename T, na)
+    >
+struct apply
+    : aux::apply_chooser< 
+          aux::apply_count_args< AUX778076_APPLY_PARAMS(T) >::value
+        >::template result_< F, AUX778076_APPLY_PARAMS(T) >::type
+{
+};
+
+#   endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#   endif // BOOST_MPL_CFG_NO_APPLY_TEMPLATE
+
+#   undef AUX778076_APPLY_N_SPEC_PARAMS
+#   undef AUX778076_APPLY_N_PARTIAL_SPEC_PARAMS
+#   undef AUX778076_APPLY_N_COMMA_PARAMS
+#   undef AUX778076_APPLY_N_PARAMS
+#   undef AUX778076_APPLY_DEF_PARAMS
+#   undef AUX778076_APPLY_PARAMS
+
+}}
+
+#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS
+#endif // BOOST_MPL_APPLY_HPP_INCLUDED
+
+///// iteration, depth == 1
+
+// For gcc 4.4 compatability, we must include the
+// BOOST_PP_ITERATION_DEPTH test inside an #else clause.
+#else // BOOST_PP_IS_ITERATING
+#if BOOST_PP_ITERATION_DEPTH() == 1
+
+#   define i_ BOOST_PP_FRAME_ITERATION(1)
+
+template<
+      typename F AUX778076_APPLY_N_COMMA_PARAMS(i_, typename T)
+    >
+struct BOOST_PP_CAT(apply,i_)
+#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+    : BOOST_PP_CAT(apply_wrap,i_)< 
+          typename lambda<F>::type
+        AUX778076_APPLY_N_COMMA_PARAMS(i_, T)
+        >
+{
+#else
+{
+    typedef typename BOOST_PP_CAT(apply_wrap,i_)< 
+          typename lambda<F>::type
+        AUX778076_APPLY_N_COMMA_PARAMS(i_, T)
+        >::type type;
+#endif
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(
+          BOOST_PP_INC(i_)
+        , BOOST_PP_CAT(apply,i_)
+        , (F AUX778076_APPLY_N_COMMA_PARAMS(i_,T))
+        )
+};
+
+
+#if defined(BOOST_MPL_CFG_MSVC_ETI_BUG)
+/// workaround for ETI bug
+template<>
+struct BOOST_PP_CAT(apply,i_)<AUX778076_APPLY_N_SPEC_PARAMS(i_, int)>
+{
+    typedef int type;
+};
+#endif
+
+#   if !defined(BOOST_MPL_CFG_NO_APPLY_TEMPLATE)
+#   if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+#if i_ == BOOST_MPL_LIMIT_METAFUNCTION_ARITY
+/// primary template (not a specialization!)
+template<
+      typename F AUX778076_APPLY_N_COMMA_PARAMS(i_, typename T)
+    >
+struct apply
+    : BOOST_PP_CAT(apply,i_)< F AUX778076_APPLY_N_COMMA_PARAMS(i_, T) >
+{
+};
+#else
+template<
+      typename F AUX778076_APPLY_N_COMMA_PARAMS(i_, typename T)
+    >
+struct apply< F AUX778076_APPLY_N_PARTIAL_SPEC_PARAMS(i_, T, na) >
+    : BOOST_PP_CAT(apply,i_)< F AUX778076_APPLY_N_COMMA_PARAMS(i_, T) >
+{
+};
+#endif
+
+#   else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+#if !defined(BOOST_MPL_CFG_NO_APPLY_TEMPLATE)
+namespace aux {
+
+template<>
+struct apply_chooser<i_>
+{
+    template<
+          typename F, AUX778076_APPLY_PARAMS(typename T)
+        >
+    struct result_
+    {
+        typedef BOOST_PP_CAT(apply,i_)<
+              F AUX778076_APPLY_N_COMMA_PARAMS(i_, T)
+            > type;
+    };
+};
+
+} // namespace aux
+#endif
+
+#   endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#   endif // BOOST_MPL_CFG_NO_APPLY_TEMPLATE
+
+#   undef i_
+
+#endif // BOOST_PP_ITERATION_DEPTH()
+#endif // BOOST_PP_IS_ITERATING

include/boost/mpl/apply_fwd.hpp

@@ -0,0 +1,107 @@
+
+#if !defined(BOOST_PP_IS_ITERATING)
+
+///// header body
+
+#ifndef BOOST_MPL_APPLY_FWD_HPP_INCLUDED
+#define BOOST_MPL_APPLY_FWD_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: apply_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#if !defined(BOOST_MPL_PREPROCESSING_MODE)
+#   include <boost/mpl/aux_/na.hpp>
+#endif
+
+#include <boost/mpl/aux_/config/use_preprocessed.hpp>
+
+#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE)
+
+#   define BOOST_MPL_PREPROCESSED_HEADER apply_fwd.hpp
+#   include <boost/mpl/aux_/include_preprocessed.hpp>
+
+#else
+
+#   include <boost/mpl/limits/arity.hpp>
+#   include <boost/mpl/aux_/preprocessor/params.hpp>
+#   include <boost/mpl/aux_/preprocessor/default_params.hpp>
+#   include <boost/mpl/aux_/config/ctps.hpp>
+#   include <boost/mpl/aux_/nttp_decl.hpp>
+
+#   include <boost/preprocessor/comma_if.hpp>
+#   include <boost/preprocessor/iterate.hpp>
+#   include <boost/preprocessor/cat.hpp>
+
+// agurt, 15/jan/02: top-level 'apply' template gives an ICE on MSVC
+// (for known reasons)
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+#   define BOOST_MPL_CFG_NO_APPLY_TEMPLATE
+#endif
+
+namespace boost { namespace mpl {
+
+// local macro, #undef-ined at the end of the header
+#   define AUX778076_APPLY_DEF_PARAMS(param, value) \
+    BOOST_MPL_PP_DEFAULT_PARAMS( \
+          BOOST_MPL_LIMIT_METAFUNCTION_ARITY \
+        , param \
+        , value \
+        ) \
+    /**/
+
+#   define AUX778076_APPLY_N_COMMA_PARAMS(n, param) \
+    BOOST_PP_COMMA_IF(n) \
+    BOOST_MPL_PP_PARAMS(n, param) \
+    /**/
+
+#   if !defined(BOOST_MPL_CFG_NO_APPLY_TEMPLATE)
+
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+// forward declaration
+template<
+      typename F, AUX778076_APPLY_DEF_PARAMS(typename T, na)
+    >
+struct apply;
+#else
+namespace aux {
+template< BOOST_AUX_NTTP_DECL(int, arity_) > struct apply_chooser;
+}
+#endif
+
+#   endif // BOOST_MPL_CFG_NO_APPLY_TEMPLATE
+
+#define BOOST_PP_ITERATION_PARAMS_1 \
+    (3,(0, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, <boost/mpl/apply_fwd.hpp>))
+#include BOOST_PP_ITERATE()
+
+
+#   undef AUX778076_APPLY_N_COMMA_PARAMS
+#   undef AUX778076_APPLY_DEF_PARAMS
+
+}}
+
+#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS
+#endif // BOOST_MPL_APPLY_FWD_HPP_INCLUDED
+
+///// iteration
+
+#else
+#define i_ BOOST_PP_FRAME_ITERATION(1)
+
+template<
+      typename F AUX778076_APPLY_N_COMMA_PARAMS(i_, typename T)
+    >
+struct BOOST_PP_CAT(apply,i_);
+
+#undef i_
+#endif // BOOST_PP_IS_ITERATING

include/boost/mpl/apply_wrap.hpp

@@ -0,0 +1,234 @@
+
+#if !defined(BOOST_PP_IS_ITERATING)
+
+///// header body
+
+#ifndef BOOST_MPL_APPLY_WRAP_HPP_INCLUDED
+#define BOOST_MPL_APPLY_WRAP_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2008
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: apply_wrap.hpp 49272 2008-10-11 06:50:46Z agurtovoy $
+// $Date: 2008-10-11 02:50:46 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49272 $
+
+#if !defined(BOOST_MPL_PREPROCESSING_MODE)
+#   include <boost/mpl/aux_/arity.hpp>
+#   include <boost/mpl/aux_/has_apply.hpp>
+#   include <boost/mpl/aux_/na.hpp>
+#   include <boost/mpl/aux_/msvc_never_true.hpp>
+#endif
+
+#include <boost/mpl/aux_/config/use_preprocessed.hpp>
+
+#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE)
+
+#   define BOOST_MPL_PREPROCESSED_HEADER apply_wrap.hpp
+#   include <boost/mpl/aux_/include_preprocessed.hpp>
+
+#else
+
+#   include <boost/mpl/limits/arity.hpp>
+#   include <boost/mpl/aux_/preprocessor/params.hpp>
+#   include <boost/mpl/aux_/preprocessor/enum.hpp>
+#   include <boost/mpl/aux_/preprocessor/add.hpp>
+#   include <boost/mpl/aux_/config/bcc.hpp>
+#   include <boost/mpl/aux_/config/ctps.hpp>
+#   include <boost/mpl/aux_/config/dtp.hpp>
+#   include <boost/mpl/aux_/config/eti.hpp>
+#   include <boost/mpl/aux_/config/msvc.hpp>
+#   include <boost/mpl/aux_/config/workaround.hpp>
+
+#   include <boost/preprocessor/comma_if.hpp>
+#   include <boost/preprocessor/logical/and.hpp>
+#   include <boost/preprocessor/inc.hpp>
+#   include <boost/preprocessor/iterate.hpp>
+
+
+namespace boost { namespace mpl {
+
+// local macros, #undef-ined at the end of the header
+#   define AUX778076_APPLY_WRAP_PARAMS(n, param) \
+    BOOST_MPL_PP_PARAMS(n, param) \
+    /**/
+
+#   define AUX778076_APPLY_WRAP_SPEC_PARAMS(n, param) \
+    BOOST_MPL_PP_ENUM(BOOST_PP_INC(n), param) \
+    /**/
+
+
+#define BOOST_PP_ITERATION_PARAMS_1 \
+    (3,(0, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, <boost/mpl/apply_wrap.hpp>))
+#include BOOST_PP_ITERATE()
+
+
+#   undef AUX778076_APPLY_WRAP_SPEC_PARAMS
+#   undef AUX778076_APPLY_WRAP_PARAMS
+
+}}
+
+#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS
+#endif // BOOST_MPL_APPLY_WRAP_HPP_INCLUDED
+
+///// iteration, depth == 1
+
+// For gcc 4.4 compatability, we must include the
+// BOOST_PP_ITERATION_DEPTH test inside an #else clause.
+#else // BOOST_PP_IS_ITERATING
+#if BOOST_PP_ITERATION_DEPTH() == 1
+
+#   define i_ BOOST_PP_FRAME_ITERATION(1)
+
+#   if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+// MSVC version
+
+#define AUX778076_MSVC_DTW_NAME BOOST_PP_CAT(msvc_apply,i_)
+#define AUX778076_MSVC_DTW_ORIGINAL_NAME apply
+#define AUX778076_MSVC_DTW_ARITY i_
+#include <boost/mpl/aux_/msvc_dtw.hpp>
+
+template<
+      typename F BOOST_PP_COMMA_IF(i_) AUX778076_APPLY_WRAP_PARAMS(i_, typename T)
+    >
+struct BOOST_PP_CAT(apply_wrap,i_)
+{
+    // Metafunction forwarding confuses vc6
+    typedef typename BOOST_PP_CAT(msvc_apply,i_)<F>::template result_<
+          AUX778076_APPLY_WRAP_PARAMS(i_, T)
+        >::type type;
+};
+
+#   elif defined(BOOST_MPL_CFG_BROKEN_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES)
+// MWCW/Borland version
+
+template<
+      int N, typename F BOOST_PP_COMMA_IF(i_) AUX778076_APPLY_WRAP_PARAMS(i_, typename T)
+    >
+struct BOOST_PP_CAT(apply_wrap_impl,i_);
+
+#define BOOST_PP_ITERATION_PARAMS_2 \
+    (3,(0, BOOST_MPL_LIMIT_METAFUNCTION_ARITY - i_, <boost/mpl/apply_wrap.hpp>))
+#include BOOST_PP_ITERATE()
+
+template<
+      typename F BOOST_PP_COMMA_IF(i_) AUX778076_APPLY_WRAP_PARAMS(i_, typename T)
+    >
+struct BOOST_PP_CAT(apply_wrap,i_)
+    : BOOST_PP_CAT(apply_wrap_impl,i_)<
+          ::boost::mpl::aux::arity<F,i_>::value
+        , F
+        BOOST_PP_COMMA_IF(i_) AUX778076_APPLY_WRAP_PARAMS(i_, T)
+        >::type
+{
+};
+
+#   else
+// ISO98 C++, with minor concession to vc7
+
+template<
+      typename F BOOST_PP_COMMA_IF(i_) AUX778076_APPLY_WRAP_PARAMS(i_, typename T)
+#if i_ == 0
+    , typename has_apply_ = typename aux::has_apply<F>::type
+#endif
+    >
+struct BOOST_PP_CAT(apply_wrap,i_)
+// metafunction forwarding confuses MSVC 7.0
+#if !BOOST_WORKAROUND(BOOST_MSVC, == 1300)
+    : F::template apply< AUX778076_APPLY_WRAP_PARAMS(i_, T) >
+{
+#else
+{    
+    typedef typename F::template apply<
+         AUX778076_APPLY_WRAP_PARAMS(i_, T)
+        >::type type;
+#endif
+};
+
+#if i_ == 0 && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+template< typename F >
+struct BOOST_PP_CAT(apply_wrap,i_)<F,true_>
+    : F::apply
+{
+};
+#endif
+
+#   endif // workarounds
+
+#if defined(BOOST_MPL_CFG_MSVC_ETI_BUG)
+/// workaround for ETI bug
+template<>
+struct BOOST_PP_CAT(apply_wrap,i_)<AUX778076_APPLY_WRAP_SPEC_PARAMS(i_, int)>
+{
+    typedef int type;
+};
+#endif
+
+#   undef i_
+
+///// iteration, depth == 2
+
+#elif BOOST_PP_ITERATION_DEPTH() == 2
+
+#   define j_ BOOST_PP_FRAME_ITERATION(2)
+
+#if i_ == 0 && j_ == 0 \
+    && defined(BOOST_MPL_CFG_BCC590_WORKAROUNDS) \
+    && !defined(BOOST_MPL_CFG_NO_HAS_APPLY)
+
+template< typename F, bool F_has_apply >
+struct apply_wrap_impl0_bcb {
+    typedef typename F::template apply< na > type;
+};
+
+template< typename F >
+struct apply_wrap_impl0_bcb< F, true > {
+    typedef typename F::apply type;
+};
+
+template<
+      typename F BOOST_PP_COMMA_IF(i_) AUX778076_APPLY_WRAP_PARAMS(i_, typename T)
+    >
+struct BOOST_PP_CAT(apply_wrap_impl,i_)<
+          BOOST_MPL_PP_ADD(i_, j_)
+        , F
+        BOOST_PP_COMMA_IF(i_) AUX778076_APPLY_WRAP_PARAMS(i_, T)
+        >
+{
+    typedef apply_wrap_impl0_bcb< F, aux::has_apply< F >::value >::type type;
+};
+#else
+
+template<
+      typename F BOOST_PP_COMMA_IF(i_) AUX778076_APPLY_WRAP_PARAMS(i_, typename T)
+    >
+struct BOOST_PP_CAT(apply_wrap_impl,i_)<
+          BOOST_MPL_PP_ADD(i_, j_)
+        , F
+        BOOST_PP_COMMA_IF(i_) AUX778076_APPLY_WRAP_PARAMS(i_, T)
+        >
+{
+    typedef typename F::template apply<
+          AUX778076_APPLY_WRAP_PARAMS(i_, T)
+#if i_ == 0 && j_ == 0
+/// since the defaults are "lost", we have to pass *something* even for nullary
+/// metafunction classes
+        na
+#else
+        BOOST_PP_COMMA_IF(BOOST_PP_AND(i_, j_)) BOOST_MPL_PP_ENUM(j_, na)
+#endif
+        > type;
+};
+
+#endif
+
+#   undef j_
+
+#endif // BOOST_PP_ITERATION_DEPTH()
+#endif // BOOST_PP_IS_ITERATING

include/boost/mpl/arg.hpp

@@ -0,0 +1,131 @@
+
+#if !defined(BOOST_PP_IS_ITERATING)
+
+///// header body
+
+#ifndef BOOST_MPL_ARG_HPP_INCLUDED
+#define BOOST_MPL_ARG_HPP_INCLUDED
+
+// Copyright Peter Dimov 2001-2002
+// Copyright Aleksey Gurtovoy 2001-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: arg.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#if !defined(BOOST_MPL_PREPROCESSING_MODE)
+#   include <boost/mpl/arg_fwd.hpp>
+#   include <boost/mpl/aux_/na.hpp>
+#   include <boost/mpl/aux_/na_assert.hpp>
+#   include <boost/mpl/aux_/arity_spec.hpp>
+#   include <boost/mpl/aux_/arg_typedef.hpp>
+#endif
+
+#include <boost/mpl/aux_/config/static_constant.hpp>
+#include <boost/mpl/aux_/config/use_preprocessed.hpp>
+
+#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE)
+
+#   define BOOST_MPL_PREPROCESSED_HEADER arg.hpp
+#   include <boost/mpl/aux_/include_preprocessed.hpp>
+
+#else
+
+#   include <boost/mpl/limits/arity.hpp>
+#   include <boost/mpl/aux_/preprocessor/default_params.hpp>
+#   include <boost/mpl/aux_/preprocessor/params.hpp>
+#   include <boost/mpl/aux_/config/lambda.hpp>
+#   include <boost/mpl/aux_/config/dtp.hpp>
+#   include <boost/mpl/aux_/nttp_decl.hpp>
+
+#   include <boost/preprocessor/iterate.hpp>
+#   include <boost/preprocessor/inc.hpp>
+#   include <boost/preprocessor/cat.hpp>
+
+BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN
+
+// local macro, #undef-ined at the end of the header
+#if !defined(BOOST_MPL_CFG_NO_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES)
+#   define AUX778076_ARG_N_DEFAULT_PARAMS(param,value) \
+    BOOST_MPL_PP_DEFAULT_PARAMS( \
+          BOOST_MPL_LIMIT_METAFUNCTION_ARITY \
+        , param \
+        , value \
+        ) \
+    /**/
+#else
+#   define AUX778076_ARG_N_DEFAULT_PARAMS(param,value) \
+    BOOST_MPL_PP_PARAMS( \
+          BOOST_MPL_LIMIT_METAFUNCTION_ARITY \
+        , param \
+        ) \
+    /**/
+#endif
+
+#define BOOST_PP_ITERATION_PARAMS_1 \
+    (3,(0, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, <boost/mpl/arg.hpp>))
+#include BOOST_PP_ITERATE()
+
+
+#   undef AUX778076_ARG_N_DEFAULT_PARAMS
+
+BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(1,int,arg)
+
+BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE
+
+#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS
+#endif // BOOST_MPL_ARG_HPP_INCLUDED
+
+///// iteration
+
+#else
+#define i_ BOOST_PP_FRAME_ITERATION(1)
+
+#if i_ > 0
+
+template<> struct arg<i_>
+{
+    BOOST_STATIC_CONSTANT(int, value = i_);
+    typedef arg<BOOST_PP_INC(i_)> next;
+    BOOST_MPL_AUX_ARG_TYPEDEF(na, tag)
+    BOOST_MPL_AUX_ARG_TYPEDEF(na, type)
+
+    template<
+          AUX778076_ARG_N_DEFAULT_PARAMS(typename U, na)
+        >
+    struct apply
+    {
+        typedef BOOST_PP_CAT(U,i_) type;
+        BOOST_MPL_AUX_ASSERT_NOT_NA(type);
+    };
+};
+
+#else
+
+template<> struct arg<-1>
+{
+    BOOST_STATIC_CONSTANT(int, value = -1);
+    BOOST_MPL_AUX_ARG_TYPEDEF(na, tag)
+    BOOST_MPL_AUX_ARG_TYPEDEF(na, type)
+
+    template<
+          AUX778076_ARG_N_DEFAULT_PARAMS(typename U, na)
+        >
+    struct apply
+    {
+        typedef U1 type;
+        BOOST_MPL_AUX_ASSERT_NOT_NA(type);
+    };
+};
+
+#endif // i_ > 0
+
+#undef i_
+#endif // BOOST_PP_IS_ITERATING

include/boost/mpl/arg_fwd.hpp

@@ -0,0 +1,28 @@
+
+#ifndef BOOST_MPL_ARG_FWD_HPP_INCLUDED
+#define BOOST_MPL_ARG_FWD_HPP_INCLUDED
+
+// Copyright Peter Dimov 2001-2002
+// Copyright Aleksey Gurtovoy 2001-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: arg_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/aux_/adl_barrier.hpp>
+#include <boost/mpl/aux_/nttp_decl.hpp>
+
+BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN
+
+template< BOOST_MPL_AUX_NTTP_DECL(int, N) > struct arg;
+
+BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE
+BOOST_MPL_AUX_ADL_BARRIER_DECL(arg)
+
+#endif // BOOST_MPL_ARG_FWD_HPP_INCLUDED

include/boost/mpl/arithmetic.hpp

@@ -0,0 +1,25 @@
+
+#ifndef BOOST_MPL_ARITHMETIC_HPP_INCLUDED
+#define BOOST_MPL_ARITHMETIC_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: arithmetic.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/plus.hpp>
+#include <boost/mpl/minus.hpp>
+#include <boost/mpl/times.hpp>
+#include <boost/mpl/divides.hpp>
+#include <boost/mpl/modulus.hpp>
+#include <boost/mpl/negate.hpp>
+#include <boost/mpl/multiplies.hpp> // deprecated
+
+#endif // BOOST_MPL_ARITHMETIC_HPP_INCLUDED

include/boost/mpl/as_sequence.hpp

@@ -0,0 +1,38 @@
+
+#ifndef BOOST_MPL_AS_SEQUENCE_HPP_INCLUDED
+#define BOOST_MPL_AS_SEQUENCE_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2002-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: as_sequence.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/mpl/single_view.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/aux_/na_spec.hpp>
+#include <boost/mpl/aux_/lambda_support.hpp>
+
+namespace boost { namespace mpl {
+
+template<
+      typename BOOST_MPL_AUX_NA_PARAM(T)
+    >
+struct as_sequence
+    : if_< is_sequence<T>, T, single_view<T> >
+{
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,as_sequence,(T))
+};
+
+BOOST_MPL_AUX_NA_SPEC_NO_ETI(1, as_sequence)
+
+}}
+
+#endif // BOOST_MPL_AS_SEQUENCE_HPP_INCLUDED

include/boost/mpl/assert.hpp

@@ -0,0 +1,370 @@
+
+#ifndef BOOST_MPL_ASSERT_HPP_INCLUDED
+#define BOOST_MPL_ASSERT_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: assert.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/aux_/value_wknd.hpp>
+#include <boost/mpl/aux_/nested_type_wknd.hpp>
+#include <boost/mpl/aux_/yes_no.hpp>
+#include <boost/mpl/aux_/na.hpp>
+#include <boost/mpl/aux_/adl_barrier.hpp>
+
+#include <boost/mpl/aux_/config/nttp.hpp>
+#include <boost/mpl/aux_/config/dtp.hpp>
+#include <boost/mpl/aux_/config/gcc.hpp>
+#include <boost/mpl/aux_/config/msvc.hpp>
+#include <boost/mpl/aux_/config/static_constant.hpp>
+#include <boost/mpl/aux_/config/pp_counter.hpp>
+#include <boost/mpl/aux_/config/workaround.hpp>
+
+#include <boost/preprocessor/cat.hpp>
+
+#include <boost/config.hpp> // make sure 'size_t' is placed into 'std'
+#include <cstddef>
+
+
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) \
+    || (BOOST_MPL_CFG_GCC != 0) \
+    || BOOST_WORKAROUND(__IBMCPP__, <= 600)
+#   define BOOST_MPL_CFG_ASSERT_USE_RELATION_NAMES
+#endif
+
+#if BOOST_WORKAROUND(__MWERKS__, < 0x3202) \
+    || BOOST_WORKAROUND(__EDG_VERSION__, <= 238) \
+    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) \
+    || BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840))
+#   define BOOST_MPL_CFG_ASSERT_BROKEN_POINTER_TO_POINTER_TO_MEMBER
+#endif
+
+// agurt, 10/nov/06: use enums for Borland (which cannot cope with static constants) 
+// and GCC (which issues "unused variable" warnings when static constants are used 
+// at a function scope)
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) \
+    || (BOOST_MPL_CFG_GCC != 0)
+#   define BOOST_MPL_AUX_ASSERT_CONSTANT(T, expr) enum { expr }
+#else
+#   define BOOST_MPL_AUX_ASSERT_CONSTANT(T, expr) BOOST_STATIC_CONSTANT(T, expr)
+#endif
+
+
+BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN
+
+struct failed {};
+
+// agurt, 24/aug/04: MSVC 7.1 workaround here and below: return/accept 
+// 'assert<false>' by reference; can't apply it unconditionally -- apparently it
+// degrades the quality of GCC diagnostics
+#if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
+#   define AUX778076_ASSERT_ARG(x) x&
+#else
+#   define AUX778076_ASSERT_ARG(x) x
+#endif
+
+template< bool C >  struct assert        { typedef void* type; };
+template<>          struct assert<false> { typedef AUX778076_ASSERT_ARG(assert) type; };
+
+template< bool C >
+int assertion_failed( typename assert<C>::type );
+
+template< bool C >
+struct assertion
+{
+    static int failed( assert<false> );
+};
+
+template<>
+struct assertion<true>
+{
+    static int failed( void* );
+};
+
+struct assert_
+{
+#if !defined(BOOST_MPL_CFG_NO_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES)
+    template< typename T1, typename T2 = na, typename T3 = na, typename T4 = na > struct types {};
+#endif
+    static assert_ const arg;
+    enum relations { equal = 1, not_equal, greater, greater_equal, less, less_equal };
+};
+
+
+#if !defined(BOOST_MPL_CFG_ASSERT_USE_RELATION_NAMES)
+
+bool operator==( failed, failed );
+bool operator!=( failed, failed );
+bool operator>( failed, failed );
+bool operator>=( failed, failed );
+bool operator<( failed, failed );
+bool operator<=( failed, failed );
+
+#if defined(__EDG_VERSION__)
+template< bool (*)(failed, failed), long x, long y > struct assert_relation {};
+#   define BOOST_MPL_AUX_ASSERT_RELATION(x, y, r) assert_relation<r,x,y>
+#else
+template< BOOST_MPL_AUX_NTTP_DECL(long, x), BOOST_MPL_AUX_NTTP_DECL(long, y), bool (*)(failed, failed) > 
+struct assert_relation {};
+#   define BOOST_MPL_AUX_ASSERT_RELATION(x, y, r) assert_relation<x,y,r>
+#endif
+
+#else // BOOST_MPL_CFG_ASSERT_USE_RELATION_NAMES
+
+boost::mpl::aux::weighted_tag<1>::type operator==( assert_, assert_ );
+boost::mpl::aux::weighted_tag<2>::type operator!=( assert_, assert_ );
+boost::mpl::aux::weighted_tag<3>::type operator>(  assert_, assert_ );
+boost::mpl::aux::weighted_tag<4>::type operator>=( assert_, assert_ );
+boost::mpl::aux::weighted_tag<5>::type operator<( assert_, assert_ );
+boost::mpl::aux::weighted_tag<6>::type operator<=( assert_, assert_ );
+
+template< assert_::relations r, long x, long y > struct assert_relation {};
+
+#endif 
+
+
+#if !defined(BOOST_MPL_CFG_ASSERT_BROKEN_POINTER_TO_POINTER_TO_MEMBER)
+
+template< bool > struct assert_arg_pred_impl { typedef int type; };
+template<> struct assert_arg_pred_impl<true> { typedef void* type; };
+
+template< typename P > struct assert_arg_pred
+{
+    typedef typename P::type p_type;
+    typedef typename assert_arg_pred_impl< p_type::value >::type type;
+};
+
+template< typename P > struct assert_arg_pred_not
+{
+    typedef typename P::type p_type;
+    BOOST_MPL_AUX_ASSERT_CONSTANT( bool, p = !p_type::value );
+    typedef typename assert_arg_pred_impl<p>::type type;
+};
+
+template< typename Pred >
+failed ************ (Pred::************ 
+      assert_arg( void (*)(Pred), typename assert_arg_pred<Pred>::type )
+    );
+
+template< typename Pred >
+failed ************ (boost::mpl::not_<Pred>::************ 
+      assert_not_arg( void (*)(Pred), typename assert_arg_pred_not<Pred>::type )
+    );
+
+template< typename Pred >
+AUX778076_ASSERT_ARG(assert<false>)
+assert_arg( void (*)(Pred), typename assert_arg_pred_not<Pred>::type );
+
+template< typename Pred >
+AUX778076_ASSERT_ARG(assert<false>)
+assert_not_arg( void (*)(Pred), typename assert_arg_pred<Pred>::type );
+
+
+#else // BOOST_MPL_CFG_ASSERT_BROKEN_POINTER_TO_POINTER_TO_MEMBER
+        
+template< bool c, typename Pred > struct assert_arg_type_impl
+{
+    typedef failed      ************ Pred::* mwcw83_wknd;
+    typedef mwcw83_wknd ************* type;
+};
+
+template< typename Pred > struct assert_arg_type_impl<true,Pred>
+{
+    typedef AUX778076_ASSERT_ARG(assert<false>) type;
+};
+
+template< typename Pred > struct assert_arg_type
+    : assert_arg_type_impl< BOOST_MPL_AUX_VALUE_WKND(BOOST_MPL_AUX_NESTED_TYPE_WKND(Pred))::value, Pred >
+{
+};
+
+template< typename Pred >
+typename assert_arg_type<Pred>::type 
+assert_arg(void (*)(Pred), int);
+
+template< typename Pred >
+typename assert_arg_type< boost::mpl::not_<Pred> >::type 
+assert_not_arg(void (*)(Pred), int);
+
+#   if !defined(BOOST_MPL_CFG_ASSERT_USE_RELATION_NAMES)
+template< long x, long y, bool (*r)(failed, failed) >
+typename assert_arg_type_impl< false,BOOST_MPL_AUX_ASSERT_RELATION(x,y,r) >::type
+assert_rel_arg( BOOST_MPL_AUX_ASSERT_RELATION(x,y,r) );
+#   else
+template< assert_::relations r, long x, long y >
+typename assert_arg_type_impl< false,assert_relation<r,x,y> >::type
+assert_rel_arg( assert_relation<r,x,y> );
+#   endif
+
+#endif // BOOST_MPL_CFG_ASSERT_BROKEN_POINTER_TO_POINTER_TO_MEMBER
+
+#undef AUX778076_ASSERT_ARG
+
+BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE
+
+
+// BOOST_MPL_ASSERT((pred<x,...>))
+
+#define BOOST_MPL_ASSERT(pred) \
+BOOST_MPL_AUX_ASSERT_CONSTANT( \
+      std::size_t \
+    , BOOST_PP_CAT(mpl_assertion_in_line_,BOOST_MPL_AUX_PP_COUNTER()) = sizeof( \
+          boost::mpl::assertion_failed<false>( \
+              boost::mpl::assert_arg( (void (*) pred)0, 1 ) \
+            ) \
+        ) \
+    ) \
+/**/
+
+// BOOST_MPL_ASSERT_NOT((pred<x,...>))
+
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+#   define BOOST_MPL_ASSERT_NOT(pred) \
+enum { \
+      BOOST_PP_CAT(mpl_assertion_in_line_,BOOST_MPL_AUX_PP_COUNTER()) = sizeof( \
+          boost::mpl::assertion<false>::failed( \
+              boost::mpl::assert_not_arg( (void (*) pred)0, 1 ) \
+            ) \
+        ) \
+}\
+/**/
+#else
+#   define BOOST_MPL_ASSERT_NOT(pred) \
+BOOST_MPL_AUX_ASSERT_CONSTANT( \
+      std::size_t \
+    , BOOST_PP_CAT(mpl_assertion_in_line_,BOOST_MPL_AUX_PP_COUNTER()) = sizeof( \
+          boost::mpl::assertion_failed<false>( \
+              boost::mpl::assert_not_arg( (void (*) pred)0, 1 ) \
+            ) \
+        ) \
+   ) \
+/**/
+#endif
+
+// BOOST_MPL_ASSERT_RELATION(x, ==|!=|<=|<|>=|>, y)
+
+#if defined(BOOST_MPL_CFG_ASSERT_USE_RELATION_NAMES)
+
+#   if !defined(BOOST_MPL_CFG_ASSERT_BROKEN_POINTER_TO_POINTER_TO_MEMBER)
+// agurt, 9/nov/06: 'enum' below is a workaround for gcc 4.0.4/4.1.1 bugs #29522 and #29518
+#   define BOOST_MPL_ASSERT_RELATION_IMPL(counter, x, rel, y)      \
+enum { BOOST_PP_CAT(mpl_assert_rel_value,counter) = (x rel y) }; \
+BOOST_MPL_AUX_ASSERT_CONSTANT( \
+      std::size_t \
+    , BOOST_PP_CAT(mpl_assertion_in_line_,counter) = sizeof( \
+        boost::mpl::assertion_failed<BOOST_PP_CAT(mpl_assert_rel_value,counter)>( \
+            (boost::mpl::failed ************ ( boost::mpl::assert_relation< \
+                  boost::mpl::assert_::relations( sizeof( \
+                      boost::mpl::assert_::arg rel boost::mpl::assert_::arg \
+                    ) ) \
+                , x \
+                , y \
+                >::************)) 0 ) \
+        ) \
+    ) \
+/**/
+#   else
+#   define BOOST_MPL_ASSERT_RELATION_IMPL(counter, x, rel, y)    \
+BOOST_MPL_AUX_ASSERT_CONSTANT( \
+      std::size_t \
+    , BOOST_PP_CAT(mpl_assert_rel,counter) = sizeof( \
+          boost::mpl::assert_::arg rel boost::mpl::assert_::arg \
+        ) \
+    ); \
+BOOST_MPL_AUX_ASSERT_CONSTANT( bool, BOOST_PP_CAT(mpl_assert_rel_value,counter) = (x rel y) ); \
+BOOST_MPL_AUX_ASSERT_CONSTANT( \
+      std::size_t \
+    , BOOST_PP_CAT(mpl_assertion_in_line_,counter) = sizeof( \
+        boost::mpl::assertion_failed<BOOST_PP_CAT(mpl_assert_rel_value,counter)>( \
+              boost::mpl::assert_rel_arg( boost::mpl::assert_relation< \
+                  boost::mpl::assert_::relations(BOOST_PP_CAT(mpl_assert_rel,counter)) \
+                , x \
+                , y \
+                >() ) \
+            ) \
+        ) \
+    ) \
+/**/
+#   endif
+
+#   define BOOST_MPL_ASSERT_RELATION(x, rel, y) \
+BOOST_MPL_ASSERT_RELATION_IMPL(BOOST_MPL_AUX_PP_COUNTER(), x, rel, y) \
+/**/
+
+#else // !BOOST_MPL_CFG_ASSERT_USE_RELATION_NAMES
+
+#   if defined(BOOST_MPL_CFG_ASSERT_BROKEN_POINTER_TO_POINTER_TO_MEMBER)
+#   define BOOST_MPL_ASSERT_RELATION(x, rel, y) \
+BOOST_MPL_AUX_ASSERT_CONSTANT( \
+      std::size_t \
+    , BOOST_PP_CAT(mpl_assertion_in_line_,BOOST_MPL_AUX_PP_COUNTER()) = sizeof( \
+        boost::mpl::assertion_failed<(x rel y)>( boost::mpl::assert_rel_arg( \
+              boost::mpl::BOOST_MPL_AUX_ASSERT_RELATION(x,y,(&boost::mpl::operator rel))() \
+            ) ) \
+        ) \
+    ) \
+/**/
+#   else
+#   define BOOST_MPL_ASSERT_RELATION(x, rel, y) \
+BOOST_MPL_AUX_ASSERT_CONSTANT( \
+      std::size_t \
+    , BOOST_PP_CAT(mpl_assertion_in_line_,BOOST_MPL_AUX_PP_COUNTER()) = sizeof( \
+        boost::mpl::assertion_failed<(x rel y)>( (boost::mpl::failed ************ ( \
+            boost::mpl::BOOST_MPL_AUX_ASSERT_RELATION(x,y,(&boost::mpl::operator rel))::************))0 ) \
+        ) \
+    ) \
+/**/
+#   endif
+
+#endif
+
+
+// BOOST_MPL_ASSERT_MSG( (pred<x,...>::value), USER_PROVIDED_MESSAGE, (types<x,...>) ) 
+
+#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3202))
+#   define BOOST_MPL_ASSERT_MSG_IMPL( counter, c, msg, types_ ) \
+struct msg; \
+typedef struct BOOST_PP_CAT(msg,counter) : boost::mpl::assert_ \
+{ \
+    using boost::mpl::assert_::types; \
+    static boost::mpl::failed ************ (msg::************ assert_arg()) types_ \
+    { return 0; } \
+} BOOST_PP_CAT(mpl_assert_arg,counter); \
+BOOST_MPL_AUX_ASSERT_CONSTANT( \
+      std::size_t \
+    , BOOST_PP_CAT(mpl_assertion_in_line_,counter) = sizeof( \
+        boost::mpl::assertion<(c)>::failed( BOOST_PP_CAT(mpl_assert_arg,counter)::assert_arg() ) \
+        ) \
+    ) \
+/**/
+#else
+#   define BOOST_MPL_ASSERT_MSG_IMPL( counter, c, msg, types_ )  \
+struct msg; \
+typedef struct BOOST_PP_CAT(msg,counter) : boost::mpl::assert_ \
+{ \
+    static boost::mpl::failed ************ (msg::************ assert_arg()) types_ \
+    { return 0; } \
+} BOOST_PP_CAT(mpl_assert_arg,counter); \
+BOOST_MPL_AUX_ASSERT_CONSTANT( \
+      std::size_t \
+    , BOOST_PP_CAT(mpl_assertion_in_line_,counter) = sizeof( \
+        boost::mpl::assertion_failed<(c)>( BOOST_PP_CAT(mpl_assert_arg,counter)::assert_arg() ) \
+        ) \
+    ) \
+/**/
+#endif
+
+#define BOOST_MPL_ASSERT_MSG( c, msg, types_ ) \
+BOOST_MPL_ASSERT_MSG_IMPL( BOOST_MPL_AUX_PP_COUNTER(), c, msg, types_ ) \
+/**/
+
+#endif // BOOST_MPL_ASSERT_HPP_INCLUDED

include/boost/mpl/at.hpp

@@ -0,0 +1,52 @@
+
+#ifndef BOOST_MPL_AT_HPP_INCLUDED
+#define BOOST_MPL_AT_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: at.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/at_fwd.hpp>
+#include <boost/mpl/aux_/at_impl.hpp>
+#include <boost/mpl/long.hpp>
+#include <boost/mpl/sequence_tag.hpp>
+#include <boost/mpl/aux_/na_spec.hpp>
+#include <boost/mpl/aux_/lambda_support.hpp>
+#include <boost/mpl/aux_/nttp_decl.hpp>
+
+namespace boost { namespace mpl {
+
+template<
+      typename BOOST_MPL_AUX_NA_PARAM(Sequence)
+    , typename BOOST_MPL_AUX_NA_PARAM(N)
+    >
+struct at
+    : at_impl< typename sequence_tag<Sequence>::type >
+        ::template apply< Sequence,N >
+{
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(2,at,(Sequence,N))
+};
+
+template<
+      typename Sequence
+    , BOOST_MPL_AUX_NTTP_DECL(long, N)
+    >
+struct at_c
+    : at_impl< typename sequence_tag<Sequence>::type >
+        ::template apply< Sequence,mpl::long_<N> >
+{
+};
+
+BOOST_MPL_AUX_NA_SPEC(2, at)
+
+}}
+
+#endif // BOOST_MPL_AT_HPP_INCLUDED

include/boost/mpl/at_fwd.hpp

@@ -0,0 +1,24 @@
+
+#ifndef BOOST_MPL_AT_FWD_HPP_INCLUDED
+#define BOOST_MPL_AT_FWD_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: at_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+namespace boost { namespace mpl {
+
+template< typename Tag > struct at_impl;
+template< typename Sequence, typename N > struct at;
+
+}}
+
+#endif // BOOST_MPL_AT_FWD_HPP_INCLUDED

include/boost/mpl/aux_/O1_size_impl.hpp

@@ -0,0 +1,87 @@
+
+#ifndef BOOST_MPL_O1_SIZE_IMPL_HPP_INCLUDED
+#define BOOST_MPL_O1_SIZE_IMPL_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: O1_size_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/O1_size_fwd.hpp>
+#include <boost/mpl/long.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/aux_/has_size.hpp>
+#include <boost/mpl/aux_/config/forwarding.hpp>
+#include <boost/mpl/aux_/config/static_constant.hpp>
+#include <boost/mpl/aux_/config/msvc.hpp>
+#include <boost/mpl/aux_/config/workaround.hpp>
+
+namespace boost { namespace mpl {
+
+// default implementation - returns 'Sequence::size' if sequence has a 'size'
+// member, and -1 otherwise; conrete sequences might override it by 
+// specializing either the 'O1_size_impl' or the primary 'O1_size' template
+
+#   if !BOOST_WORKAROUND(BOOST_MSVC, < 1300) \
+    && !BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
+
+namespace aux {
+template< typename Sequence > struct O1_size_impl
+    : Sequence::size
+{
+};
+}
+
+template< typename Tag >
+struct O1_size_impl
+{
+    template< typename Sequence > struct apply
+#if !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING)
+        : if_<
+              aux::has_size<Sequence>
+            , aux::O1_size_impl<Sequence>
+            , long_<-1>
+            >::type
+    {
+#else
+    {
+        typedef typename if_<
+              aux::has_size<Sequence>
+            , aux::O1_size_impl<Sequence>
+            , long_<-1>
+            >::type type;
+
+        BOOST_STATIC_CONSTANT(long, value =
+              (if_<
+                  aux::has_size<Sequence>
+                , aux::O1_size_impl<Sequence>
+                , long_<-1>
+                >::type::value)
+            );
+#endif
+    };
+};
+
+#   else // BOOST_MSVC
+
+template< typename Tag >
+struct O1_size_impl
+{
+    template< typename Sequence > struct apply
+        : long_<-1>
+        {
+        };
+};
+
+#   endif
+
+}}
+
+#endif // BOOST_MPL_O1_SIZE_IMPL_HPP_INCLUDED

include/boost/mpl/aux_/adl_barrier.hpp

@@ -0,0 +1,48 @@
+
+#ifndef BOOST_MPL_AUX_ADL_BARRIER_HPP_INCLUDED
+#define BOOST_MPL_AUX_ADL_BARRIER_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2002-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: adl_barrier.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/aux_/config/adl.hpp>
+#include <boost/mpl/aux_/config/gcc.hpp>
+#include <boost/mpl/aux_/config/workaround.hpp>
+
+#if !defined(BOOST_MPL_CFG_NO_ADL_BARRIER_NAMESPACE)
+
+#   define BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE mpl_
+#   define BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN namespace mpl_ {
+#   define BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE }
+#   define BOOST_MPL_AUX_ADL_BARRIER_DECL(type) \
+    namespace boost { namespace mpl { \
+    using ::BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::type; \
+    } } \
+/**/
+
+#if !defined(BOOST_MPL_PREPROCESSING_MODE)
+namespace BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE { namespace aux {} }
+namespace boost { namespace mpl { using namespace BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE; 
+namespace aux { using namespace BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::aux; }
+}}
+#endif
+
+#else // BOOST_MPL_CFG_NO_ADL_BARRIER_NAMESPACE
+
+#   define BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE boost::mpl
+#   define BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN namespace boost { namespace mpl {
+#   define BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE }}
+#   define BOOST_MPL_AUX_ADL_BARRIER_DECL(type) /**/
+
+#endif
+
+#endif // BOOST_MPL_AUX_ADL_BARRIER_HPP_INCLUDED

include/boost/mpl/aux_/advance_backward.hpp

@@ -0,0 +1,128 @@
+
+#if !defined(BOOST_PP_IS_ITERATING)
+
+///// header body
+
+#ifndef BOOST_MPL_AUX778076_ADVANCE_BACKWARD_HPP_INCLUDED
+#define BOOST_MPL_AUX778076_ADVANCE_BACKWARD_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: advance_backward.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#if !defined(BOOST_MPL_PREPROCESSING_MODE)
+#   include <boost/mpl/prior.hpp>
+#   include <boost/mpl/apply_wrap.hpp>
+#endif
+
+#include <boost/mpl/aux_/config/use_preprocessed.hpp>
+
+#if    !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE)
+
+#   define BOOST_MPL_PREPROCESSED_HEADER advance_backward.hpp
+#   include <boost/mpl/aux_/include_preprocessed.hpp>
+
+#else
+
+#   include <boost/mpl/limits/unrolling.hpp>
+#   include <boost/mpl/aux_/nttp_decl.hpp>
+#   include <boost/mpl/aux_/config/eti.hpp>
+
+#   include <boost/preprocessor/iterate.hpp>
+#   include <boost/preprocessor/cat.hpp>
+#   include <boost/preprocessor/inc.hpp>
+
+namespace boost { namespace mpl { namespace aux {
+
+// forward declaration
+template< BOOST_MPL_AUX_NTTP_DECL(long, N) > struct advance_backward;
+
+#   define BOOST_PP_ITERATION_PARAMS_1 \
+    (3,(0, BOOST_MPL_LIMIT_UNROLLING, <boost/mpl/aux_/advance_backward.hpp>))
+#   include BOOST_PP_ITERATE()
+
+// implementation for N that exceeds BOOST_MPL_LIMIT_UNROLLING
+template< BOOST_MPL_AUX_NTTP_DECL(long, N) >
+struct advance_backward
+{
+    template< typename Iterator > struct apply
+    {
+        typedef typename apply_wrap1<
+              advance_backward<BOOST_MPL_LIMIT_UNROLLING>
+            , Iterator
+            >::type chunk_result_;
+
+        typedef typename apply_wrap1<
+              advance_backward<(
+                (N - BOOST_MPL_LIMIT_UNROLLING) < 0
+                    ? 0
+                    : N - BOOST_MPL_LIMIT_UNROLLING
+                    )>
+            , chunk_result_
+            >::type type;
+    };
+};
+
+}}}
+
+#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS
+#endif // BOOST_MPL_AUX778076_ADVANCE_BACKWARD_HPP_INCLUDED
+
+///// iteration, depth == 1
+
+// For gcc 4.4 compatability, we must include the
+// BOOST_PP_ITERATION_DEPTH test inside an #else clause.
+#else // BOOST_PP_IS_ITERATING
+#if BOOST_PP_ITERATION_DEPTH() == 1
+#define i_ BOOST_PP_FRAME_ITERATION(1)
+
+template<>
+struct advance_backward< BOOST_PP_FRAME_ITERATION(1) >
+{
+    template< typename Iterator > struct apply
+    {
+        typedef Iterator iter0;
+
+#if i_ > 0
+#   define BOOST_PP_ITERATION_PARAMS_2 \
+    (3,(1, BOOST_PP_FRAME_ITERATION(1), <boost/mpl/aux_/advance_backward.hpp>))
+#   include BOOST_PP_ITERATE()
+#endif
+
+        typedef BOOST_PP_CAT(iter,BOOST_PP_FRAME_ITERATION(1)) type;
+    };
+
+#if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG)
+    /// ETI workaround
+    template<> struct apply<int>
+    {
+        typedef int type;
+    };
+#endif
+};
+
+#undef i_
+
+///// iteration, depth == 2
+
+#elif BOOST_PP_ITERATION_DEPTH() == 2
+
+#   define AUX778076_ITER_0 BOOST_PP_CAT(iter,BOOST_PP_DEC(BOOST_PP_FRAME_ITERATION(2)))
+#   define AUX778076_ITER_1 BOOST_PP_CAT(iter,BOOST_PP_FRAME_ITERATION(2))
+
+        typedef typename prior<AUX778076_ITER_0>::type AUX778076_ITER_1;
+        
+#   undef AUX778076_ITER_1
+#   undef AUX778076_ITER_0
+
+#endif // BOOST_PP_ITERATION_DEPTH()
+#endif // BOOST_PP_IS_ITERATING

include/boost/mpl/aux_/advance_forward.hpp

@@ -0,0 +1,127 @@
+
+#if !defined(BOOST_PP_IS_ITERATING)
+
+///// header body
+
+#ifndef BOOST_MPL_AUX_ADVANCE_FORWARD_HPP_INCLUDED
+#define BOOST_MPL_AUX_ADVANCE_FORWARD_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: advance_forward.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#if !defined(BOOST_MPL_PREPROCESSING_MODE)
+#   include <boost/mpl/next.hpp>
+#   include <boost/mpl/apply_wrap.hpp>
+#endif
+
+#include <boost/mpl/aux_/config/use_preprocessed.hpp>
+
+#if    !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE)
+
+#   define BOOST_MPL_PREPROCESSED_HEADER advance_forward.hpp
+#   include <boost/mpl/aux_/include_preprocessed.hpp>
+
+#else
+
+#   include <boost/mpl/limits/unrolling.hpp>
+#   include <boost/mpl/aux_/nttp_decl.hpp>
+#   include <boost/mpl/aux_/config/eti.hpp>
+
+#   include <boost/preprocessor/iterate.hpp>
+#   include <boost/preprocessor/cat.hpp>
+#   include <boost/preprocessor/inc.hpp>
+
+namespace boost { namespace mpl { namespace aux {
+
+// forward declaration
+template< BOOST_MPL_AUX_NTTP_DECL(long, N) > struct advance_forward;
+
+#   define BOOST_PP_ITERATION_PARAMS_1 \
+    (3,(0, BOOST_MPL_LIMIT_UNROLLING, <boost/mpl/aux_/advance_forward.hpp>))
+#   include BOOST_PP_ITERATE()
+
+// implementation for N that exceeds BOOST_MPL_LIMIT_UNROLLING
+template< BOOST_MPL_AUX_NTTP_DECL(long, N) > 
+struct advance_forward
+{
+    template< typename Iterator > struct apply
+    {
+        typedef typename apply_wrap1<
+              advance_forward<BOOST_MPL_LIMIT_UNROLLING>
+            , Iterator
+            >::type chunk_result_;
+
+        typedef typename apply_wrap1<
+              advance_forward<(
+                (N - BOOST_MPL_LIMIT_UNROLLING) < 0
+                    ? 0
+                    : N - BOOST_MPL_LIMIT_UNROLLING
+                    )>
+            , chunk_result_
+            >::type type;
+    };
+};
+
+}}}
+
+#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS
+#endif // BOOST_MPL_AUX_ADVANCE_FORWARD_HPP_INCLUDED
+
+///// iteration, depth == 1
+
+// For gcc 4.4 compatability, we must include the
+// BOOST_PP_ITERATION_DEPTH test inside an #else clause.
+#else // BOOST_PP_IS_ITERATING
+#if BOOST_PP_ITERATION_DEPTH() == 1
+#define i_ BOOST_PP_FRAME_ITERATION(1)
+
+template<>
+struct advance_forward< BOOST_PP_FRAME_ITERATION(1) >
+{
+    template< typename Iterator > struct apply
+    {
+        typedef Iterator iter0;
+
+#if i_ > 0
+#   define BOOST_PP_ITERATION_PARAMS_2 \
+    (3,(1, i_, <boost/mpl/aux_/advance_forward.hpp>))
+#   include BOOST_PP_ITERATE()
+#endif
+        typedef BOOST_PP_CAT(iter,i_) type;
+    };
+
+#if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG)
+    /// ETI workaround
+    template<> struct apply<int>
+    {
+        typedef int type;
+    };
+#endif
+};
+
+#undef i_
+
+///// iteration, depth == 2
+
+#elif BOOST_PP_ITERATION_DEPTH() == 2
+
+#   define AUX778076_ITER_0 BOOST_PP_CAT(iter,BOOST_PP_DEC(BOOST_PP_FRAME_ITERATION(2)))
+#   define AUX778076_ITER_1 BOOST_PP_CAT(iter,BOOST_PP_FRAME_ITERATION(2))
+
+        typedef typename next<AUX778076_ITER_0>::type AUX778076_ITER_1;
+        
+#   undef AUX778076_ITER_1
+#   undef AUX778076_ITER_0
+
+#endif // BOOST_PP_ITERATION_DEPTH()
+#endif // BOOST_PP_IS_ITERATING

include/boost/mpl/aux_/apply_1st.hpp

@@ -0,0 +1,35 @@
+
+#ifndef BOOST_MPL_AUX_APPLY_1ST_HPP_INCLUDED
+#define BOOST_MPL_AUX_APPLY_1ST_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2002-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: apply_1st.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/apply.hpp>
+
+namespace boost { namespace mpl { namespace aux {
+
+struct apply_1st
+{
+    template< typename Pair, typename T > struct apply
+        : apply2<
+              typename Pair::first
+            , typename Pair::second
+            , T
+            >
+    {
+    };
+};
+
+}}}
+
+#endif // BOOST_MPL_AUX_APPLY_1ST_HPP_INCLUDED

include/boost/mpl/aux_/arg_typedef.hpp

@@ -0,0 +1,31 @@
+
+#ifndef BOOST_MPL_AUX_ARG_TYPEDEF_HPP_INCLUDED
+#define BOOST_MPL_AUX_ARG_TYPEDEF_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2001-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: arg_typedef.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/aux_/config/lambda.hpp>
+#include <boost/mpl/aux_/config/workaround.hpp>
+
+#if defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) \
+    || BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840))
+    
+#   define BOOST_MPL_AUX_ARG_TYPEDEF(T, name) typedef T name;
+
+#else
+
+#   define BOOST_MPL_AUX_ARG_TYPEDEF(T, name) /**/
+
+#endif
+
+#endif // BOOST_MPL_AUX_ARG_TYPEDEF_HPP_INCLUDED

include/boost/mpl/aux_/arithmetic_op.hpp

@@ -0,0 +1,92 @@
+
+// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: arithmetic_op.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#if !defined(BOOST_MPL_PREPROCESSING_MODE)
+#   include <boost/mpl/integral_c.hpp>
+#   include <boost/mpl/aux_/largest_int.hpp>
+#   include <boost/mpl/aux_/value_wknd.hpp>
+#endif
+
+#if !defined(AUX778076_OP_PREFIX)
+#   define AUX778076_OP_PREFIX AUX778076_OP_NAME
+#endif
+
+#include <boost/mpl/aux_/numeric_op.hpp>
+#include <boost/mpl/aux_/config/static_constant.hpp>
+#include <boost/mpl/aux_/config/use_preprocessed.hpp>
+
+#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE)
+
+#   define BOOST_MPL_PREPROCESSED_HEADER AUX778076_OP_PREFIX.hpp
+#   include <boost/mpl/aux_/include_preprocessed.hpp>
+
+#else
+
+#   include <boost/mpl/aux_/config/workaround.hpp>
+#   include <boost/preprocessor/cat.hpp>
+
+
+namespace boost { namespace mpl {
+
+#if defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC)
+namespace aux {
+template< typename T, T n1, T n2 >
+struct BOOST_PP_CAT(AUX778076_OP_PREFIX,_wknd)
+{
+    BOOST_STATIC_CONSTANT(T, value = (n1 AUX778076_OP_TOKEN n2));
+    typedef integral_c<T,value> type;
+};
+}
+#endif
+
+template<>
+struct AUX778076_OP_IMPL_NAME<integral_c_tag,integral_c_tag>
+{
+    template< typename N1, typename N2 > struct apply
+#if !defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC)
+        : integral_c<
+              typename aux::largest_int<
+                  typename N1::value_type
+                , typename N2::value_type
+                >::type
+            , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value
+                  AUX778076_OP_TOKEN BOOST_MPL_AUX_VALUE_WKND(N2)::value
+                )
+            >
+#else
+        : aux::BOOST_PP_CAT(AUX778076_OP_PREFIX,_wknd)<
+              typename aux::largest_int<
+                  typename N1::value_type
+                , typename N2::value_type
+                >::type
+            , N1::value
+            , N2::value
+            >::type
+#endif
+    {
+    };
+};
+
+}}
+
+#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS
+
+#undef AUX778076_OP_TAG_NAME
+#undef AUX778076_OP_IMPL_NAME
+#undef AUX778076_OP_ARITY
+#undef AUX778076_OP_PREFIX
+#undef AUX778076_OP_NAME
+#undef AUX778076_OP_TOKEN

include/boost/mpl/aux_/arity.hpp

@@ -0,0 +1,39 @@
+
+#ifndef BOOST_MPL_AUX_ARITY_HPP_INCLUDED
+#define BOOST_MPL_AUX_ARITY_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2001-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: arity.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/aux_/config/dtp.hpp>
+
+#if defined(BOOST_MPL_CFG_BROKEN_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES)
+
+#   include <boost/mpl/aux_/nttp_decl.hpp>
+#   include <boost/mpl/aux_/config/static_constant.hpp>
+
+namespace boost { namespace mpl { namespace aux {
+
+// agurt, 15/mar/02: it's possible to implement the template so that it will 
+// "just work" and do not require any specialization, but not on the compilers
+// that require the arity workaround in the first place
+template< typename F, BOOST_MPL_AUX_NTTP_DECL(int, N) >
+struct arity
+{
+    BOOST_STATIC_CONSTANT(int, value = N);
+};
+
+}}}
+
+#endif // BOOST_MPL_CFG_BROKEN_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES
+
+#endif // BOOST_MPL_AUX_ARITY_HPP_INCLUDED

include/boost/mpl/aux_/arity_spec.hpp

@@ -0,0 +1,67 @@
+
+#ifndef BOOST_MPL_AUX_ARITY_SPEC_HPP_INCLUDED
+#define BOOST_MPL_AUX_ARITY_SPEC_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2001-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: arity_spec.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/limits/arity.hpp>
+#include <boost/mpl/aux_/config/dtp.hpp>
+#include <boost/mpl/aux_/preprocessor/params.hpp>
+#include <boost/mpl/aux_/arity.hpp>
+#include <boost/mpl/aux_/template_arity_fwd.hpp>
+#include <boost/mpl/aux_/config/ttp.hpp>
+#include <boost/mpl/aux_/config/lambda.hpp>
+#include <boost/mpl/aux_/config/static_constant.hpp>
+
+#if defined(BOOST_MPL_CFG_BROKEN_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES)
+#   define BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(i,type,name) \
+namespace aux { \
+template< BOOST_MPL_AUX_NTTP_DECL(int, N), BOOST_MPL_PP_PARAMS(i,type T) > \
+struct arity< \
+      name< BOOST_MPL_PP_PARAMS(i,T) > \
+    , N \
+    > \
+{ \
+    BOOST_STATIC_CONSTANT(int \
+        , value = BOOST_MPL_LIMIT_METAFUNCTION_ARITY \
+        ); \
+}; \
+} \
+/**/
+#else
+#   define BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(i,type,name) /**/
+#endif
+
+#   define BOOST_MPL_AUX_ARITY_SPEC(i,name) \
+    BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(i,typename,name) \
+/**/
+
+
+#if defined(BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) \
+    && !defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT)
+#   define BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(i, name) \
+namespace aux { \
+template< BOOST_MPL_PP_PARAMS(i,typename T) > \
+struct template_arity< name<BOOST_MPL_PP_PARAMS(i,T)> > \
+    : int_<i> \
+{ \
+}; \
+} \
+/**/
+#else
+#   define BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(i, name) /**/
+#endif
+
+
+#endif // BOOST_MPL_AUX_ARITY_SPEC_HPP_INCLUDED

include/boost/mpl/aux_/at_impl.hpp

@@ -0,0 +1,45 @@
+
+#ifndef BOOST_MPL_AUX_AT_IMPL_HPP_INCLUDED
+#define BOOST_MPL_AUX_AT_IMPL_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: at_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/begin_end.hpp>
+#include <boost/mpl/advance.hpp>
+#include <boost/mpl/deref.hpp>
+#include <boost/mpl/aux_/traits_lambda_spec.hpp>
+
+namespace boost { namespace mpl {
+
+// default implementation; conrete sequences might override it by 
+// specializing either the 'at_impl' or the primary 'at' template
+
+template< typename Tag >
+struct at_impl
+{
+    template< typename Sequence, typename N > struct apply
+    {
+        typedef typename advance<
+              typename begin<Sequence>::type
+            , N
+            >::type iter_;
+
+        typedef typename deref<iter_>::type type;
+    };
+};
+
+BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(2, at_impl)
+
+}}
+
+#endif // BOOST_MPL_AUX_AT_IMPL_HPP_INCLUDED

include/boost/mpl/aux_/back_impl.hpp

@@ -0,0 +1,43 @@
+
+#ifndef BOOST_MPL_AUX_BACK_IMPL_HPP_INCLUDED
+#define BOOST_MPL_AUX_BACK_IMPL_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: back_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/begin_end.hpp>
+#include <boost/mpl/next_prior.hpp>
+#include <boost/mpl/deref.hpp>
+#include <boost/mpl/aux_/traits_lambda_spec.hpp>
+
+namespace boost { namespace mpl {
+
+// default implementation, requires at least bi-directional iterators;
+// conrete sequences might override it by specializing either the 
+// 'back_impl' or the primary 'back' template
+
+template< typename Tag >
+struct back_impl
+{
+    template< typename Sequence > struct apply
+    {
+        typedef typename end<Sequence>::type end_;
+        typedef typename prior<end_>::type last_;
+        typedef typename deref<last_>::type type;
+    };
+};
+
+BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(1, back_impl)
+
+}}
+
+#endif // BOOST_MPL_AUX_BACK_IMPL_HPP_INCLUDED

include/boost/mpl/aux_/basic_bind.hpp

@@ -0,0 +1,21 @@
+
+#ifndef BOOST_MPL_AUX_BASIC_BIND_HPP_INCLUDED
+#define BOOST_MPL_AUX_BASIC_BIND_HPP_INCLUDED
+
+// Copyright Peter Dimov 2001
+// Copyright Aleksey Gurtovoy 2001-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: basic_bind.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#define BOOST_MPL_CFG_NO_UNNAMED_PLACEHOLDER_SUPPORT
+#include <boost/mpl/bind.hpp>
+
+#endif // BOOST_MPL_AUX_BASIC_BIND_HPP_INCLUDED

include/boost/mpl/aux_/begin_end_impl.hpp

@@ -0,0 +1,101 @@
+
+#ifndef BOOST_MPL_AUX_BEGIN_END_IMPL_HPP_INCLUDED
+#define BOOST_MPL_AUX_BEGIN_END_IMPL_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: begin_end_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/begin_end_fwd.hpp>
+#include <boost/mpl/sequence_tag_fwd.hpp>
+#include <boost/mpl/void.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/aux_/has_begin.hpp>
+#include <boost/mpl/aux_/na.hpp>
+#include <boost/mpl/aux_/traits_lambda_spec.hpp>
+#include <boost/mpl/aux_/config/eti.hpp>
+
+namespace boost { namespace mpl {
+
+
+namespace aux { 
+
+template< typename Sequence > 
+struct begin_type 
+{ 
+    typedef typename Sequence::begin type; 
+};
+template< typename Sequence > 
+struct end_type
+{ 
+    typedef typename Sequence::end type; 
+};
+
+}
+
+// default implementation; conrete sequences might override it by 
+// specializing either the 'begin_impl/end_impl' or the primary 
+// 'begin/end' templates
+
+template< typename Tag >
+struct begin_impl
+{
+    template< typename Sequence > struct apply
+    {
+        typedef typename eval_if<aux::has_begin<Sequence, true_>,
+                                 aux::begin_type<Sequence>, void_>::type type;
+    };
+};
+
+template< typename Tag >
+struct end_impl
+{
+    template< typename Sequence > struct apply
+    {
+        typedef typename eval_if<aux::has_begin<Sequence, true_>,
+                                 aux::end_type<Sequence>, void_>::type type;
+    };
+};
+
+// specialize 'begin_trait/end_trait' for two pre-defined tags
+
+#   define AUX778076_IMPL_SPEC(name, tag, result) \
+template<> \
+struct name##_impl<tag> \
+{ \
+    template< typename Sequence > struct apply \
+    { \
+        typedef result type; \
+    }; \
+}; \
+/**/
+
+// a sequence with nested 'begin/end' typedefs; just query them
+AUX778076_IMPL_SPEC(begin, nested_begin_end_tag, typename Sequence::begin)
+AUX778076_IMPL_SPEC(end, nested_begin_end_tag, typename Sequence::end)
+
+// if a type 'T' does not contain 'begin/end' or 'tag' members 
+// and doesn't specialize either 'begin/end' or 'begin_impl/end_impl' 
+// templates, then we end up here
+AUX778076_IMPL_SPEC(begin, non_sequence_tag, void_)
+AUX778076_IMPL_SPEC(end, non_sequence_tag, void_)
+AUX778076_IMPL_SPEC(begin, na, void_)
+AUX778076_IMPL_SPEC(end, na, void_)
+
+#   undef AUX778076_IMPL_SPEC
+
+
+BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC_IMPL(1,begin_impl)
+BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC_IMPL(1,end_impl)
+
+}}
+
+#endif // BOOST_MPL_AUX_BEGIN_END_IMPL_HPP_INCLUDED

include/boost/mpl/aux_/clear_impl.hpp

@@ -0,0 +1,35 @@
+
+#ifndef BOOST_MPL_AUX_CLEAR_IMPL_HPP_INCLUDED
+#define BOOST_MPL_AUX_CLEAR_IMPL_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: clear_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/clear_fwd.hpp>
+#include <boost/mpl/aux_/traits_lambda_spec.hpp>
+#include <boost/mpl/aux_/config/eti.hpp>
+
+namespace boost { namespace mpl {
+
+// no default implementation; the definition is needed to make MSVC happy
+
+template< typename Tag >
+struct clear_impl
+{
+    template< typename Sequence > struct apply;
+};
+
+BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(1, clear_impl)
+
+}}
+
+#endif // BOOST_MPL_AUX_CLEAR_IMPL_HPP_INCLUDED

include/boost/mpl/aux_/common_name_wknd.hpp

@@ -0,0 +1,34 @@
+
+#ifndef BOOST_MPL_AUX_COMMON_NAME_WKND_HPP_INCLUDED
+#define BOOST_MPL_AUX_COMMON_NAME_WKND_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2002-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: common_name_wknd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/aux_/config/workaround.hpp>
+
+#if BOOST_WORKAROUND(__BORLANDC__, < 0x561)
+// agurt, 12/nov/02: to suppress the bogus "Cannot have both a template class 
+// and function named 'xxx'" diagnostic
+#   define BOOST_MPL_AUX_COMMON_NAME_WKND(name) \
+namespace name_##wknd { \
+template< typename > void name(); \
+} \
+/**/
+
+#else
+
+#   define BOOST_MPL_AUX_COMMON_NAME_WKND(name) /**/
+
+#endif // __BORLANDC__
+
+#endif // BOOST_MPL_AUX_COMMON_NAME_WKND_HPP_INCLUDED

include/boost/mpl/aux_/comparison_op.hpp

@@ -0,0 +1,83 @@
+
+// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: comparison_op.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#if !defined(BOOST_MPL_PREPROCESSING_MODE)
+#   include <boost/mpl/bool.hpp>
+#   include <boost/mpl/aux_/value_wknd.hpp>
+#endif
+
+#if !defined(AUX778076_OP_PREFIX)
+#   define AUX778076_OP_PREFIX AUX778076_OP_NAME
+#endif
+
+#define AUX778076_OP_ARITY 2
+
+#include <boost/mpl/aux_/numeric_op.hpp>
+#include <boost/mpl/aux_/config/static_constant.hpp>
+#include <boost/mpl/aux_/config/use_preprocessed.hpp>
+
+#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE)
+
+#   define BOOST_MPL_PREPROCESSED_HEADER AUX778076_OP_PREFIX.hpp
+#   include <boost/mpl/aux_/include_preprocessed.hpp>
+
+#else
+
+#   include <boost/mpl/aux_/config/integral.hpp>
+#   include <boost/preprocessor/cat.hpp>
+
+namespace boost { namespace mpl {
+
+// MSVC workaround: implement less in terms of greater
+#if 0 AUX778076_OP_TOKEN 1 && !(1 AUX778076_OP_TOKEN 0) && !(0 AUX778076_OP_TOKEN 0)
+#   define AUX778076_OP(N1, N2) \
+    ( BOOST_MPL_AUX_VALUE_WKND(N2)::value > BOOST_MPL_AUX_VALUE_WKND(N1)::value ) \
+/**/
+#else
+#   define AUX778076_OP(N1, N2) \
+    ( BOOST_MPL_AUX_VALUE_WKND(N1)::value \
+          AUX778076_OP_TOKEN BOOST_MPL_AUX_VALUE_WKND(N2)::value \
+        ) \
+/**/
+#endif
+
+template<>
+struct AUX778076_OP_IMPL_NAME<integral_c_tag,integral_c_tag>
+{
+    template< typename N1, typename N2 > struct apply
+#if !defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC)
+        : bool_< AUX778076_OP(N1, N2) >
+    {
+#else
+    {
+        BOOST_STATIC_CONSTANT(bool, value = AUX778076_OP(N1, N2));
+        typedef bool_<value> type;
+#endif
+    };
+};
+
+#undef AUX778076_OP
+
+}}
+
+#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS
+
+#undef AUX778076_OP_TAG_NAME
+#undef AUX778076_OP_IMPL_NAME
+#undef AUX778076_OP_ARITY
+#undef AUX778076_OP_PREFIX
+#undef AUX778076_OP_NAME
+#undef AUX778076_OP_TOKEN

include/boost/mpl/aux_/config/adl.hpp

@@ -0,0 +1,40 @@
+
+#ifndef BOOST_MPL_AUX_CONFIG_ADL_HPP_INCLUDED
+#define BOOST_MPL_AUX_CONFIG_ADL_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2002-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: adl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/aux_/config/msvc.hpp>
+#include <boost/mpl/aux_/config/intel.hpp>
+#include <boost/mpl/aux_/config/gcc.hpp>
+#include <boost/mpl/aux_/config/workaround.hpp>
+
+// agurt, 25/apr/04: technically, the ADL workaround is only needed for GCC,
+// but putting everything expect public, user-specializable metafunctions into
+// a separate global namespace has a nice side effect of reducing the length 
+// of template instantiation symbols, so we apply the workaround on all 
+// platforms that can handle it
+
+#if !defined(BOOST_MPL_CFG_NO_ADL_BARRIER_NAMESPACE) \
+    && (   BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400)) \
+        || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) \
+        || BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) \
+        || BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3202)) \
+        || BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, BOOST_TESTED_AT(810)) \
+        )
+
+#   define BOOST_MPL_CFG_NO_ADL_BARRIER_NAMESPACE
+
+#endif
+
+#endif // BOOST_MPL_AUX_CONFIG_ADL_HPP_INCLUDED

include/boost/mpl/aux_/config/arrays.hpp

@@ -0,0 +1,30 @@
+
+#ifndef BOOST_MPL_AUX_CONFIG_ARRAYS_HPP_INCLUDED
+#define BOOST_MPL_AUX_CONFIG_ARRAYS_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2003-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: arrays.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/aux_/config/msvc.hpp>
+#include <boost/mpl/aux_/config/workaround.hpp>
+
+#if    !defined(BOOST_MPL_CFG_NO_DEPENDENT_ARRAY_TYPES) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE) \
+    && ( BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) \
+        || BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
+        )
+
+#   define BOOST_MPL_CFG_NO_DEPENDENT_ARRAY_TYPES
+
+#endif
+
+#endif // BOOST_MPL_AUX_CONFIG_ARRAYS_HPP_INCLUDED

include/boost/mpl/aux_/config/bcc.hpp

@@ -0,0 +1,28 @@
+
+#ifndef BOOST_MPL_AUX_CONFIG_BCC_HPP_INCLUDED
+#define BOOST_MPL_AUX_CONFIG_BCC_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2008
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: bcc.hpp 49272 2008-10-11 06:50:46Z agurtovoy $
+// $Date: 2004-09-02 10:41:37 -0500 (Thu, 02 Sep 2004) $
+// $Revision: 24874 $
+
+#include <boost/mpl/aux_/config/workaround.hpp>
+
+#if    !defined(BOOST_MPL_CFG_BCC590_WORKAROUNDS) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE) \
+    && BOOST_WORKAROUND(__BORLANDC__, >= 0x590) \
+    && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610))
+
+#   define BOOST_MPL_CFG_BCC590_WORKAROUNDS
+
+#endif
+
+#endif // BOOST_MPL_AUX_CONFIG_BCC_HPP_INCLUDED

include/boost/mpl/aux_/config/bind.hpp

@@ -0,0 +1,33 @@
+
+#ifndef BOOST_MPL_AUX_CONFIG_BIND_HPP_INCLUDED
+#define BOOST_MPL_AUX_CONFIG_BIND_HPP_INCLUDED
+
+// Copyright David Abrahams 2002
+// Copyright Aleksey Gurtovoy 2002-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: bind.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/aux_/config/msvc.hpp>
+#include <boost/mpl/aux_/config/workaround.hpp>
+
+#if    !defined(BOOST_MPL_CFG_NO_BIND_TEMPLATE) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE) \
+    && (   BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
+        || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) \
+        )
+
+#   define BOOST_MPL_CFG_NO_BIND_TEMPLATE
+
+#endif
+
+//#define BOOST_MPL_CFG_NO_UNNAMED_PLACEHOLDER_SUPPORT
+
+#endif // BOOST_MPL_AUX_CONFIG_BIND_HPP_INCLUDED

include/boost/mpl/aux_/config/compiler.hpp

@@ -0,0 +1,66 @@
+
+#ifndef BOOST_MPL_AUX_CONFIG_COMPILER_HPP_INCLUDED
+#define BOOST_MPL_AUX_CONFIG_COMPILER_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2001-2008
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: compiler.hpp 53189 2009-05-22 20:07:55Z hkaiser $
+// $Date: 2009-05-22 16:07:55 -0400 (Fri, 22 May 2009) $
+// $Revision: 53189 $
+
+#if !defined(BOOST_MPL_CFG_COMPILER_DIR)
+
+#   include <boost/mpl/aux_/config/dtp.hpp>
+#   include <boost/mpl/aux_/config/ttp.hpp>
+#   include <boost/mpl/aux_/config/ctps.hpp>
+#   include <boost/mpl/aux_/config/msvc.hpp>
+#   include <boost/mpl/aux_/config/gcc.hpp>
+#   include <boost/mpl/aux_/config/workaround.hpp>
+
+#   if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+#       define BOOST_MPL_CFG_COMPILER_DIR msvc60
+
+#   elif BOOST_WORKAROUND(BOOST_MSVC, == 1300)
+#       define BOOST_MPL_CFG_COMPILER_DIR msvc70
+
+#   elif BOOST_WORKAROUND(BOOST_MPL_CFG_GCC, BOOST_TESTED_AT(0x0304))
+#       define BOOST_MPL_CFG_COMPILER_DIR gcc
+
+#   elif BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610))
+#       if !defined(BOOST_MPL_CFG_NO_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES)
+#           define BOOST_MPL_CFG_COMPILER_DIR bcc551
+#       elif BOOST_WORKAROUND(__BORLANDC__, >= 0x590)
+#           define BOOST_MPL_CFG_COMPILER_DIR bcc
+#       else
+#           define BOOST_MPL_CFG_COMPILER_DIR bcc_pre590
+#       endif
+
+#   elif BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840))
+#       define BOOST_MPL_CFG_COMPILER_DIR dmc
+
+#   elif defined(__MWERKS__)
+#       if defined(BOOST_MPL_CFG_BROKEN_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES)
+#           define BOOST_MPL_CFG_COMPILER_DIR mwcw
+#       else
+#           define BOOST_MPL_CFG_COMPILER_DIR plain
+#       endif
+
+#   elif defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#       define BOOST_MPL_CFG_COMPILER_DIR no_ctps
+
+#   elif defined(BOOST_MPL_CFG_NO_TEMPLATE_TEMPLATE_PARAMETERS)
+#       define BOOST_MPL_CFG_COMPILER_DIR no_ttp
+
+#   else
+#       define BOOST_MPL_CFG_COMPILER_DIR plain
+#   endif
+
+#endif // BOOST_MPL_CFG_COMPILER_DIR
+
+#endif // BOOST_MPL_AUX_CONFIG_COMPILER_HPP_INCLUDED

include/boost/mpl/aux_/config/ctps.hpp

@@ -0,0 +1,30 @@
+
+#ifndef BOOST_MPL_AUX_CONFIG_CTPS_HPP_INCLUDED
+#define BOOST_MPL_AUX_CONFIG_CTPS_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: ctps.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/aux_/config/workaround.hpp>
+#include <boost/config.hpp>
+
+#if    !defined(BOOST_MPL_CFG_NO_NONTYPE_TEMPLATE_PARTIAL_SPEC) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE) \
+    && BOOST_WORKAROUND(__BORLANDC__, < 0x582)
+
+#   define BOOST_MPL_CFG_NO_NONTYPE_TEMPLATE_PARTIAL_SPEC
+
+#endif
+
+// BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION is defined in <boost/config.hpp>
+
+#endif // BOOST_MPL_AUX_CONFIG_CTPS_HPP_INCLUDED

include/boost/mpl/aux_/config/dependent_nttp.hpp

@@ -0,0 +1,35 @@
+
+#ifndef BOOST_MPL_AUX_CONFIG_DEPENDENT_NTTP_HPP_INCLUDED
+#define BOOST_MPL_AUX_CONFIG_DEPENDENT_NTTP_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2002-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: dependent_nttp.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/aux_/config/gcc.hpp>
+#include <boost/mpl/aux_/config/workaround.hpp>
+
+// GCC and EDG-based compilers incorrectly reject the following code:
+//   template< typename T, T n > struct a;
+//   template< typename T > struct b;
+//   template< typename T, T n > struct b< a<T,n> > {};
+
+#if    !defined(BOOST_MPL_CFG_NO_DEPENDENT_NONTYPE_PARAMETER_IN_PARTIAL_SPEC) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE) \
+    && (   BOOST_WORKAROUND(__EDG_VERSION__, BOOST_TESTED_AT(300)) \
+        || BOOST_WORKAROUND(BOOST_MPL_CFG_GCC, BOOST_TESTED_AT(0x0302)) \
+        )
+
+#   define BOOST_MPL_CFG_NO_DEPENDENT_NONTYPE_PARAMETER_IN_PARTIAL_SPEC
+
+#endif
+
+#endif // BOOST_MPL_AUX_CONFIG_DEPENDENT_NTTP_HPP_INCLUDED

include/boost/mpl/aux_/config/dmc_ambiguous_ctps.hpp

@@ -0,0 +1,27 @@
+
+#ifndef BOOST_MPL_AUX_CONFIG_DMC_AMBIGUOUS_CTPS_HPP_INCLUDED
+#define BOOST_MPL_AUX_CONFIG_DMC_AMBIGUOUS_CTPS_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: dmc_ambiguous_ctps.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/aux_/config/workaround.hpp>
+
+#if    !defined(BOOST_MPL_CFG_DMC_AMBIGUOUS_CTPS) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE) \
+    && BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840))
+
+#   define BOOST_MPL_CFG_DMC_AMBIGUOUS_CTPS
+
+#endif
+
+#endif // BOOST_MPL_AUX_CONFIG_DMC_AMBIGUOUS_CTPS_HPP_INCLUDED

include/boost/mpl/aux_/config/dtp.hpp

@@ -0,0 +1,46 @@
+
+#ifndef BOOST_MPL_AUX_CONFIG_DTP_HPP_INCLUDED
+#define BOOST_MPL_AUX_CONFIG_DTP_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2001-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: dtp.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/aux_/config/workaround.hpp>
+
+// MWCW 7.x-8.0 "losts" default template parameters of nested class 
+// templates when their owner classes are passed as arguments to other 
+// templates; Borland 5.5.1 "forgets" them from the very beginning (if 
+// the owner class is a class template), and Borland 5.6 isn't even
+// able to compile a definition of nested class template with DTP
+
+#if    !defined(BOOST_MPL_CFG_NO_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE) \
+    && BOOST_WORKAROUND(__BORLANDC__, >= 0x560) \
+    && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610))
+
+#   define BOOST_MPL_CFG_NO_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES
+
+#endif
+
+
+#if    !defined(BOOST_MPL_CFG_BROKEN_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE) \
+    && (   BOOST_WORKAROUND(__MWERKS__, <= 0x3001) \
+        || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) \
+        || defined(BOOST_MPL_CFG_NO_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) \
+        )
+        
+#   define BOOST_MPL_CFG_BROKEN_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES
+
+#endif
+
+#endif // BOOST_MPL_AUX_CONFIG_DTP_HPP_INCLUDED

include/boost/mpl/aux_/config/eti.hpp

@@ -0,0 +1,47 @@
+
+#ifndef BOOST_MPL_AUX_CONFIG_ETI_HPP_INCLUDED
+#define BOOST_MPL_AUX_CONFIG_ETI_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2001-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: eti.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/aux_/config/msvc.hpp>
+#include <boost/mpl/aux_/config/workaround.hpp>
+
+// flags for MSVC 6.5's so-called "early template instantiation bug"
+#if    !defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE) \
+    && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+
+#   define BOOST_MPL_CFG_MSVC_60_ETI_BUG
+
+#endif
+
+#if    !defined(BOOST_MPL_CFG_MSVC_70_ETI_BUG) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE) \
+    && BOOST_WORKAROUND(BOOST_MSVC, == 1300)
+
+#   define BOOST_MPL_CFG_MSVC_70_ETI_BUG
+
+#endif
+
+#if    !defined(BOOST_MPL_CFG_MSVC_ETI_BUG) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE) \
+    && ( defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG) \
+        || defined(BOOST_MPL_CFG_MSVC_70_ETI_BUG) \
+        )
+
+#   define BOOST_MPL_CFG_MSVC_ETI_BUG
+
+#endif
+
+#endif // BOOST_MPL_AUX_CONFIG_ETI_HPP_INCLUDED

include/boost/mpl/aux_/config/forwarding.hpp

@@ -0,0 +1,27 @@
+
+#ifndef BOOST_MPL_AUX_CONFIG_FORWARDING_HPP_INCLUDED
+#define BOOST_MPL_AUX_CONFIG_FORWARDING_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: forwarding.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/aux_/config/workaround.hpp>
+
+#if    !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE) \
+    && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610))
+
+#   define BOOST_MPL_CFG_NO_NESTED_FORWARDING
+
+#endif
+
+#endif // BOOST_MPL_AUX_CONFIG_FORWARDING_HPP_INCLUDED

include/boost/mpl/aux_/config/gcc.hpp

@@ -0,0 +1,23 @@
+
+#ifndef BOOST_MPL_AUX_CONFIG_GCC_HPP_INCLUDED
+#define BOOST_MPL_AUX_CONFIG_GCC_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: gcc.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#if defined(__GNUC__) && !defined(__EDG_VERSION__)
+#   define BOOST_MPL_CFG_GCC ((__GNUC__ << 8) | __GNUC_MINOR__)
+#else
+#   define BOOST_MPL_CFG_GCC 0
+#endif
+
+#endif // BOOST_MPL_AUX_CONFIG_GCC_HPP_INCLUDED

include/boost/mpl/aux_/config/has_apply.hpp

@@ -0,0 +1,32 @@
+
+#ifndef BOOST_MPL_AUX_CONFIG_HAS_APPLY_HPP_INCLUDED
+#define BOOST_MPL_AUX_CONFIG_HAS_APPLY_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: has_apply.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/aux_/config/has_xxx.hpp>
+#include <boost/mpl/aux_/config/msvc.hpp>
+#include <boost/mpl/aux_/config/workaround.hpp>
+
+#if !defined(BOOST_MPL_CFG_NO_HAS_APPLY) \
+    && (   defined(BOOST_MPL_CFG_NO_HAS_XXX) \
+        || BOOST_WORKAROUND(__EDG_VERSION__, < 300) \
+        || BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
+        || BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3202)) \
+        )
+
+#   define BOOST_MPL_CFG_NO_HAS_APPLY
+
+#endif
+
+#endif // BOOST_MPL_AUX_CONFIG_HAS_APPLY_HPP_INCLUDED

include/boost/mpl/aux_/config/has_xxx.hpp

@@ -0,0 +1,33 @@
+
+#ifndef BOOST_MPL_AUX_CONFIG_HAS_XXX_HPP_INCLUDED
+#define BOOST_MPL_AUX_CONFIG_HAS_XXX_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2002-2004
+// Copyright David Abrahams 2002-2003
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: has_xxx.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/aux_/config/overload_resolution.hpp>
+#include <boost/mpl/aux_/config/workaround.hpp>
+
+// agurt, 11/jan/03: signals a stub-only 'has_xxx' implementation
+
+#if !defined(BOOST_MPL_CFG_NO_HAS_XXX) \
+    && (   defined(BOOST_MPL_CFG_BROKEN_OVERLOAD_RESOLUTION) \
+        || BOOST_WORKAROUND(__GNUC__, <= 2) \
+        || BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) \
+        )
+
+#   define BOOST_MPL_CFG_NO_HAS_XXX
+
+#endif
+
+#endif // BOOST_MPL_AUX_CONFIG_HAS_XXX_HPP_INCLUDED

include/boost/mpl/aux_/config/integral.hpp

@@ -0,0 +1,38 @@
+
+#ifndef BOOST_MPL_AUX_CONFIG_INTEGRAL_HPP_INCLUDED
+#define BOOST_MPL_AUX_CONFIG_INTEGRAL_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: integral.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/aux_/config/msvc.hpp>
+#include <boost/mpl/aux_/config/workaround.hpp>
+
+#if    !defined(BOOST_MPL_CFG_BCC_INTEGRAL_CONSTANTS) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE) \
+    && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610))
+
+#   define BOOST_MPL_CFG_BCC_INTEGRAL_CONSTANTS
+
+#endif
+
+#if    !defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE) \
+    && ( BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
+        || BOOST_WORKAROUND(__EDG_VERSION__, <= 238) \
+        )
+
+#   define BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC
+
+#endif
+
+#endif // BOOST_MPL_AUX_CONFIG_INTEGRAL_HPP_INCLUDED

include/boost/mpl/aux_/config/intel.hpp

@@ -0,0 +1,21 @@
+
+#ifndef BOOST_MPL_AUX_CONFIG_INTEL_HPP_INCLUDED
+#define BOOST_MPL_AUX_CONFIG_INTEL_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: intel.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+
+// BOOST_INTEL_CXX_VERSION is defined here:
+#include <boost/config.hpp>
+
+#endif // BOOST_MPL_AUX_CONFIG_INTEL_HPP_INCLUDED

include/boost/mpl/aux_/config/lambda.hpp

@@ -0,0 +1,32 @@
+
+#ifndef BOOST_MPL_AUX_CONFIG_LAMBDA_HPP_INCLUDED
+#define BOOST_MPL_AUX_CONFIG_LAMBDA_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2002-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: lambda.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/aux_/config/ttp.hpp>
+#include <boost/mpl/aux_/config/ctps.hpp>
+
+// agurt, 15/jan/02: full-fledged implementation requires both 
+// template template parameters _and_ partial specialization
+
+#if    !defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) \
+    && (   defined(BOOST_MPL_CFG_NO_TEMPLATE_TEMPLATE_PARAMETERS) \
+        || defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
+        )
+
+#   define BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT
+
+#endif
+
+#endif // BOOST_MPL_AUX_CONFIG_LAMBDA_HPP_INCLUDED

include/boost/mpl/aux_/config/msvc.hpp

@@ -0,0 +1,21 @@
+
+#ifndef BOOST_MPL_AUX_CONFIG_MSVC_HPP_INCLUDED
+#define BOOST_MPL_AUX_CONFIG_MSVC_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2002-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: msvc.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+
+// BOOST_MSVC is defined here:
+#include <boost/config.hpp>
+
+#endif // BOOST_MPL_AUX_CONFIG_MSVC_HPP_INCLUDED

include/boost/mpl/aux_/config/msvc_typename.hpp

@@ -0,0 +1,26 @@
+
+#ifndef BOOST_MPL_AUX_CONFIG_MSVC_TYPENAME_HPP_INCLUDED
+#define BOOST_MPL_AUX_CONFIG_MSVC_TYPENAME_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: msvc_typename.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/aux_/config/msvc.hpp>
+#include <boost/mpl/aux_/config/workaround.hpp>
+
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+#   define BOOST_MSVC_TYPENAME
+#else
+#   define BOOST_MSVC_TYPENAME typename
+#endif
+
+#endif // BOOST_MPL_AUX_CONFIG_MSVC_TYPENAME_HPP_INCLUDED

include/boost/mpl/aux_/config/nttp.hpp

@@ -0,0 +1,41 @@
+
+#ifndef BOOST_MPL_AUX_CONFIG_NTTP_HPP_INCLUDED
+#define BOOST_MPL_AUX_CONFIG_NTTP_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2001-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: nttp.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/aux_/config/msvc.hpp>
+#include <boost/mpl/aux_/config/workaround.hpp>
+
+// MSVC 6.5 ICE-s on the code as simple as this (see "aux_/nttp_decl.hpp"
+// for a workaround):
+//
+//    namespace std {
+//    template< typename Char > struct string;
+//    }
+//
+//    void foo(std::string<char>);
+//
+//    namespace boost { namespace mpl {
+//    template< int > struct arg;
+//    }}
+
+#if    !defined(BOOST_MPL_CFG_NTTP_BUG) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE) \
+    && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+
+#   define BOOST_MPL_CFG_NTTP_BUG
+
+#endif
+
+#endif // BOOST_MPL_AUX_CONFIG_NTTP_HPP_INCLUDED

include/boost/mpl/aux_/config/operators.hpp

@@ -0,0 +1,33 @@
+
+#ifndef BOOST_MPL_AUX_CONFIG_OPERATORS_HPP_INCLUDED
+#define BOOST_MPL_AUX_CONFIG_OPERATORS_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2003-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: operators.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/aux_/config/gcc.hpp>
+#include <boost/mpl/aux_/config/msvc.hpp>
+#include <boost/mpl/aux_/config/workaround.hpp>
+
+#if !defined(BOOST_MPL_CFG_USE_OPERATORS_OVERLOADING) \
+    && ( BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
+        || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) \
+        || BOOST_WORKAROUND(__EDG_VERSION__, <= 245) \
+        || BOOST_WORKAROUND(BOOST_MPL_CFG_GCC, <= 0x0295) \
+        || BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600)) \
+        )
+
+#   define BOOST_MPL_CFG_USE_OPERATORS_OVERLOADING
+
+#endif
+
+#endif // BOOST_MPL_AUX_CONFIG_OPERATORS_HPP_INCLUDED

include/boost/mpl/aux_/config/overload_resolution.hpp

@@ -0,0 +1,29 @@
+
+#ifndef BOOST_MPL_AUX_CONFIG_OVERLOAD_RESOLUTION_HPP_INCLUDED
+#define BOOST_MPL_AUX_CONFIG_OVERLOAD_RESOLUTION_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2002-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: overload_resolution.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/aux_/config/workaround.hpp>
+
+#if    !defined(BOOST_MPL_CFG_BROKEN_OVERLOAD_RESOLUTION) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE) \
+    && (   BOOST_WORKAROUND(__BORLANDC__, < 0x590) \
+        || BOOST_WORKAROUND(__MWERKS__, < 0x3001) \
+        )
+
+#   define BOOST_MPL_CFG_BROKEN_OVERLOAD_RESOLUTION
+
+#endif
+
+#endif // BOOST_MPL_AUX_CONFIG_OVERLOAD_RESOLUTION_HPP_INCLUDED

include/boost/mpl/aux_/config/pp_counter.hpp

@@ -0,0 +1,26 @@
+
+#ifndef BOOST_MPL_AUX_CONFIG_PP_COUNTER_HPP_INCLUDED
+#define BOOST_MPL_AUX_CONFIG_PP_COUNTER_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: pp_counter.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#if !defined(BOOST_MPL_AUX_PP_COUNTER)
+#   include <boost/mpl/aux_/config/msvc.hpp>
+#   if BOOST_WORKAROUND(BOOST_MSVC, >= 1300)
+#       define BOOST_MPL_AUX_PP_COUNTER() __COUNTER__
+#   else
+#       define BOOST_MPL_AUX_PP_COUNTER() __LINE__
+#   endif
+#endif
+
+#endif // BOOST_MPL_AUX_CONFIG_PP_COUNTER_HPP_INCLUDED

include/boost/mpl/aux_/config/preprocessor.hpp

@@ -0,0 +1,39 @@
+
+#ifndef BOOST_MPL_AUX_CONFIG_PREPROCESSOR_HPP_INCLUDED
+#define BOOST_MPL_AUX_CONFIG_PREPROCESSOR_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: preprocessor.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/aux_/config/workaround.hpp>
+
+#if !defined(BOOST_MPL_CFG_BROKEN_PP_MACRO_EXPANSION) \
+    && (   BOOST_WORKAROUND(__MWERKS__, <= 0x3003) \
+        || BOOST_WORKAROUND(__BORLANDC__, < 0x582) \
+        || BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(502)) \
+        )
+
+#   define BOOST_MPL_CFG_BROKEN_PP_MACRO_EXPANSION
+
+#endif
+
+#if !defined(BOOST_MPL_CFG_NO_OWN_PP_PRIMITIVES)
+#   define BOOST_MPL_CFG_NO_OWN_PP_PRIMITIVES
+#endif
+
+#if !defined(BOOST_NEEDS_TOKEN_PASTING_OP_FOR_TOKENS_JUXTAPOSING) \
+    && BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840))
+#   define BOOST_NEEDS_TOKEN_PASTING_OP_FOR_TOKENS_JUXTAPOSING
+#endif
+
+
+#endif // BOOST_MPL_AUX_CONFIG_PREPROCESSOR_HPP_INCLUDED

include/boost/mpl/aux_/config/static_constant.hpp

@@ -0,0 +1,25 @@
+
+#ifndef BOOST_MPL_AUX_CONFIG_STATIC_CONSTANT_HPP_INCLUDED
+#define BOOST_MPL_AUX_CONFIG_STATIC_CONSTANT_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: static_constant.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#if !defined(BOOST_MPL_PREPROCESSING_MODE)
+// BOOST_STATIC_CONSTANT is defined here:
+#   include <boost/config.hpp>
+#else
+// undef the macro for the preprocessing mode
+#   undef BOOST_STATIC_CONSTANT
+#endif
+
+#endif // BOOST_MPL_AUX_CONFIG_STATIC_CONSTANT_HPP_INCLUDED

include/boost/mpl/aux_/config/ttp.hpp

@@ -0,0 +1,41 @@
+
+#ifndef BOOST_MPL_AUX_CONFIG_TTP_HPP_INCLUDED
+#define BOOST_MPL_AUX_CONFIG_TTP_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: ttp.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/aux_/config/msvc.hpp>
+#include <boost/mpl/aux_/config/gcc.hpp>
+#include <boost/mpl/aux_/config/workaround.hpp>
+
+#if !defined(BOOST_MPL_CFG_NO_TEMPLATE_TEMPLATE_PARAMETERS) \
+    && ( defined(BOOST_NO_TEMPLATE_TEMPLATES) \
+      || BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT( 0x590) ) \
+       )
+
+#   define BOOST_MPL_CFG_NO_TEMPLATE_TEMPLATE_PARAMETERS
+
+#endif
+
+
+#if    !defined(BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE) \
+    && (   BOOST_WORKAROUND(BOOST_MPL_CFG_GCC, BOOST_TESTED_AT(0x0302)) \
+        || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) \
+        )
+
+#   define BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING
+
+#endif
+
+#endif // BOOST_MPL_AUX_CONFIG_TTP_HPP_INCLUDED

include/boost/mpl/aux_/config/typeof.hpp

@@ -0,0 +1,38 @@
+
+#ifndef BOOST_MPL_AUX_CONFIG_TYPEOF_HPP_INCLUDED
+#define BOOST_MPL_AUX_CONFIG_TYPEOF_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2003-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: typeof.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/aux_/config/gcc.hpp>
+
+#if !defined(BOOST_MPL_CFG_HAS_TYPEOF) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE) \
+    && (   defined(BOOST_MPL_CFG_GCC) && BOOST_MPL_CFG_GCC >= 0x0302 \
+        || defined(__MWERKS__) && __MWERKS__ >= 0x3000 \
+        )
+
+#   define BOOST_MPL_CFG_HAS_TYPEOF
+
+#endif
+
+
+#if !defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE) \
+    && defined(BOOST_MPL_CFG_HAS_TYPEOF)
+
+#   define BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES
+
+#endif
+
+#endif // BOOST_MPL_AUX_CONFIG_TYPEOF_HPP_INCLUDED

include/boost/mpl/aux_/config/use_preprocessed.hpp

@@ -0,0 +1,19 @@
+
+#ifndef BOOST_MPL_AUX_CONFIG_USE_PREPROCESSED_HPP_INCLUDED
+#define BOOST_MPL_AUX_CONFIG_USE_PREPROCESSED_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: use_preprocessed.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+// #define BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS
+
+#endif // BOOST_MPL_AUX_CONFIG_USE_PREPROCESSED_HPP_INCLUDED

include/boost/mpl/aux_/config/workaround.hpp

@@ -0,0 +1,19 @@
+
+#ifndef BOOST_MPL_AUX_CONFIG_WORKAROUND_HPP_INCLUDED
+#define BOOST_MPL_AUX_CONFIG_WORKAROUND_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2002-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: workaround.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/detail/workaround.hpp>
+
+#endif // BOOST_MPL_AUX_CONFIG_WORKAROUND_HPP_INCLUDED

include/boost/mpl/aux_/contains_impl.hpp

@@ -0,0 +1,61 @@
+
+#ifndef BOOST_MPL_AUX_CONTAINS_IMPL_HPP_INCLUDED
+#define BOOST_MPL_AUX_CONTAINS_IMPL_HPP_INCLUDED
+
+// Copyright Eric Friedman 2002
+// Copyright Aleksey Gurtovoy 2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: contains_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/contains_fwd.hpp>
+#include <boost/mpl/begin_end.hpp>
+#include <boost/mpl/find.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/aux_/traits_lambda_spec.hpp>
+#include <boost/mpl/aux_/config/forwarding.hpp>
+#include <boost/mpl/aux_/config/static_constant.hpp>
+
+#include <boost/type_traits/is_same.hpp>
+
+namespace boost { namespace mpl {
+
+template< typename Tag >
+struct contains_impl
+{
+    template< typename Sequence, typename T > struct apply
+#if !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING)
+        : not_< is_same<
+              typename find<Sequence,T>::type
+            , typename end<Sequence>::type
+            > >
+    {
+#else
+    {
+        typedef not_< is_same<
+              typename find<Sequence,T>::type
+            , typename end<Sequence>::type
+            > > type;
+
+        BOOST_STATIC_CONSTANT(bool, value = 
+              (not_< is_same<
+                  typename find<Sequence,T>::type
+                , typename end<Sequence>::type
+                > >::value)
+            );
+#endif
+    };
+};
+
+BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(2,contains_impl)
+
+}}
+
+#endif // BOOST_MPL_AUX_CONTAINS_IMPL_HPP_INCLUDED

include/boost/mpl/aux_/count_args.hpp

@@ -0,0 +1,105 @@
+
+// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: count_args.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/preprocessor/expr_if.hpp>
+#include <boost/preprocessor/inc.hpp>
+#include <boost/preprocessor/cat.hpp>
+
+#if !defined(AUX778076_COUNT_ARGS_PARAM_NAME)
+#   define AUX778076_COUNT_ARGS_PARAM_NAME T
+#endif
+
+#if !defined(AUX778076_COUNT_ARGS_TEMPLATE_PARAM)
+#   define AUX778076_COUNT_ARGS_TEMPLATE_PARAM typename AUX778076_COUNT_ARGS_PARAM_NAME
+#endif
+
+// local macros, #undef-ined at the end of the header
+
+#if !defined(AUX778076_COUNT_ARGS_USE_STANDARD_PP_PRIMITIVES)
+
+#   include <boost/mpl/aux_/preprocessor/repeat.hpp>
+#   include <boost/mpl/aux_/preprocessor/params.hpp>
+
+#   define AUX778076_COUNT_ARGS_REPEAT BOOST_MPL_PP_REPEAT
+#   define AUX778076_COUNT_ARGS_PARAMS(param) \
+    BOOST_MPL_PP_PARAMS( \
+          AUX778076_COUNT_ARGS_ARITY \
+        , param \
+        ) \
+    /**/
+
+#else
+
+#   include <boost/preprocessor/enum_shifted_params.hpp>
+#   include <boost/preprocessor/repeat.hpp>
+#   include <boost/preprocessor/inc.hpp>
+
+#   define AUX778076_COUNT_ARGS_REPEAT BOOST_PP_REPEAT
+#   define AUX778076_COUNT_ARGS_PARAMS(param) \
+    BOOST_PP_ENUM_SHIFTED_PARAMS( \
+          BOOST_PP_INC(AUX778076_COUNT_ARGS_ARITY) \
+        , param \
+        ) \
+    /**/
+
+#endif // AUX778076_COUNT_ARGS_USE_STANDARD_PP_PRIMITIVES
+
+
+#define AUX778076_IS_ARG_TEMPLATE_NAME \
+    BOOST_PP_CAT(is_,BOOST_PP_CAT(AUX778076_COUNT_ARGS_PREFIX,_arg)) \
+/**/
+
+#define AUX778076_COUNT_ARGS_FUNC(unused, i, param) \
+    BOOST_PP_EXPR_IF(i, +) \
+    AUX778076_IS_ARG_TEMPLATE_NAME<BOOST_PP_CAT(param,BOOST_PP_INC(i))>::value \
+/**/
+
+// is_<xxx>_arg
+template< AUX778076_COUNT_ARGS_TEMPLATE_PARAM >
+struct AUX778076_IS_ARG_TEMPLATE_NAME
+{
+    BOOST_STATIC_CONSTANT(bool, value = true);
+};
+
+template<>
+struct AUX778076_IS_ARG_TEMPLATE_NAME<AUX778076_COUNT_ARGS_DEFAULT>
+{
+    BOOST_STATIC_CONSTANT(bool, value = false);
+};
+
+// <xxx>_count_args
+template<
+      AUX778076_COUNT_ARGS_PARAMS(AUX778076_COUNT_ARGS_TEMPLATE_PARAM)
+    >
+struct BOOST_PP_CAT(AUX778076_COUNT_ARGS_PREFIX,_count_args)
+{
+    BOOST_STATIC_CONSTANT(int, value = AUX778076_COUNT_ARGS_REPEAT(
+          AUX778076_COUNT_ARGS_ARITY
+        , AUX778076_COUNT_ARGS_FUNC
+        , AUX778076_COUNT_ARGS_PARAM_NAME
+        ));
+};
+
+#undef AUX778076_COUNT_ARGS_FUNC
+#undef AUX778076_IS_ARG_TEMPLATE_NAME
+#undef AUX778076_COUNT_ARGS_PARAMS
+#undef AUX778076_COUNT_ARGS_REPEAT
+
+#undef AUX778076_COUNT_ARGS_ARITY
+#undef AUX778076_COUNT_ARGS_DEFAULT
+#undef AUX778076_COUNT_ARGS_PREFIX
+#undef AUX778076_COUNT_ARGS_USE_STANDARD_PP_PRIMITIVES
+#undef AUX778076_COUNT_ARGS_TEMPLATE_PARAM
+#undef AUX778076_COUNT_ARGS_PARAM_NAME

include/boost/mpl/aux_/count_impl.hpp

@@ -0,0 +1,44 @@
+
+#ifndef BOOST_MPL_AUX_COUNT_IMPL_HPP_INCLUDED
+#define BOOST_MPL_AUX_COUNT_IMPL_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: count_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/count_fwd.hpp>
+#include <boost/mpl/count_if.hpp>
+#include <boost/mpl/same_as.hpp>
+#include <boost/mpl/aux_/config/static_constant.hpp>
+#include <boost/mpl/aux_/config/workaround.hpp>
+#include <boost/mpl/aux_/traits_lambda_spec.hpp>
+
+namespace boost { namespace mpl {
+
+template< typename Tag > struct count_impl
+{
+    template< typename Sequence, typename T > struct apply
+#if BOOST_WORKAROUND(__BORLANDC__,BOOST_TESTED_AT(0x561))
+    {
+        typedef typename count_if< Sequence,same_as<T> >::type type;
+        BOOST_STATIC_CONSTANT(int, value = BOOST_MPL_AUX_VALUE_WKND(type)::value);
+#else
+        : count_if< Sequence,same_as<T> >
+    {
+#endif
+    };
+};
+
+BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(2,count_impl)
+
+}}
+
+#endif // BOOST_MPL_AUX_COUNT_IMPL_HPP_INCLUDED

include/boost/mpl/aux_/empty_impl.hpp

@@ -0,0 +1,43 @@
+
+#ifndef BOOST_MPL_AUX_EMPTY_IMPL_HPP_INCLUDED
+#define BOOST_MPL_AUX_EMPTY_IMPL_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: empty_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/empty_fwd.hpp>
+#include <boost/mpl/begin_end.hpp>
+#include <boost/mpl/aux_/traits_lambda_spec.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+namespace boost { namespace mpl {
+
+// default implementation; conrete sequences might override it by 
+// specializing either the 'empty_impl' or the primary 'empty' template
+
+template< typename Tag >
+struct empty_impl
+{
+    template< typename Sequence > struct apply
+        : is_same<
+              typename begin<Sequence>::type
+            , typename end<Sequence>::type
+            >
+    {
+    };
+};
+
+BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(1,empty_impl)
+
+}}
+
+#endif // BOOST_MPL_AUX_EMPTY_IMPL_HPP_INCLUDED

include/boost/mpl/aux_/erase_impl.hpp

@@ -0,0 +1,69 @@
+
+#ifndef BOOST_MPL_AUX_ERASE_IMPL_HPP_INCLUDED
+#define BOOST_MPL_AUX_ERASE_IMPL_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: erase_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/clear.hpp>
+#include <boost/mpl/push_front.hpp>
+#include <boost/mpl/reverse_fold.hpp>
+#include <boost/mpl/iterator_range.hpp>
+#include <boost/mpl/next.hpp>
+#include <boost/mpl/aux_/na.hpp>
+
+namespace boost { namespace mpl {
+
+// default implementation; conrete sequences might override it by 
+// specializing either the 'erase_impl' or the primary 'erase' template
+
+template< typename Tag >
+struct erase_impl
+{
+    template<
+          typename Sequence
+        , typename First
+        , typename Last
+        >
+    struct apply
+    {
+        typedef typename if_na< Last,typename next<First>::type >::type last_;
+        
+        // 1st half: [begin, first)
+        typedef iterator_range<
+              typename begin<Sequence>::type
+            , First
+            > first_half_;
+
+        // 2nd half: [last, end) ... that is, [last + 1, end)
+        typedef iterator_range<
+              last_
+            , typename end<Sequence>::type
+            > second_half_;
+
+        typedef typename reverse_fold<
+              second_half_
+            , typename clear<Sequence>::type
+            , push_front<_,_>
+            >::type half_sequence_;
+
+        typedef typename reverse_fold<
+              first_half_
+            , half_sequence_
+            , push_front<_,_>
+            >::type type;
+    };
+};
+
+}}
+
+#endif // BOOST_MPL_AUX_ERASE_IMPL_HPP_INCLUDED

include/boost/mpl/aux_/erase_key_impl.hpp

@@ -0,0 +1,32 @@
+
+#ifndef BOOST_MPL_AUX_ERASE_KEY_IMPL_HPP_INCLUDED
+#define BOOST_MPL_AUX_ERASE_KEY_IMPL_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: erase_key_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/erase_key_fwd.hpp>
+#include <boost/mpl/aux_/traits_lambda_spec.hpp>
+
+namespace boost { namespace mpl {
+
+template< typename Tag >
+struct erase_key_impl
+{
+    template< typename Sequence, typename Key > struct apply;
+};
+
+BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(2, erase_key_impl)
+
+}}
+
+#endif // BOOST_MPL_AUX_ERASE_KEY_IMPL_HPP_INCLUDED

include/boost/mpl/aux_/filter_iter.hpp

@@ -0,0 +1,140 @@
+
+#ifndef BOOST_MPL_AUX_FILTER_ITER_HPP_INCLUDED
+#define BOOST_MPL_AUX_FILTER_ITER_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: filter_iter.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/find_if.hpp>
+#include <boost/mpl/iterator_range.hpp>
+#include <boost/mpl/iterator_tags.hpp>
+#include <boost/mpl/deref.hpp>
+#include <boost/mpl/aux_/lambda_spec.hpp>
+#include <boost/mpl/aux_/config/ctps.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+namespace boost { namespace mpl {
+
+namespace aux {
+
+template<
+      typename Iterator
+    , typename LastIterator
+    , typename Predicate
+    > 
+struct filter_iter;
+
+template<
+      typename Iterator
+    , typename LastIterator
+    , typename Predicate
+    >
+struct next_filter_iter
+{
+    typedef typename find_if<
+          iterator_range<Iterator,LastIterator>
+        , Predicate
+        >::type base_iter_;
+ 
+    typedef filter_iter<base_iter_,LastIterator,Predicate> type;
+};
+
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+template<
+      typename Iterator
+    , typename LastIterator
+    , typename Predicate
+    >
+struct filter_iter
+{
+    typedef Iterator base;
+    typedef forward_iterator_tag category;
+    typedef typename aux::next_filter_iter<
+          typename mpl::next<base>::type
+        , LastIterator
+        , Predicate
+        >::type next;
+    
+    typedef typename deref<base>::type type;
+};
+
+template<
+      typename LastIterator
+    , typename Predicate
+    >
+struct filter_iter< LastIterator,LastIterator,Predicate >
+{
+    typedef LastIterator base;
+    typedef forward_iterator_tag category;
+};
+
+#else
+
+template< bool >
+struct filter_iter_impl
+{
+    template<
+          typename Iterator
+        , typename LastIterator
+        , typename Predicate
+        >
+    struct result_
+    {
+        typedef Iterator base;
+        typedef forward_iterator_tag category;
+        typedef typename next_filter_iter<
+              typename mpl::next<Iterator>::type
+            , LastIterator
+            , Predicate
+            >::type next;
+        
+        typedef typename deref<base>::type type;
+    };
+};
+
+template<>
+struct filter_iter_impl< true >
+{
+    template<
+          typename Iterator
+        , typename LastIterator
+        , typename Predicate
+        >
+    struct result_
+    {
+        typedef Iterator base;
+        typedef forward_iterator_tag category;
+    };
+};
+
+template<
+      typename Iterator
+    , typename LastIterator
+    , typename Predicate
+    >
+struct filter_iter
+    : filter_iter_impl<
+          ::boost::is_same<Iterator,LastIterator>::value
+        >::template result_< Iterator,LastIterator,Predicate >
+{
+};
+
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+} // namespace aux
+
+BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(3, aux::filter_iter)
+
+}}
+
+#endif // BOOST_MPL_AUX_FILTER_ITER_HPP_INCLUDED

include/boost/mpl/aux_/find_if_pred.hpp

@@ -0,0 +1,31 @@
+
+#ifndef BOOST_MPL_AUX_FIND_IF_PRED_HPP_INCLUDED
+#define BOOST_MPL_AUX_FIND_IF_PRED_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+// Copyright Eric Friedman 2002
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+#include <boost/mpl/aux_/iter_apply.hpp>
+#include <boost/mpl/not.hpp>
+
+namespace boost { namespace mpl { namespace aux {
+
+template< typename Predicate >
+struct find_if_pred
+{
+    template< typename Iterator >
+    struct apply
+    {
+        typedef not_< aux::iter_apply1<Predicate,Iterator> > type;
+    };
+};
+
+}}}
+
+#endif // BOOST_MPL_AUX_FIND_IF_PRED_HPP_INCLUDED

include/boost/mpl/aux_/fold_impl.hpp

@@ -0,0 +1,43 @@
+
+#ifndef BOOST_MPL_AUX_FOLD_IMPL_HPP_INCLUDED
+#define BOOST_MPL_AUX_FOLD_IMPL_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: fold_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#if !defined(BOOST_MPL_PREPROCESSING_MODE)
+#   include <boost/mpl/next_prior.hpp>
+#   include <boost/mpl/apply.hpp>
+#   include <boost/mpl/deref.hpp>
+#   include <boost/mpl/aux_/config/ctps.hpp>
+#   if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#       include <boost/mpl/if.hpp>
+#       include <boost/type_traits/is_same.hpp>
+#   endif
+#endif
+
+#include <boost/mpl/aux_/config/use_preprocessed.hpp>
+
+#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE)
+
+#   define BOOST_MPL_PREPROCESSED_HEADER fold_impl.hpp
+#   include <boost/mpl/aux_/include_preprocessed.hpp>
+
+#else
+
+#   define AUX778076_FOLD_IMPL_OP(iter) typename deref<iter>::type
+#   define AUX778076_FOLD_IMPL_NAME_PREFIX fold
+#   include <boost/mpl/aux_/fold_impl_body.hpp>
+
+#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS
+#endif // BOOST_MPL_AUX_FOLD_IMPL_HPP_INCLUDED

include/boost/mpl/aux_/fold_impl_body.hpp

@@ -0,0 +1,365 @@
+
+// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION
+
+#if !defined(BOOST_PP_IS_ITERATING)
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: fold_impl_body.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#   include <boost/mpl/limits/unrolling.hpp>
+#   include <boost/mpl/aux_/preprocessor/repeat.hpp>
+#   include <boost/mpl/aux_/config/workaround.hpp>
+#   include <boost/mpl/aux_/config/ctps.hpp>
+#   include <boost/mpl/aux_/nttp_decl.hpp>
+#   include <boost/mpl/aux_/config/eti.hpp>
+
+#   include <boost/preprocessor/iterate.hpp>
+#   include <boost/preprocessor/dec.hpp>
+#   include <boost/preprocessor/cat.hpp>
+
+// local macros, #undef-ined at the end of the header
+
+#   define AUX778076_ITER_FOLD_STEP(unused, i, unused2) \
+    typedef typename apply2< \
+          ForwardOp \
+        , BOOST_PP_CAT(state,i) \
+        , AUX778076_FOLD_IMPL_OP(BOOST_PP_CAT(iter,i)) \
+        >::type BOOST_PP_CAT(state,BOOST_PP_INC(i)); \
+    typedef typename mpl::next<BOOST_PP_CAT(iter,i)>::type \
+        BOOST_PP_CAT(iter,BOOST_PP_INC(i)); \
+    /**/
+
+#   define AUX778076_FOLD_IMPL_NAME \
+    BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_impl) \
+    /**/
+
+#   define AUX778076_FOLD_CHUNK_NAME \
+    BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_chunk) \
+    /**/
+
+namespace boost { namespace mpl { namespace aux {
+
+/// forward declaration
+template<
+      BOOST_MPL_AUX_NTTP_DECL(int, N)
+    , typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    > 
+struct AUX778076_FOLD_IMPL_NAME;
+
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+#   if !BOOST_WORKAROUND(__BORLANDC__, < 0x600)
+
+#   define BOOST_PP_ITERATION_PARAMS_1 \
+    (3,(0, BOOST_MPL_LIMIT_UNROLLING, <boost/mpl/aux_/fold_impl_body.hpp>))
+#   include BOOST_PP_ITERATE()
+
+// implementation for N that exceeds BOOST_MPL_LIMIT_UNROLLING
+template<
+      BOOST_MPL_AUX_NTTP_DECL(int, N)
+    , typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    > 
+struct AUX778076_FOLD_IMPL_NAME
+{
+    typedef AUX778076_FOLD_IMPL_NAME<
+          BOOST_MPL_LIMIT_UNROLLING
+        , First
+        , Last
+        , State
+        , ForwardOp
+        > chunk_;
+
+    typedef AUX778076_FOLD_IMPL_NAME<
+          ( (N - BOOST_MPL_LIMIT_UNROLLING) < 0 ? 0 : N - BOOST_MPL_LIMIT_UNROLLING )
+        , typename chunk_::iterator
+        , Last
+        , typename chunk_::state
+        , ForwardOp
+        > res_;
+        
+    typedef typename res_::state state;
+    typedef typename res_::iterator iterator;
+};
+
+// fallback implementation for sequences of unknown size
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    > 
+struct AUX778076_FOLD_IMPL_NAME<-1,First,Last,State,ForwardOp>
+    : AUX778076_FOLD_IMPL_NAME<
+          -1
+        , typename mpl::next<First>::type
+        , Last
+        , typename apply2<ForwardOp,State,AUX778076_FOLD_IMPL_OP(First)>::type
+        , ForwardOp
+        >
+{
+};
+
+template<
+      typename Last
+    , typename State
+    , typename ForwardOp
+    > 
+struct AUX778076_FOLD_IMPL_NAME<-1,Last,Last,State,ForwardOp>
+{
+    typedef State state;
+    typedef Last iterator;
+};
+
+#   else // BOOST_WORKAROUND(__BORLANDC__, < 0x600)
+
+// Borland have some serious problems with the unrolled version, so
+// we always use a basic implementation
+template<
+      BOOST_MPL_AUX_NTTP_DECL(int, N)
+    , typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    > 
+struct AUX778076_FOLD_IMPL_NAME
+{
+    typedef AUX778076_FOLD_IMPL_NAME<
+          -1
+        , typename mpl::next<First>::type
+        , Last
+        , typename apply2<ForwardOp,State,AUX778076_FOLD_IMPL_OP(First)>::type
+        , ForwardOp
+        > res_;
+
+    typedef typename res_::state state;
+    typedef typename res_::iterator iterator;
+    typedef state type;
+};
+
+template<
+      BOOST_MPL_AUX_NTTP_DECL(int, N)
+     , typename Last
+    , typename State
+    , typename ForwardOp
+    > 
+struct AUX778076_FOLD_IMPL_NAME<N,Last,Last,State,ForwardOp >
+{
+    typedef State state;
+    typedef Last iterator;
+    typedef state type;
+};
+
+#   endif // BOOST_WORKAROUND(__BORLANDC__, < 0x600)
+ 
+#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+template< BOOST_MPL_AUX_NTTP_DECL(int, N) >
+struct AUX778076_FOLD_CHUNK_NAME;
+
+#   define BOOST_PP_ITERATION_PARAMS_1 \
+    (3,(0, BOOST_MPL_LIMIT_UNROLLING, <boost/mpl/aux_/fold_impl_body.hpp>))
+#   include BOOST_PP_ITERATE()
+
+// implementation for N that exceeds BOOST_MPL_LIMIT_UNROLLING
+template< BOOST_MPL_AUX_NTTP_DECL(int, N) > 
+struct AUX778076_FOLD_CHUNK_NAME
+{
+    template<
+          typename First
+        , typename Last
+        , typename State
+        , typename ForwardOp
+        > 
+    struct result_
+    {
+        typedef AUX778076_FOLD_IMPL_NAME<
+              BOOST_MPL_LIMIT_UNROLLING
+            , First
+            , Last
+            , State
+            , ForwardOp
+            > chunk_;
+
+        typedef AUX778076_FOLD_IMPL_NAME<
+              ( (N - BOOST_MPL_LIMIT_UNROLLING) < 0 ? 0 : N - BOOST_MPL_LIMIT_UNROLLING )
+            , typename chunk_::iterator
+            , Last
+            , typename chunk_::state
+            , ForwardOp
+            > res_;
+
+        typedef typename res_::state state;
+        typedef typename res_::iterator iterator;
+    };
+};
+
+// fallback implementation for sequences of unknown size
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    > 
+struct BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_step);
+
+template<
+      typename Last
+    , typename State
+    >
+struct BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_null_step)
+{
+    typedef Last iterator;
+    typedef State state;
+};
+
+template<> 
+struct AUX778076_FOLD_CHUNK_NAME<-1>
+{
+    template<
+          typename First
+        , typename Last
+        , typename State
+        , typename ForwardOp
+        > 
+    struct result_
+    {
+        typedef typename if_<
+              typename is_same<First,Last>::type
+            , BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_null_step)<Last,State>
+            , BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_step)<First,Last,State,ForwardOp>
+            >::type res_;
+
+        typedef typename res_::state state;
+        typedef typename res_::iterator iterator;
+    };
+
+#if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG)
+    /// ETI workaround
+    template<> struct result_<int,int,int,int>
+    {
+        typedef int state;
+        typedef int iterator;
+    };
+#endif
+};
+
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    > 
+struct BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_step)
+{
+    // can't inherit here - it breaks MSVC 7.0
+    typedef AUX778076_FOLD_CHUNK_NAME<-1>::template result_<
+          typename mpl::next<First>::type
+        , Last
+        , typename apply2<ForwardOp,State,AUX778076_FOLD_IMPL_OP(First)>::type
+        , ForwardOp
+        > chunk_;
+
+    typedef typename chunk_::state state;
+    typedef typename chunk_::iterator iterator;
+};
+
+template<
+      BOOST_MPL_AUX_NTTP_DECL(int, N)
+    , typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    > 
+struct AUX778076_FOLD_IMPL_NAME
+    : AUX778076_FOLD_CHUNK_NAME<N>
+        ::template result_<First,Last,State,ForwardOp>
+{
+};
+
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+}}}
+
+#   undef AUX778076_FOLD_IMPL_NAME
+#   undef AUX778076_FOLD_CHUNK_NAME
+#   undef AUX778076_ITER_FOLD_STEP
+
+#undef AUX778076_FOLD_IMPL_OP
+#undef AUX778076_FOLD_IMPL_NAME_PREFIX
+
+///// iteration
+
+#else
+
+#   define n_ BOOST_PP_FRAME_ITERATION(1)
+
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    >
+struct AUX778076_FOLD_IMPL_NAME<n_,First,Last,State,ForwardOp>
+{
+    typedef First iter0;
+    typedef State state0;
+
+    BOOST_MPL_PP_REPEAT(n_, AUX778076_ITER_FOLD_STEP, unused)
+
+    typedef BOOST_PP_CAT(state,n_) state;
+    typedef BOOST_PP_CAT(iter,n_) iterator;
+};
+
+#else
+
+template<> struct AUX778076_FOLD_CHUNK_NAME<n_>
+{
+    template<
+          typename First
+        , typename Last
+        , typename State
+        , typename ForwardOp
+        >
+    struct result_
+    {
+        typedef First iter0;
+        typedef State state0;
+
+        BOOST_MPL_PP_REPEAT(n_, AUX778076_ITER_FOLD_STEP, unused)
+
+        typedef BOOST_PP_CAT(state,n_) state;
+        typedef BOOST_PP_CAT(iter,n_) iterator;
+    };
+
+#if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG)
+    /// ETI workaround
+    template<> struct result_<int,int,int,int>
+    {
+        typedef int state;
+        typedef int iterator;
+    };
+#endif
+};
+
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+#   undef n_
+
+#endif // BOOST_PP_IS_ITERATING

include/boost/mpl/aux_/fold_op.hpp

@@ -0,0 +1,37 @@
+
+#ifndef BOOST_MPL_AUX_FOLD_OP_HPP_INCLUDED
+#define BOOST_MPL_AUX_FOLD_OP_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2001-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: fold_op.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/apply.hpp>
+
+namespace boost { namespace mpl { namespace aux {
+
+// hand-written version is more efficient than bind/lambda expression
+template< typename Op >
+struct fold_op
+{
+    template< typename T1, typename T2 > struct apply
+    {
+        typedef typename apply2<
+              Op
+            , T1
+            , typename T2::type
+            >::type type;
+    };
+};
+
+}}}
+
+#endif // BOOST_MPL_AUX_FOLD_OP_HPP_INCLUDED

include/boost/mpl/aux_/fold_pred.hpp

@@ -0,0 +1,37 @@
+
+#ifndef BOOST_MPL_AUX_FOLD_PRED_HPP_INCLUDED
+#define BOOST_MPL_AUX_FOLD_PRED_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2001-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: fold_pred.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/same_as.hpp>
+#include <boost/mpl/apply.hpp>
+
+namespace boost { namespace mpl { namespace aux {
+
+template< typename Last >
+struct fold_pred
+{
+    template<
+          typename State
+        , typename Iterator
+        >
+    struct apply
+        : not_same_as<Last>::template apply<Iterator>
+    {
+    };
+};
+
+}}}
+
+#endif // BOOST_MPL_AUX_FOLD_PRED_HPP_INCLUDED

include/boost/mpl/aux_/front_impl.hpp

@@ -0,0 +1,41 @@
+
+#ifndef BOOST_MPL_AUX_FRONT_IMPL_HPP_INCLUDED
+#define BOOST_MPL_AUX_FRONT_IMPL_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: front_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/front_fwd.hpp>
+#include <boost/mpl/begin_end.hpp>
+#include <boost/mpl/deref.hpp>
+#include <boost/mpl/aux_/traits_lambda_spec.hpp>
+
+namespace boost { namespace mpl {
+
+// default implementation; conrete sequences might override it by 
+// specializing either the 'front_impl' or the primary 'front' template
+
+template< typename Tag >
+struct front_impl
+{
+    template< typename Sequence > struct apply
+    {
+        typedef typename begin<Sequence>::type iter_;
+        typedef typename deref<iter_>::type type;
+    };
+};
+
+BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(1,front_impl)
+
+}}
+
+#endif // BOOST_MPL_AUX_FRONT_IMPL_HPP_INCLUDED

include/boost/mpl/aux_/full_lambda.hpp

@@ -0,0 +1,354 @@
+
+#if !defined(BOOST_PP_IS_ITERATING)
+
+///// header body
+
+#ifndef BOOST_MPL_AUX_FULL_LAMBDA_HPP_INCLUDED
+#define BOOST_MPL_AUX_FULL_LAMBDA_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2001-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: full_lambda.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#if !defined(BOOST_MPL_PREPROCESSING_MODE)
+#   include <boost/mpl/lambda_fwd.hpp>
+#   include <boost/mpl/bind_fwd.hpp>
+#   include <boost/mpl/protect.hpp>
+#   include <boost/mpl/quote.hpp>
+#   include <boost/mpl/arg.hpp>
+#   include <boost/mpl/bool.hpp>
+#   include <boost/mpl/int_fwd.hpp>
+#   include <boost/mpl/aux_/template_arity.hpp>
+#   include <boost/mpl/aux_/na_spec.hpp>
+#   include <boost/mpl/aux_/config/ttp.hpp>
+#   if defined(BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING)
+#       include <boost/mpl/if.hpp>
+#   endif
+#endif
+
+#include <boost/mpl/aux_/lambda_arity_param.hpp>
+#include <boost/mpl/aux_/config/use_preprocessed.hpp>
+
+#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE)
+
+#   define BOOST_MPL_PREPROCESSED_HEADER full_lambda.hpp
+#   include <boost/mpl/aux_/include_preprocessed.hpp>
+
+#else
+
+#   include <boost/mpl/limits/arity.hpp>
+#   include <boost/mpl/aux_/preprocessor/default_params.hpp>
+#   include <boost/mpl/aux_/preprocessor/params.hpp>
+#   include <boost/mpl/aux_/preprocessor/enum.hpp>
+#   include <boost/mpl/aux_/preprocessor/repeat.hpp>
+#   include <boost/mpl/aux_/config/dmc_ambiguous_ctps.hpp>
+
+#   include <boost/preprocessor/iterate.hpp>
+#   include <boost/preprocessor/comma_if.hpp>
+#   include <boost/preprocessor/inc.hpp>
+#   include <boost/preprocessor/cat.hpp>
+
+namespace boost { namespace mpl {
+
+// local macros, #undef-ined at the end of the header
+#   define AUX778076_LAMBDA_PARAMS(i_, param) \
+    BOOST_MPL_PP_PARAMS(i_, param) \
+    /**/
+
+#   define AUX778076_BIND_PARAMS(param) \
+    BOOST_MPL_PP_PARAMS( \
+          BOOST_MPL_LIMIT_METAFUNCTION_ARITY \
+        , param \
+        ) \
+    /**/
+
+#   define AUX778076_BIND_N_PARAMS(i_, param) \
+    BOOST_PP_COMMA_IF(i_) \
+    BOOST_MPL_PP_PARAMS(i_, param) \
+    /**/
+
+#   define AUX778076_ARITY_PARAM(param) \
+    BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(param) \
+    /**/
+
+
+#define n_ BOOST_MPL_LIMIT_METAFUNCTION_ARITY
+namespace aux {
+
+template<
+      BOOST_MPL_PP_DEFAULT_PARAMS(n_,bool C,false)
+    >
+struct lambda_or
+    : true_
+{
+};
+
+template<>
+struct lambda_or< BOOST_MPL_PP_ENUM(n_,false) >
+    : false_
+{
+};
+
+} // namespace aux
+#undef n_
+
+template<
+      typename T
+    , typename Tag
+    AUX778076_ARITY_PARAM(typename Arity)
+    >
+struct lambda
+{
+    typedef false_ is_le;
+    typedef T result_;
+    typedef T type;
+};
+
+template<
+      typename T
+    >
+struct is_lambda_expression
+    : lambda<T>::is_le
+{
+};
+
+
+template< int N, typename Tag >
+struct lambda< arg<N>,Tag AUX778076_ARITY_PARAM(int_<-1>) >
+{
+    typedef true_ is_le;
+    typedef mpl::arg<N> result_; // qualified for the sake of MIPSpro 7.41
+    typedef mpl::protect<result_> type; 
+};
+
+
+#define BOOST_PP_ITERATION_PARAMS_1 \
+    (3,(0, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, <boost/mpl/aux_/full_lambda.hpp>))
+#include BOOST_PP_ITERATE()
+
+/// special case for 'protect'
+template< typename T, typename Tag >
+struct lambda< mpl::protect<T>,Tag AUX778076_ARITY_PARAM(int_<1>) >
+{
+    typedef false_ is_le;
+    typedef mpl::protect<T> result_;
+    typedef result_ type;
+};
+
+/// specializations for the main 'bind' form
+template<
+      typename F, AUX778076_BIND_PARAMS(typename T)
+    , typename Tag
+    >
+struct lambda<
+          bind<F,AUX778076_BIND_PARAMS(T)>
+        , Tag
+        AUX778076_ARITY_PARAM(int_<BOOST_PP_INC(BOOST_MPL_LIMIT_METAFUNCTION_ARITY)>)
+        >
+{
+    typedef false_ is_le;
+    typedef bind<F, AUX778076_BIND_PARAMS(T)> result_;
+    typedef result_ type;
+};
+
+
+#if defined(BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING)
+
+template<
+      typename F
+    , typename Tag1
+    , typename Tag2
+    , typename Arity
+    >
+struct lambda<
+          lambda<F,Tag1,Arity>
+        , Tag2
+        , int_<3>
+        >
+{
+    typedef lambda< F,Tag2 > l1;
+    typedef lambda< Tag1,Tag2 > l2;
+
+    typedef typename l1::is_le is_le;
+    typedef bind1< quote1<aux::template_arity>, typename l1::result_ > arity_;
+    typedef lambda< typename if_<is_le,arity_,Arity>::type,Tag2 > l3;
+    
+    typedef aux::le_result3<is_le, Tag2, mpl::lambda, l1, l2, l3> le_result_;
+    typedef typename le_result_::result_ result_;
+    typedef typename le_result_::type type;
+};
+
+#elif !defined(BOOST_MPL_CFG_DMC_AMBIGUOUS_CTPS)
+
+/// workaround for MWCW 8.3+/EDG < 303, leads to ambiguity on Digital Mars
+template<
+      typename F, typename Tag1, typename Tag2
+    >
+struct lambda<
+          lambda< F,Tag1 >
+        , Tag2
+        >
+{
+    typedef lambda< F,Tag2 > l1;
+    typedef lambda< Tag1,Tag2 > l2;
+    
+    typedef typename l1::is_le is_le;
+    typedef aux::le_result2<is_le, Tag2, mpl::lambda, l1, l2> le_result_;
+    typedef typename le_result_::result_ result_;
+    typedef typename le_result_::type type;
+};
+
+#endif
+
+#   undef AUX778076_ARITY_PARAM
+#   undef AUX778076_BIND_N_PARAMS
+#   undef AUX778076_BIND_PARAMS
+#   undef AUX778076_LAMBDA_PARAMS
+
+#if !defined(BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING)
+BOOST_MPL_AUX_NA_SPEC(2, lambda)
+#else
+BOOST_MPL_AUX_NA_SPEC2(2, 3, lambda)
+#endif
+
+}}
+
+#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS
+#endif // BOOST_MPL_AUX_FULL_LAMBDA_HPP_INCLUDED
+
+///// iteration, depth == 1
+
+// For gcc 4.4 compatability, we must include the
+// BOOST_PP_ITERATION_DEPTH test inside an #else clause.
+#else // BOOST_PP_IS_ITERATING
+#if BOOST_PP_ITERATION_DEPTH() == 1
+#define i_ BOOST_PP_FRAME_ITERATION(1)
+
+#if i_ > 0
+
+namespace aux {
+
+#   define AUX778076_RESULT(unused, i_, T) \
+    BOOST_PP_COMMA_IF(i_) \
+    typename BOOST_PP_CAT(T, BOOST_PP_INC(i_))::result_ \
+    /**/
+
+#   define AUX778076_TYPE(unused, i_, T) \
+    BOOST_PP_COMMA_IF(i_) \
+    typename BOOST_PP_CAT(T, BOOST_PP_INC(i_))::type \
+    /**/
+
+template<
+      typename IsLE, typename Tag
+    , template< AUX778076_LAMBDA_PARAMS(i_, typename P) > class F
+    , AUX778076_LAMBDA_PARAMS(i_, typename L)
+    >
+struct BOOST_PP_CAT(le_result,i_)
+{
+    typedef F<
+          BOOST_MPL_PP_REPEAT(i_, AUX778076_TYPE, L)
+        > result_;
+    
+    typedef result_ type;
+};
+
+template<
+      typename Tag
+    , template< AUX778076_LAMBDA_PARAMS(i_, typename P) > class F
+    , AUX778076_LAMBDA_PARAMS(i_, typename L)
+    >
+struct BOOST_PP_CAT(le_result,i_)< true_,Tag,F,AUX778076_LAMBDA_PARAMS(i_, L) >
+{
+    typedef BOOST_PP_CAT(bind,i_)<
+          BOOST_PP_CAT(quote,i_)<F,Tag>
+        , BOOST_MPL_PP_REPEAT(i_, AUX778076_RESULT, L)
+        > result_;
+
+    typedef mpl::protect<result_> type;
+};
+
+#   undef AUX778076_TYPE
+#   undef AUX778076_RESULT
+
+} // namespace aux
+
+
+#   define AUX778076_LAMBDA_TYPEDEF(unused, i_, T) \
+    typedef lambda< BOOST_PP_CAT(T, BOOST_PP_INC(i_)), Tag > \
+        BOOST_PP_CAT(l,BOOST_PP_INC(i_)); \
+/**/
+
+#   define AUX778076_IS_LE_TYPEDEF(unused, i_, unused2) \
+    typedef typename BOOST_PP_CAT(l,BOOST_PP_INC(i_))::is_le \
+        BOOST_PP_CAT(is_le,BOOST_PP_INC(i_)); \
+/**/
+
+#   define AUX778076_IS_LAMBDA_EXPR(unused, i_, unused2) \
+    BOOST_PP_COMMA_IF(i_) \
+    BOOST_PP_CAT(is_le,BOOST_PP_INC(i_))::value \
+/**/
+
+template<
+      template< AUX778076_LAMBDA_PARAMS(i_, typename P) > class F
+    , AUX778076_LAMBDA_PARAMS(i_, typename T)
+    , typename Tag
+    >
+struct lambda< 
+          F<AUX778076_LAMBDA_PARAMS(i_, T)>
+        , Tag
+        AUX778076_ARITY_PARAM(int_<i_>)
+        >
+{
+    BOOST_MPL_PP_REPEAT(i_, AUX778076_LAMBDA_TYPEDEF, T)
+    BOOST_MPL_PP_REPEAT(i_, AUX778076_IS_LE_TYPEDEF, unused)
+
+    typedef typename aux::lambda_or<
+          BOOST_MPL_PP_REPEAT(i_, AUX778076_IS_LAMBDA_EXPR, unused)
+        >::type is_le;
+
+    typedef aux::BOOST_PP_CAT(le_result,i_)<
+          is_le, Tag, F, AUX778076_LAMBDA_PARAMS(i_, l)
+        > le_result_;
+    
+    typedef typename le_result_::result_ result_;
+    typedef typename le_result_::type type;
+};
+
+
+#   undef AUX778076_IS_LAMBDA_EXPR
+#   undef AUX778076_IS_LE_TYPEDEF
+#   undef AUX778076_LAMBDA_TYPEDEF
+
+#endif // i_ > 0
+
+template<
+      typename F AUX778076_BIND_N_PARAMS(i_, typename T)
+    , typename Tag
+    >
+struct lambda<
+          BOOST_PP_CAT(bind,i_)<F AUX778076_BIND_N_PARAMS(i_, T)>
+        , Tag
+        AUX778076_ARITY_PARAM(int_<BOOST_PP_INC(i_)>)
+        >
+{
+    typedef false_ is_le;
+    typedef BOOST_PP_CAT(bind,i_)<
+          F
+        AUX778076_BIND_N_PARAMS(i_, T)
+        > result_;
+        
+    typedef result_ type;
+};
+
+#undef i_
+#endif // BOOST_PP_ITERATION_DEPTH()
+#endif // BOOST_PP_IS_ITERATING

include/boost/mpl/aux_/has_apply.hpp

@@ -0,0 +1,32 @@
+
+#ifndef BOOST_MPL_AUX_HAS_APPLY_HPP_INCLUDED
+#define BOOST_MPL_AUX_HAS_APPLY_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: has_apply.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/has_xxx.hpp>
+#include <boost/mpl/aux_/config/has_apply.hpp>
+
+namespace boost { namespace mpl { namespace aux {
+#if !defined(BOOST_MPL_CFG_NO_HAS_APPLY)
+BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(has_apply, apply, false)
+#else
+template< typename T, typename fallback_ = false_ >
+struct has_apply
+    : fallback_
+{
+};
+#endif
+}}}
+
+#endif // BOOST_MPL_AUX_HAS_APPLY_HPP_INCLUDED

include/boost/mpl/aux_/has_begin.hpp

@@ -0,0 +1,23 @@
+
+#ifndef BOOST_MPL_AUX_HAS_BEGIN_HPP_INCLUDED
+#define BOOST_MPL_AUX_HAS_BEGIN_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2002-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: has_begin.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/has_xxx.hpp>
+
+namespace boost { namespace mpl { namespace aux {
+BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(has_begin, begin, true)
+}}}
+
+#endif // BOOST_MPL_AUX_HAS_BEGIN_HPP_INCLUDED

include/boost/mpl/aux_/has_key_impl.hpp

@@ -0,0 +1,34 @@
+
+#ifndef BOOST_MPL_AUX_HAS_KEY_IMPL_HPP_INCLUDED
+#define BOOST_MPL_AUX_HAS_KEY_IMPL_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2002-2004
+// Copyright David Abrahams 2003
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: has_key_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/has_key_fwd.hpp>
+#include <boost/mpl/aux_/traits_lambda_spec.hpp>
+
+namespace boost { namespace mpl {
+
+// no default implementation; the definition is needed to make MSVC happy 
+
+template< typename Tag > struct has_key_impl
+{
+    template< typename AssociativeSequence, typename Key > struct apply;
+};
+
+BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(2,has_key_impl)
+
+}}
+
+#endif // BOOST_MPL_AUX_HAS_KEY_IMPL_HPP_INCLUDED

include/boost/mpl/aux_/has_rebind.hpp

@@ -0,0 +1,99 @@
+
+#ifndef BOOST_MPL_AUX_HAS_REBIND_HPP_INCLUDED
+#define BOOST_MPL_AUX_HAS_REBIND_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2002-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: has_rebind.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/aux_/config/msvc.hpp>
+#include <boost/mpl/aux_/config/intel.hpp>
+#include <boost/mpl/aux_/config/workaround.hpp>
+
+#if BOOST_WORKAROUND(__EDG_VERSION__, <= 244) && !defined(BOOST_INTEL_CXX_VERSION)
+#   include <boost/mpl/has_xxx.hpp>
+#elif BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+#   include <boost/mpl/has_xxx.hpp>
+#   include <boost/mpl/if.hpp>
+#   include <boost/mpl/bool.hpp>
+#   include <boost/mpl/aux_/msvc_is_class.hpp>
+#elif BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610))
+#   include <boost/mpl/if.hpp>
+#   include <boost/mpl/bool.hpp>
+#   include <boost/mpl/aux_/yes_no.hpp>
+#   include <boost/mpl/aux_/config/static_constant.hpp>
+#   include <boost/type_traits/is_class.hpp>
+#else
+#   include <boost/mpl/aux_/type_wrapper.hpp>
+#   include <boost/mpl/aux_/yes_no.hpp>
+#   include <boost/mpl/aux_/config/static_constant.hpp>
+#endif
+
+namespace boost { namespace mpl { namespace aux {
+
+#if BOOST_WORKAROUND(__EDG_VERSION__, <= 244) && !defined(BOOST_INTEL_CXX_VERSION)
+
+BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(has_rebind, rebind, false)
+
+#elif BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+
+BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(has_rebind_impl, rebind, false)
+
+template< typename T >
+struct has_rebind
+    : if_< 
+          msvc_is_class<T>
+        , has_rebind_impl<T>
+        , bool_<false>
+        >::type
+{
+};
+
+#else // the rest
+
+template< typename T > struct has_rebind_tag {};
+no_tag operator|(has_rebind_tag<int>, void const volatile*);
+
+#   if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610))
+template< typename T >
+struct has_rebind
+{
+    static has_rebind_tag<T>* get();
+    BOOST_STATIC_CONSTANT(bool, value = 
+          sizeof(has_rebind_tag<int>() | get()) == sizeof(yes_tag)
+        );
+};
+#   else // __BORLANDC__
+template< typename T >
+struct has_rebind_impl
+{
+    static T* get();
+    BOOST_STATIC_CONSTANT(bool, value = 
+          sizeof(has_rebind_tag<int>() | get()) == sizeof(yes_tag)
+        );
+};
+
+template< typename T >
+struct has_rebind
+    : if_< 
+          is_class<T>
+        , has_rebind_impl<T>
+        , bool_<false>
+        >::type
+{
+};
+#   endif // __BORLANDC__
+
+#endif
+
+}}}
+
+#endif // BOOST_MPL_AUX_HAS_REBIND_HPP_INCLUDED

include/boost/mpl/aux_/has_size.hpp

@@ -0,0 +1,23 @@
+
+#ifndef BOOST_MPL_AUX_HAS_SIZE_HPP_INCLUDED
+#define BOOST_MPL_AUX_HAS_SIZE_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2002-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: has_size.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/has_xxx.hpp>
+
+namespace boost { namespace mpl { namespace aux {
+BOOST_MPL_HAS_XXX_TRAIT_DEF(size)
+}}}
+
+#endif // BOOST_MPL_AUX_HAS_SIZE_HPP_INCLUDED

include/boost/mpl/aux_/has_tag.hpp

@@ -0,0 +1,23 @@
+
+#ifndef BOOST_MPL_AUX_HAS_TAG_HPP_INCLUDED
+#define BOOST_MPL_AUX_HAS_TAG_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2002-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: has_tag.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/has_xxx.hpp>
+
+namespace boost { namespace mpl { namespace aux {
+BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(has_tag, tag, false)
+}}}
+
+#endif // BOOST_MPL_AUX_HAS_TAG_HPP_INCLUDED

include/boost/mpl/aux_/has_type.hpp

@@ -0,0 +1,23 @@
+
+#ifndef BOOST_MPL_AUX_HAS_TYPE_HPP_INCLUDED
+#define BOOST_MPL_AUX_HAS_TYPE_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2002-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: has_type.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/has_xxx.hpp>
+
+namespace boost { namespace mpl { namespace aux {
+BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(has_type, type, true)
+}}}
+
+#endif // BOOST_MPL_AUX_HAS_TYPE_HPP_INCLUDED

include/boost/mpl/aux_/include_preprocessed.hpp

@@ -0,0 +1,42 @@
+
+// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION
+
+// Copyright Aleksey Gurtovoy 2000-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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: include_preprocessed.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/aux_/config/compiler.hpp>
+#include <boost/mpl/aux_/config/preprocessor.hpp>
+#include <boost/mpl/aux_/config/workaround.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/stringize.hpp>
+
+#if !defined(BOOST_NEEDS_TOKEN_PASTING_OP_FOR_TOKENS_JUXTAPOSING)
+#   define AUX778076_PREPROCESSED_HEADER \
+    BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER \
+/**/
+#else
+#   define AUX778076_PREPROCESSED_HEADER \
+    BOOST_PP_CAT(BOOST_MPL_CFG_COMPILER_DIR,/)##BOOST_MPL_PREPROCESSED_HEADER \
+/**/
+#endif
+
+#if BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(700))
+#   define AUX778076_INCLUDE_STRING BOOST_PP_STRINGIZE(boost/mpl/aux_/preprocessed/AUX778076_PREPROCESSED_HEADER)
+#   include AUX778076_INCLUDE_STRING
+#   undef AUX778076_INCLUDE_STRING
+#else
+#   include BOOST_PP_STRINGIZE(boost/mpl/aux_/preprocessed/AUX778076_PREPROCESSED_HEADER)
+#endif
+
+#   undef AUX778076_PREPROCESSED_HEADER
+
+#undef BOOST_MPL_PREPROCESSED_HEADER

include/boost/mpl/aux_/insert_impl.hpp

@@ -0,0 +1,68 @@
+
+#ifndef BOOST_MPL_INSERT_IMPL_HPP_INCLUDED
+#define BOOST_MPL_INSERT_IMPL_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: insert_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/reverse_fold.hpp>
+#include <boost/mpl/iterator_range.hpp>
+#include <boost/mpl/clear.hpp>
+#include <boost/mpl/push_front.hpp>
+#include <boost/mpl/aux_/na_spec.hpp>
+#include <boost/mpl/aux_/traits_lambda_spec.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+namespace boost { namespace mpl {
+
+// default implementation; conrete sequences might override it by 
+// specializing either the 'insert_impl' or the primary 'insert' template
+
+template< typename Tag >
+struct insert_impl
+{
+    template<
+          typename Sequence
+        , typename Pos
+        , typename T
+        >
+    struct apply
+    {
+        typedef iterator_range<
+              typename begin<Sequence>::type
+            , Pos
+            > first_half_;
+
+        typedef iterator_range<
+              Pos
+            , typename end<Sequence>::type
+            > second_half_;
+
+        typedef typename reverse_fold<
+              second_half_
+            , typename clear<Sequence>::type
+            , push_front<_,_>
+            >::type half_sequence_;
+
+        typedef typename reverse_fold<
+              first_half_
+            , typename push_front<half_sequence_,T>::type
+            , push_front<_,_>
+            >::type type;
+    };
+};
+
+BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(3,insert_impl)
+
+}}
+
+#endif // BOOST_MPL_INSERT_IMPL_HPP_INCLUDED

include/boost/mpl/aux_/insert_range_impl.hpp

@@ -0,0 +1,77 @@
+
+#ifndef BOOST_MPL_AUX_INSERT_RANGE_IMPL_HPP_INCLUDED
+#define BOOST_MPL_AUX_INSERT_RANGE_IMPL_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: insert_range_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/copy.hpp>
+#include <boost/mpl/clear.hpp>
+#include <boost/mpl/front_inserter.hpp>
+#include <boost/mpl/joint_view.hpp>
+#include <boost/mpl/iterator_range.hpp>
+#include <boost/mpl/aux_/na_spec.hpp>
+#include <boost/mpl/aux_/iter_push_front.hpp>
+#include <boost/mpl/aux_/traits_lambda_spec.hpp>
+#include <boost/mpl/aux_/config/forwarding.hpp>
+
+#include <boost/type_traits/same_traits.hpp>
+
+namespace boost { namespace mpl {
+
+// default implementation; conrete sequences might override it by 
+// specializing either the 'insert_range_impl' or the primary 
+// 'insert_range' template
+
+
+template< typename Tag >
+struct insert_range_impl
+{
+    template<
+          typename Sequence
+        , typename Pos
+        , typename Range
+        >
+    struct apply
+#if !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING)
+        : reverse_copy<
+              joint_view< 
+                  iterator_range<typename begin<Sequence>::type,Pos>
+                , joint_view< 
+                      Range
+                    , iterator_range<Pos,typename end<Sequence>::type>
+                    >
+                >
+            , front_inserter< typename clear<Sequence>::type >
+            >
+    {
+#else
+    {
+        typedef typename reverse_copy<
+              joint_view< 
+                  iterator_range<typename begin<Sequence>::type,Pos>
+                , joint_view< 
+                      Range
+                    , iterator_range<Pos,typename end<Sequence>::type>
+                    >
+                >
+            , front_inserter< typename clear<Sequence>::type >
+            >::type type;
+#endif
+    };
+};
+
+BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(3,insert_range_impl)
+
+}}
+
+#endif // BOOST_MPL_AUX_INSERT_RANGE_IMPL_HPP_INCLUDED

include/boost/mpl/aux_/inserter_algorithm.hpp

@@ -0,0 +1,159 @@
+
+#ifndef BOOST_MPL_AUX_INSERTER_ALGORITHM_HPP_INCLUDED
+#define BOOST_MPL_AUX_INSERTER_ALGORITHM_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2003-2004
+// Copyright David Abrahams 2003-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: inserter_algorithm.hpp 55648 2009-08-18 05:16:53Z agurtovoy $
+// $Date: 2009-08-18 01:16:53 -0400 (Tue, 18 Aug 2009) $
+// $Revision: 55648 $
+
+#include <boost/mpl/back_inserter.hpp>
+#include <boost/mpl/front_inserter.hpp>
+#include <boost/mpl/push_back.hpp>
+#include <boost/mpl/push_front.hpp>
+#include <boost/mpl/back_inserter.hpp>
+#include <boost/mpl/front_inserter.hpp>
+#include <boost/mpl/clear.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/aux_/na.hpp>
+#include <boost/mpl/aux_/common_name_wknd.hpp>
+#include <boost/mpl/aux_/na_spec.hpp>
+#include <boost/mpl/aux_/preprocessor/params.hpp>
+#include <boost/mpl/aux_/preprocessor/default_params.hpp>
+#include <boost/mpl/aux_/config/ctps.hpp>
+
+#include <boost/preprocessor/arithmetic/dec.hpp>
+
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+#   define BOOST_MPL_AUX_INSERTER_ALGORITHM_DEF(arity, name) \
+BOOST_MPL_AUX_COMMON_NAME_WKND(name) \
+template< \
+      BOOST_MPL_PP_DEFAULT_PARAMS(arity, typename P, na) \
+    > \
+struct name \
+    : aux::name##_impl<BOOST_MPL_PP_PARAMS(arity, P)> \
+{ \
+}; \
+\
+template< \
+      BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), typename P) \
+    > \
+struct name< BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), P),na > \
+    : if_< has_push_back< typename clear<P1>::type> \
+        , aux::name##_impl< \
+              BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), P) \
+            , back_inserter< typename clear<P1>::type > \
+            > \
+        , aux::reverse_##name##_impl< \
+              BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), P) \
+            , front_inserter< typename clear<P1>::type > \
+            > \
+        >::type \
+{ \
+}; \
+\
+template< \
+      BOOST_MPL_PP_DEFAULT_PARAMS(arity, typename P, na) \
+    > \
+struct reverse_##name \
+    : aux::reverse_##name##_impl<BOOST_MPL_PP_PARAMS(arity, P)> \
+{ \
+}; \
+\
+template< \
+      BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), typename P) \
+    > \
+struct reverse_##name< BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), P),na > \
+    : if_< has_push_back<P1> \
+        , aux::reverse_##name##_impl< \
+              BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), P) \
+            , back_inserter< typename clear<P1>::type > \
+            > \
+        , aux::name##_impl< \
+              BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), P) \
+            , front_inserter< typename clear<P1>::type > \
+            > \
+        >::type \
+{ \
+}; \
+BOOST_MPL_AUX_NA_SPEC(arity, name) \
+BOOST_MPL_AUX_NA_SPEC(arity, reverse_##name) \
+/**/
+
+#else
+
+#   define BOOST_MPL_AUX_INSERTER_ALGORITHM_DEF(arity, name) \
+BOOST_MPL_AUX_COMMON_NAME_WKND(name) \
+template< \
+      BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), typename P) \
+    > \
+struct def_##name##_impl \
+    : if_< has_push_back<P1> \
+        , aux::name##_impl< \
+              BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), P) \
+            , back_inserter< typename clear<P1>::type > \
+            > \
+        , aux::reverse_##name##_impl< \
+              BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), P) \
+            , front_inserter< typename clear<P1>::type > \
+            > \
+        >::type \
+{ \
+}; \
+\
+template< \
+      BOOST_MPL_PP_DEFAULT_PARAMS(arity, typename P, na) \
+    > \
+struct name \
+{ \
+    typedef typename eval_if< \
+          is_na<BOOST_PP_CAT(P, arity)> \
+        , def_##name##_impl<BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), P)> \
+        , aux::name##_impl<BOOST_MPL_PP_PARAMS(arity, P)> \
+        >::type type; \
+}; \
+\
+template< \
+      BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), typename P) \
+    > \
+struct def_reverse_##name##_impl \
+    : if_< has_push_back<P1> \
+        , aux::reverse_##name##_impl< \
+              BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), P) \
+            , back_inserter< typename clear<P1>::type > \
+            > \
+        , aux::name##_impl< \
+              BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), P) \
+            , front_inserter< typename clear<P1>::type > \
+            > \
+        >::type \
+{ \
+}; \
+template< \
+      BOOST_MPL_PP_DEFAULT_PARAMS(arity, typename P, na) \
+    > \
+struct reverse_##name \
+{ \
+    typedef typename eval_if< \
+          is_na<BOOST_PP_CAT(P, arity)> \
+        , def_reverse_##name##_impl<BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), P)> \
+        , aux::reverse_##name##_impl<BOOST_MPL_PP_PARAMS(arity, P)> \
+        >::type type; \
+}; \
+BOOST_MPL_AUX_NA_SPEC(arity, name) \
+BOOST_MPL_AUX_NA_SPEC(arity, reverse_##name) \
+/**/
+
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+#endif // BOOST_MPL_AUX_INSERTER_ALGORITHM_HPP_INCLUDED

include/boost/mpl/aux_/integral_wrapper.hpp

@@ -0,0 +1,93 @@
+
+// Copyright Aleksey Gurtovoy 2000-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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: integral_wrapper.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION!
+
+#include <boost/mpl/integral_c_tag.hpp>
+#include <boost/mpl/aux_/static_cast.hpp>
+#include <boost/mpl/aux_/nttp_decl.hpp>
+#include <boost/mpl/aux_/config/static_constant.hpp>
+#include <boost/mpl/aux_/config/workaround.hpp>
+
+#include <boost/preprocessor/cat.hpp>
+
+#if !defined(AUX_WRAPPER_NAME)
+#   define AUX_WRAPPER_NAME BOOST_PP_CAT(AUX_WRAPPER_VALUE_TYPE,_)
+#endif
+
+#if !defined(AUX_WRAPPER_PARAMS)
+#   define AUX_WRAPPER_PARAMS(N) BOOST_MPL_AUX_NTTP_DECL(AUX_WRAPPER_VALUE_TYPE, N)
+#endif
+
+#if !defined(AUX_WRAPPER_INST)
+#   if BOOST_WORKAROUND(__MWERKS__, <= 0x2407)
+#       define AUX_WRAPPER_INST(value) AUX_WRAPPER_NAME< value >
+#   else 
+#       define AUX_WRAPPER_INST(value) BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::AUX_WRAPPER_NAME< value >
+#   endif
+#endif
+
+BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN
+
+template< AUX_WRAPPER_PARAMS(N) >
+struct AUX_WRAPPER_NAME
+{
+    BOOST_STATIC_CONSTANT(AUX_WRAPPER_VALUE_TYPE, value = N);
+// agurt, 08/mar/03: SGI MIPSpro C++ workaround, have to #ifdef because some 
+// other compilers (e.g. MSVC) are not particulary happy about it
+#if BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
+    typedef struct AUX_WRAPPER_NAME type;
+#else
+    typedef AUX_WRAPPER_NAME type;
+#endif
+    typedef AUX_WRAPPER_VALUE_TYPE value_type;
+    typedef integral_c_tag tag;
+
+// have to #ifdef here: some compilers don't like the 'N + 1' form (MSVC),
+// while some other don't like 'value + 1' (Borland), and some don't like
+// either
+#if BOOST_WORKAROUND(__EDG_VERSION__, <= 243)
+ private:
+    BOOST_STATIC_CONSTANT(AUX_WRAPPER_VALUE_TYPE, next_value = BOOST_MPL_AUX_STATIC_CAST(AUX_WRAPPER_VALUE_TYPE, (N + 1)));
+    BOOST_STATIC_CONSTANT(AUX_WRAPPER_VALUE_TYPE, prior_value = BOOST_MPL_AUX_STATIC_CAST(AUX_WRAPPER_VALUE_TYPE, (N - 1)));
+ public:
+    typedef AUX_WRAPPER_INST(next_value) next;
+    typedef AUX_WRAPPER_INST(prior_value) prior;
+#elif BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x561)) \
+    || BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(502)) \
+    || (BOOST_WORKAROUND(__HP_aCC, <= 53800) && (BOOST_WORKAROUND(__hpxstd98, != 1)))
+    typedef AUX_WRAPPER_INST( BOOST_MPL_AUX_STATIC_CAST(AUX_WRAPPER_VALUE_TYPE, (N + 1)) ) next;
+    typedef AUX_WRAPPER_INST( BOOST_MPL_AUX_STATIC_CAST(AUX_WRAPPER_VALUE_TYPE, (N - 1)) ) prior;
+#else
+    typedef AUX_WRAPPER_INST( BOOST_MPL_AUX_STATIC_CAST(AUX_WRAPPER_VALUE_TYPE, (value + 1)) ) next;
+    typedef AUX_WRAPPER_INST( BOOST_MPL_AUX_STATIC_CAST(AUX_WRAPPER_VALUE_TYPE, (value - 1)) ) prior;
+#endif
+
+    // enables uniform function call syntax for families of overloaded 
+    // functions that return objects of both arithmetic ('int', 'long',
+    // 'double', etc.) and wrapped integral types (for an example, see 
+    // "mpl/example/power.cpp")
+    operator AUX_WRAPPER_VALUE_TYPE() const { return static_cast<AUX_WRAPPER_VALUE_TYPE>(this->value); } 
+};
+
+#if !defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION)
+template< AUX_WRAPPER_PARAMS(N) >
+AUX_WRAPPER_VALUE_TYPE const AUX_WRAPPER_INST(N)::value;
+#endif
+
+BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE
+
+#undef AUX_WRAPPER_NAME
+#undef AUX_WRAPPER_PARAMS
+#undef AUX_WRAPPER_INST
+#undef AUX_WRAPPER_VALUE_TYPE

include/boost/mpl/aux_/is_msvc_eti_arg.hpp

@@ -0,0 +1,64 @@
+
+#ifndef BOOST_MPL_AUX_IS_MSVC_ETI_ARG_HPP_INCLUDED
+#define BOOST_MPL_AUX_IS_MSVC_ETI_ARG_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2001-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: is_msvc_eti_arg.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/aux_/yes_no.hpp>
+#include <boost/mpl/aux_/config/eti.hpp>
+#include <boost/mpl/aux_/config/static_constant.hpp>
+
+namespace boost { namespace mpl { namespace aux {
+
+#if defined(BOOST_MPL_CFG_MSVC_ETI_BUG)
+
+#if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG)
+
+template< typename T >
+struct is_msvc_eti_arg
+{ 
+    BOOST_STATIC_CONSTANT(bool, value = false);
+};
+
+#else // BOOST_MPL_CFG_MSVC_60_ETI_BUG
+
+struct eti_int_convertible
+{
+    eti_int_convertible(int);
+};
+
+template< typename T >
+struct is_msvc_eti_arg
+{ 
+    static no_tag test(...);
+    static yes_tag test(eti_int_convertible);
+    static T& get();
+
+    BOOST_STATIC_CONSTANT(bool, value = 
+          sizeof(test(get())) == sizeof(yes_tag)
+        );
+};
+
+#endif
+
+template<>
+struct is_msvc_eti_arg<int>
+{ 
+    BOOST_STATIC_CONSTANT(bool, value = true);
+};
+
+#endif // BOOST_MPL_CFG_MSVC_ETI_BUG
+
+}}}
+
+#endif // BOOST_MPL_AUX_IS_MSVC_ETI_ARG_HPP_INCLUDED

include/boost/mpl/aux_/iter_apply.hpp

@@ -0,0 +1,47 @@
+
+#ifndef BOOST_MPL_ITER_APPLY_HPP_INCLUDED
+#define BOOST_MPL_ITER_APPLY_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2002-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: iter_apply.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/apply.hpp>
+#include <boost/mpl/deref.hpp>
+
+namespace boost { namespace mpl { namespace aux {
+
+template<
+      typename F
+    , typename Iterator
+    >
+struct iter_apply1
+    : apply1< F,typename deref<Iterator>::type >
+{
+};
+
+template<
+      typename F
+    , typename Iterator1
+    , typename Iterator2
+    >
+struct iter_apply2
+    : apply2<
+          F
+        , typename deref<Iterator1>::type
+        , typename deref<Iterator2>::type
+        >
+{
+};
+
+}}}
+
+#endif // BOOST_MPL_ITER_APPLY_HPP_INCLUDED

include/boost/mpl/aux_/iter_fold_if_impl.hpp

@@ -0,0 +1,210 @@
+
+#ifndef BOOST_MPL_AUX_ITER_FOLD_IF_IMPL_HPP_INCLUDED
+#define BOOST_MPL_AUX_ITER_FOLD_IF_IMPL_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2001-2004
+// Copyright David Abrahams 2001-2002
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: iter_fold_if_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#if !defined(BOOST_MPL_PREPROCESSING_MODE)
+#   include <boost/mpl/identity.hpp>
+#   include <boost/mpl/next.hpp>
+#   include <boost/mpl/if.hpp>
+#   include <boost/mpl/apply.hpp>
+#   include <boost/mpl/aux_/value_wknd.hpp>
+#endif
+
+#include <boost/mpl/aux_/config/use_preprocessed.hpp>
+
+#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE)
+
+#   define BOOST_MPL_PREPROCESSED_HEADER iter_fold_if_impl.hpp
+#   include <boost/mpl/aux_/include_preprocessed.hpp>
+
+#else
+
+#   include <boost/mpl/limits/unrolling.hpp>
+#   include <boost/preprocessor/arithmetic/sub.hpp>
+#   include <boost/preprocessor/repeat.hpp>
+#   include <boost/preprocessor/inc.hpp>
+#   include <boost/preprocessor/dec.hpp>
+#   include <boost/preprocessor/cat.hpp>
+
+namespace boost { namespace mpl { namespace aux {
+
+template< typename Iterator, typename State >
+struct iter_fold_if_null_step
+{
+    typedef State state;
+    typedef Iterator iterator;
+};
+
+template< bool >
+struct iter_fold_if_step_impl
+{
+    template<
+          typename Iterator
+        , typename State
+        , typename StateOp
+        , typename IteratorOp
+        >
+    struct result_
+    {
+        typedef typename apply2<StateOp,State,Iterator>::type state;
+        typedef typename IteratorOp::type iterator;
+    };
+};
+
+template<>
+struct iter_fold_if_step_impl<false>
+{
+    template<
+          typename Iterator
+        , typename State
+        , typename StateOp
+        , typename IteratorOp
+        >
+    struct result_
+    {
+        typedef State state;
+        typedef Iterator iterator;
+    };
+};
+
+// agurt, 25/jun/02: MSVC 6.5 workaround, had to get rid of inheritance 
+// here and in 'iter_fold_if_backward_step', because sometimes it interfered 
+// with the "early template instantiation bug" in _really_ ugly ways
+template<
+      typename Iterator
+    , typename State
+    , typename ForwardOp
+    , typename Predicate
+    >
+struct iter_fold_if_forward_step
+{
+    typedef typename apply2<Predicate,State,Iterator>::type not_last;
+    typedef typename iter_fold_if_step_impl<
+          BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value
+        >::template result_< Iterator,State,ForwardOp,mpl::next<Iterator> > impl_;
+
+    typedef typename impl_::state state;
+    typedef typename impl_::iterator iterator;
+};
+
+template<
+      typename Iterator
+    , typename State
+    , typename BackwardOp
+    , typename Predicate
+    >
+struct iter_fold_if_backward_step
+{
+    typedef typename apply2<Predicate,State,Iterator>::type not_last;
+    typedef typename iter_fold_if_step_impl<
+          BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value
+        >::template result_< Iterator,State,BackwardOp,identity<Iterator> > impl_;
+
+    typedef typename impl_::state state;
+    typedef typename impl_::iterator iterator;
+};
+
+
+// local macros, #undef-ined at the end of the header
+
+#   define AUX_ITER_FOLD_FORWARD_STEP(unused, i, unused2) \
+    typedef iter_fold_if_forward_step< \
+          typename BOOST_PP_CAT(forward_step,i)::iterator \
+        , typename BOOST_PP_CAT(forward_step,i)::state \
+        , ForwardOp \
+        , ForwardPredicate \
+        > BOOST_PP_CAT(forward_step, BOOST_PP_INC(i)); \
+    /**/
+
+#   define AUX_ITER_FOLD_BACKWARD_STEP_FUNC(i) \
+    typedef iter_fold_if_backward_step< \
+          typename BOOST_PP_CAT(forward_step,BOOST_PP_DEC(i))::iterator \
+        , typename BOOST_PP_CAT(backward_step,i)::state \
+        , BackwardOp \
+        , BackwardPredicate \
+        > BOOST_PP_CAT(backward_step,BOOST_PP_DEC(i)); \
+    /**/
+
+#   define AUX_ITER_FOLD_BACKWARD_STEP(unused, i, unused2) \
+    AUX_ITER_FOLD_BACKWARD_STEP_FUNC( \
+        BOOST_PP_SUB_D(1,BOOST_MPL_LIMIT_UNROLLING,i) \
+        ) \
+    /**/
+
+#   define AUX_LAST_FORWARD_STEP \
+    BOOST_PP_CAT(forward_step, BOOST_MPL_LIMIT_UNROLLING) \
+    /**/
+
+#   define AUX_LAST_BACKWARD_STEP \
+    BOOST_PP_CAT(backward_step, BOOST_MPL_LIMIT_UNROLLING) \
+    /**/
+
+template<
+      typename Iterator
+    , typename State
+    , typename ForwardOp
+    , typename ForwardPredicate
+    , typename BackwardOp
+    , typename BackwardPredicate
+    >
+struct iter_fold_if_impl
+{
+ private:
+    typedef iter_fold_if_null_step<Iterator,State> forward_step0;
+    BOOST_PP_REPEAT(
+          BOOST_MPL_LIMIT_UNROLLING
+        , AUX_ITER_FOLD_FORWARD_STEP
+        , unused
+        )
+    
+    typedef typename if_<
+          typename AUX_LAST_FORWARD_STEP::not_last
+        , iter_fold_if_impl<
+              typename AUX_LAST_FORWARD_STEP::iterator
+            , typename AUX_LAST_FORWARD_STEP::state
+            , ForwardOp
+            , ForwardPredicate
+            , BackwardOp
+            , BackwardPredicate
+            >
+        , iter_fold_if_null_step<
+              typename AUX_LAST_FORWARD_STEP::iterator
+            , typename AUX_LAST_FORWARD_STEP::state
+            >
+        >::type AUX_LAST_BACKWARD_STEP;
+
+    BOOST_PP_REPEAT(
+          BOOST_MPL_LIMIT_UNROLLING
+        , AUX_ITER_FOLD_BACKWARD_STEP
+        , unused
+        )
+
+ public:
+    typedef typename backward_step0::state state;
+    typedef typename AUX_LAST_BACKWARD_STEP::iterator iterator;
+};
+
+#   undef AUX_LAST_BACKWARD_STEP
+#   undef AUX_LAST_FORWARD_STEP
+#   undef AUX_ITER_FOLD_BACKWARD_STEP
+#   undef AUX_ITER_FOLD_BACKWARD_STEP_FUNC
+#   undef AUX_ITER_FOLD_FORWARD_STEP
+
+}}}
+
+#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS
+#endif // BOOST_MPL_AUX_ITER_FOLD_IF_IMPL_HPP_INCLUDED

include/boost/mpl/aux_/iter_fold_impl.hpp

@@ -0,0 +1,42 @@
+
+#ifndef BOOST_MPL_AUX_ITER_FOLD_IMPL_HPP_INCLUDED
+#define BOOST_MPL_AUX_ITER_FOLD_IMPL_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: iter_fold_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#if !defined(BOOST_MPL_PREPROCESSING_MODE)
+#   include <boost/mpl/next_prior.hpp>
+#   include <boost/mpl/apply.hpp>
+#   include <boost/mpl/aux_/config/ctps.hpp>
+#   if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#       include <boost/mpl/if.hpp>
+#       include <boost/type_traits/is_same.hpp>
+#   endif
+#endif
+
+#include <boost/mpl/aux_/config/use_preprocessed.hpp>
+
+#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE)
+
+#   define BOOST_MPL_PREPROCESSED_HEADER iter_fold_impl.hpp
+#   include <boost/mpl/aux_/include_preprocessed.hpp>
+
+#else
+
+#   define AUX778076_FOLD_IMPL_OP(iter) iter
+#   define AUX778076_FOLD_IMPL_NAME_PREFIX iter_fold
+#   include <boost/mpl/aux_/fold_impl_body.hpp>
+
+#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS
+#endif // BOOST_MPL_AUX_ITER_FOLD_IMPL_HPP_INCLUDED

include/boost/mpl/aux_/iter_push_front.hpp

@@ -0,0 +1,36 @@
+
+#ifndef BOOST_MPL_ITER_PUSH_FRONT_HPP_INCLUDED
+#define BOOST_MPL_ITER_PUSH_FRONT_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2002-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: iter_push_front.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/push_front.hpp>
+#include <boost/mpl/deref.hpp>
+
+namespace boost { namespace mpl { namespace aux {
+
+template<
+      typename Sequence
+    , typename Iterator
+    >
+struct iter_push_front
+{
+    typedef typename push_front<
+          Sequence
+        , typename deref<Iterator>::type
+        >::type type;
+};
+
+}}}
+
+#endif // BOOST_MPL_ITER_PUSH_FRONT_HPP_INCLUDED

include/boost/mpl/aux_/joint_iter.hpp

@@ -0,0 +1,120 @@
+
+#ifndef BOOST_MPL_AUX_JOINT_ITER_HPP_INCLUDED
+#define BOOST_MPL_AUX_JOINT_ITER_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: joint_iter.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/next_prior.hpp>
+#include <boost/mpl/deref.hpp>
+#include <boost/mpl/iterator_tags.hpp>
+#include <boost/mpl/aux_/lambda_spec.hpp>
+#include <boost/mpl/aux_/config/ctps.hpp>
+
+#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#   include <boost/type_traits/is_same.hpp>
+#endif
+
+namespace boost { namespace mpl {
+
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+template<
+      typename Iterator1
+    , typename LastIterator1
+    , typename Iterator2
+    >
+struct joint_iter
+{
+    typedef Iterator1 base;
+    typedef forward_iterator_tag category;
+};
+
+template<
+      typename LastIterator1
+    , typename Iterator2
+    >
+struct joint_iter<LastIterator1,LastIterator1,Iterator2>
+{
+    typedef Iterator2 base;
+    typedef forward_iterator_tag category;
+};
+
+
+template< typename I1, typename L1, typename I2 >
+struct deref< joint_iter<I1,L1,I2> >
+{
+    typedef typename joint_iter<I1,L1,I2>::base base_;
+    typedef typename deref<base_>::type type;
+};
+
+template< typename I1, typename L1, typename I2 >
+struct next< joint_iter<I1,L1,I2> >
+{
+    typedef joint_iter< typename mpl::next<I1>::type,L1,I2 > type;
+};
+
+template< typename L1, typename I2 >
+struct next< joint_iter<L1,L1,I2> >
+{
+    typedef joint_iter< L1,L1,typename mpl::next<I2>::type > type;
+};
+
+#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+template<
+      typename Iterator1
+    , typename LastIterator1
+    , typename Iterator2
+    >
+struct joint_iter;
+
+template< bool > struct joint_iter_impl
+{
+    template< typename I1, typename L1, typename I2 > struct result_
+    {
+        typedef I1 base;
+        typedef forward_iterator_tag category;
+        typedef joint_iter< typename mpl::next<I1>::type,L1,I2 > next;
+        typedef typename deref<I1>::type type;
+    };
+};
+
+template<> struct joint_iter_impl<true>
+{
+    template< typename I1, typename L1, typename I2 > struct result_
+    {
+        typedef I2 base;
+        typedef forward_iterator_tag category;
+        typedef joint_iter< L1,L1,typename mpl::next<I2>::type > next;
+        typedef typename deref<I2>::type type;
+    };
+};
+
+template<
+      typename Iterator1
+    , typename LastIterator1
+    , typename Iterator2
+    >
+struct joint_iter
+    : joint_iter_impl< is_same<Iterator1,LastIterator1>::value >
+        ::template result_<Iterator1,LastIterator1,Iterator2>
+{
+};
+
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(3, joint_iter)
+
+}}
+
+#endif // BOOST_MPL_AUX_JOINT_ITER_HPP_INCLUDED

include/boost/mpl/aux_/lambda_arity_param.hpp

@@ -0,0 +1,25 @@
+
+#ifndef BOOST_MPL_AUX_LAMBDA_ARITY_PARAM_HPP_INCLUDED
+#define BOOST_MPL_AUX_LAMBDA_ARITY_PARAM_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2001-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: lambda_arity_param.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/aux_/config/ttp.hpp>
+
+#if !defined(BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING)
+#   define BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(param)    
+#else
+#   define BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(param) , param
+#endif
+
+#endif // BOOST_MPL_AUX_LAMBDA_ARITY_PARAM_HPP_INCLUDED

include/boost/mpl/aux_/lambda_no_ctps.hpp

@@ -0,0 +1,193 @@
+
+#if !defined(BOOST_PP_IS_ITERATING)
+
+///// header body
+
+#ifndef BOOST_MPL_AUX_LAMBDA_NO_CTPS_HPP_INCLUDED
+#define BOOST_MPL_AUX_LAMBDA_NO_CTPS_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: lambda_no_ctps.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#if !defined(BOOST_MPL_PREPROCESSING_MODE)
+#   include <boost/mpl/lambda_fwd.hpp>
+#   include <boost/mpl/bind_fwd.hpp>
+#   include <boost/mpl/protect.hpp>
+#   include <boost/mpl/is_placeholder.hpp>
+#   include <boost/mpl/if.hpp>
+#   include <boost/mpl/identity.hpp>
+#   include <boost/mpl/bool.hpp>
+#   include <boost/mpl/aux_/na_spec.hpp>
+#   include <boost/mpl/aux_/lambda_support.hpp>
+#   include <boost/mpl/aux_/template_arity.hpp>
+#   include <boost/mpl/aux_/value_wknd.hpp>
+#endif
+
+#include <boost/mpl/aux_/config/use_preprocessed.hpp>
+
+#if    !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE)
+
+#   define BOOST_MPL_PREPROCESSED_HEADER lambda_no_ctps.hpp
+#   include <boost/mpl/aux_/include_preprocessed.hpp>
+
+#else
+
+#   include <boost/mpl/limits/arity.hpp>
+#   include <boost/mpl/aux_/preprocessor/params.hpp>
+#   include <boost/mpl/aux_/preprocessor/default_params.hpp>
+#   include <boost/mpl/aux_/preprocessor/repeat.hpp>
+#   include <boost/mpl/aux_/preprocessor/enum.hpp>
+#   include <boost/mpl/aux_/config/msvc.hpp>
+#   include <boost/mpl/aux_/config/workaround.hpp>
+
+#   include <boost/preprocessor/comma_if.hpp>
+#   include <boost/preprocessor/iterate.hpp>
+#   include <boost/preprocessor/inc.hpp>
+#   include <boost/preprocessor/cat.hpp>
+
+namespace boost { namespace mpl {
+
+#   define AUX778076_LAMBDA_PARAMS(i_, param) \
+    BOOST_MPL_PP_PARAMS(i_, param) \
+    /**/
+
+namespace aux {
+
+#define n_ BOOST_MPL_LIMIT_METAFUNCTION_ARITY
+template<
+      BOOST_MPL_PP_DEFAULT_PARAMS(n_,bool C,false)
+    >
+struct lambda_or
+    : true_
+{
+};
+
+template<>
+struct lambda_or< BOOST_MPL_PP_ENUM(n_,false) >
+    : false_
+{
+};
+#undef n_
+
+template< typename Arity > struct lambda_impl
+{
+    template< typename T, typename Tag, typename Protect > struct result_
+    {
+        typedef T type;
+        typedef is_placeholder<T> is_le;
+    };
+};
+
+#define BOOST_PP_ITERATION_PARAMS_1 \
+    (3,(1, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, <boost/mpl/aux_/lambda_no_ctps.hpp>))
+#include BOOST_PP_ITERATE()
+
+} // namespace aux
+
+template<
+      typename T
+    , typename Tag
+    , typename Protect
+    >
+struct lambda
+{
+    /// Metafunction forwarding confuses MSVC 6.x
+    typedef typename aux::template_arity<T>::type arity_;
+    typedef typename aux::lambda_impl<arity_>
+        ::template result_< T,Tag,Protect > l_;
+
+    typedef typename l_::type type;
+    typedef typename l_::is_le is_le;
+    
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(3, lambda, (T, Tag, Protect))
+};
+
+BOOST_MPL_AUX_NA_SPEC2(1, 3, lambda)
+
+template<
+      typename T
+    >
+struct is_lambda_expression
+    : lambda<T>::is_le
+{
+};
+
+#   undef AUX778076_LAMBDA_PARAMS
+
+}}
+
+#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS
+#endif // BOOST_MPL_AUX_LAMBDA_NO_CTPS_HPP_INCLUDED
+
+///// iteration, depth == 1
+
+#else
+
+#define i_ BOOST_PP_FRAME_ITERATION(1)
+
+#   define AUX778076_LAMBDA_TYPEDEF(unused, i_, F) \
+    typedef lambda< \
+          typename F::BOOST_PP_CAT(arg,BOOST_PP_INC(i_)) \
+        , Tag \
+        , false_ \
+        > BOOST_PP_CAT(l,BOOST_PP_INC(i_)); \
+    /**/
+
+#   define AUX778076_IS_LE_TYPEDEF(unused, i_, unused2) \
+    typedef typename BOOST_PP_CAT(l,BOOST_PP_INC(i_))::is_le \
+        BOOST_PP_CAT(is_le,BOOST_PP_INC(i_)); \
+    /**/
+
+#   define AUX778076_IS_LAMBDA_EXPR(unused, i_, unused2) \
+    BOOST_PP_COMMA_IF(i_) \
+    BOOST_MPL_AUX_MSVC_VALUE_WKND(BOOST_PP_CAT(is_le,BOOST_PP_INC(i_)))::value \
+    /**/
+
+#   define AUX778076_LAMBDA_RESULT(unused, i_, unused2) \
+    , typename BOOST_PP_CAT(l,BOOST_PP_INC(i_))::type \
+    /**/
+
+template<> struct lambda_impl< int_<i_> >
+{
+    template< typename F, typename Tag, typename Protect > struct result_
+    {
+        BOOST_MPL_PP_REPEAT(i_, AUX778076_LAMBDA_TYPEDEF, F)
+        BOOST_MPL_PP_REPEAT(i_, AUX778076_IS_LE_TYPEDEF, unused)
+
+        typedef aux::lambda_or<
+              BOOST_MPL_PP_REPEAT(i_, AUX778076_IS_LAMBDA_EXPR, unused)
+            > is_le;
+
+        typedef BOOST_PP_CAT(bind,i_)<
+              typename F::rebind
+            BOOST_MPL_PP_REPEAT(i_, AUX778076_LAMBDA_RESULT, unused)
+            > bind_;
+
+        typedef typename if_<
+              is_le
+            , if_< Protect, mpl::protect<bind_>, bind_ >
+            , identity<F>
+            >::type type_;
+    
+        typedef typename type_::type type;
+    };
+};
+
+#   undef AUX778076_LAMBDA_RESULT
+#   undef AUX778076_IS_LAMBDA_EXPR
+#   undef AUX778076_IS_LE_TYPEDEF
+#   undef AUX778076_LAMBDA_TYPEDEF
+
+#undef i_
+
+#endif // BOOST_PP_IS_ITERATING

include/boost/mpl/aux_/lambda_spec.hpp

@@ -0,0 +1,49 @@
+
+#ifndef BOOST_MPL_AUX_LAMBDA_SPEC_HPP_INCLUDED
+#define BOOST_MPL_AUX_LAMBDA_SPEC_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2001-2007
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: lambda_spec.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/void.hpp>
+#include <boost/mpl/lambda_fwd.hpp>
+#include <boost/mpl/int_fwd.hpp>
+#include <boost/mpl/aux_/preprocessor/params.hpp>
+#include <boost/mpl/aux_/lambda_arity_param.hpp>
+#include <boost/mpl/aux_/config/lambda.hpp>
+
+#if !defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT)
+
+#   define BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(i, name) \
+template< \
+      BOOST_MPL_PP_PARAMS(i, typename T) \
+    , typename Tag \
+    > \
+struct lambda< \
+      name< BOOST_MPL_PP_PARAMS(i, T) > \
+    , Tag \
+    BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(int_<i>) \
+    > \
+{ \
+    typedef false_ is_le; \
+    typedef name< BOOST_MPL_PP_PARAMS(i, T) > result_; \
+    typedef result_ type; \
+}; \
+/**/
+
+#else
+
+#   define BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(i, name) /**/
+
+#endif
+
+#endif // BOOST_MPL_AUX_LAMBDA_SPEC_HPP_INCLUDED

include/boost/mpl/aux_/lambda_support.hpp

@@ -0,0 +1,169 @@
+
+#ifndef BOOST_MPL_AUX_LAMBDA_SUPPORT_HPP_INCLUDED
+#define BOOST_MPL_AUX_LAMBDA_SUPPORT_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2001-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: lambda_support.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/aux_/config/lambda.hpp>
+
+#if !defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT)
+
+#   define BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(i, name, params) /**/
+#   define BOOST_MPL_AUX_LAMBDA_SUPPORT(i,name,params) /**/
+
+#else
+
+#   include <boost/mpl/int_fwd.hpp>
+#   include <boost/mpl/aux_/yes_no.hpp>
+#   include <boost/mpl/aux_/na_fwd.hpp>
+#   include <boost/mpl/aux_/preprocessor/params.hpp>
+#   include <boost/mpl/aux_/preprocessor/enum.hpp>
+#   include <boost/mpl/aux_/config/msvc.hpp>
+#   include <boost/mpl/aux_/config/workaround.hpp>
+
+#   include <boost/preprocessor/tuple/to_list.hpp>
+#   include <boost/preprocessor/list/for_each_i.hpp>
+#   include <boost/preprocessor/inc.hpp>
+#   include <boost/preprocessor/cat.hpp>
+
+#   define BOOST_MPL_AUX_LAMBDA_SUPPORT_ARG_TYPEDEF_FUNC(R,typedef_,i,param) \
+    typedef_ param BOOST_PP_CAT(arg,BOOST_PP_INC(i)); \
+    /**/
+
+// agurt, 07/mar/03: restore an old revision for the sake of SGI MIPSpro C++
+#if BOOST_WORKAROUND(__EDG_VERSION__, <= 238) 
+
+#   define BOOST_MPL_AUX_LAMBDA_SUPPORT(i, name, params) \
+    typedef BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::int_<i> arity; \
+    BOOST_PP_LIST_FOR_EACH_I_R( \
+          1 \
+        , BOOST_MPL_AUX_LAMBDA_SUPPORT_ARG_TYPEDEF_FUNC \
+        , typedef \
+        , BOOST_PP_TUPLE_TO_LIST(i,params) \
+        ) \
+    struct rebind \
+    { \
+        template< BOOST_MPL_PP_PARAMS(i,typename U) > struct apply \
+            : name< BOOST_MPL_PP_PARAMS(i,U) > \
+        { \
+        }; \
+    }; \
+    /**/
+
+#   define BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(i, name, params) \
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(i, name, params) \
+    /**/
+
+#elif BOOST_WORKAROUND(__EDG_VERSION__, <= 244) && !defined(BOOST_INTEL_CXX_VERSION)
+// agurt, 18/jan/03: old EDG-based compilers actually enforce 11.4 para 9
+// (in strict mode), so we have to provide an alternative to the 
+// MSVC-optimized implementation
+
+#   define BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(i, name, params) \
+    typedef BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::int_<i> arity; \
+    BOOST_PP_LIST_FOR_EACH_I_R( \
+          1 \
+        , BOOST_MPL_AUX_LAMBDA_SUPPORT_ARG_TYPEDEF_FUNC \
+        , typedef \
+        , BOOST_PP_TUPLE_TO_LIST(i,params) \
+        ) \
+    struct rebind; \
+/**/
+
+#   define BOOST_MPL_AUX_LAMBDA_SUPPORT(i, name, params) \
+    BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(i, name, params) \
+}; \
+template< BOOST_MPL_PP_PARAMS(i,typename T) > \
+struct name<BOOST_MPL_PP_PARAMS(i,T)>::rebind \
+{ \
+    template< BOOST_MPL_PP_PARAMS(i,typename U) > struct apply \
+        : name< BOOST_MPL_PP_PARAMS(i,U) > \
+    { \
+    }; \
+/**/
+
+#else // __EDG_VERSION__
+
+namespace boost { namespace mpl { namespace aux {
+template< typename T > struct has_rebind_tag;
+}}}
+
+#   define BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(i, name, params) \
+    typedef BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::int_<i> arity; \
+    BOOST_PP_LIST_FOR_EACH_I_R( \
+          1 \
+        , BOOST_MPL_AUX_LAMBDA_SUPPORT_ARG_TYPEDEF_FUNC \
+        , typedef \
+        , BOOST_PP_TUPLE_TO_LIST(i,params) \
+        ) \
+    friend class BOOST_PP_CAT(name,_rebind); \
+    typedef BOOST_PP_CAT(name,_rebind) rebind; \
+/**/
+
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610))
+#   define BOOST_MPL_AUX_LAMBDA_SUPPORT_HAS_REBIND(i, name, params) \
+template< BOOST_MPL_PP_PARAMS(i,typename T) > \
+::boost::mpl::aux::yes_tag operator|( \
+      ::boost::mpl::aux::has_rebind_tag<int> \
+    , name<BOOST_MPL_PP_PARAMS(i,T)>* \
+    ); \
+::boost::mpl::aux::no_tag operator|( \
+      ::boost::mpl::aux::has_rebind_tag<int> \
+    , name< BOOST_MPL_PP_ENUM(i,::boost::mpl::na) >* \
+    ); \
+/**/
+#elif !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+#   define BOOST_MPL_AUX_LAMBDA_SUPPORT_HAS_REBIND(i, name, params) \
+template< BOOST_MPL_PP_PARAMS(i,typename T) > \
+::boost::mpl::aux::yes_tag operator|( \
+      ::boost::mpl::aux::has_rebind_tag<int> \
+    , ::boost::mpl::aux::has_rebind_tag< name<BOOST_MPL_PP_PARAMS(i,T)> >* \
+    ); \
+/**/
+#else
+#   define BOOST_MPL_AUX_LAMBDA_SUPPORT_HAS_REBIND(i, name, params) /**/
+#endif
+
+#   if !defined(__BORLANDC__)
+#   define BOOST_MPL_AUX_LAMBDA_SUPPORT(i, name, params) \
+    BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(i, name, params) \
+}; \
+BOOST_MPL_AUX_LAMBDA_SUPPORT_HAS_REBIND(i, name, params) \
+class BOOST_PP_CAT(name,_rebind) \
+{ \
+ public: \
+    template< BOOST_MPL_PP_PARAMS(i,typename U) > struct apply \
+        : name< BOOST_MPL_PP_PARAMS(i,U) > \
+    { \
+    }; \
+/**/
+#   else
+#   define BOOST_MPL_AUX_LAMBDA_SUPPORT(i, name, params) \
+    BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(i, name, params) \
+}; \
+BOOST_MPL_AUX_LAMBDA_SUPPORT_HAS_REBIND(i, name, params) \
+class BOOST_PP_CAT(name,_rebind) \
+{ \
+ public: \
+    template< BOOST_MPL_PP_PARAMS(i,typename U) > struct apply \
+    { \
+        typedef typename name< BOOST_MPL_PP_PARAMS(i,U) >::type type; \
+    }; \
+/**/
+#   endif // __BORLANDC__
+
+#endif // __EDG_VERSION__
+
+#endif // BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT
+
+#endif // BOOST_MPL_AUX_LAMBDA_SUPPORT_HPP_INCLUDED

include/boost/mpl/aux_/largest_int.hpp

@@ -0,0 +1,63 @@
+
+#ifndef BOOST_MPL_AUX_LARGEST_INT_HPP_INCLUDED
+#define BOOST_MPL_AUX_LARGEST_INT_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: largest_int.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/aux_/config/integral.hpp>
+#include <boost/config.hpp>
+
+namespace boost { namespace mpl { namespace aux {
+
+template< typename T > struct integral_rank;
+
+template<> struct integral_rank<bool>           : int_<1> {};
+template<> struct integral_rank<signed char>    : int_<2> {};
+template<> struct integral_rank<char>           : int_<3> {};
+template<> struct integral_rank<unsigned char>  : int_<4> {};
+#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+template<> struct integral_rank<wchar_t>        : int_<5> {};
+#endif
+template<> struct integral_rank<short>          : int_<6> {};
+template<> struct integral_rank<unsigned short> : int_<7> {};
+template<> struct integral_rank<int>            : int_<8> {};
+template<> struct integral_rank<unsigned int>   : int_<9> {};
+template<> struct integral_rank<long>           : int_<10> {};
+template<> struct integral_rank<unsigned long>  : int_<11> {};
+
+#if defined(BOOST_HAS_LONG_LONG)
+template<> struct integral_rank<long_long_type> : int_<12> {};
+template<> struct integral_rank<ulong_long_type>: int_<13> {};
+#endif
+
+template< typename T1, typename T2 > struct largest_int
+#if !defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC)
+    : if_c< 
+          ( integral_rank<T1>::value >= integral_rank<T2>::value )
+        , T1
+        , T2
+        >
+{
+#else
+{
+    enum { rank1 = integral_rank<T1>::value };
+    enum { rank2 = integral_rank<T2>::value };
+    typedef typename if_c< (rank1 >= rank2),T1,T2 >::type type;
+#endif
+};
+
+}}}
+
+#endif // BOOST_MPL_AUX_LARGEST_INT_HPP_INCLUDED