Merge from Trunk

[SVN r49251]

include/boost/fusion/container/list/detail/at_impl.hpp

@@ -1,7 +1,7 @@
 /*=============================================================================
     Copyright (c) 2001-2006 Joel de Guzman
 
-    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    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)
 ==============================================================================*/
 #if !defined(FUSION_AT_IMPL_07172005_0726)
@@ -15,6 +15,71 @@
 
 namespace boost { namespace fusion
 {
+    namespace detail
+    {
+        template <typename Cons>
+        struct cons_deref
+        {
+            typedef typename Cons::car_type type;
+        };
+
+        template <typename Cons, int I>
+        struct cons_advance
+        {
+            typedef typename
+                cons_advance<Cons, I-1>::type::cdr_type
+            type;
+        };
+
+        template <typename Cons>
+        struct cons_advance<Cons, 0>
+        {
+            typedef Cons type;
+        };
+
+        template <typename Cons>
+        struct cons_advance<Cons, 1>
+        {
+            typedef typename Cons::cdr_type type;
+        };
+
+        template <typename Cons>
+        struct cons_advance<Cons, 2>
+        {
+#if BOOST_WORKAROUND(BOOST_MSVC, > 1400) // VC8 and above
+            typedef typename Cons::cdr_type::cdr_type type;
+#else
+            typedef typename Cons::cdr_type _a;
+            typedef typename _a::cdr_type type;
+#endif
+        };
+
+        template <typename Cons>
+        struct cons_advance<Cons, 3>
+        {
+#if BOOST_WORKAROUND(BOOST_MSVC, > 1400) // VC8 and above
+            typedef typename Cons::cdr_type::cdr_type::cdr_type type;
+#else
+            typedef typename Cons::cdr_type _a;
+            typedef typename _a::cdr_type _b;
+            typedef typename _b::cdr_type type;
+#endif
+        };
+
+        template <typename Cons>
+        struct cons_advance<Cons, 4>
+        {
+#if BOOST_WORKAROUND(BOOST_MSVC, > 1400) // VC8 and above
+            typedef typename Cons::cdr_type::cdr_type::cdr_type::cdr_type type;
+#else
+            typedef typename Cons::cdr_type _a;
+            typedef typename _a::cdr_type _b;
+            typedef typename _b::cdr_type _c;
+            typedef typename _c::cdr_type type;
+#endif
+        };
+    }
+
     struct cons_tag;
 
     namespace extension
@@ -26,22 +91,10 @@ namespace boost { namespace fusion
         struct at_impl<cons_tag>
         {
             template <typename Sequence, typename N>
-            struct apply 
+            struct apply
             {
-                typedef typename
+                typedef detail::cons_deref<
-                    mpl::eval_if<
+                    typename detail::cons_advance<Sequence, N::value>::type>
-                        is_const<Sequence>
-                      , add_const<typename Sequence::cdr_type>
-                      , mpl::identity<typename Sequence::cdr_type>
-                    >::type
-                cdr_type;
-
-                typedef typename 
-                    mpl::eval_if<
-                        mpl::bool_<N::value == 0>
-                      , mpl::identity<typename Sequence::car_type>
-                      , apply<cdr_type, mpl::int_<N::value-1> >
-                    >
                 element;
 
                 typedef typename

include/boost/fusion/functional/invocation/invoke.hpp

@@ -1,8 +1,8 @@
 /*=============================================================================
-    Copyright (c) 2005-2006 João Abecasis
+    Copyright (c) 2005-2006 Joao Abecasis
     Copyright (c) 2006-2007 Tobias Schwinger
-  
+
-    Use modification and distribution are subject to the Boost Software 
+    Use modification and distribution are subject to the Boost Software
     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
     http://www.boost.org/LICENSE_1_0.txt).
 ==============================================================================*/
@@ -71,21 +71,21 @@ namespace boost { namespace fusion
     {
         namespace ft = function_types;
 
-        template< 
+        template<
-            typename Function, class Sequence, 
+            typename Function, class Sequence,
             int N = result_of::size<Sequence>::value,
             bool CBI = ft::is_callable_builtin<Function>::value,
             bool RandomAccess = traits::is_random_access<Sequence>::value
             >
         struct invoke_impl;
 
-        template <class Sequence, int N> 
+        template <class Sequence, int N>
         struct invoke_param_types;
 
         template <typename T, class Sequence>
         struct invoke_data_member;
 
-        template <typename Function, class Sequence, int N, bool RandomAccess> 
+        template <typename Function, class Sequence, int N, bool RandomAccess>
         struct invoke_mem_fn;
 
         #define  BOOST_PP_FILENAME_1 <boost/fusion/functional/invocation/invoke.hpp>
@@ -116,7 +116,7 @@ namespace boost { namespace fusion
                     invoke_mem_fn<Function,Sequence,1,RandomAccess>,
                     invoke_data_member<Function, Sequence> >,
                 mpl::identity< invoke_nonmember_builtin<
-                    Function,Sequence,1,RandomAccess> > 
+                    Function,Sequence,1,RandomAccess> >
             >::type
         { };
 
@@ -139,7 +139,7 @@ namespace boost { namespace fusion
 
         public:
 
-            typedef typename boost::add_reference<qualified_type>::type 
+            typedef typename boost::add_reference<qualified_type>::type
                 result_type;
 
             static inline result_type call(T C::* f, Sequence & s)
@@ -154,10 +154,10 @@ namespace boost { namespace fusion
     {
         template <typename Function, class Sequence> struct invoke
         {
-            typedef typename detail::invoke_impl< 
+            typedef typename detail::invoke_impl<
                 typename boost::remove_reference<Function>::type, Sequence
               >::result_type type;
-        }; 
+        };
     }
 
     template <typename Function, class Sequence>
@@ -242,7 +242,7 @@ namespace boost { namespace fusion
         public:
 
             typedef typename boost::result_of<
-                Function(BOOST_PP_ENUM_PARAMS(N,typename seq::T)) 
+                Function(BOOST_PP_ENUM_PARAMS(N,typename seq::T))
                 >::type result_type;
 
             template <typename F>
@@ -274,7 +274,7 @@ namespace boost { namespace fusion
                 typename seq::I0 i0 = fusion::begin(s);
                 BOOST_PP_REPEAT_FROM_TO(1,N,M,~)
 
-                return (that_ptr< typename mpl::front< 
+                return (that_ptr< typename mpl::front<
                                       ft::parameter_types<Function> >::type
                     >::get(*i0)->*f)(BOOST_PP_ENUM_SHIFTED_PARAMS(N,*i));
             }
@@ -302,5 +302,5 @@ namespace boost { namespace fusion
 
 #undef N
 #endif // defined(BOOST_PP_IS_ITERATING)
-#endif 
+#endif
 

include/boost/fusion/functional/invocation/invoke_function_object.hpp

@@ -1,8 +1,8 @@
 /*=============================================================================
-    Copyright (c) 2005-2006 João Abecasis
+    Copyright (c) 2005-2006 Joao Abecasis
     Copyright (c) 2006-2007 Tobias Schwinger
-  
+
-    Use modification and distribution are subject to the Boost Software 
+    Use modification and distribution are subject to the Boost Software
     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
     http://www.boost.org/LICENSE_1_0.txt).
 ==============================================================================*/
@@ -51,14 +51,14 @@ namespace boost { namespace fusion
 
     namespace detail
     {
-        template< 
+        template<
-            class Function, class Sequence, 
+            class Function, class Sequence,
             int N = result_of::size<Sequence>::value,
-            bool RandomAccess = traits::is_random_access<Sequence>::value 
+            bool RandomAccess = traits::is_random_access<Sequence>::value
             >
         struct invoke_function_object_impl;
 
-        template <class Sequence, int N> 
+        template <class Sequence, int N>
         struct invoke_function_object_param_types;
 
         #define  BOOST_PP_FILENAME_1 \
@@ -72,10 +72,10 @@ namespace boost { namespace fusion
     {
         template <class Function, class Sequence> struct invoke_function_object
         {
-            typedef typename detail::invoke_function_object_impl< 
+            typedef typename detail::invoke_function_object_impl<
                 typename boost::remove_reference<Function>::type, Sequence
                 >::result_type type;
-        }; 
+        };
     }
 
     template <class Function, class Sequence>
@@ -114,7 +114,7 @@ namespace boost { namespace fusion
 
             typedef typename boost::result_of<
 #define M(z,j,data)                                                             \
-        typename result_of::at_c<Sequence,j>::type 
+        typename result_of::at_c<Sequence,j>::type
                 Function (BOOST_PP_ENUM(N,M,~)) >::type result_type;
 #undef M
 
@@ -154,7 +154,7 @@ namespace boost { namespace fusion
             }
         };
 
-        template <class Sequence> 
+        template <class Sequence>
         struct invoke_function_object_param_types<Sequence,N>
         {
 #if N > 0
@@ -173,5 +173,5 @@ namespace boost { namespace fusion
 
 #undef N
 #endif // defined(BOOST_PP_IS_ITERATING)
-#endif 
+#endif
 

include/boost/fusion/functional/invocation/invoke_procedure.hpp

@@ -1,8 +1,8 @@
 /*=============================================================================
-    Copyright (c) 2005-2006 João Abecasis
+    Copyright (c) 2005-2006 Joao Abecasis
     Copyright (c) 2006-2007 Tobias Schwinger
-  
+
-    Use modification and distribution are subject to the Boost Software 
+    Use modification and distribution are subject to the Boost Software
     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
     http://www.boost.org/LICENSE_1_0.txt).
 ==============================================================================*/
@@ -58,8 +58,8 @@ namespace boost { namespace fusion
     {
         namespace ft = function_types;
 
-        template< 
+        template<
-            typename Function, class Sequence, 
+            typename Function, class Sequence,
             int N = result_of::size<Sequence>::value,
             bool MFP = ft::is_member_function_pointer<Function>::value,
             bool RandomAccess = traits::is_random_access<Sequence>::value
@@ -167,5 +167,5 @@ namespace boost { namespace fusion
 
 #undef N
 #endif // defined(BOOST_PP_IS_ITERATING)
-#endif 
+#endif
 

include/boost/fusion/include/at_c.hpp

@@ -0,0 +1,12 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    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)
+==============================================================================*/
+#if !defined(FUSION_INCLUDE_AT_C)
+#define FUSION_INCLUDE_AT_C
+
+#include <boost/fusion/sequence/intrinsic/at_c.hpp>
+
+#endif

include/boost/fusion/include/end.hpp

@@ -4,8 +4,8 @@
     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)
 ==============================================================================*/
-#if !defined(FUSION_INCLUDE_BEGIN)
+#if !defined(FUSION_INCLUDE_END)
-#define FUSION_INCLUDE_BEGIN
+#define FUSION_INCLUDE_END
 
 #include <boost/fusion/sequence/intrinsic/end.hpp>
 

include/boost/fusion/sequence/intrinsic/at_c.hpp

@@ -0,0 +1,13 @@
+/*=============================================================================
+    Copyright (c) 2001-2006 Joel de Guzman
+
+    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)
+==============================================================================*/
+#if !defined(FUSION_AT_C_08252008_0308)
+#define FUSION_AT_C_08252008_0308
+
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+
+#endif
+

include/boost/fusion/tuple/detail/tuple_expand.hpp

@@ -1,19 +1,19 @@
 /*=============================================================================
     Copyright (c) 2001-2006 Joel de Guzman
 
-    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 ==============================================================================*/
 #ifndef BOOST_PP_IS_ITERATING
-#if !defined(FUSION_TUPLE_FORWARD_CTOR_10032005_0815)
+#if !defined(FUSION_TUPLE_EXPAND_10032005_0815)
-#define FUSION_TUPLE_FORWARD_CTOR_10032005_0815
+#define FUSION_TUPLE_EXPAND_10032005_0815
 
 #include <boost/preprocessor/iterate.hpp>
 #include <boost/preprocessor/repetition/enum_params.hpp>
 #include <boost/preprocessor/repetition/enum_binary_params.hpp>
 
 #define BOOST_PP_FILENAME_1 \
-    <boost/fusion/tuple/detail/tuple_forward_ctor.hpp>
+    <boost/fusion/tuple/detail/tuple_expand.hpp>
 #define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_VECTOR_SIZE)
 #include BOOST_PP_ITERATE()
 
@@ -34,6 +34,17 @@
         N, typename detail::call_param<T, >::type _))
         : base_type(BOOST_PP_ENUM_PARAMS(N, _)) {}
 
+    template <BOOST_PP_ENUM_PARAMS(N, typename U)>
+    tuple(tuple<BOOST_PP_ENUM_PARAMS(N, U)> const& rhs)
+        : base_type(rhs) {}
+
+    template <BOOST_PP_ENUM_PARAMS(N, typename U)>
+    tuple& operator=(tuple<BOOST_PP_ENUM_PARAMS(N, U)> const& rhs)
+    {
+        base_type::operator=(rhs);
+        return *this;
+    }
+
 #undef N
 #endif // defined(BOOST_PP_IS_ITERATING)
 

include/boost/fusion/tuple/tuple.hpp

@@ -1,7 +1,7 @@
 /*=============================================================================
     Copyright (c) 2005 Joel de Guzman
 
-    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    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)
 ==============================================================================*/
 #if !defined(FUSION_TUPLE_10032005_0810)
@@ -16,6 +16,7 @@
 #include <boost/fusion/sequence/io.hpp>
 #include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/is_const.hpp>
+#include <boost/config/no_tr1/utility.hpp>
 
 namespace boost { namespace fusion
 {
@@ -23,35 +24,50 @@ namespace boost { namespace fusion
     struct tuple : vector<BOOST_PP_ENUM_PARAMS(FUSION_MAX_VECTOR_SIZE, T)>
     {
         typedef vector<
-            BOOST_PP_ENUM_PARAMS(FUSION_MAX_VECTOR_SIZE, T)> 
+            BOOST_PP_ENUM_PARAMS(FUSION_MAX_VECTOR_SIZE, T)>
         base_type;
 
         tuple()
             : base_type() {}
-        
+
-        template <typename Sequence>
+        tuple(tuple const& rhs)
-        tuple(Sequence const& rhs)
             : base_type(rhs) {}
 
-        #include <boost/fusion/tuple/detail/tuple_forward_ctor.hpp>
+        template <typename U1, typename U2>
+        tuple(std::pair<U1, U2> const& rhs)
+            : base_type(rhs) {}
+
+        #include <boost/fusion/tuple/detail/tuple_expand.hpp>
 
         template <typename T>
-        tuple&
+        tuple& operator=(T const& rhs)
-        operator=(T const& rhs)
+        {
+            base_type::operator=(rhs);
+            return *this;
+        }
+
+        tuple& operator=(tuple const& rhs)
+        {
+            base_type::operator=(rhs);
+            return *this;
+        }
+
+        template <typename U1, typename U2>
+        tuple& operator=(std::pair<U1, U2> const& rhs)
         {
             base_type::operator=(rhs);
             return *this;
         }
     };
 
-    template <typename Tuple> 
+    template <typename Tuple>
     struct tuple_size : result_of::size<Tuple> {};
 
-    template <int N, typename Tuple> 
+    template <int N, typename Tuple>
     struct tuple_element : result_of::value_at_c<Tuple, N> {};
 
     template <int N, typename Tuple>
-    inline typename 
+    inline typename
         lazy_disable_if<
             is_const<Tuple>
           , result_of::at_c<Tuple, N>