Added boost header

test/external/boost/fusion/algorithm/iteration/detail/fold.hpp

@@ -0,0 +1,462 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2006 Dan Marsden
+    Copyright (c) 2009-2010 Christopher Schmidt
+
+    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)
+==============================================================================*/
+#include <boost/preprocessor/cat.hpp>
+
+#ifdef BOOST_FUSION_REVERSE_FOLD
+#   ifdef BOOST_FUSION_ITER_FOLD
+#       define BOOST_FUSION_FOLD_NAME reverse_iter_fold
+#   else
+#       define BOOST_FUSION_FOLD_NAME reverse_fold
+#   endif
+
+#   define BOOST_FUSION_FOLD_IMPL_FIRST_IT_FUNCTION end
+#   define BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION prior
+#   define BOOST_FUSION_FOLD_IMPL_FIRST_IT_META_TRANSFORM(IT)                   \
+        typename fusion::result_of::prior<IT>::type
+#   define BOOST_FUSION_FOLD_IMPL_FIRST_IT_TRANSFORM(IT) fusion::prior(IT)
+#else
+#   ifdef BOOST_FUSION_ITER_FOLD
+#       define BOOST_FUSION_FOLD_NAME iter_fold
+#   else
+#       define BOOST_FUSION_FOLD_NAME fold
+#   endif
+
+#   define BOOST_FUSION_FOLD_IMPL_FIRST_IT_FUNCTION begin
+#   define BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION next
+#   define BOOST_FUSION_FOLD_IMPL_FIRST_IT_META_TRANSFORM(IT) IT
+#   define BOOST_FUSION_FOLD_IMPL_FIRST_IT_TRANSFORM(IT) IT
+#endif
+#ifdef BOOST_FUSION_ITER_FOLD
+#   define BOOST_FUSION_FOLD_IMPL_INVOKE_IT_META_TRANSFORM(IT) IT&
+#   define BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(IT) IT
+#else
+#   define BOOST_FUSION_FOLD_IMPL_INVOKE_IT_META_TRANSFORM(IT)                  \
+        typename fusion::result_of::deref<IT>::type
+#   define BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(IT) fusion::deref(IT)
+#endif
+
+namespace boost { namespace fusion
+{
+    namespace detail
+    {
+        template<typename State, typename It, typename F>
+        struct BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)
+          : boost::result_of<
+                F(
+                typename add_reference<typename add_const<State>::type>::type,
+                BOOST_FUSION_FOLD_IMPL_INVOKE_IT_META_TRANSFORM(It))
+            >
+        {};
+
+        template<typename Result,int N>
+        struct BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)
+        {
+            template<typename State, typename It0, typename F>
+            static Result
+            call(State const& state,It0 const& it0,F f)
+            {
+                typedef typename
+                    result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<
+                        It0 const
+                    >::type
+                It1;
+                It1 it1 = fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it0);
+                typedef typename
+                    result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<
+                        It1
+                    >::type
+                It2;
+                It2 it2 = fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it1);
+                typedef typename
+                    result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<
+                        It2
+                    >::type
+                It3;
+                It3 it3 = fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it2);
+
+                typedef typename BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<State,It0,F>::type State1;
+                State1 const state1=f(state,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it0));
+
+                typedef typename BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<State1,It1,F>::type State2;
+                State2 const state2=f(state1,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it1));
+
+                typedef typename BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<State2,It2,F>::type State3;
+                State3 const state3=f(state2,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it2));
+
+                return BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)<
+                    Result
+                  , N-4
+                >::call(
+                    f(state3,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it3)),
+                    fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it3),
+                    f);
+            }
+        };
+
+        template<typename Result>
+        struct BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)<Result,3>
+        {
+            template<typename State, typename It0, typename F>
+            static Result
+            call(State const& state,It0 const& it0,F f)
+            {
+                typedef typename
+                    result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<
+                        It0 const
+                    >::type
+                It1;
+                It1 it1 = fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it0);
+                typedef typename
+                    result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<
+                        It1
+                    >::type
+                It2;
+                It2 it2 = fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it1);
+
+                typedef typename BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<State,It0,F>::type State1;
+                State1 const state1=f(state,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it0));
+
+                typedef typename BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<State1,It1,F>::type State2;
+                State2 const state2=f(state1,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it1));
+
+                return f(state2,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it2));
+            }
+        };
+
+        template<typename Result>
+        struct BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)<Result,2>
+        {
+            template<typename State, typename It0, typename F>
+            static Result
+            call(State const& state,It0 const& it0,F f)
+            {
+                typedef typename BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<State,It0,F>::type State1;
+                State1 const state1=f(state,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it0));
+
+                return f(
+                    state1,
+                    BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(
+                        fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it0)));
+            }
+        };
+
+        template<typename Result>
+        struct BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)<Result,1>
+        {
+            template<typename State, typename It0, typename F>
+            static Result
+            call(State const& state,It0 const& it0,F f)
+            {
+                return f(state,
+                    BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it0));
+            }
+        };
+
+        template<typename Result>
+        struct BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)<Result,0>
+        {
+            template<typename State, typename It0, typename F>
+            static Result
+            call(State const& state,It0 const& it0, F)
+            {
+                return static_cast<Result>(state);
+            }
+        };
+
+        template<typename StateRef, typename It0, typename F, int N>
+        struct BOOST_PP_CAT(result_of_unrolled_,BOOST_FUSION_FOLD_NAME)
+        {
+            typedef typename
+                BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<
+                    StateRef
+                  , It0 const
+                  , F
+                >::type
+            rest1;
+            typedef typename
+                result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<
+                    It0 const
+                >::type
+            it1;
+            typedef typename
+                BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<
+                    rest1
+                  , it1
+                  , F
+                >::type
+            rest2;
+            typedef typename
+                result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<it1>::type
+            it2;
+            typedef typename
+                BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<
+                    rest2
+                  , it2
+                  , F
+                >::type
+            rest3;
+            typedef typename
+                result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<it2>::type
+            it3;
+
+            typedef typename
+                BOOST_PP_CAT(result_of_unrolled_,BOOST_FUSION_FOLD_NAME)<
+                    typename BOOST_PP_CAT(
+                        BOOST_FUSION_FOLD_NAME, _lvalue_state)<
+                        rest3
+                      , it3
+                      , F
+                    >::type
+                  , typename result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<
+                        it3
+                    >::type
+                  , F
+                  , N-4
+                >::type
+            type;
+        };
+
+        template<typename StateRef, typename It0, typename F>
+        struct BOOST_PP_CAT(result_of_unrolled_,BOOST_FUSION_FOLD_NAME)<
+            StateRef
+          , It0
+          , F
+          , 3
+        >
+        {
+            typedef typename
+                BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<
+                    StateRef
+                  , It0 const
+                  , F
+                >::type
+            rest1;
+            typedef typename
+                result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<
+                    It0 const
+                >::type
+            it1;
+
+            typedef typename
+                BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<
+                    typename BOOST_PP_CAT(
+                        BOOST_FUSION_FOLD_NAME, _lvalue_state)<
+                        rest1
+                      , it1
+                      , F
+                    >::type
+                  , typename result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<
+                        it1 const
+                    >::type const
+                  , F
+                >::type
+            type;
+        };
+
+        template<typename StateRef, typename It0, typename F>
+        struct BOOST_PP_CAT(result_of_unrolled_,BOOST_FUSION_FOLD_NAME)<
+            StateRef
+          , It0
+          , F
+          , 2
+        >
+          : BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<
+                typename BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<
+                    StateRef
+                  , It0 const
+                  , F
+                >::type
+              , typename result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<
+                    It0 const
+                >::type const
+              , F
+            >
+        {};
+
+        template<typename StateRef, typename It0, typename F>
+        struct BOOST_PP_CAT(result_of_unrolled_,BOOST_FUSION_FOLD_NAME)<
+            StateRef
+          , It0
+          , F
+          , 1
+        >
+          : BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<
+                StateRef
+              , It0 const
+              , F
+            >
+        {};
+
+        template<typename StateRef, typename It0, typename F>
+        struct BOOST_PP_CAT(result_of_unrolled_,BOOST_FUSION_FOLD_NAME)<
+            StateRef
+          , It0
+          , F
+          , 0
+        >
+        {
+            typedef StateRef type;
+        };
+
+        template<typename StateRef, typename It0, typename F, int SeqSize>
+        struct BOOST_PP_CAT(result_of_first_unrolled,BOOST_FUSION_FOLD_NAME)
+        {
+            typedef typename
+                BOOST_PP_CAT(result_of_unrolled_,BOOST_FUSION_FOLD_NAME)<
+                    typename boost::result_of<
+                        F(
+                            StateRef,
+                            BOOST_FUSION_FOLD_IMPL_INVOKE_IT_META_TRANSFORM(
+                                It0 const)
+                        )
+                    >::type
+                  , typename result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<
+                        It0 const
+                    >::type
+                  , F
+                  , SeqSize-1
+                >::type
+            type;
+        };
+
+        template<int SeqSize, typename StateRef, typename Seq, typename F>
+        struct BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME,_impl)
+        {
+            typedef typename
+                BOOST_PP_CAT(
+                    result_of_first_unrolled,BOOST_FUSION_FOLD_NAME)<
+                    StateRef
+                  , BOOST_FUSION_FOLD_IMPL_FIRST_IT_META_TRANSFORM(
+                        typename result_of::BOOST_FUSION_FOLD_IMPL_FIRST_IT_FUNCTION<Seq>::type
+                    )
+                  , F
+                  , SeqSize
+                >::type
+            type;
+
+            static type
+            call(StateRef state, Seq& seq, F f)
+            {
+                typedef
+                    BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)<
+                        type
+                      , SeqSize
+                    >
+                unrolled_impl;
+
+                return unrolled_impl::call(
+                    state,
+                    BOOST_FUSION_FOLD_IMPL_FIRST_IT_TRANSFORM(
+                        fusion::BOOST_FUSION_FOLD_IMPL_FIRST_IT_FUNCTION(seq)),
+                    f);
+            }
+        };
+
+        template<typename StateRef, typename Seq, typename F>
+        struct BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME,_impl)<0,StateRef,Seq,F>
+        {
+            typedef StateRef type;
+
+            static StateRef
+            call(StateRef state, Seq&, F)
+            {
+                return static_cast<StateRef>(state);
+            }
+        };
+
+        template<typename Seq, typename State, typename F, bool IsSegmented>
+        struct BOOST_PP_CAT(result_of_, BOOST_FUSION_FOLD_NAME)
+          : BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME,_impl)<
+                result_of::size<Seq>::value
+              , typename add_reference<
+                    typename add_const<State>::type
+                >::type
+              , Seq
+              , F
+            >
+        {};
+    }
+
+    namespace result_of
+    {
+        template<typename Seq, typename State, typename F>
+        struct BOOST_FUSION_FOLD_NAME
+          : detail::BOOST_PP_CAT(result_of_, BOOST_FUSION_FOLD_NAME)<
+                Seq
+              , State
+              , F
+              , traits::is_segmented<Seq>::type::value
+            >
+        {};
+    }
+
+    template<typename Seq, typename State, typename F>
+    inline typename result_of::BOOST_FUSION_FOLD_NAME<
+        Seq
+      , State const
+      , F
+    >::type
+    BOOST_FUSION_FOLD_NAME(Seq& seq, State const& state, F f)
+    {
+        return result_of::BOOST_FUSION_FOLD_NAME<Seq,State const,F>::call(
+            state,
+            seq,
+            f);
+    }
+
+    template<typename Seq, typename State, typename F>
+    inline typename result_of::BOOST_FUSION_FOLD_NAME<
+        Seq const
+      , State const
+      , F
+    >::type
+    BOOST_FUSION_FOLD_NAME(Seq const& seq, State const& state, F f)
+    {
+        return result_of::BOOST_FUSION_FOLD_NAME<Seq const,State const,F>::call(
+            state,
+            seq,
+            f);
+    }
+
+    template<typename Seq, typename State, typename F>
+    inline typename result_of::BOOST_FUSION_FOLD_NAME<
+        Seq
+      , State const
+      , F
+    >::type
+    BOOST_FUSION_FOLD_NAME(Seq& seq, State& state, F f)
+    {
+        return result_of::BOOST_FUSION_FOLD_NAME<Seq,State,F>::call(
+            state,
+            seq,
+            f);
+    }
+
+    template<typename Seq, typename State, typename F>
+    inline typename result_of::BOOST_FUSION_FOLD_NAME<
+        Seq const
+      , State const
+      , F
+    >::type
+    BOOST_FUSION_FOLD_NAME(Seq const& seq, State& state, F f)
+    {
+        return result_of::BOOST_FUSION_FOLD_NAME<Seq const,State,F>::call(
+            state,
+            seq,
+            f);
+    }
+}}
+
+#undef BOOST_FUSION_FOLD_NAME
+#undef BOOST_FUSION_FOLD_IMPL_FIRST_IT_FUNCTION
+#undef BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION
+#undef BOOST_FUSION_FOLD_IMPL_FIRST_IT_META_TRANSFORM
+#undef BOOST_FUSION_FOLD_IMPL_FIRST_IT_TRANSFORM
+#undef BOOST_FUSION_FOLD_IMPL_INVOKE_IT_META_TRANSFORM
+#undef BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM